Debian Codegraph @

libdrgn/python/program.c

raw
1 // Copyright (c) Meta Platforms, Inc. and affiliates.
2 // SPDX-License-Identifier: LGPL-2.1-or-later
3
4 #include "drgnpy.h"
5 #include "../bitops.h"
6 #include "../error.h"
7 #include "../hash_table.h"
8 #include "../linux_kernel.h"
9 #include "../log.h"
10 #include "../program.h"
11 #include "../string_builder.h"
12 #include "../symbol.h"
13 #include "../util.h"
14 #include "../vector.h"
15
16 DEFINE_HASH_SET_FUNCTIONS(pyobjectp_set, ptr_key_hash_pair, scalar_key_eq);
17
18 static PyObject *percent_s;
19 static PyObject *logging_StreamHandler;
20 static PyObject *logger;
21 static PyObject *logger_log;
22
23 static void drgnpy_log_fn(struct drgn_program *prog, void *arg,
24 enum drgn_log_level level, const char *format,
25 va_list ap, struct drgn_error *err)
26 {
27 STRING_BUILDER(sb);
28 if (!string_builder_vappendf(&sb, format, ap))
29 return;
30 if (err && !string_builder_append_error(&sb, err))
31 return;
32
33 PyGILState_guard();
34 PyObject *ret = PyObject_CallFunction(logger_log, "iOs#",
35 (level + 1) * 10, percent_s,
36 sb.str ? sb.str : "",
37 (Py_ssize_t)sb.len);
38 if (ret)
39 Py_DECREF(ret);
40 else
41 PyErr_WriteUnraisable(logger_log);
42 }
43
44 static int get_logging_status(int *log_level_ret, bool *enable_progress_bar_ret)
45 {
46 // We don't use getEffectiveLevel() because that doesn't take
47 // logging.disable() into account.
48 int level;
49 for (level = 0; level < DRGN_LOG_NONE; level++) {
50 _cleanup_pydecref_ PyObject *enabled =
51 PyObject_CallMethod(logger, "isEnabledFor", "i",
52 (level + 1) * 10);
53 if (!enabled)
54 return -1;
55 int ret = PyObject_IsTrue(enabled);
56 if (ret < 0)
57 return -1;
58 if (ret)
59 break;
60 }
61
62 *log_level_ret = level;
63
64 if (level > DRGN_LOG_WARNING || !isatty(STDERR_FILENO)) {
65 *enable_progress_bar_ret = false;
66 return 0;
67 }
68
69 PyObject *current_logger = logger;
70 _cleanup_pydecref_ PyObject *logger_to_decref = NULL;
71 do {
72 _cleanup_pydecref_ PyObject *handlers =
73 PyObject_GetAttrString(current_logger, "handlers");
74 if (!handlers)
75 return -1;
76
77 Py_ssize_t size = PySequence_Size(handlers);
78 if (size < 0)
79 return -1;
80
81 for (Py_ssize_t i = 0; i < size; i++) {
82 _cleanup_pydecref_ PyObject *handler =
83 PySequence_GetItem(handlers, i);
84 if (!handler)
85 return -1;
86
87 int r = PyObject_IsInstance(handler,
88 logging_StreamHandler);
89 if (r < 0)
90 return -1;
91 if (!r)
92 continue;
93
94 _cleanup_pydecref_ PyObject *stream =
95 PyObject_GetAttrString(handler, "stream");
96 if (!stream)
97 return -1;
98
99 _cleanup_pydecref_ PyObject *fd_obj =
100 PyObject_CallMethod(stream, "fileno", NULL);
101 if (!fd_obj) {
102 // Ignore AttributeError,
103 // io.UnsupportedOperation, etc.
104 if (PyErr_ExceptionMatches(PyExc_Exception)) {
105 PyErr_Clear();
106 continue;
107 } else {
108 return -1;
109 }
110 }
111
112 long fd = PyLong_AsLong(fd_obj);
113 if (fd == -1 && PyErr_Occurred())
114 return -1;
115
116 if (fd == STDERR_FILENO) {
117 *enable_progress_bar_ret = true;
118 return 0;
119 }
120 }
121
122 _cleanup_pydecref_ PyObject *propagate =
123 PyObject_GetAttrString(current_logger, "propagate");
124 if (!propagate)
125 return -1;
126 int ret = PyObject_IsTrue(propagate);
127 if (ret < 0)
128 return -1;
129 if (!ret)
130 break;
131
132 Py_XDECREF(logger_to_decref);
133 logger_to_decref = PyObject_GetAttrString(current_logger,
134 "parent");
135 if (!logger_to_decref)
136 return -1;
137 current_logger = logger_to_decref;
138 } while (current_logger != Py_None);
139
140 *enable_progress_bar_ret = false;
141 return 0;
142 }
143
144 // This is slightly heinous. We need to sync the Python logging configuration
145 // with libdrgn, but the Python log level and handlers can change at any time,
146 // and there are no APIs to be notified of this.
147 //
148 // To sync the log level, we monkey patch logger._cache.clear() to update the
149 // libdrgn log level on every live program.
150 //
151 // We also check handlers in that monkey patch, which isn't the right place to
152 // hook but should work in practice in most cases.
153 static int cached_log_level;
154 static bool cached_enable_progress_bar;
155 static struct pyobjectp_set programs = HASH_TABLE_INIT;
156
157 static int cache_logging_status(void)
158 {
159 return get_logging_status(&cached_log_level,
160 &cached_enable_progress_bar);
161 }
162
163 static PyObject *LoggerCacheWrapper_clear(PyObject *self)
164 {
165 PyDict_Clear(self);
166 if (!pyobjectp_set_empty(&programs)) {
167 if (cache_logging_status())
168 return NULL;
169 hash_table_for_each(pyobjectp_set, it, &programs) {
170 Program *prog = (Program *)*it.entry;
171 drgn_program_set_log_level(&prog->prog,
172 cached_log_level);
173 drgn_program_set_progress_file(&prog->prog,
174 cached_enable_progress_bar
175 ? stderr : NULL);
176 }
177 }
178 Py_RETURN_NONE;
179 }
180
181 static PyMethodDef LoggerCacheWrapper_methods[] = {
182 {"clear", (PyCFunction)LoggerCacheWrapper_clear, METH_NOARGS},
183 {},
184 };
185
186 static PyTypeObject LoggerCacheWrapper_type = {
187 PyVarObject_HEAD_INIT(NULL, 0)
188 .tp_name = "_drgn._LoggerCacheWrapper",
189 .tp_methods = LoggerCacheWrapper_methods,
190 };
191
192 static int init_logger_cache_wrapper(void)
193 {
194 LoggerCacheWrapper_type.tp_base = &PyDict_Type;
195 if (PyType_Ready(&LoggerCacheWrapper_type))
196 return -1;
197 _cleanup_pydecref_ PyObject *cache_wrapper =
198 PyObject_CallFunction((PyObject *)&LoggerCacheWrapper_type,
199 NULL);
200 if (!cache_wrapper)
201 return -1;
202 return PyObject_SetAttrString(logger, "_cache", cache_wrapper);
203 }
204
205 static int Program_init_logging(Program *prog)
206 {
207 // The cache is only maintained while there are live programs, so if
208 // this is the only program, we need to update the cache.
209 if (pyobjectp_set_empty(&programs) && cache_logging_status())
210 return -1;
211
212 PyObject *obj = (PyObject *)prog;
213 if (pyobjectp_set_insert(&programs, &obj, NULL) < 0)
214 return -1;
215 drgn_program_set_log_callback(&prog->prog, drgnpy_log_fn, NULL);
216 drgn_program_set_log_level(&prog->prog, cached_log_level);
217 drgn_program_set_progress_file(&prog->prog,
218 cached_enable_progress_bar ? stderr : NULL);
219 return 0;
220 }
221
222 static void Program_deinit_logging(Program *prog)
223 {
224 PyObject *obj = (PyObject *)prog;
225 pyobjectp_set_delete(&programs, &obj);
226 }
227
228 int init_logging(void)
229 {
230 percent_s = PyUnicode_InternFromString("%s");
231 if (!percent_s)
232 return -1;
233
234 _cleanup_pydecref_ PyObject *logging = PyImport_ImportModule("logging");
235 if (!logging)
236 return -1;
237 logging_StreamHandler = PyObject_GetAttrString(logging,
238 "StreamHandler");
239 if (!logging_StreamHandler)
240 return -1;
241 logger = PyObject_CallMethod(logging, "getLogger", "s", "drgn");
242 if (!logger)
243 return -1;
244 logger_log = PyObject_GetAttrString(logger, "log");
245 if (!logger_log)
246 return -1;
247
248 return init_logger_cache_wrapper();
249 }
250
251 int Program_hold_object(Program *prog, PyObject *obj)
252 {
253 int ret = pyobjectp_set_insert(&prog->objects, &obj, NULL);
254 if (ret > 0) {
255 Py_INCREF(obj);
256 ret = 0;
257 } else if (ret < 0) {
258 PyErr_NoMemory();
259 }
260 return ret;
261 }
262
263 bool Program_hold_reserve(Program *prog, size_t n)
264 {
265 if (!pyobjectp_set_reserve(&prog->objects,
266 pyobjectp_set_size(&prog->objects) + n)) {
267 PyErr_NoMemory();
268 return false;
269 }
270 return true;
271 }
272
273 int Program_type_arg(Program *prog, PyObject *type_obj, bool can_be_none,
274 struct drgn_qualified_type *ret)
275 {
276 struct drgn_error *err;
277
278 if (PyObject_TypeCheck(type_obj, &DrgnType_type)) {
279 if (DrgnType_prog((DrgnType *)type_obj) != prog) {
280 PyErr_SetString(PyExc_ValueError,
281 "type is from different program");
282 return -1;
283 }
284 ret->type = ((DrgnType *)type_obj)->type;
285 ret->qualifiers = ((DrgnType *)type_obj)->qualifiers;
286 } else if (PyUnicode_Check(type_obj)) {
287 const char *name;
288
289 name = PyUnicode_AsUTF8(type_obj);
290 if (!name)
291 return -1;
292 err = drgn_program_find_type(&prog->prog, name, NULL, ret);
293 if (err) {
294 set_drgn_error(err);
295 return -1;
296 }
297 } else if (can_be_none && type_obj == Py_None) {
298 ret->type = NULL;
299 ret->qualifiers = 0;
300 } else {
301 PyErr_SetString(PyExc_TypeError,
302 can_be_none ?
303 "type must be Type, str, or None" :
304 "type must be Type or str");
305 return -1;
306 }
307 return 0;
308 }
309
310 drgn_blocking_state drgn_begin_blocking(void)
311 {
312 PyThreadState *state = PyGILState_GetThisThreadState();
313 // If the current thread doesn't hold the GIL (because it's not in
314 // Python or because this blocking section is nested in another), don't
315 // do anything.
316 if (!state || state != PyThreadState_GetUnchecked())
317 return NULL;
318 PyEval_ReleaseThread(state);
319 return (drgn_blocking_state)state;
320 }
321
322 void drgn_end_blocking(drgn_blocking_state state)
323 {
324 if (state)
325 PyEval_RestoreThread((PyThreadState *)state);
326 }
327
328 static Program *Program_new_impl(const struct drgn_platform *platform)
329 {
330 _cleanup_pydecref_ PyObject *cache = PyDict_New();
331 if (!cache)
332 return NULL;
333 _cleanup_pydecref_ PyObject *config = PyDict_New();
334 if (!config)
335 return NULL;
336
337 _cleanup_pydecref_ Program *prog = call_tp_alloc(Program);
338 if (!prog)
339 return NULL;
340 prog->cache = no_cleanup_ptr(cache);
341 prog->config = no_cleanup_ptr(config);
342 pyobjectp_set_init(&prog->objects);
343 drgn_program_init(&prog->prog, platform);
344 if (Program_init_logging(prog))
345 return NULL;
346 return_ptr(prog);
347 }
348
349 static Program *Program_new(PyTypeObject *subtype, PyObject *args,
350 PyObject *kwds)
351 {
352 static char *keywords[] = { "platform", "vmcoreinfo", NULL };
353 PyObject *platform_obj = NULL;
354 const char *vmcoreinfo = NULL;
355 Py_ssize_t vmcoreinfo_size;
356 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O$z#:Program", keywords,
357 &platform_obj, &vmcoreinfo,
358 &vmcoreinfo_size))
359 return NULL;
360
361 struct drgn_platform *platform;
362 if (!platform_obj || platform_obj == Py_None) {
363 platform = NULL;
364 } else if (PyObject_TypeCheck(platform_obj, &Platform_type)) {
365 platform = ((Platform *)platform_obj)->platform;
366 } else {
367 PyErr_SetString(PyExc_TypeError,
368 "platform must be Platform or None");
369 return NULL;
370 }
371 _cleanup_pydecref_ Program *prog = Program_new_impl(platform);
372 if (!prog)
373 return NULL;
374 if (vmcoreinfo) {
375 struct drgn_error *err = drgn_program_parse_vmcoreinfo(
376 &prog->prog, vmcoreinfo, vmcoreinfo_size);
377 if (err)
378 return set_drgn_error(err);
379 }
380 return_ptr(prog);
381 }
382
383 LIBDRGN_PUBLIC struct drgn_error *
384 drgn_program_create(const struct drgn_platform *platform,
385 struct drgn_program **ret)
386 {
387 bool success;
388 drgn_initialize_python_guard(&success);
389 if (!success)
390 return drgn_error_from_python();
391 Program *prog = Program_new_impl(platform);
392 if (!prog)
393 return drgn_error_from_python();
394 *ret = &prog->prog;
395 return NULL;
396 }
397
398 LIBDRGN_PUBLIC void drgn_program_destroy(struct drgn_program *prog)
399 {
400 if (prog) {
401 PyGILState_guard();
402 Py_DECREF(container_of(prog, Program, prog));
403 }
404 }
405
406 static void Program_dealloc(Program *self)
407 {
408 PyObject_GC_UnTrack(self);
409 Program_deinit_logging(self);
410 drgn_program_deinit(&self->prog);
411 hash_table_for_each(pyobjectp_set, it, &self->objects)
412 Py_DECREF(*it.entry);
413 pyobjectp_set_deinit(&self->objects);
414 Py_XDECREF(self->config);
415 Py_XDECREF(self->cache);
416 Py_TYPE(self)->tp_free((PyObject *)self);
417 }
418
419 static int Program_traverse(Program *self, visitproc visit, void *arg)
420 {
421 hash_table_for_each(pyobjectp_set, it, &self->objects)
422 Py_VISIT(*it.entry);
423 Py_VISIT(self->cache);
424 Py_VISIT(self->config);
425 return 0;
426 }
427
428 static int Program_clear(Program *self)
429 {
430 hash_table_for_each(pyobjectp_set, it, &self->objects)
431 Py_DECREF(*it.entry);
432 pyobjectp_set_deinit(&self->objects);
433 pyobjectp_set_init(&self->objects);
434 Py_CLEAR(self->cache);
435 Py_CLEAR(self->config);
436 return 0;
437 }
438
439 static struct drgn_error *py_memory_read_fn(void *buf, uint64_t address,
440 size_t count, uint64_t offset,
441 void *arg, bool physical)
442 {
443 struct drgn_error *err;
444
445 PyGILState_guard();
446
447 _cleanup_pydecref_ PyObject *ret =
448 PyObject_CallFunction(arg, "KKKO", (unsigned long long)address,
449 (unsigned long long)count,
450 (unsigned long long)offset,
451 physical ? Py_True : Py_False);
452 if (!ret)
453 return drgn_error_from_python();
454 Py_buffer view;
455 if (PyObject_GetBuffer(ret, &view, PyBUF_SIMPLE) == -1)
456 return drgn_error_from_python();
457 if (view.len != count) {
458 PyErr_Format(PyExc_ValueError,
459 "memory read callback returned buffer of length %zd (expected %zu)",
460 view.len, count);
461 err = drgn_error_from_python();
462 goto out;
463 }
464 memcpy(buf, view.buf, count);
465 err = NULL;
466 out:
467 PyBuffer_Release(&view);
468 return err;
469 }
470
471 static PyObject *Program_add_memory_segment(Program *self, PyObject *args,
472 PyObject *kwds)
473 {
474 static char *keywords[] = {
475 "address", "size", "read_fn", "physical", NULL,
476 };
477 struct drgn_error *err;
478 struct index_arg address = {};
479 struct index_arg size = {};
480 PyObject *read_fn;
481 int physical = 0;
482
483 if (!PyArg_ParseTupleAndKeywords(args, kwds,
484 "O&O&O|p:add_memory_segment", keywords,
485 index_converter, &address,
486 index_converter, &size, &read_fn,
487 &physical))
488 return NULL;
489
490 if (!PyCallable_Check(read_fn)) {
491 PyErr_SetString(PyExc_TypeError, "read_fn must be callable");
492 return NULL;
493 }
494
495 if (Program_hold_object(self, read_fn) == -1)
496 return NULL;
497 err = drgn_program_add_memory_segment(&self->prog, address.uvalue,
498 size.uvalue, py_memory_read_fn,
499 read_fn, physical);
500 if (err)
501 return set_drgn_error(err);
502 Py_RETURN_NONE;
503 }
504
505 static struct drgn_error *
506 py_debug_info_find_fn(struct drgn_module * const *modules, size_t num_modules,
507 void *arg)
508 {
509 PyGILState_guard();
510
511 _cleanup_pydecref_ PyObject *modules_list = PyList_New(num_modules);
512 if (!modules_list)
513 return drgn_error_from_python();
514 for (size_t i = 0; i < num_modules; i++) {
515 PyObject *module_obj = Module_wrap(modules[i]);
516 if (!module_obj)
517 return drgn_error_from_python();
518 PyList_SET_ITEM(modules_list, i, module_obj);
519 }
520 _cleanup_pydecref_ PyObject *obj =
521 PyObject_CallOneArg(arg, modules_list);
522 if (!obj)
523 return drgn_error_from_python();
524 return NULL;
525 }
526
527 static inline struct drgn_error *
528 py_type_find_fn_common(PyObject *type_obj, void *arg,
529 struct drgn_qualified_type *ret)
530 {
531 if (!PyObject_TypeCheck(type_obj, &DrgnType_type)) {
532 PyErr_SetString(PyExc_TypeError,
533 "type find callback must return Type or None");
534 return drgn_error_from_python();
535 }
536 // This check is also done in libdrgn, but we need it here because if
537 // the type isn't from this program, then there's no guarantee that it
538 // will remain valid after we decrement its reference count.
539 if (DrgnType_prog((DrgnType *)type_obj)
540 != (Program *)PyTuple_GET_ITEM(arg, 0)) {
541 PyErr_SetString(PyExc_ValueError,
542 "type find callback returned type from wrong program");
543 return drgn_error_from_python();
544 }
545 ret->type = ((DrgnType *)type_obj)->type;
546 ret->qualifiers = ((DrgnType *)type_obj)->qualifiers;
547 return NULL;
548 }
549
550 static struct drgn_error *py_type_find_fn(uint64_t kinds, const char *name,
551 size_t name_len, const char *filename,
552 void *arg,
553 struct drgn_qualified_type *ret)
554 {
555 PyGILState_guard();
556
557 _cleanup_pydecref_ PyObject *name_obj =
558 PyUnicode_FromStringAndSize(name, name_len);
559 if (!name_obj)
560 return drgn_error_from_python();
561
562 _cleanup_pydecref_ PyObject *kinds_obj = TypeKindSet_wrap(kinds);
563 if (!kinds_obj)
564 return drgn_error_from_python();
565 _cleanup_pydecref_ PyObject *type_obj =
566 PyObject_CallFunction(PyTuple_GET_ITEM(arg, 1), "OOOs",
567 PyTuple_GET_ITEM(arg, 0), kinds_obj,
568 name_obj, filename);
569 if (!type_obj)
570 return drgn_error_from_python();
571 if (type_obj == Py_None)
572 return &drgn_not_found;
573 return py_type_find_fn_common(type_obj, arg, ret);
574 }
575
576 // Old version for add_type_finder().
577 static struct drgn_error *py_type_find_fn_old(uint64_t kinds, const char *name,
578 size_t name_len,
579 const char *filename, void *arg,
580 struct drgn_qualified_type *ret)
581 {
582 PyGILState_guard();
583
584 _cleanup_pydecref_ PyObject *name_obj =
585 PyUnicode_FromStringAndSize(name, name_len);
586 if (!name_obj)
587 return drgn_error_from_python();
588
589 int kind;
590 for_each_bit(kind, kinds) {
591 _cleanup_pydecref_ PyObject *
592 kind_obj = PyObject_CallFunction(TypeKind_class, "i",
593 kind);
594 if (!kind_obj)
595 return drgn_error_from_python();
596 _cleanup_pydecref_ PyObject *type_obj =
597 PyObject_CallFunction(PyTuple_GET_ITEM(arg, 1), "OOs",
598 kind_obj, name_obj, filename);
599 if (!type_obj)
600 return drgn_error_from_python();
601 if (type_obj == Py_None)
602 continue;
603 return py_type_find_fn_common(type_obj, arg, ret);
604 }
605 return &drgn_not_found;
606 }
607
608 static struct drgn_error *py_object_find_fn(const char *name, size_t name_len,
609 const char *filename,
610 enum drgn_find_object_flags flags,
611 void *arg, struct drgn_object *ret)
612 {
613 PyGILState_guard();
614
615 _cleanup_pydecref_ PyObject *name_obj =
616 PyUnicode_FromStringAndSize(name, name_len);
617 if (!name_obj)
618 return drgn_error_from_python();
619 _cleanup_pydecref_ PyObject *flags_obj =
620 PyObject_CallFunction(FindObjectFlags_class, "i", (int)flags);
621 if (!flags_obj)
622 return drgn_error_from_python();
623 _cleanup_pydecref_ PyObject *obj =
624 PyObject_CallFunction(arg, "OOOs",
625 container_of(drgn_object_program(ret), Program, prog),
626 name_obj, flags_obj, filename);
627 if (!obj)
628 return drgn_error_from_python();
629 if (obj == Py_None)
630 return &drgn_not_found;
631 if (!PyObject_TypeCheck(obj, &DrgnObject_type)) {
632 PyErr_SetString(PyExc_TypeError,
633 "object find callback must return Object or None");
634 return drgn_error_from_python();
635 }
636
637 return drgn_object_copy(ret, &((DrgnObject *)obj)->obj);
638 }
639
640 static struct drgn_error *
641 py_symbol_find_fn(const char *name, uint64_t addr,
642 enum drgn_find_symbol_flags flags, void *arg,
643 struct drgn_symbol_result_builder *builder)
644 {
645 // Fast path for SymbolIndex: don't bother converting to and from Python
646 // types, as this is a C finder. Use Py_TYPE and pointer comparison
647 // directly here to avoid needing to take the GIL for
648 // PyObject_TypeCheck(). SymbolIndex cannot be subclassed, so the logic
649 // for subclass checking is unnecessary anyway.
650 if (Py_TYPE(PyTuple_GET_ITEM(arg, 1)) == &SymbolIndex_type) {
651 SymbolIndex *ix = (SymbolIndex *)PyTuple_GET_ITEM(arg, 1);
652 return drgn_symbol_index_find(name, addr, flags, &ix->index, builder);
653 }
654
655 PyGILState_guard();
656
657 _cleanup_pydecref_ PyObject *name_obj = NULL;
658 if (flags & DRGN_FIND_SYMBOL_NAME) {
659 name_obj = PyUnicode_FromString(name);
660 if (!name_obj)
661 return drgn_error_from_python();
662 } else {
663 name_obj = Py_None;
664 Py_INCREF(name_obj);
665 }
666
667 _cleanup_pydecref_ PyObject *address_obj = NULL;
668 if (flags & DRGN_FIND_SYMBOL_ADDR) {
669 address_obj = PyLong_FromUnsignedLong(addr);
670 if (!address_obj)
671 return drgn_error_from_python();
672 } else {
673 address_obj = Py_None;
674 Py_INCREF(address_obj);
675 }
676
677 _cleanup_pydecref_ PyObject *one_obj = PyBool_FromLong(flags & DRGN_FIND_SYMBOL_ONE);
678
679 _cleanup_pydecref_ PyObject *tmp =
680 PyObject_CallFunction(PyTuple_GET_ITEM(arg, 1), "OOOO",
681 PyTuple_GET_ITEM(arg, 0), name_obj,
682 address_obj, one_obj);
683 if (!tmp)
684 return drgn_error_from_python();
685
686 _cleanup_pydecref_ PyObject *obj =
687 PySequence_Fast(tmp, "symbol finder must return a sequence");
688 if (!obj)
689 return drgn_error_from_python();
690
691 size_t len = PySequence_Fast_GET_SIZE(obj);
692 if (len > 1 && (flags & DRGN_FIND_SYMBOL_ONE)) {
693 return drgn_error_create(DRGN_ERROR_INVALID_ARGUMENT,
694 "symbol finder returned multiple elements, but one was requested");
695 }
696
697 for (size_t i = 0; i < len; i++) {
698 PyObject *item = PySequence_Fast_GET_ITEM(obj, i);
699 if (!PyObject_TypeCheck(item, &Symbol_type))
700 return drgn_error_create(DRGN_ERROR_TYPE,
701 "symbol finder results must be of type Symbol");
702 _cleanup_free_ struct drgn_symbol *sym = malloc(sizeof(*sym));
703 if (!sym)
704 return &drgn_enomem;
705 struct drgn_error *err = drgn_symbol_copy(sym, ((Symbol *)item)->sym);
706 if (err)
707 return err;
708
709 if (!drgn_symbol_result_builder_add(builder, sym))
710 return &drgn_enomem;
711 sym = NULL; // owned by the builder now
712 }
713
714 return NULL;
715 }
716
717 #define debug_info_finder_arg(self, fn) PyObject *arg = fn;
718 #define type_finder_arg(self, fn) \
719 _cleanup_pydecref_ PyObject *arg = Py_BuildValue("OO", self, fn); \
720 if (!arg) \
721 return NULL;
722 #define object_finder_arg(self, fn) PyObject *arg = fn;
723 #define symbol_finder_arg type_finder_arg
724
725 #define DEFINE_PROGRAM_FINDER_METHODS(which) \
726 static PyObject *Program_register_##which##_finder(Program *self, \
727 PyObject *args, \
728 PyObject *kwds) \
729 { \
730 struct drgn_error *err; \
731 static char *keywords[] = {"name", "fn", "enable_index", NULL}; \
732 const char *name; \
733 PyObject *fn; \
734 PyObject *enable_index_obj = Py_None; \
735 if (!PyArg_ParseTupleAndKeywords(args, kwds, \
736 "sO|$O:register_" #which "_finder", \
737 keywords, &name, &fn, \
738 &enable_index_obj)) \
739 return NULL; \
740 \
741 if (!PyCallable_Check(fn)) { \
742 PyErr_SetString(PyExc_TypeError, "fn must be callable"); \
743 return NULL; \
744 } \
745 \
746 size_t enable_index; \
747 if (enable_index_obj == Py_None) { \
748 enable_index = DRGN_HANDLER_REGISTER_DONT_ENABLE; \
749 } else { \
750 _cleanup_pydecref_ PyObject *negative_one = PyLong_FromLong(-1);\
751 if (!negative_one) \
752 return NULL; \
753 int eq = PyObject_RichCompareBool(enable_index_obj, \
754 negative_one, Py_EQ); \
755 if (eq < 0) \
756 return NULL; \
757 if (eq) { \
758 enable_index = DRGN_HANDLER_REGISTER_ENABLE_LAST; \
759 } else { \
760 enable_index = PyLong_AsSize_t(enable_index_obj); \
761 if (enable_index == (size_t)-1 && PyErr_Occurred()) \
762 return NULL; \
763 /* \
764 * If the index happens to be the \
765 * DRGN_HANDLER_REGISTER_DONT_ENABLE sentinel \
766 * (SIZE_MAX - 1), set it to something else; it's \
767 * impossible to have this many finders anyways. \
768 */ \
769 if (enable_index == DRGN_HANDLER_REGISTER_DONT_ENABLE) \
770 enable_index--; \
771 } \
772 } \
773 \
774 which##_finder_arg(self, fn) \
775 if (!Program_hold_reserve(self, 1)) \
776 return NULL; \
777 const struct drgn_##which##_finder_ops ops = { \
778 .find = py_##which##_find_fn, \
779 }; \
780 err = drgn_program_register_##which##_finder(&self->prog, name, &ops, \
781 arg, enable_index); \
782 if (err) \
783 return set_drgn_error(err); \
784 Program_hold_object(self, arg); \
785 Py_RETURN_NONE; \
786 \
787 } \
788 \
789 static PyObject *Program_registered_##which##_finders(Program *self) \
790 { \
791 struct drgn_error *err; \
792 _cleanup_free_ const char **names = NULL; \
793 size_t count; \
794 err = drgn_program_registered_##which##_finders(&self->prog, &names, \
795 &count); \
796 if (err) \
797 return set_drgn_error(err); \
798 _cleanup_pydecref_ PyObject *res = PySet_New(NULL); \
799 if (!res) \
800 return NULL; \
801 for (size_t i = 0; i < count; i++) { \
802 _cleanup_pydecref_ PyObject *name = \
803 PyUnicode_FromString(names[i]); \
804 if (!name) \
805 return NULL; \
806 if (PySet_Add(res, name)) \
807 return NULL; \
808 } \
809 return_ptr(res); \
810 } \
811 \
812 static PyObject *Program_set_enabled_##which##_finders(Program *self, \
813 PyObject *args, \
814 PyObject *kwds) \
815 { \
816 struct drgn_error *err; \
817 static char *keywords[] = {"names", NULL}; \
818 PyObject *names_obj; \
819 if (!PyArg_ParseTupleAndKeywords(args, kwds, \
820 "O:set_enabled_" #which "_finders", \
821 keywords, &names_obj)) \
822 return NULL; \
823 _cleanup_pydecref_ PyObject *names_seq = \
824 PySequence_Fast(names_obj, "names must be sequence"); \
825 if (!names_seq) \
826 return NULL; \
827 size_t count = PySequence_Fast_GET_SIZE(names_seq); \
828 _cleanup_free_ const char **names = \
829 malloc_array(count, sizeof(names[0])); \
830 if (!names) \
831 return NULL; \
832 for (size_t i = 0; i < count; i++) { \
833 names[i] = PyUnicode_AsUTF8(PySequence_Fast_GET_ITEM(names_seq, i));\
834 if (!names[i]) \
835 return NULL; \
836 } \
837 err = drgn_program_set_enabled_##which##_finders(&self->prog, names, \
838 count); \
839 if (err) \
840 return set_drgn_error(err); \
841 Py_RETURN_NONE; \
842 } \
843 \
844 static PyObject *Program_enabled_##which##_finders(Program *self) \
845 { \
846 struct drgn_error *err; \
847 _cleanup_free_ const char **names = NULL; \
848 size_t count; \
849 err = drgn_program_enabled_##which##_finders(&self->prog, &names, \
850 &count); \
851 if (err) \
852 return set_drgn_error(err); \
853 _cleanup_pydecref_ PyObject *res = PyList_New(count); \
854 if (!res) \
855 return NULL; \
856 for (size_t i = 0; i < count; i++) { \
857 PyObject *name = PyUnicode_FromString(names[i]); \
858 if (!name) \
859 return NULL; \
860 PyList_SET_ITEM(res, i, name); \
861 } \
862 return_ptr(res); \
863 }
864
865 DEFINE_PROGRAM_FINDER_METHODS(debug_info)
866 DEFINE_PROGRAM_FINDER_METHODS(type)
867 DEFINE_PROGRAM_FINDER_METHODS(object)
868 DEFINE_PROGRAM_FINDER_METHODS(symbol)
869
870 static PyObject *deprecated_finder_name_obj(PyObject *fn)
871 {
872 _cleanup_pydecref_ PyObject *name_attr_obj =
873 PyObject_GetAttrString(fn, "__name__");
874 if (name_attr_obj) {
875 return PyUnicode_FromFormat("%S_%lu", name_attr_obj, random());
876 } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
877 PyErr_Clear();
878 return PyUnicode_FromFormat("%lu", random());
879 } else {
880 return NULL;
881 }
882 }
883
884 static PyObject *Program_add_type_finder(Program *self, PyObject *args,
885 PyObject *kwds)
886 {
887 struct drgn_error *err;
888 static char *keywords[] = {"fn", NULL};
889 PyObject *fn;
890 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:add_type_finder",
891 keywords, &fn))
892 return NULL;
893
894 if (!PyCallable_Check(fn)) {
895 PyErr_SetString(PyExc_TypeError, "fn must be callable");
896 return NULL;
897 }
898
899 _cleanup_pydecref_ PyObject *arg = Py_BuildValue("OO", self, fn);
900 if (!arg)
901 return NULL;
902
903 _cleanup_pydecref_ PyObject *name_obj = deprecated_finder_name_obj(fn);
904 if (!name_obj)
905 return NULL;
906 const char *name = PyUnicode_AsUTF8(name_obj);
907 if (!name)
908 return NULL;
909
910 if (!Program_hold_reserve(self, 1))
911 return NULL;
912 const struct drgn_type_finder_ops ops = {
913 .find = py_type_find_fn_old,
914 };
915 err = drgn_program_register_type_finder(&self->prog, name, &ops, arg,
916 0);
917 if (err)
918 return set_drgn_error(err);
919 Program_hold_object(self, arg);
920 Py_RETURN_NONE;
921 }
922
923 static PyObject *Program_add_object_finder(Program *self, PyObject *args,
924 PyObject *kwds)
925 {
926 struct drgn_error *err;
927
928 static char *keywords[] = {"fn", NULL};
929 PyObject *fn;
930 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:add_object_finder",
931 keywords, &fn))
932 return NULL;
933
934 if (!PyCallable_Check(fn)) {
935 PyErr_SetString(PyExc_TypeError, "fn must be callable");
936 return NULL;
937 }
938
939 _cleanup_pydecref_ PyObject *name_obj = deprecated_finder_name_obj(fn);
940 if (!name_obj)
941 return NULL;
942 const char *name = PyUnicode_AsUTF8(name_obj);
943 if (!name)
944 return NULL;
945
946 if (!Program_hold_reserve(self, 1))
947 return NULL;
948 const struct drgn_object_finder_ops ops = {
949 .find = py_object_find_fn,
950 };
951 err = drgn_program_register_object_finder(&self->prog, name, &ops, fn,
952 0);
953 if (err)
954 return set_drgn_error(err);
955 Program_hold_object(self, fn);
956 Py_RETURN_NONE;
957 }
958
959 static PyObject *Program_set_core_dump(Program *self, PyObject *args,
960 PyObject *kwds)
961 {
962 static char *keywords[] = {"path", NULL};
963 struct drgn_error *err;
964 PATH_ARG(path, .allow_fd = true);
965
966 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&:set_core_dump",
967 keywords, path_converter, &path))
968 return NULL;
969
970 if (path.fd >= 0)
971 err = drgn_program_set_core_dump_fd(&self->prog, path.fd);
972 else
973 err = drgn_program_set_core_dump(&self->prog, path.path);
974 if (err)
975 return set_drgn_error(err);
976 Py_RETURN_NONE;
977 }
978
979 static PyObject *Program_set_kernel(Program *self)
980 {
981 struct drgn_error *err;
982
983 err = drgn_program_set_kernel(&self->prog);
984 if (err)
985 return set_drgn_error(err);
986 Py_RETURN_NONE;
987 }
988
989 static PyObject *Program_set_linux_kernel_custom(Program *self, PyObject *args,
990 PyObject *kwds)
991 {
992 static char *keywords[] = {"vmcoreinfo", "is_live", NULL};
993 struct drgn_error *err;
994 const char *vmcoreinfo;
995 Py_ssize_t vmcoreinfo_size;
996 int is_live;
997
998 if (!PyArg_ParseTupleAndKeywords(args, kwds,
999 "s#p:set_linux_kernel_custom", keywords,
1000 &vmcoreinfo, &vmcoreinfo_size,
1001 &is_live))
1002 return NULL;
1003
1004 err = drgn_program_set_linux_kernel_custom(&self->prog, vmcoreinfo,
1005 vmcoreinfo_size, is_live);
1006 if (err)
1007 return set_drgn_error(err);
1008 Py_RETURN_NONE;
1009 }
1010
1011 static PyObject *Program_set_pid(Program *self, PyObject *args, PyObject *kwds)
1012 {
1013 static char *keywords[] = {"pid", NULL};
1014 struct drgn_error *err;
1015 int pid;
1016
1017 if (!PyArg_ParseTupleAndKeywords(args, kwds, "i:set_pid", keywords,
1018 &pid))
1019 return NULL;
1020
1021 err = drgn_program_set_pid(&self->prog, pid);
1022 if (err)
1023 return set_drgn_error(err);
1024 Py_RETURN_NONE;
1025 }
1026
1027 static PyObject *Program_set_qemu_qmp(Program *self, PyObject *args,
1028 PyObject *kwds)
1029 {
1030 static char *keywords[] = {"address", NULL};
1031 struct drgn_error *err;
1032 PyObject *address;
1033
1034 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:set_qemu_qmp", keywords,
1035 &address))
1036 return NULL;
1037
1038 if (PyIndex_Check(address)) {
1039 int overflow;
1040 long fd = PyLong_AsLongAndOverflow(address, &overflow);
1041 if (fd == -1 && PyErr_Occurred())
1042 return NULL;
1043 if (overflow > 0 || fd > INT_MAX) {
1044 PyErr_SetString(PyExc_OverflowError,
1045 "fd is greater than maximum");
1046 return NULL;
1047 }
1048 if (fd < 0) {
1049 PyErr_SetString(PyExc_ValueError, "fd is negative");
1050 return NULL;
1051 }
1052 err = drgn_program_set_qemu_qmp_fd(&self->prog, fd);
1053 } else if (PyUnicode_Check(address)) {
1054 const char *s = PyUnicode_AsUTF8(address);
1055 if (!s)
1056 return NULL;
1057 err = drgn_program_set_qemu_qmp(&self->prog, s);
1058 } else {
1059 return PyErr_Format(PyExc_TypeError,
1060 "address must be str or int, not %s",
1061 Py_TYPE(address)->tp_name);
1062 }
1063 if (err)
1064 return set_drgn_error(err);
1065 Py_RETURN_NONE;
1066 }
1067
1068 static ModuleIterator *Program_modules(Program *self)
1069 {
1070 struct drgn_error *err;
1071 ModuleIterator *it = call_tp_alloc(ModuleIterator);
1072 if (!it)
1073 return NULL;
1074 err = drgn_created_module_iterator_create(&self->prog, &it->it);
1075 if (err) {
1076 it->it = NULL;
1077 Py_DECREF(it);
1078 return set_drgn_error(err);
1079 }
1080 Py_INCREF(self);
1081 return it;
1082 }
1083
1084 static ModuleIterator *Program_loaded_modules(Program *self)
1085 {
1086 struct drgn_error *err;
1087 ModuleIterator *it =
1088 (ModuleIterator *)ModuleIteratorWithNew_type.tp_alloc(
1089 &ModuleIteratorWithNew_type, 0);
1090 if (!it)
1091 return NULL;
1092 err = drgn_loaded_module_iterator_create(&self->prog, &it->it);
1093 if (err) {
1094 it->it = NULL;
1095 Py_DECREF(it);
1096 return set_drgn_error(err);
1097 }
1098 Py_INCREF(self);
1099 return it;
1100 }
1101
1102 static PyObject *Program_create_loaded_modules(Program *self)
1103 {
1104 struct drgn_error *err = drgn_create_loaded_modules(&self->prog);
1105 if (err)
1106 return set_drgn_error(err);
1107 Py_RETURN_NONE;
1108 }
1109
1110 static inline PyObject *Module_wrap_find(struct drgn_module *module)
1111 {
1112 if (module)
1113 return Module_wrap(module);
1114 PyErr_SetString(PyExc_LookupError, "module not found");
1115 return NULL;
1116 }
1117
1118 static PyObject *Program_main_module(Program *self, PyObject *args,
1119 PyObject *kwds)
1120 {
1121 struct drgn_error *err;
1122 static char *keywords[] = {"name", "create", NULL};
1123 PATH_ARG(name);
1124 int create = 0;
1125 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&$p:main_module",
1126 keywords, path_converter, &name,
1127 &create))
1128 return NULL;
1129
1130 if (create) {
1131 if (!name.path) {
1132 PyErr_SetString(PyExc_TypeError,
1133 "name must be given if create=True");
1134 return NULL;
1135 }
1136 struct drgn_module *module;
1137 err = drgn_module_find_or_create_main(&self->prog, name.path,
1138 &module, NULL);
1139 if (err) {
1140 set_drgn_error(err);
1141 return NULL;
1142 }
1143 return Module_wrap(module);
1144 } else {
1145 return Module_wrap_find(drgn_module_find_main(&self->prog,
1146 name.path));
1147 }
1148 }
1149
1150 static PyObject *Program_shared_library_module(Program *self, PyObject *args,
1151 PyObject *kwds)
1152 {
1153 struct drgn_error *err;
1154 static char *keywords[] = {"name", "dynamic_address", "create", NULL};
1155 PATH_ARG(name);
1156 struct index_arg dynamic_address = {};
1157 int create = 0;
1158 if (!PyArg_ParseTupleAndKeywords(args, kwds,
1159 "O&O&|$p:shared_library_module",
1160 keywords, path_converter, &name,
1161 index_converter, &dynamic_address,
1162 &create))
1163 return NULL;
1164
1165 if (create) {
1166 struct drgn_module *module;
1167 err = drgn_module_find_or_create_shared_library(&self->prog,
1168 name.path,
1169 dynamic_address.uvalue,
1170 &module, NULL);
1171 if (err) {
1172 set_drgn_error(err);
1173 return NULL;
1174 }
1175 return Module_wrap(module);
1176 } else {
1177 return Module_wrap_find(drgn_module_find_shared_library(&self->prog,
1178 name.path,
1179 dynamic_address.uvalue));
1180 }
1181 }
1182
1183 static PyObject *Program_vdso_module(Program *self, PyObject *args,
1184 PyObject *kwds)
1185 {
1186 struct drgn_error *err;
1187 static char *keywords[] = {"name", "dynamic_address", "create", NULL};
1188 PATH_ARG(name);
1189 struct index_arg dynamic_address = {};
1190 int create = 0;
1191 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&|$p:vdso_module",
1192 keywords, path_converter, &name,
1193 index_converter, &dynamic_address,
1194 &create))
1195 return NULL;
1196
1197 if (create) {
1198 struct drgn_module *module;
1199 err = drgn_module_find_or_create_vdso(&self->prog, name.path,
1200 dynamic_address.uvalue,
1201 &module, NULL);
1202 if (err) {
1203 set_drgn_error(err);
1204 return NULL;
1205 }
1206 return Module_wrap(module);
1207 } else {
1208 return Module_wrap_find(drgn_module_find_vdso(&self->prog,
1209 name.path,
1210 dynamic_address.uvalue));
1211 }
1212 }
1213
1214 static PyObject *Program_relocatable_module(Program *self, PyObject *args,
1215 PyObject *kwds)
1216 {
1217 struct drgn_error *err;
1218 static char *keywords[] = {"name", "address", "create", NULL};
1219 PATH_ARG(name);
1220 struct index_arg address = {};
1221 int create = 0;
1222 if (!PyArg_ParseTupleAndKeywords(args, kwds,
1223 "O&O&|$p:relocatable_module", keywords,
1224 path_converter, &name, index_converter,
1225 &address, &create))
1226 return NULL;
1227
1228 if (create) {
1229 struct drgn_module *module;
1230 err = drgn_module_find_or_create_relocatable(&self->prog,
1231 name.path,
1232 address.uvalue,
1233 &module, NULL);
1234 if (err) {
1235 set_drgn_error(err);
1236 return NULL;
1237 }
1238 return Module_wrap(module);
1239 } else {
1240 return Module_wrap_find(drgn_module_find_relocatable(&self->prog,
1241 name.path,
1242 address.uvalue));
1243 }
1244 }
1245
1246 static PyObject *Program_linux_kernel_loadable_module(Program *self,
1247 PyObject *args,
1248 PyObject *kwds)
1249 {
1250 struct drgn_error *err;
1251 static char *keywords[] = {"module_obj", "create", NULL};
1252 DrgnObject *module_obj;
1253 int create = 0;
1254 if (!PyArg_ParseTupleAndKeywords(args, kwds,
1255 "O!|$p:linux_kernel_loadable_module",
1256 keywords, &DrgnObject_type,
1257 &module_obj, &create))
1258 return NULL;
1259
1260 if (DrgnObject_prog(module_obj) != self) {
1261 PyErr_SetString(PyExc_ValueError,
1262 "object is from different program");
1263 return NULL;
1264 }
1265
1266 struct drgn_module *module;
1267 if (create) {
1268 err = drgn_module_find_or_create_linux_kernel_loadable(&module_obj->obj,
1269 &module,
1270 NULL);
1271 if (err) {
1272 set_drgn_error(err);
1273 return NULL;
1274 }
1275 return Module_wrap(module);
1276 } else {
1277 err = drgn_module_find_linux_kernel_loadable(&module_obj->obj,
1278 &module);
1279 if (err) {
1280 set_drgn_error(err);
1281 return NULL;
1282 }
1283 return Module_wrap_find(module);
1284 }
1285 }
1286
1287 static PyObject *Program_extra_module(Program *self, PyObject *args,
1288 PyObject *kwds)
1289 {
1290 struct drgn_error *err;
1291 static char *keywords[] = {"name", "id", "create", NULL};
1292 PATH_ARG(name);
1293 struct index_arg id = {};
1294 int create = 0;
1295 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|O&$p:extra_module",
1296 keywords, path_converter, &name,
1297 index_converter, &id, &create))
1298 return NULL;
1299
1300 if (create) {
1301 struct drgn_module *module;
1302 err = drgn_module_find_or_create_extra(&self->prog, name.path,
1303 id.uvalue, &module,
1304 NULL);
1305 if (err) {
1306 set_drgn_error(err);
1307 return NULL;
1308 }
1309 return Module_wrap(module);
1310 } else {
1311 return Module_wrap_find(drgn_module_find_extra(&self->prog,
1312 name.path,
1313 id.uvalue));
1314 }
1315 }
1316
1317 static PyObject *Program_module(Program *self, PyObject *arg)
1318 {
1319 struct drgn_module *module;
1320 if (PyUnicode_Check(arg)) {
1321 const char *name = PyUnicode_AsUTF8(arg);
1322 if (!name)
1323 return NULL;
1324 module = drgn_module_find_by_name(&self->prog, name);
1325 } else {
1326 struct index_arg address = {};
1327 if (!index_converter(arg, &address))
1328 return NULL;
1329 module = drgn_module_find_by_address(&self->prog,
1330 address.uvalue);
1331 }
1332 return Module_wrap_find(module);
1333 }
1334
1335 static DebugInfoOptions *Program_get_debug_info_options(Program *self, void *arg)
1336 {
1337 DebugInfoOptions *options = call_tp_alloc(DebugInfoOptions);
1338 if (options) {
1339 options->options = drgn_program_debug_info_options(&self->prog);
1340 options->prog = self;
1341 Py_INCREF(self);
1342 }
1343 return options;
1344 }
1345
1346 static int Program_set_debug_info_options(Program *self, PyObject *value, void *arg)
1347 {
1348 SETTER_NO_DELETE("debug_info_options", value);
1349 if (!PyObject_TypeCheck(value, &DebugInfoOptions_type)) {
1350 PyErr_SetString(PyExc_TypeError,
1351 "debug_info_options must be DebugInfoOptions");
1352 return -1;
1353 }
1354 struct drgn_error *err =
1355 drgn_debug_info_options_copy(drgn_program_debug_info_options(&self->prog),
1356 ((DebugInfoOptions *)value)->options);
1357 if (err) {
1358 set_drgn_error(err);
1359 return -1;
1360 }
1361 return 0;
1362 }
1363
1364 static PyObject *Program_load_debug_info(Program *self, PyObject *args,
1365 PyObject *kwds)
1366 {
1367 static char *keywords[] = {"paths", "default", "main", NULL};
1368 struct drgn_error *err;
1369 PATH_SEQUENCE_ARG(paths, .allow_none = true);
1370 int load_default = 0;
1371 int load_main = 0;
1372 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O&pp:load_debug_info",
1373 keywords, path_sequence_converter,
1374 &paths, &load_default, &load_main))
1375 return NULL;
1376 err = drgn_program_load_debug_info(&self->prog, paths.paths,
1377 path_sequence_size(&paths),
1378 load_default, load_main);
1379 if (err) {
1380 set_drgn_error(err);
1381 return NULL;
1382 }
1383 Py_RETURN_NONE;
1384 }
1385
1386 static PyObject *Program_load_default_debug_info(Program *self)
1387 {
1388 struct drgn_error *err;
1389
1390 err = drgn_program_load_debug_info(&self->prog, NULL, 0, true, true);
1391 if (err)
1392 return set_drgn_error(err);
1393 Py_RETURN_NONE;
1394 }
1395
1396 static PyObject *Program_load_module_debug_info(Program *self, PyObject *args)
1397 {
1398 size_t num_modules = PyTuple_GET_SIZE(args);
1399 _cleanup_free_ struct drgn_module **modules =
1400 malloc_array(num_modules, sizeof(*modules));
1401 if (!modules) {
1402 PyErr_NoMemory();
1403 return NULL;
1404 }
1405
1406 for (size_t i = 0; i < num_modules; i++) {
1407 PyObject *item = PyTuple_GET_ITEM(args, i);
1408 if (!PyObject_TypeCheck(item, &Module_type)) {
1409 return PyErr_Format(PyExc_TypeError,
1410 "expected Module, not %s",
1411 Py_TYPE(item)->tp_name);
1412 }
1413 modules[i] = ((Module *)item)->module;
1414 if (modules[i]->prog != &self->prog) {
1415 PyErr_SetString(PyExc_ValueError,
1416 "module from wrong program");
1417 return NULL;
1418 }
1419 }
1420
1421 struct drgn_error *err =
1422 drgn_load_module_debug_info(modules, &num_modules);
1423 if (err)
1424 return set_drgn_error(err);
1425 Py_RETURN_NONE;
1426 }
1427
1428 DEFINE_VECTOR(drgn_module_vector, struct drgn_module *);
1429
1430 static PyObject *Program_find_standard_debug_info(Program *self, PyObject *args,
1431 PyObject *kwds)
1432 {
1433 struct drgn_error *err;
1434 static char *keywords[] = {"modules", "options", NULL};
1435 PyObject *modules_obj;
1436 PyObject *options_obj = Py_None;
1437 if (!PyArg_ParseTupleAndKeywords(args, kwds,
1438 "O|O:find_standard_debug_info",
1439 keywords, &modules_obj, &options_obj))
1440 return NULL;
1441
1442 _cleanup_pydecref_ PyObject *it = PyObject_GetIter(modules_obj);
1443 if (!it)
1444 return NULL;
1445
1446 Py_ssize_t length_hint = PyObject_LengthHint(modules_obj, 1);
1447 if (length_hint == -1)
1448 return 0;
1449
1450 VECTOR(drgn_module_vector, modules);
1451 if (!drgn_module_vector_reserve(&modules, length_hint))
1452 return PyErr_NoMemory();
1453
1454 for (;;) {
1455 _cleanup_pydecref_ PyObject *item = PyIter_Next(it);
1456 if (!item)
1457 break;
1458
1459 if (!PyObject_TypeCheck(item, &Module_type)) {
1460 return PyErr_Format(PyExc_TypeError,
1461 "expected Module, not %s",
1462 Py_TYPE(item)->tp_name);
1463 }
1464 struct drgn_module *module = ((Module *)item)->module;
1465 if (module->prog != &self->prog) {
1466 PyErr_SetString(PyExc_ValueError,
1467 "module from wrong program");
1468 return NULL;
1469 }
1470 if (!drgn_module_vector_append(&modules, &module))
1471 return PyErr_NoMemory();
1472 }
1473 if (PyErr_Occurred())
1474 return NULL;
1475
1476 struct drgn_debug_info_options *options;
1477 if (options_obj == Py_None) {
1478 options = NULL;
1479 } else if (PyObject_TypeCheck(options_obj, &DebugInfoOptions_type)) {
1480 options = ((DebugInfoOptions *)options_obj)->options;
1481 } else {
1482 PyErr_SetString(PyExc_TypeError,
1483 "options must be DebugInfoOptions or None");
1484 return NULL;
1485 }
1486
1487 err = drgn_find_standard_debug_info(drgn_module_vector_begin(&modules),
1488 drgn_module_vector_size(&modules),
1489 options);
1490 if (err)
1491 return set_drgn_error(err);
1492 Py_RETURN_NONE;
1493 }
1494
1495 static PyObject *Program_read(Program *self, PyObject *args, PyObject *kwds)
1496 {
1497 static char *keywords[] = {"address", "size", "physical", NULL};
1498 struct drgn_error *err;
1499 struct index_arg address = {};
1500 Py_ssize_t size;
1501 int physical = 0;
1502 bool clear;
1503 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&n|p:read", keywords,
1504 index_converter, &address, &size,
1505 &physical))
1506 return NULL;
1507
1508 if (size < 0) {
1509 PyErr_SetString(PyExc_ValueError, "negative size");
1510 return NULL;
1511 }
1512 _cleanup_pydecref_ PyObject *buf =
1513 PyBytes_FromStringAndSize(NULL, size);
1514 if (!buf)
1515 return NULL;
1516 clear = set_drgn_in_python();
1517 err = drgn_program_read_memory(&self->prog, PyBytes_AS_STRING(buf),
1518 address.uvalue, size, physical);
1519 if (clear)
1520 clear_drgn_in_python();
1521 if (err)
1522 return set_drgn_error(err);
1523 return_ptr(buf);
1524 }
1525
1526 static PyObject *Program_read_c_string(Program *self, PyObject *args,
1527 PyObject *kwds)
1528 {
1529 static char *keywords[] = {"address", "physical", "max_size", NULL};
1530 struct drgn_error *err;
1531 struct index_arg address = {};
1532 int physical = 0;
1533 Py_ssize_t max_size = PY_SSIZE_T_MAX;
1534 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|p$n:read_c_string",
1535 keywords, index_converter, &address,
1536 &physical, &max_size))
1537 return NULL;
1538
1539 if (max_size < 0) {
1540 PyErr_SetString(PyExc_ValueError, "negative max_size");
1541 return NULL;
1542 }
1543 bool clear = set_drgn_in_python();
1544 _cleanup_free_ char *str = NULL;
1545 err = drgn_program_read_c_string(&self->prog, address.uvalue, physical,
1546 max_size, &str);
1547 if (clear)
1548 clear_drgn_in_python();
1549 if (err)
1550 return set_drgn_error(err);
1551 return PyBytes_FromString(str);
1552 }
1553
1554 #define METHOD_READ(x, type) \
1555 static PyObject *Program_read_##x(Program *self, PyObject *args, \
1556 PyObject *kwds) \
1557 { \
1558 static char *keywords[] = {"address", "physical", NULL}; \
1559 struct drgn_error *err; \
1560 struct index_arg address = {}; \
1561 int physical = 0; \
1562 type tmp; \
1563 \
1564 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|p:read_"#x, keywords, \
1565 index_converter, &address, &physical)) \
1566 return NULL; \
1567 \
1568 err = drgn_program_read_##x(&self->prog, address.uvalue, physical, \
1569 &tmp); \
1570 if (err) \
1571 return set_drgn_error(err); \
1572 if (sizeof(tmp) <= sizeof(unsigned long)) \
1573 return PyLong_FromUnsignedLong(tmp); \
1574 else \
1575 return PyLong_FromUnsignedLongLong(tmp); \
1576 }
1577 METHOD_READ(u8, uint8_t)
1578 METHOD_READ(u16, uint16_t)
1579 METHOD_READ(u32, uint32_t)
1580 METHOD_READ(u64, uint64_t)
1581 METHOD_READ(word, uint64_t)
1582 #undef METHOD_READ
1583
1584 static PyObject *Program_search_memory(Program *self, PyObject *args,
1585 PyObject *kwds)
1586 {
1587 struct drgn_error *err;
1588 static char *keywords[] = {"value", "alignment", NULL};
1589 PyObject *value_obj;
1590 PyObject *alignment_obj = Py_None;
1591 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|$O:search_memory",
1592 keywords, &value_obj, &alignment_obj))
1593 return NULL;
1594
1595 struct drgn_memory_search_iterator *it;
1596 if (PyObject_TypeCheck(value_obj, &PyBytes_Type)) {
1597 char *needle;
1598 Py_ssize_t size;
1599 if (PyBytes_AsStringAndSize(value_obj, &needle, &size))
1600 return NULL;
1601
1602 uint64_t alignment;
1603 if (alignment_obj == Py_None)
1604 alignment = 1;
1605 else if (PyLong_AsUInt64(alignment_obj, &alignment))
1606 return NULL;
1607
1608 err = drgn_program_search_memory(&self->prog, needle, size,
1609 alignment, &it);
1610 if (err)
1611 return set_drgn_error(err);
1612 } else if (PyObject_TypeCheck(value_obj, &PyUnicode_Type)) {
1613 Py_ssize_t size;
1614 const char *needle = PyUnicode_AsUTF8AndSize(value_obj, &size);
1615 if (!needle)
1616 return NULL;
1617
1618 uint64_t alignment;
1619 if (alignment_obj == Py_None)
1620 alignment = 1;
1621 else if (PyLong_AsUInt64(alignment_obj, &alignment))
1622 return NULL;
1623
1624 err = drgn_program_search_memory(&self->prog, needle, size,
1625 alignment, &it);
1626 if (err)
1627 return set_drgn_error(err);
1628 } else {
1629 if (alignment_obj != Py_None) {
1630 PyErr_SetString(PyExc_TypeError,
1631 "alignment is only allowed with bytes or str value");
1632 return NULL;
1633 }
1634 if (PyObject_TypeCheck(value_obj, &DrgnObject_type)) {
1635 err = drgn_search_memory_for_object(&((DrgnObject *)value_obj)->obj,
1636 &it);
1637 if (err)
1638 return set_drgn_error(err);
1639 } else if (PyIndex_Check(value_obj)) {
1640 uint64_t value;
1641 if (PyLong_AsUInt64(value_obj, &value))
1642 return NULL;
1643 err = drgn_program_search_memory_word(&self->prog,
1644 value, &it);
1645 if (err)
1646 return set_drgn_error(err);
1647 } else {
1648 return PyErr_Format(PyExc_TypeError,
1649 "value must be bytes, str, int, "
1650 "or drgn.Object, not %.200s",
1651 Py_TYPE(value_obj)->tp_name);
1652 }
1653 }
1654
1655 PyObject *ret =
1656 MemorySearchIterator_wrap(&MemorySearchIterator_type, it);
1657 if (!ret)
1658 drgn_memory_search_iterator_destroy(it);
1659 return ret;
1660 }
1661
1662 #define X(bits) \
1663 DEFINE_VECTOR(uint##bits##_vector, uint##bits##_t); \
1664 DEFINE_VECTOR(uint##bits##_range_vector, uint##bits##_t [2]); \
1665 static PyObject *Program_search_memory_u##bits(Program *self, PyObject *args, \
1666 PyObject *kwds) \
1667 { \
1668 struct drgn_error *err; \
1669 \
1670 static char *keywords[] = {"ignore_mask", NULL}; \
1671 _cleanup_pydecref_ PyObject *empty_tuple = PyTuple_New(0); \
1672 if (!empty_tuple) \
1673 return NULL; \
1674 PyObject *ignore_mask_obj = NULL; \
1675 if (!PyArg_ParseTupleAndKeywords(empty_tuple, kwds, \
1676 "|$O:search_memory_u" #bits, \
1677 keywords, &ignore_mask_obj)) \
1678 return NULL; \
1679 \
1680 VECTOR(uint##bits##_vector, values); \
1681 VECTOR(uint##bits##_range_vector, ranges); \
1682 \
1683 Py_ssize_t num_args = PyTuple_GET_SIZE(args); \
1684 for (Py_ssize_t i = 0; i < num_args; i++) { \
1685 PyObject *item = PyTuple_GET_ITEM(args, i); \
1686 if (PyTuple_Check(item)) { \
1687 if (PyTuple_GET_SIZE(item) != 2) { \
1688 PyErr_SetString(PyExc_TypeError, \
1689 "values must be int or (int, int)");\
1690 return NULL; \
1691 } \
1692 uint##bits##_t (*entry)[2] = \
1693 uint##bits##_range_vector_append_entry(&ranges);\
1694 if (!entry) \
1695 return PyErr_NoMemory(); \
1696 if (PyLong_AsUInt##bits(PyTuple_GET_ITEM(item, 0), \
1697 &(*entry)[0]) \
1698 || PyLong_AsUInt##bits(PyTuple_GET_ITEM(item, 1), \
1699 &(*entry)[1])) \
1700 return NULL; \
1701 } else { \
1702 uint##bits##_t *entry = \
1703 uint##bits##_vector_append_entry(&values); \
1704 if (!entry) \
1705 return PyErr_NoMemory(); \
1706 if (PyLong_AsUInt##bits(item, entry)) \
1707 return NULL; \
1708 } \
1709 } \
1710 \
1711 uint##bits##_t ignore_mask; \
1712 if (!ignore_mask_obj) \
1713 ignore_mask = 0; \
1714 else if (PyLong_AsUInt##bits(ignore_mask_obj, &ignore_mask)) \
1715 return NULL; \
1716 \
1717 struct drgn_memory_search_iterator *it; \
1718 err = drgn_program_search_memory_u##bits##_multi(&self->prog, \
1719 uint##bits##_vector_begin(&values), \
1720 uint##bits##_vector_size(&values), \
1721 ignore_mask, \
1722 uint##bits##_range_vector_begin(&ranges), \
1723 uint##bits##_range_vector_size(&ranges), &it); \
1724 if (err) \
1725 return set_drgn_error(err); \
1726 PyObject *ret = \
1727 MemorySearchIterator_wrap(&MemorySearchIteratorWithInt_type, \
1728 it); \
1729 if (!ret) \
1730 drgn_memory_search_iterator_destroy(it); \
1731 return ret; \
1732 }
1733 SEARCH_MEMORY_UINT_SIZES
1734 #undef X
1735
1736 static PyObject *Program_search_memory_word(Program *self, PyObject *args,
1737 PyObject *kwds)
1738 {
1739 struct drgn_error *err;
1740 bool is_64_bit;
1741 err = drgn_program_is_64_bit(&self->prog, &is_64_bit);
1742 if (err)
1743 return set_drgn_error(err);
1744 return (is_64_bit
1745 ? Program_search_memory_u64
1746 : Program_search_memory_u32)(self, args, kwds);
1747 }
1748
1749 static PyObject *Program_search_memory_regex(Program *self, PyObject *args,
1750 PyObject *kwds)
1751 {
1752 struct drgn_error *err;
1753 static char *keywords[] = {"pattern", NULL};
1754 PyObject *pattern_obj;
1755 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|$:search_memory_regex",
1756 keywords, &pattern_obj))
1757 return NULL;
1758
1759 const char *pattern;
1760 Py_ssize_t pattern_len;
1761 bool utf8;
1762 if (PyObject_TypeCheck(pattern_obj, &PyBytes_Type)) {
1763 if (PyBytes_AsStringAndSize(pattern_obj, (char **)&pattern,
1764 &pattern_len))
1765 return NULL;
1766 utf8 = false;
1767 } else if (PyObject_TypeCheck(pattern_obj, &PyUnicode_Type)) {
1768 pattern = PyUnicode_AsUTF8AndSize(pattern_obj, &pattern_len);
1769 if (!pattern)
1770 return NULL;
1771 utf8 = true;
1772 } else {
1773 PyErr_SetString(PyExc_TypeError,
1774 "pattern must be bytes or str");
1775 return NULL;
1776 }
1777
1778 struct drgn_memory_search_iterator *it;
1779 err = drgn_program_search_memory_regex(&self->prog, pattern,
1780 pattern_len, utf8, &it);
1781 if (err)
1782 return set_drgn_error(err);
1783 PyObject *ret =
1784 MemorySearchIterator_wrap(utf8
1785 ? &MemorySearchIteratorWithStr_type
1786 : &MemorySearchIteratorWithBytes_type,
1787 it);
1788 if (!ret)
1789 drgn_memory_search_iterator_destroy(it);
1790 return ret;
1791 }
1792
1793 static PyObject *Program_find_type(Program *self, PyObject *args, PyObject *kwds)
1794 {
1795 static char *keywords[] = {"name", "filename", NULL};
1796 struct drgn_error *err;
1797 PyObject *name_or_type;
1798 PATH_ARG(filename, .allow_none = true);
1799 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:type", keywords,
1800 &name_or_type, path_converter,
1801 &filename))
1802 return NULL;
1803
1804 if (PyObject_TypeCheck(name_or_type, &DrgnType_type)) {
1805 if (DrgnType_prog((DrgnType *)name_or_type) != self) {
1806 PyErr_SetString(PyExc_ValueError,
1807 "type is from different program");
1808 return NULL;
1809 }
1810 Py_INCREF(name_or_type);
1811 return name_or_type;
1812 } else if (!PyUnicode_Check(name_or_type)) {
1813 PyErr_SetString(PyExc_TypeError,
1814 "type() argument 1 must be str or Type");
1815 return NULL;
1816 }
1817
1818 const char *name = PyUnicode_AsUTF8(name_or_type);
1819 if (!name)
1820 return NULL;
1821 bool clear = set_drgn_in_python();
1822 struct drgn_qualified_type qualified_type;
1823 err = drgn_program_find_type(&self->prog, name, filename.path,
1824 &qualified_type);
1825 if (clear)
1826 clear_drgn_in_python();
1827 if (err) {
1828 set_drgn_error(err);
1829 return NULL;
1830 }
1831 return DrgnType_wrap(qualified_type);
1832 }
1833
1834 static void *set_object_not_found_error(struct drgn_error *err, PyObject *name)
1835 {
1836 _cleanup_pydecref_ PyObject *args = Py_BuildValue("(s)", err->message);
1837 drgn_error_destroy(err);
1838 if (!args)
1839 return NULL;
1840
1841 _cleanup_pydecref_ PyObject *kwargs =
1842 Py_BuildValue("{sO}", "name", name);
1843 if (!kwargs)
1844 return NULL;
1845
1846 _cleanup_pydecref_ PyObject *exc =
1847 PyObject_Call((PyObject *)&ObjectNotFoundError_type, args,
1848 kwargs);
1849 if (exc)
1850 PyErr_SetObject((PyObject *)&ObjectNotFoundError_type, exc);
1851 return NULL;
1852 }
1853
1854 static DrgnObject *Program_find_object(Program *self, PyObject *name_obj,
1855 const char *filename,
1856 enum drgn_find_object_flags flags)
1857 {
1858 struct drgn_error *err;
1859
1860 if (!PyUnicode_Check(name_obj)) {
1861 PyErr_Format(PyExc_TypeError, "name must be str, not %.200s",
1862 Py_TYPE(name_obj)->tp_name);
1863 return NULL;
1864 }
1865 const char *name = PyUnicode_AsUTF8(name_obj);
1866 if (!name)
1867 return NULL;
1868
1869 _cleanup_pydecref_ DrgnObject *ret = DrgnObject_alloc(self);
1870 if (!ret)
1871 return NULL;
1872 bool clear = set_drgn_in_python();
1873 err = drgn_program_find_object(&self->prog, name, filename, flags,
1874 &ret->obj);
1875 if (clear)
1876 clear_drgn_in_python();
1877 if (err && err->code == DRGN_ERROR_LOOKUP)
1878 return set_object_not_found_error(err, name_obj);
1879 else if (err)
1880 return set_drgn_error(err);
1881 return_ptr(ret);
1882 }
1883
1884 static DrgnObject *Program_object(Program *self, PyObject *args,
1885 PyObject *kwds)
1886 {
1887 static char *keywords[] = {"name", "flags", "filename", NULL};
1888 PyObject *name;
1889 struct enum_arg flags = {
1890 .type = FindObjectFlags_class,
1891 .value = DRGN_FIND_OBJECT_ANY,
1892 };
1893 PATH_ARG(filename, .allow_none = true);
1894 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&O&:object", keywords,
1895 &name, enum_converter, &flags,
1896 path_converter, &filename))
1897 return NULL;
1898
1899 return Program_find_object(self, name, filename.path, flags.value);
1900 }
1901
1902 static DrgnObject *Program_constant(Program *self, PyObject *args,
1903 PyObject *kwds)
1904 {
1905 static char *keywords[] = {"name", "filename", NULL};
1906 PyObject *name;
1907 PATH_ARG(filename, .allow_none = true);
1908 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:constant", keywords,
1909 &name, path_converter, &filename))
1910 return NULL;
1911
1912 return Program_find_object(self, name, filename.path,
1913 DRGN_FIND_OBJECT_CONSTANT);
1914 }
1915
1916 static DrgnObject *Program_function(Program *self, PyObject *args,
1917 PyObject *kwds)
1918 {
1919 static char *keywords[] = {"name", "filename", NULL};
1920 PyObject *name;
1921 PATH_ARG(filename, .allow_none = true);
1922 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:function", keywords,
1923 &name, path_converter, &filename))
1924 return NULL;
1925
1926 return Program_find_object(self, name, filename.path,
1927 DRGN_FIND_OBJECT_FUNCTION);
1928 }
1929
1930 static DrgnObject *Program_variable(Program *self, PyObject *args,
1931 PyObject *kwds)
1932 {
1933 static char *keywords[] = {"name", "filename", NULL};
1934 PyObject *name;
1935 PATH_ARG(filename, .allow_none = true);
1936 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O&:variable", keywords,
1937 &name, path_converter, &filename))
1938 return NULL;
1939
1940 return Program_find_object(self, name, filename.path,
1941 DRGN_FIND_OBJECT_VARIABLE);
1942 }
1943
1944 static PyObject *Program_stack_trace(Program *self, PyObject *args,
1945 PyObject *kwds)
1946 {
1947 static char *keywords[] = {"thread", NULL};
1948 struct drgn_error *err;
1949 PyObject *thread;
1950 struct drgn_stack_trace *trace;
1951
1952 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:stack_trace", keywords,
1953 &thread))
1954 return NULL;
1955
1956 if (PyObject_TypeCheck(thread, &DrgnObject_type)) {
1957 err = drgn_object_stack_trace(&((DrgnObject *)thread)->obj,
1958 &trace);
1959 } else {
1960 struct index_arg tid = {};
1961
1962 if (!index_converter(thread, &tid))
1963 return NULL;
1964 err = drgn_program_stack_trace(&self->prog, tid.uvalue, &trace);
1965 }
1966 if (err)
1967 return set_drgn_error(err);
1968
1969 PyObject *ret = StackTrace_wrap(trace);
1970 if (!ret)
1971 drgn_stack_trace_destroy(trace);
1972 return ret;
1973 }
1974
1975 static PyObject *Program_stack_trace_from_pcs(Program *self, PyObject *args,
1976 PyObject *kwds)
1977 {
1978 static char *keywords[] = {"pcs", NULL};
1979 struct drgn_error *err;
1980 PyObject *pypcs;
1981 struct drgn_stack_trace *trace;
1982
1983 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:stack_trace_from_pcs",
1984 keywords, &pypcs))
1985 return NULL;
1986
1987 _cleanup_pydecref_ PyObject *pypcseq = PySequence_Fast(
1988 pypcs, "stack_trace_from_pcs() argument 1 must be a list");
1989 if (!pypcseq)
1990 return NULL;
1991
1992 size_t size = PySequence_Fast_GET_SIZE(pypcseq);
1993 _cleanup_free_ uint64_t *pcs = malloc_array(size, sizeof(uint64_t));
1994 for (uint64_t i = 0; i != size; ++i) {
1995 struct index_arg pc = {};
1996
1997 if (!index_converter(PySequence_Fast_GET_ITEM(pypcseq, i), &pc))
1998 return NULL;
1999 pcs[i] = pc.uvalue;
2000 }
2001
2002 err = drgn_program_stack_trace_from_pcs(&self->prog, pcs, size, &trace);
2003 if (err)
2004 return set_drgn_error(err);
2005
2006 PyObject *ret = StackTrace_wrap(trace);
2007 if (!ret)
2008 drgn_stack_trace_destroy(trace);
2009 return ret;
2010 }
2011
2012 static PyObject *Program_source_location(Program *self, PyObject *arg)
2013 {
2014 struct drgn_error *err;
2015
2016 struct drgn_source_location_list *locs;
2017 if (PyUnicode_Check(arg)) {
2018 const char *address_str = PyUnicode_AsUTF8(arg);
2019 if (!address_str)
2020 return NULL;
2021 err = drgn_program_addr2line(&self->prog, address_str, &locs);
2022 } else {
2023 struct index_arg address = {};
2024 if (!index_converter(arg, &address))
2025 return NULL;
2026 err = drgn_program_source_location(&self->prog, address.uvalue,
2027 &locs);
2028 }
2029 if (err)
2030 return set_drgn_error(err);
2031
2032 PyObject *ret = SourceLocationList_wrap(locs);
2033 if (!ret)
2034 drgn_source_location_list_destroy(locs);
2035 return ret;
2036 }
2037
2038 static PyObject *Program_symbols(Program *self, PyObject *args)
2039 {
2040 struct drgn_error *err;
2041
2042 PyObject *arg = Py_None;
2043 if (!PyArg_ParseTuple(args, "|O:symbols", &arg))
2044 return NULL;
2045
2046 struct drgn_symbol **symbols;
2047 size_t count;
2048 if (arg == Py_None) {
2049 err = drgn_program_find_symbols_by_name(&self->prog, NULL,
2050 &symbols, &count);
2051 } else if (PyUnicode_Check(arg)) {
2052 const char *name = PyUnicode_AsUTF8(arg);
2053 if (!name)
2054 return NULL;
2055 err = drgn_program_find_symbols_by_name(&self->prog, name,
2056 &symbols, &count);
2057 } else {
2058 struct index_arg address = {};
2059 if (!index_converter(arg, &address))
2060 return NULL;
2061 err = drgn_program_find_symbols_by_address(&self->prog,
2062 address.uvalue,
2063 &symbols, &count);
2064 }
2065 if (err)
2066 return set_drgn_error(err);
2067
2068 return Symbol_list_wrap(symbols, count, (PyObject *)self);
2069 }
2070
2071 static PyObject *Program_symbol(Program *self, PyObject *arg)
2072 {
2073 struct drgn_error *err;
2074 struct drgn_symbol *sym;
2075 PyObject *ret;
2076
2077 if (PyUnicode_Check(arg)) {
2078 const char *name;
2079
2080 name = PyUnicode_AsUTF8(arg);
2081 if (!name)
2082 return NULL;
2083 err = drgn_program_find_symbol_by_name(&self->prog, name, &sym);
2084 } else {
2085 struct index_arg address = {};
2086
2087 if (!index_converter(arg, &address))
2088 return NULL;
2089 err = drgn_program_find_symbol_by_address(&self->prog,
2090 address.uvalue, &sym);
2091 }
2092 if (err)
2093 return set_drgn_error(err);
2094 ret = Symbol_wrap(sym, (PyObject *)self);
2095 if (!ret) {
2096 drgn_symbol_destroy(sym);
2097 return NULL;
2098 }
2099 return ret;
2100 }
2101
2102 static ThreadIterator *Program_threads(Program *self)
2103 {
2104 struct drgn_thread_iterator *it;
2105 struct drgn_error *err = drgn_thread_iterator_create(&self->prog, &it);
2106 if (err)
2107 return set_drgn_error(err);
2108 ThreadIterator *ret = call_tp_alloc(ThreadIterator);
2109 if (!ret) {
2110 drgn_thread_iterator_destroy(it);
2111 return NULL;
2112 }
2113 ret->prog = self;
2114 ret->iterator = it;
2115 Py_INCREF(self);
2116 return ret;
2117 }
2118
2119 static PyObject *Program_thread(Program *self, PyObject *args, PyObject *kwds)
2120 {
2121 static char *keywords[] = {"tid", NULL};
2122 struct drgn_error *err;
2123 struct index_arg tid = {};
2124
2125 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&:thread", keywords,
2126 index_converter, &tid))
2127 return NULL;
2128
2129 struct drgn_thread *thread;
2130 err = drgn_program_find_thread(&self->prog, tid.uvalue, &thread);
2131 if (err)
2132 return set_drgn_error(err);
2133 if (!thread) {
2134 return PyErr_Format(PyExc_LookupError,
2135 "thread with ID %llu not found",
2136 tid.uvalue);
2137 }
2138 PyObject *ret = Thread_wrap(thread);
2139 drgn_thread_destroy(thread);
2140 return ret;
2141 }
2142
2143 static PyObject *Program_main_thread(Program *self)
2144 {
2145 struct drgn_error *err;
2146 struct drgn_thread *thread;
2147 err = drgn_program_main_thread(&self->prog, &thread);
2148 if (err)
2149 return set_drgn_error(err);
2150 return Thread_wrap(thread);
2151 }
2152
2153 static PyObject *Program_crashed_thread(Program *self)
2154 {
2155 struct drgn_error *err;
2156 struct drgn_thread *thread;
2157 err = drgn_program_crashed_thread(&self->prog, &thread);
2158 if (err)
2159 return set_drgn_error(err);
2160 return Thread_wrap(thread);
2161 }
2162
2163 static PyObject *Program_address_size(Program *self)
2164 {
2165 struct drgn_error *err;
2166 uint64_t address_size;
2167 err = drgn_program_address_size(&self->prog, &address_size);
2168 if (err)
2169 return set_drgn_error(err);
2170 return PyLong_FromUInt64(address_size);
2171 }
2172
2173 // Used for testing.
2174 static PyObject *Program__log(Program *self, PyObject *args, PyObject *kwds)
2175 {
2176 int level;
2177 const char *str;
2178 if (!PyArg_ParseTuple(args, "is", &level, &str))
2179 return NULL;
2180 drgn_log(level, &self->prog, "%s", str);
2181 Py_RETURN_NONE;
2182 }
2183
2184 static DrgnObject *Program_subscript(Program *self, PyObject *key)
2185 {
2186 if (!PyUnicode_Check(key)) {
2187 PyErr_SetObject(PyExc_KeyError, key);
2188 return NULL;
2189 }
2190 return Program_find_object(self, key, NULL, DRGN_FIND_OBJECT_ANY);
2191 }
2192
2193 static int Program_contains(Program *self, PyObject *key)
2194 {
2195 struct drgn_error *err;
2196
2197 if (!PyUnicode_Check(key)) {
2198 PyErr_SetObject(PyExc_KeyError, key);
2199 return 0;
2200 }
2201
2202 const char *name = PyUnicode_AsUTF8(key);
2203 if (!name)
2204 return -1;
2205
2206 DRGN_OBJECT(tmp, &self->prog);
2207 bool clear = set_drgn_in_python();
2208 err = drgn_program_find_object(&self->prog, name, NULL,
2209 DRGN_FIND_OBJECT_ANY, &tmp);
2210 if (clear)
2211 clear_drgn_in_python();
2212 if (err) {
2213 if (err->code == DRGN_ERROR_LOOKUP) {
2214 drgn_error_destroy(err);
2215 return 0;
2216 } else {
2217 set_drgn_error(err);
2218 return -1;
2219 }
2220 }
2221 return 1;
2222 }
2223
2224 static PyObject *Program_get_flags(Program *self, void *arg)
2225 {
2226 return PyObject_CallFunction(ProgramFlags_class, "k",
2227 (unsigned long)self->prog.flags);
2228 }
2229
2230 static PyObject *Program_get_platform(Program *self, void *arg)
2231 {
2232 const struct drgn_platform *platform;
2233
2234 platform = drgn_program_platform(&self->prog);
2235 if (platform)
2236 return Platform_wrap(platform);
2237 else
2238 Py_RETURN_NONE;
2239 }
2240
2241 static PyObject *Program_get_core_dump_path(Program *self, void *arg)
2242 {
2243 const char *path = drgn_program_core_dump_path(&self->prog);
2244 if (!path)
2245 Py_RETURN_NONE;
2246 return PyUnicode_FromString(path);
2247 }
2248
2249 static PyObject *Program_get_language(Program *self, void *arg)
2250 {
2251 return Language_wrap(drgn_program_language(&self->prog));
2252 }
2253
2254 static int Program_set_language(Program *self, PyObject *value, void *arg)
2255 {
2256 SETTER_NO_DELETE("language", value);
2257 if (!PyObject_TypeCheck(value, &Language_type)) {
2258 PyErr_SetString(PyExc_TypeError, "language must be Language");
2259 return -1;
2260 }
2261 drgn_program_set_language(&self->prog, ((Language *)value)->language);
2262 return 0;
2263 }
2264
2265 #define PROGRAM_FINDER_METHOD_DEFS(which) \
2266 {"register_" #which "_finder", \
2267 (PyCFunction)Program_register_##which##_finder, \
2268 METH_VARARGS | METH_KEYWORDS, \
2269 drgn_Program_register_##which##_finder_DOC}, \
2270 {"registered_" #which "_finders", \
2271 (PyCFunction)Program_registered_##which##_finders, METH_NOARGS, \
2272 drgn_Program_registered_##which##_finders_DOC}, \
2273 {"set_enabled_" #which "_finders", \
2274 (PyCFunction)Program_set_enabled_##which##_finders, \
2275 METH_VARARGS | METH_KEYWORDS, \
2276 drgn_Program_set_enabled_##which##_finders_DOC}, \
2277 {"enabled_" #which "_finders", \
2278 (PyCFunction)Program_enabled_##which##_finders, METH_NOARGS, \
2279 drgn_Program_enabled_##which##_finders_DOC}
2280
2281 static PyMethodDef Program_methods[] = {
2282 {"add_memory_segment", (PyCFunction)Program_add_memory_segment,
2283 METH_VARARGS | METH_KEYWORDS, drgn_Program_add_memory_segment_DOC},
2284 PROGRAM_FINDER_METHOD_DEFS(debug_info),
2285 PROGRAM_FINDER_METHOD_DEFS(type),
2286 PROGRAM_FINDER_METHOD_DEFS(object),
2287 PROGRAM_FINDER_METHOD_DEFS(symbol),
2288 {"add_type_finder", (PyCFunction)Program_add_type_finder,
2289 METH_VARARGS | METH_KEYWORDS, drgn_Program_add_type_finder_DOC},
2290 {"add_object_finder", (PyCFunction)Program_add_object_finder,
2291 METH_VARARGS | METH_KEYWORDS, drgn_Program_add_object_finder_DOC},
2292 {"set_core_dump", (PyCFunction)Program_set_core_dump,
2293 METH_VARARGS | METH_KEYWORDS, drgn_Program_set_core_dump_DOC},
2294 {"set_kernel", (PyCFunction)Program_set_kernel, METH_NOARGS,
2295 drgn_Program_set_kernel_DOC},
2296 {"set_linux_kernel_custom", (PyCFunction)Program_set_linux_kernel_custom,
2297 METH_VARARGS | METH_KEYWORDS, drgn_Program_set_linux_kernel_custom_DOC},
2298 {"set_pid", (PyCFunction)Program_set_pid, METH_VARARGS | METH_KEYWORDS,
2299 drgn_Program_set_pid_DOC},
2300 {"set_qemu_qmp", (PyCFunction)Program_set_qemu_qmp,
2301 METH_VARARGS | METH_KEYWORDS, drgn_Program_set_qemu_qmp_DOC},
2302 {"modules", (PyCFunction)Program_modules, METH_NOARGS,
2303 drgn_Program_modules_DOC},
2304 {"loaded_modules", (PyCFunction)Program_loaded_modules, METH_NOARGS,
2305 drgn_Program_loaded_modules_DOC},
2306 {"create_loaded_modules", (PyCFunction)Program_create_loaded_modules,
2307 METH_NOARGS, drgn_Program_create_loaded_modules_DOC},
2308 {"main_module", (PyCFunction)Program_main_module,
2309 METH_VARARGS | METH_KEYWORDS, drgn_Program_main_module_DOC},
2310 {"shared_library_module", (PyCFunction)Program_shared_library_module,
2311 METH_VARARGS | METH_KEYWORDS, drgn_Program_shared_library_module_DOC},
2312 {"vdso_module", (PyCFunction)Program_vdso_module,
2313 METH_VARARGS | METH_KEYWORDS, drgn_Program_vdso_module_DOC},
2314 {"relocatable_module", (PyCFunction)Program_relocatable_module,
2315 METH_VARARGS | METH_KEYWORDS, drgn_Program_relocatable_module_DOC},
2316 {"linux_kernel_loadable_module",
2317 (PyCFunction)Program_linux_kernel_loadable_module,
2318 METH_VARARGS | METH_KEYWORDS,
2319 drgn_Program_linux_kernel_loadable_module_DOC},
2320 {"extra_module", (PyCFunction)Program_extra_module,
2321 METH_VARARGS | METH_KEYWORDS, drgn_Program_extra_module_DOC},
2322 {"module", (PyCFunction)Program_module, METH_O,
2323 drgn_Program_module_DOC},
2324 {"load_debug_info", (PyCFunction)Program_load_debug_info,
2325 METH_VARARGS | METH_KEYWORDS, drgn_Program_load_debug_info_DOC},
2326 {"load_default_debug_info",
2327 (PyCFunction)Program_load_default_debug_info, METH_NOARGS,
2328 drgn_Program_load_default_debug_info_DOC},
2329 {"load_module_debug_info", (PyCFunction)Program_load_module_debug_info,
2330 METH_VARARGS, drgn_Program_load_module_debug_info_DOC},
2331 {"find_standard_debug_info",
2332 (PyCFunction)Program_find_standard_debug_info,
2333 METH_VARARGS | METH_KEYWORDS,
2334 drgn_Program_find_standard_debug_info_DOC},
2335 {"__getitem__", (PyCFunction)Program_subscript, METH_O | METH_COEXIST,
2336 drgn_Program___getitem___DOC},
2337 {"__contains__", (PyCFunction)Program_contains, METH_O | METH_COEXIST,
2338 drgn_Program___contains___DOC},
2339 {"read", (PyCFunction)Program_read, METH_VARARGS | METH_KEYWORDS,
2340 drgn_Program_read_DOC},
2341 {"read_c_string", (PyCFunction)Program_read_c_string,
2342 METH_VARARGS | METH_KEYWORDS, drgn_Program_read_c_string_DOC},
2343 #define METHOD_DEF_READ(x) \
2344 {"read_"#x, (PyCFunction)Program_read_##x, \
2345 METH_VARARGS | METH_KEYWORDS, drgn_Program_read_##x##_DOC}
2346 METHOD_DEF_READ(u8),
2347 METHOD_DEF_READ(u16),
2348 METHOD_DEF_READ(u32),
2349 METHOD_DEF_READ(u64),
2350 METHOD_DEF_READ(word),
2351 #undef METHOD_READ_U
2352 {"search_memory", (PyCFunction)Program_search_memory,
2353 METH_VARARGS | METH_KEYWORDS, drgn_Program_search_memory_DOC},
2354 #define X(bits) \
2355 {"search_memory_u" #bits, (PyCFunction)Program_search_memory_u##bits, \
2356 METH_VARARGS | METH_KEYWORDS, \
2357 drgn_Program_search_memory_u##bits##_DOC},
2358 SEARCH_MEMORY_UINT_SIZES
2359 #undef X
2360 {"search_memory_word", (PyCFunction)Program_search_memory_word,
2361 METH_VARARGS | METH_KEYWORDS, drgn_Program_search_memory_word_DOC},
2362 {"search_memory_regex", (PyCFunction)Program_search_memory_regex,
2363 METH_VARARGS | METH_KEYWORDS, drgn_Program_search_memory_regex_DOC},
2364 {"type", (PyCFunction)Program_find_type, METH_VARARGS | METH_KEYWORDS,
2365 drgn_Program_type_DOC},
2366 {"object", (PyCFunction)Program_object, METH_VARARGS | METH_KEYWORDS,
2367 drgn_Program_object_DOC},
2368 {"constant", (PyCFunction)Program_constant,
2369 METH_VARARGS | METH_KEYWORDS, drgn_Program_constant_DOC},
2370 {"function", (PyCFunction)Program_function,
2371 METH_VARARGS | METH_KEYWORDS, drgn_Program_function_DOC},
2372 {"variable", (PyCFunction)Program_variable,
2373 METH_VARARGS | METH_KEYWORDS, drgn_Program_variable_DOC},
2374 {"stack_trace", (PyCFunction)Program_stack_trace,
2375 METH_VARARGS | METH_KEYWORDS, drgn_Program_stack_trace_DOC},
2376 {"stack_trace_from_pcs", (PyCFunction)Program_stack_trace_from_pcs,
2377 METH_VARARGS | METH_KEYWORDS, drgn_Program_stack_trace_from_pcs_DOC},
2378 {"source_location", (PyCFunction)Program_source_location, METH_O,
2379 drgn_Program_source_location_DOC},
2380 {"symbols", (PyCFunction)Program_symbols, METH_VARARGS,
2381 drgn_Program_symbols_DOC},
2382 {"symbol", (PyCFunction)Program_symbol, METH_O,
2383 drgn_Program_symbol_DOC},
2384 {"threads", (PyCFunction)Program_threads, METH_NOARGS,
2385 drgn_Program_threads_DOC},
2386 {"thread", (PyCFunction)Program_thread,
2387 METH_VARARGS | METH_KEYWORDS, drgn_Program_thread_DOC},
2388 {"main_thread", (PyCFunction)Program_main_thread, METH_NOARGS,
2389 drgn_Program_main_thread_DOC},
2390 {"crashed_thread", (PyCFunction)Program_crashed_thread, METH_NOARGS,
2391 drgn_Program_crashed_thread_DOC},
2392 {"address_size", (PyCFunction)Program_address_size, METH_NOARGS,
2393 drgn_Program_address_size_DOC},
2394 {"void_type", (PyCFunction)Program_void_type,
2395 METH_VARARGS | METH_KEYWORDS, drgn_Program_void_type_DOC},
2396 {"int_type", (PyCFunction)Program_int_type,
2397 METH_VARARGS | METH_KEYWORDS, drgn_Program_int_type_DOC},
2398 {"bool_type", (PyCFunction)Program_bool_type,
2399 METH_VARARGS | METH_KEYWORDS, drgn_Program_bool_type_DOC},
2400 {"float_type", (PyCFunction)Program_float_type,
2401 METH_VARARGS | METH_KEYWORDS, drgn_Program_float_type_DOC},
2402 {"struct_type", (PyCFunction)Program_struct_type,
2403 METH_VARARGS | METH_KEYWORDS, drgn_Program_struct_type_DOC},
2404 {"union_type", (PyCFunction)Program_union_type,
2405 METH_VARARGS | METH_KEYWORDS, drgn_Program_union_type_DOC},
2406 {"class_type", (PyCFunction)Program_class_type,
2407 METH_VARARGS | METH_KEYWORDS, drgn_Program_class_type_DOC},
2408 {"enum_type", (PyCFunction)Program_enum_type,
2409 METH_VARARGS | METH_KEYWORDS, drgn_Program_enum_type_DOC},
2410 {"typedef_type", (PyCFunction)Program_typedef_type,
2411 METH_VARARGS | METH_KEYWORDS, drgn_Program_typedef_type_DOC},
2412 {"pointer_type", (PyCFunction)Program_pointer_type,
2413 METH_VARARGS | METH_KEYWORDS, drgn_Program_pointer_type_DOC},
2414 {"array_type", (PyCFunction)Program_array_type,
2415 METH_VARARGS | METH_KEYWORDS, drgn_Program_array_type_DOC},
2416 {"function_type", (PyCFunction)Program_function_type,
2417 METH_VARARGS | METH_KEYWORDS, drgn_Program_function_type_DOC},
2418 {"_log", (PyCFunction)Program__log, METH_VARARGS},
2419 {},
2420 };
2421
2422 static PyMemberDef Program_members[] = {
2423 {"cache", T_OBJECT_EX, offsetof(Program, cache), 0,
2424 drgn_Program_cache_DOC},
2425 {"config", T_OBJECT_EX, offsetof(Program, config), 0,
2426 drgn_Program_config_DOC},
2427 {},
2428 };
2429
2430 static PyGetSetDef Program_getset[] = {
2431 {"flags", (getter)Program_get_flags, NULL, drgn_Program_flags_DOC},
2432 {"platform", (getter)Program_get_platform, NULL,
2433 drgn_Program_platform_DOC},
2434 {"core_dump_path", (getter)Program_get_core_dump_path, NULL,
2435 drgn_Program_core_dump_path_DOC},
2436 {"language", (getter)Program_get_language, (setter)Program_set_language,
2437 drgn_Program_language_DOC},
2438 {"debug_info_options", (getter)Program_get_debug_info_options,
2439 (setter)Program_set_debug_info_options,
2440 drgn_Program_debug_info_options_DOC},
2441 {},
2442 };
2443
2444 static PyMappingMethods Program_as_mapping = {
2445 .mp_subscript = (binaryfunc)Program_subscript,
2446 };
2447
2448 static PySequenceMethods Program_as_sequence = {
2449 .sq_contains = (objobjproc)Program_contains,
2450 };
2451
2452 PyTypeObject Program_type = {
2453 PyVarObject_HEAD_INIT(NULL, 0)
2454 .tp_name = "_drgn.Program",
2455 .tp_basicsize = sizeof(Program),
2456 .tp_dealloc = (destructor)Program_dealloc,
2457 .tp_as_sequence = &Program_as_sequence,
2458 .tp_as_mapping = &Program_as_mapping,
2459 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
2460 .tp_doc = drgn_Program_DOC,
2461 .tp_traverse = (traverseproc)Program_traverse,
2462 .tp_clear = (inquiry)Program_clear,
2463 .tp_methods = Program_methods,
2464 .tp_members = Program_members,
2465 .tp_getset = Program_getset,
2466 .tp_new = (newfunc)Program_new,
2467 };
2468
2469 Program *program_from_core_dump(PyObject *self, PyObject *args, PyObject *kwds)
2470 {
2471 static char *keywords[] = {"path", NULL};
2472 struct drgn_error *err;
2473 PATH_ARG(path, .allow_fd = true);
2474 if (!PyArg_ParseTupleAndKeywords(args, kwds,
2475 "O&:program_from_core_dump", keywords,
2476 path_converter, &path))
2477 return NULL;
2478
2479 _cleanup_pydecref_ Program *prog =
2480 (Program *)PyObject_CallObject((PyObject *)&Program_type, NULL);
2481 if (!prog)
2482 return NULL;
2483
2484 if (path.fd >= 0)
2485 err = drgn_program_init_core_dump_fd(&prog->prog, path.fd);
2486 else
2487 err = drgn_program_init_core_dump(&prog->prog, path.path);
2488 if (err)
2489 return set_drgn_error(err);
2490 return_ptr(prog);
2491 }
2492
2493 Program *program_from_kernel(PyObject *self)
2494 {
2495 struct drgn_error *err;
2496 _cleanup_pydecref_ Program *prog =
2497 (Program *)PyObject_CallObject((PyObject *)&Program_type, NULL);
2498 if (!prog)
2499 return NULL;
2500 err = drgn_program_init_kernel(&prog->prog);
2501 if (err)
2502 return set_drgn_error(err);
2503 return_ptr(prog);
2504 }
2505
2506 Program *program_from_pid(PyObject *self, PyObject *args, PyObject *kwds)
2507 {
2508 struct drgn_error *err;
2509 static char *keywords[] = {"pid", NULL};
2510 int pid;
2511 if (!PyArg_ParseTupleAndKeywords(args, kwds, "i:program_from_pid",
2512 keywords, &pid))
2513 return NULL;
2514
2515 _cleanup_pydecref_ Program *prog =
2516 (Program *)PyObject_CallObject((PyObject *)&Program_type, NULL);
2517 if (!prog)
2518 return NULL;
2519 err = drgn_program_init_pid(&prog->prog, pid);
2520 if (err)
2521 return set_drgn_error(err);
2522 return_ptr(prog);
2523 }