Debian Codegraph @

libdrgn/python/stack_trace.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 "../stack_trace.h"
6 #include "../util.h"
7
8 PyObject *StackTrace_wrap(struct drgn_stack_trace *trace) {
9 StackTrace *ret = call_tp_alloc(StackTrace);
10 if (!ret)
11 return NULL;
12 Py_INCREF(container_of(trace->prog, Program, prog));
13 ret->trace = trace;
14 return (PyObject *)ret;
15 }
16
17 static void StackTrace_dealloc(StackTrace *self)
18 {
19 PyObject_GC_UnTrack(self);
20 if (self->trace) {
21 struct drgn_program *prog = self->trace->prog;
22 drgn_stack_trace_destroy(self->trace);
23 Py_DECREF(container_of(prog, Program, prog));
24 }
25 Py_TYPE(self)->tp_free((PyObject *)self);
26 }
27
28 static int StackTrace_traverse(StackTrace *self, visitproc visit, void *arg)
29 {
30 if (self->trace)
31 Py_VISIT(container_of(self->trace->prog, Program, prog));
32 return 0;
33 }
34
35 static Program *StackTrace_get_prog(StackTrace *self, void *arg)
36 {
37 Program *prog = container_of(drgn_stack_trace_program(self->trace),
38 Program, prog);
39 Py_INCREF(prog);
40 return prog;
41 }
42
43 static PyObject *StackTrace_str(StackTrace *self)
44 {
45 struct drgn_error *err;
46 _cleanup_free_ char *str = NULL;
47 err = drgn_format_stack_trace(self->trace, &str);
48 if (err)
49 return set_drgn_error(err);
50 return PyUnicode_FromString(str);
51 }
52
53 static Py_ssize_t StackTrace_length(StackTrace *self)
54 {
55 return drgn_stack_trace_num_frames(self->trace);
56 }
57
58 static StackFrame *StackTrace_item(StackTrace *self, Py_ssize_t i)
59 {
60 if (i < 0 || i >= drgn_stack_trace_num_frames(self->trace)) {
61 PyErr_SetString(PyExc_IndexError,
62 "stack frame index out of range");
63 return NULL;
64 }
65 StackFrame *ret = call_tp_alloc(StackFrame);
66 if (!ret)
67 return NULL;
68 ret->i = i;
69 ret->trace = self;
70 Py_INCREF(self);
71 return ret;
72 }
73
74 static PyMethodDef StackTrace_methods[] = {
75 {"_repr_pretty_", (PyCFunction)repr_pretty_from_str,
76 METH_VARARGS | METH_KEYWORDS},
77 {},
78 };
79
80 static PySequenceMethods StackTrace_as_sequence = {
81 .sq_length = (lenfunc)StackTrace_length,
82 .sq_item = (ssizeargfunc)StackTrace_item,
83 };
84
85 static PyGetSetDef StackTrace_getset[] = {
86 {"prog", (getter)StackTrace_get_prog, NULL, drgn_StackTrace_prog_DOC},
87 {},
88 };
89
90 PyTypeObject StackTrace_type = {
91 PyVarObject_HEAD_INIT(NULL, 0)
92 .tp_name = "_drgn.StackTrace",
93 .tp_basicsize = sizeof(StackTrace),
94 .tp_dealloc = (destructor)StackTrace_dealloc,
95 .tp_as_sequence = &StackTrace_as_sequence,
96 .tp_str = (reprfunc)StackTrace_str,
97 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
98 .tp_doc = drgn_StackTrace_DOC,
99 .tp_traverse = (traverseproc)StackTrace_traverse,
100 .tp_methods = StackTrace_methods,
101 .tp_getset = StackTrace_getset,
102 };
103
104 static void StackFrame_dealloc(StackFrame *self)
105 {
106 PyObject_GC_UnTrack(self);
107 Py_XDECREF(self->trace);
108 Py_TYPE(self)->tp_free((PyObject *)self);
109 }
110
111 static int StackFrame_traverse(StackFrame *self, visitproc visit, void *arg)
112 {
113 Py_VISIT(self->trace);
114 return 0;
115 }
116
117 static PyObject *StackFrame_str(StackFrame *self)
118 {
119 struct drgn_error *err;
120 _cleanup_free_ char *str = NULL;
121 err = drgn_format_stack_frame(self->trace->trace, self->i, &str);
122 if (err)
123 return set_drgn_error(err);
124 return PyUnicode_FromString(str);
125 }
126
127 static PyObject *StackFrame_locals(StackFrame *self)
128 {
129 struct drgn_error *err;
130 const char **names;
131 size_t count;
132 err = drgn_stack_frame_locals(self->trace->trace, self->i, &names,
133 &count);
134 if (err)
135 return set_drgn_error(err);
136
137 _cleanup_pydecref_ PyObject *list = PyList_New(count);
138 if (!list) {
139 drgn_stack_frame_locals_destroy(names, count);
140 return NULL;
141 }
142 for (size_t i = 0; i < count; i++) {
143 PyObject *string = PyUnicode_FromString(names[i]);
144 if (!string) {
145 drgn_stack_frame_locals_destroy(names, count);
146 return NULL;
147 }
148 PyList_SET_ITEM(list, i, string);
149 }
150 drgn_stack_frame_locals_destroy(names, count);
151 return_ptr(list);
152 }
153
154 static DrgnObject *StackFrame_subscript(StackFrame *self, PyObject *key)
155 {
156 struct drgn_error *err;
157 Program *prog = container_of(self->trace->trace->prog, Program, prog);
158 if (!PyUnicode_Check(key)) {
159 PyErr_SetObject(PyExc_KeyError, key);
160 return NULL;
161 }
162 const char *name = PyUnicode_AsUTF8(key);
163 if (!name)
164 return NULL;
165 _cleanup_pydecref_ DrgnObject *ret = DrgnObject_alloc(prog);
166 if (!ret)
167 return NULL;
168 bool clear = set_drgn_in_python();
169 err = drgn_stack_frame_find_object(self->trace->trace, self->i, name,
170 &ret->obj);
171 if (clear)
172 clear_drgn_in_python();
173 if (err) {
174 if (err->code == DRGN_ERROR_LOOKUP) {
175 drgn_error_destroy(err);
176 PyErr_SetObject(PyExc_KeyError, key);
177 } else {
178 set_drgn_error(err);
179 }
180 return NULL;
181 }
182 return_ptr(ret);
183 }
184
185 static int StackFrame_contains(StackFrame *self, PyObject *key)
186 {
187 struct drgn_error *err;
188 if (!PyUnicode_Check(key)) {
189 PyErr_SetObject(PyExc_KeyError, key);
190 return -1;
191 }
192 const char *name = PyUnicode_AsUTF8(key);
193 if (!name)
194 return -1;
195 DRGN_OBJECT(tmp, self->trace->trace->prog);
196 err = drgn_stack_frame_find_object(self->trace->trace, self->i, name,
197 &tmp);
198 if (!err) {
199 return 1;
200 } else if (err->code == DRGN_ERROR_LOOKUP) {
201 drgn_error_destroy(err);
202 return 0;
203 } else {
204 return -1;
205 }
206 }
207
208 static PyObject *StackFrame_source_name(StackFrame *self)
209 {
210 _cleanup_free_ char *str = NULL;
211 struct drgn_error *err =
212 drgn_stack_frame_source_name(self->trace->trace, self->i,
213 &str);
214 if (err)
215 return set_drgn_error(err);
216 if (!str)
217 Py_RETURN_NONE;
218 return PyUnicode_FromString(str);
219 }
220
221 static PyObject *StackFrame_source(StackFrame *self)
222 {
223 int line;
224 int column;
225 const char *filename = drgn_stack_frame_source(self->trace->trace,
226 self->i, &line, &column);
227 if (!filename) {
228 PyErr_SetString(PyExc_LookupError,
229 "source code location not available");
230 return NULL;
231 }
232
233 static PyMethodDef meth = {
234 .ml_name = "name",
235 .ml_meth = (PyCFunction)StackFrame_source_name,
236 .ml_flags = METH_NOARGS,
237 };
238 return PyObject_CallFunction(SourceLocation_type, "siiN", filename,
239 line, column,
240 PyCFunction_New(&meth, (PyObject *)self));
241 }
242
243 static PyObject *StackFrame_symbol(StackFrame *self)
244 {
245 struct drgn_error *err;
246 Program *prog = container_of(self->trace->trace->prog, Program, prog);
247 struct drgn_symbol *sym;
248 err = drgn_stack_frame_symbol(self->trace->trace, self->i, &sym);
249 if (err)
250 return set_drgn_error(err);
251 PyObject *ret = Symbol_wrap(sym, (PyObject *)prog);
252 if (!ret) {
253 drgn_symbol_destroy(sym);
254 return NULL;
255 }
256 return ret;
257 }
258
259 static PyObject *StackFrame_register(StackFrame *self, PyObject *arg)
260 {
261 const char *name = PyUnicode_AsUTF8(arg);
262 if (!name)
263 return NULL;
264 const struct drgn_platform *platform =
265 drgn_program_platform(self->trace->trace->prog);
266 const struct drgn_register *reg =
267 drgn_platform_register_by_name(platform, name);
268 if (!reg) {
269 return PyErr_Format(PyExc_ValueError,
270 "unknown register %R", arg);
271 }
272 uint64_t value;
273 if (!drgn_stack_frame_register(self->trace->trace, self->i, reg,
274 &value)) {
275 PyErr_SetString(PyExc_LookupError,
276 "register value is not known");
277 return NULL;
278 }
279 return PyLong_FromUInt64(value);
280 }
281
282 static PyObject *StackFrame_registers(StackFrame *self)
283 {
284 _cleanup_pydecref_ PyObject *dict = PyDict_New();
285 if (!dict)
286 return NULL;
287 const struct drgn_platform *platform =
288 drgn_program_platform(self->trace->trace->prog);
289 size_t num_registers = drgn_platform_num_registers(platform);
290 for (size_t i = 0; i < num_registers; i++) {
291 const struct drgn_register *reg =
292 drgn_platform_register(platform, i);
293 uint64_t value;
294 if (!drgn_stack_frame_register(self->trace->trace, self->i, reg,
295 &value))
296 continue;
297 _cleanup_pydecref_ PyObject *value_obj =
298 PyLong_FromUInt64(value);
299 if (!value_obj)
300 return NULL;
301 size_t num_names;
302 const char * const *names = drgn_register_names(reg,
303 &num_names);
304 for (size_t j = 0; j < num_names; j++) {
305 if (PyDict_SetItemString(dict, names[j], value_obj))
306 return NULL;
307 }
308 }
309 return_ptr(dict);
310 }
311
312 static PyObject *StackFrame_get_name(StackFrame *self, void *arg)
313 {
314 _cleanup_free_ char *name = NULL;
315 struct drgn_error *err = drgn_stack_frame_name(self->trace->trace,
316 self->i, &name);
317 if (err)
318 return set_drgn_error(err);
319 return PyUnicode_FromString(name);
320 }
321
322 static PyObject *StackFrame_get_function_name(StackFrame *self, void *arg)
323 {
324 const char *function_name =
325 drgn_stack_frame_function_name(self->trace->trace, self->i);
326 if (function_name)
327 return PyUnicode_FromString(function_name);
328 else
329 Py_RETURN_NONE;
330 }
331
332 static PyObject *StackFrame_get_is_inline(StackFrame *self, void *arg)
333 {
334 Py_RETURN_BOOL(drgn_stack_frame_is_inline(self->trace->trace, self->i));
335 }
336
337 static PyObject *StackFrame_get_interrupted(StackFrame *self, void *arg)
338 {
339 Py_RETURN_BOOL(drgn_stack_frame_interrupted(self->trace->trace,
340 self->i));
341 }
342
343 static PyObject *StackFrame_get_pc(StackFrame *self, void *arg)
344 {
345 uint64_t pc;
346 if (drgn_stack_frame_pc(self->trace->trace, self->i, &pc)) {
347 return PyLong_FromUInt64(pc);
348 } else {
349 PyErr_SetString(PyExc_LookupError,
350 "program counter is not known");
351 return NULL;
352 }
353 }
354
355 static PyObject *StackFrame_get_sp(StackFrame *self, void *arg)
356 {
357 uint64_t sp;
358 if (drgn_stack_frame_sp(self->trace->trace, self->i, &sp)) {
359 return PyLong_FromUInt64(sp);
360 } else {
361 PyErr_SetString(PyExc_LookupError,
362 "stack pointer is not known");
363 return NULL;
364 }
365 }
366
367 static PyMethodDef StackFrame_methods[] = {
368 {"__getitem__", (PyCFunction)StackFrame_subscript,
369 METH_O | METH_COEXIST, drgn_StackFrame___getitem___DOC},
370 {"__contains__", (PyCFunction)StackFrame_contains,
371 METH_O | METH_COEXIST, drgn_StackFrame___contains___DOC},
372 {"locals", (PyCFunction)StackFrame_locals,
373 METH_NOARGS, drgn_StackFrame_locals_DOC},
374 {"source", (PyCFunction)StackFrame_source, METH_NOARGS,
375 drgn_StackFrame_source_DOC},
376 {"symbol", (PyCFunction)StackFrame_symbol, METH_NOARGS,
377 drgn_StackFrame_symbol_DOC},
378 {"register", (PyCFunction)StackFrame_register,
379 METH_O, drgn_StackFrame_register_DOC},
380 {"registers", (PyCFunction)StackFrame_registers,
381 METH_NOARGS, drgn_StackFrame_registers_DOC},
382 {"_repr_pretty_", (PyCFunction)repr_pretty_from_str,
383 METH_VARARGS | METH_KEYWORDS},
384 {},
385 };
386
387 static PyGetSetDef StackFrame_getset[] = {
388 {"name", (getter)StackFrame_get_name, NULL, drgn_StackFrame_name_DOC},
389 {"function_name", (getter)StackFrame_get_function_name, NULL,
390 drgn_StackFrame_function_name_DOC},
391 {"is_inline", (getter)StackFrame_get_is_inline, NULL,
392 drgn_StackFrame_is_inline_DOC},
393 {"interrupted", (getter)StackFrame_get_interrupted, NULL,
394 drgn_StackFrame_interrupted_DOC},
395 {"pc", (getter)StackFrame_get_pc, NULL, drgn_StackFrame_pc_DOC},
396 {"sp", (getter)StackFrame_get_sp, NULL, drgn_StackFrame_sp_DOC},
397 {},
398 };
399
400 static PyMappingMethods StackFrame_as_mapping = {
401 .mp_subscript = (binaryfunc)StackFrame_subscript,
402 };
403
404 static PySequenceMethods StackFrame_as_sequence = {
405 .sq_contains = (objobjproc)StackFrame_contains,
406 };
407
408 PyTypeObject StackFrame_type = {
409 PyVarObject_HEAD_INIT(NULL, 0)
410 .tp_name = "_drgn.StackFrame",
411 .tp_basicsize = sizeof(StackFrame),
412 .tp_dealloc = (destructor)StackFrame_dealloc,
413 .tp_as_sequence = &StackFrame_as_sequence,
414 .tp_as_mapping = &StackFrame_as_mapping,
415 .tp_str = (reprfunc)StackFrame_str,
416 .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
417 .tp_doc = drgn_StackFrame_DOC,
418 .tp_traverse = (traverseproc)StackFrame_traverse,
419 .tp_methods = StackFrame_methods,
420 .tp_getset = StackFrame_getset,
421 };