GDB (xrefs)
Loading...
Searching...
No Matches
py-infthread.c
Go to the documentation of this file.
1/* Python interface to inferior threads.
2
3 Copyright (C) 2009-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "gdbthread.h"
22#include "inferior.h"
23#include "python-internal.h"
24
25extern PyTypeObject thread_object_type
27
28/* Require that INFERIOR be a valid inferior ID. */
29#define THPY_REQUIRE_VALID(Thread) \
30 do { \
31 if (!Thread->thread) \
32 { \
33 PyErr_SetString (PyExc_RuntimeError, \
34 _("Thread no longer exists.")); \
35 return NULL; \
36 } \
37 } while (0)
38
41{
42 gdbpy_ref<thread_object> thread_obj;
43
45 if (inf_obj == NULL)
46 return NULL;
47
48 thread_obj.reset (PyObject_New (thread_object, &thread_object_type));
49 if (thread_obj == NULL)
50 return NULL;
51
52 thread_obj->thread = tp;
53 thread_obj->inf_obj = (PyObject *) inf_obj.release ();
54
55 return thread_obj;
56}
57
58static void
60{
61 Py_DECREF (((thread_object *) self)->inf_obj);
62 Py_TYPE (self)->tp_free (self);
63}
64
65static PyObject *
66thpy_get_name (PyObject *self, void *ignore)
67{
68 thread_object *thread_obj = (thread_object *) self;
69
70 THPY_REQUIRE_VALID (thread_obj);
71
72 const char *name = thread_name (thread_obj->thread);
73 if (name == NULL)
74 Py_RETURN_NONE;
75
76 return PyUnicode_FromString (name);
77}
78
79/* Return a string containing target specific additional information about
80 the state of the thread, or None, if there is no such additional
81 information. */
82
83static PyObject *
84thpy_get_details (PyObject *self, void *ignore)
85{
86 thread_object *thread_obj = (thread_object *) self;
87
88 THPY_REQUIRE_VALID (thread_obj);
89
90 /* GCC can't tell that extra_info will always be assigned after the
91 'catch', so initialize it. */
92 const char *extra_info = nullptr;
93 try
94 {
95 extra_info = target_extra_thread_info (thread_obj->thread);
96 }
97 catch (const gdb_exception &except)
98 {
100 }
101 if (extra_info == nullptr)
102 Py_RETURN_NONE;
103
104 return PyUnicode_FromString (extra_info);
105}
106
107static int
108thpy_set_name (PyObject *self, PyObject *newvalue, void *ignore)
109{
110 thread_object *thread_obj = (thread_object *) self;
111 gdb::unique_xmalloc_ptr<char> name;
112
113 if (! thread_obj->thread)
114 {
115 PyErr_SetString (PyExc_RuntimeError, _("Thread no longer exists."));
116 return -1;
117 }
118
119 if (newvalue == NULL)
120 {
121 PyErr_SetString (PyExc_TypeError,
122 _("Cannot delete `name' attribute."));
123 return -1;
124 }
125 else if (newvalue == Py_None)
126 {
127 /* Nothing. */
128 }
129 else if (! gdbpy_is_string (newvalue))
130 {
131 PyErr_SetString (PyExc_TypeError,
132 _("The value of `name' must be a string."));
133 return -1;
134 }
135 else
136 {
138 if (! name)
139 return -1;
140 }
141
142 thread_obj->thread->set_name (std::move (name));
143
144 return 0;
145}
146
147/* Getter for InferiorThread.num. */
148
149static PyObject *
150thpy_get_num (PyObject *self, void *closure)
151{
152 thread_object *thread_obj = (thread_object *) self;
153
154 THPY_REQUIRE_VALID (thread_obj);
155
156 gdbpy_ref<> result
158 return result.release ();
159}
160
161/* Getter for InferiorThread.global_num. */
162
163static PyObject *
164thpy_get_global_num (PyObject *self, void *closure)
165{
166 thread_object *thread_obj = (thread_object *) self;
167
168 THPY_REQUIRE_VALID (thread_obj);
169
170 gdbpy_ref<> result
172 return result.release ();
173}
174
175/* Getter for InferiorThread.ptid -> (pid, lwp, tid).
176 Returns a tuple with the thread's ptid components. */
177
178static PyObject *
179thpy_get_ptid (PyObject *self, void *closure)
180{
181 thread_object *thread_obj = (thread_object *) self;
182
183 THPY_REQUIRE_VALID (thread_obj);
184
185 return gdbpy_create_ptid_object (thread_obj->thread->ptid);
186}
187
188/* Getter for InferiorThread.inferior -> Inferior. */
189
190static PyObject *
191thpy_get_inferior (PyObject *self, void *ignore)
192{
193 thread_object *thread_obj = (thread_object *) self;
194
195 THPY_REQUIRE_VALID (thread_obj);
196 Py_INCREF (thread_obj->inf_obj);
197
198 return thread_obj->inf_obj;
199}
200
201/* Implementation of InferiorThread.switch ().
202 Makes this the GDB selected thread. */
203
204static PyObject *
206{
207 thread_object *thread_obj = (thread_object *) self;
208
209 THPY_REQUIRE_VALID (thread_obj);
210
211 try
212 {
213 switch_to_thread (thread_obj->thread);
214 }
215 catch (const gdb_exception &except)
216 {
218 }
219
220 Py_RETURN_NONE;
221}
222
223/* Implementation of InferiorThread.is_stopped () -> Boolean.
224 Return whether the thread is stopped. */
225
226static PyObject *
228{
229 thread_object *thread_obj = (thread_object *) self;
230
231 THPY_REQUIRE_VALID (thread_obj);
232
233 if (thread_obj->thread->state == THREAD_STOPPED)
234 Py_RETURN_TRUE;
235
236 Py_RETURN_FALSE;
237}
238
239/* Implementation of InferiorThread.is_running () -> Boolean.
240 Return whether the thread is running. */
241
242static PyObject *
244{
245 thread_object *thread_obj = (thread_object *) self;
246
247 THPY_REQUIRE_VALID (thread_obj);
248
249 if (thread_obj->thread->state == THREAD_RUNNING)
250 Py_RETURN_TRUE;
251
252 Py_RETURN_FALSE;
253}
254
255/* Implementation of InferiorThread.is_exited () -> Boolean.
256 Return whether the thread is exited. */
257
258static PyObject *
260{
261 thread_object *thread_obj = (thread_object *) self;
262
263 THPY_REQUIRE_VALID (thread_obj);
264
265 if (thread_obj->thread->state == THREAD_EXITED)
266 Py_RETURN_TRUE;
267
268 Py_RETURN_FALSE;
269}
270
271/* Implementation of gdb.InfThread.is_valid (self) -> Boolean.
272 Returns True if this inferior Thread object still exists
273 in GDB. */
274
275static PyObject *
277{
278 thread_object *thread_obj = (thread_object *) self;
279
280 if (! thread_obj->thread)
281 Py_RETURN_FALSE;
282
283 Py_RETURN_TRUE;
284}
285
286/* Implementation of gdb.InferiorThread.handle (self) -> handle. */
287
288static PyObject *
290{
291 thread_object *thread_obj = (thread_object *) self;
292 THPY_REQUIRE_VALID (thread_obj);
293
294 gdb::array_view<const gdb_byte> hv;
295
296 try
297 {
299 }
300 catch (const gdb_exception &except)
301 {
303 }
304
305 if (hv.size () == 0)
306 {
307 PyErr_SetString (PyExc_RuntimeError, _("Thread handle not found."));
308 return NULL;
309 }
310
311 PyObject *object = PyBytes_FromStringAndSize ((const char *) hv.data (),
312 hv.size());
313 return object;
314}
315
316/* Return a reference to a new Python object representing a ptid_t.
317 The object is a tuple containing (pid, lwp, tid). */
318PyObject *
320{
321 int pid;
322 long lwp;
323 ULONGEST tid;
324 PyObject *ret;
325
326 ret = PyTuple_New (3);
327 if (!ret)
328 return NULL;
329
330 pid = ptid.pid ();
331 lwp = ptid.lwp ();
332 tid = ptid.tid ();
333
335 if (pid_obj == nullptr)
336 return nullptr;
338 if (lwp_obj == nullptr)
339 return nullptr;
341 if (tid_obj == nullptr)
342 return nullptr;
343
344 /* Note that these steal references, hence the use of 'release'. */
345 PyTuple_SET_ITEM (ret, 0, pid_obj.release ());
346 PyTuple_SET_ITEM (ret, 1, lwp_obj.release ());
347 PyTuple_SET_ITEM (ret, 2, tid_obj.release ());
348
349 return ret;
350}
351
352/* Implementation of gdb.selected_thread () -> gdb.InferiorThread.
353 Returns the selected thread object. */
354
355PyObject *
357{
358 if (inferior_ptid != null_ptid)
359 return thread_to_thread_object (inferior_thread ()).release ();
360
361 Py_RETURN_NONE;
362}
363
366{
367 if (PyType_Ready (&thread_object_type) < 0)
368 return -1;
369
370 return gdb_pymodule_addobject (gdb_module, "InferiorThread",
372}
373
375
376
377
379{
380 { "name", thpy_get_name, thpy_set_name,
381 "The name of the thread, as set by the user or the OS.", NULL },
382 { "details", thpy_get_details, NULL,
383 "A target specific string containing extra thread state details.",
384 NULL },
385 { "num", thpy_get_num, NULL,
386 "Per-inferior number of the thread, as assigned by GDB.", NULL },
387 { "global_num", thpy_get_global_num, NULL,
388 "Global number of the thread, as assigned by GDB.", NULL },
389 { "ptid", thpy_get_ptid, NULL, "ID of the thread, as assigned by the OS.",
390 NULL },
391 { "inferior", thpy_get_inferior, NULL,
392 "The Inferior object this thread belongs to.", NULL },
393
394 { NULL }
395};
396
397static PyMethodDef thread_object_methods[] =
398{
399 { "is_valid", thpy_is_valid, METH_NOARGS,
400 "is_valid () -> Boolean.\n\
401Return true if this inferior thread is valid, false if not." },
402 { "switch", thpy_switch, METH_NOARGS,
403 "switch ()\n\
404Makes this the GDB selected thread." },
405 { "is_stopped", thpy_is_stopped, METH_NOARGS,
406 "is_stopped () -> Boolean\n\
407Return whether the thread is stopped." },
408 { "is_running", thpy_is_running, METH_NOARGS,
409 "is_running () -> Boolean\n\
410Return whether the thread is running." },
411 { "is_exited", thpy_is_exited, METH_NOARGS,
412 "is_exited () -> Boolean\n\
413Return whether the thread is exited." },
414 { "handle", thpy_thread_handle, METH_NOARGS,
415 "handle () -> handle\n\
416Return thread library specific handle for thread." },
417
418 { NULL }
419};
420
421PyTypeObject thread_object_type =
422{
423 PyVarObject_HEAD_INIT (NULL, 0)
424 "gdb.InferiorThread", /*tp_name*/
425 sizeof (thread_object), /*tp_basicsize*/
426 0, /*tp_itemsize*/
427 thpy_dealloc, /*tp_dealloc*/
428 0, /*tp_print*/
429 0, /*tp_getattr*/
430 0, /*tp_setattr*/
431 0, /*tp_compare*/
432 0, /*tp_repr*/
433 0, /*tp_as_number*/
434 0, /*tp_as_sequence*/
435 0, /*tp_as_mapping*/
436 0, /*tp_hash */
437 0, /*tp_call*/
438 0, /*tp_str*/
439 0, /*tp_getattro*/
440 0, /*tp_setattro*/
441 0, /*tp_as_buffer*/
442 Py_TPFLAGS_DEFAULT, /*tp_flags*/
443 "GDB thread object", /* tp_doc */
444 0, /* tp_traverse */
445 0, /* tp_clear */
446 0, /* tp_richcompare */
447 0, /* tp_weaklistoffset */
448 0, /* tp_iter */
449 0, /* tp_iternext */
450 thread_object_methods, /* tp_methods */
451 0, /* tp_members */
452 thread_object_getset, /* tp_getset */
453 0, /* tp_base */
454 0, /* tp_dict */
455 0, /* tp_descr_get */
456 0, /* tp_descr_set */
457 0, /* tp_dictoffset */
458 0, /* tp_init */
459 0 /* tp_alloc */
460};
const char *const name
enum thread_state state
Definition gdbthread.h:339
int per_inf_num
Definition gdbthread.h:298
ptid_t ptid
Definition gdbthread.h:259
void set_name(gdb::unique_xmalloc_ptr< char > name)
Definition gdbthread.h:314
struct inferior * inf
Definition gdbthread.h:301
@ THREAD_STOPPED
Definition gdbthread.h:72
@ THREAD_RUNNING
Definition gdbthread.h:75
@ THREAD_EXITED
Definition gdbthread.h:79
struct thread_info * inferior_thread(void)
Definition thread.c:85
void switch_to_thread(struct thread_info *thr)
Definition thread.c:1360
const char * thread_name(thread_info *thread)
Definition thread.c:2095
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int int rusage_t pid_t pid
Definition gnu-nat.c:1791
ptid_t inferior_ptid
Definition infcmd.c:74
gdbpy_ref< inferior_object > inferior_to_inferior_object(struct inferior *inferior)
gdbpy_ref thread_to_thread_object(thread_info *thr)
#define THPY_REQUIRE_VALID(Thread)
static PyObject * thpy_is_running(PyObject *self, PyObject *args)
static PyObject * thpy_get_details(PyObject *self, void *ignore)
static PyObject * thpy_get_global_num(PyObject *self, void *closure)
static gdb_PyGetSetDef thread_object_getset[]
static PyMethodDef thread_object_methods[]
static int thpy_set_name(PyObject *self, PyObject *newvalue, void *ignore)
PyTypeObject thread_object_type
PyObject * gdbpy_create_ptid_object(ptid_t ptid)
static PyObject * thpy_get_num(PyObject *self, void *closure)
PyObject * gdbpy_selected_thread(PyObject *self, PyObject *args)
static PyObject * thpy_thread_handle(PyObject *self, PyObject *args)
static PyObject * thpy_is_stopped(PyObject *self, PyObject *args)
static void thpy_dealloc(PyObject *self)
static PyObject * thpy_is_valid(PyObject *self, PyObject *args)
static PyObject * thpy_is_exited(PyObject *self, PyObject *args)
static PyObject * thpy_get_ptid(PyObject *self, void *closure)
static PyObject * thpy_switch(PyObject *self, PyObject *args)
static PyObject * thpy_get_inferior(PyObject *self, void *ignore)
static PyObject * thpy_get_name(PyObject *self, void *ignore)
static int CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION gdbpy_initialize_thread(void)
gdbpy_ref< thread_object > create_thread_object(struct thread_info *tp)
gdb::ref_ptr< T, gdbpy_ref_policy< T > > gdbpy_ref
Definition py-ref.h:42
gdbpy_ref gdb_py_object_from_longest(LONGEST l)
Definition py-utils.c:282
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition py-utils.c:334
gdb::unique_xmalloc_ptr< char > python_string_to_host_string(PyObject *obj)
Definition py-utils.c:142
int gdbpy_is_string(PyObject *obj)
Definition py-utils.c:164
gdbpy_ref gdb_py_object_from_ulongest(ULONGEST l)
Definition py-utils.c:293
PyObject * gdb_module
#define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)
#define CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION
#define GDBPY_INITIALIZE_FILE(INIT,...)
#define GDB_PY_HANDLE_EXCEPTION(Exception)
PyObject_HEAD struct thread_info * thread
PyObject * inf_obj
const char * target_extra_thread_info(thread_info *tp)
Definition target.c:418
gdb::array_view< const gdb_byte > target_thread_info_to_thread_handle(struct thread_info *tip)
Definition target.c:2649
int PyObject
Definition varobj.c:41