1 /* Python interface to inferior threads. 2 3 Copyright (C) 2009-2020 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 25 extern PyTypeObject thread_object_type 26 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("thread_object"); 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 39 gdbpy_ref<thread_object> 40 create_thread_object (struct thread_info *tp) 41 { 42 gdbpy_ref<thread_object> thread_obj; 43 44 gdbpy_ref<inferior_object> inf_obj = inferior_to_inferior_object (tp->inf); 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 58 static void 59 thpy_dealloc (PyObject *self) 60 { 61 Py_DECREF (((thread_object *) self)->inf_obj); 62 Py_TYPE (self)->tp_free (self); 63 } 64 65 static PyObject * 66 thpy_get_name (PyObject *self, void *ignore) 67 { 68 thread_object *thread_obj = (thread_object *) self; 69 const char *name; 70 71 THPY_REQUIRE_VALID (thread_obj); 72 73 name = thread_obj->thread->name; 74 if (name == NULL) 75 name = target_thread_name (thread_obj->thread); 76 77 if (name == NULL) 78 Py_RETURN_NONE; 79 80 return PyString_FromString (name); 81 } 82 83 static int 84 thpy_set_name (PyObject *self, PyObject *newvalue, void *ignore) 85 { 86 thread_object *thread_obj = (thread_object *) self; 87 gdb::unique_xmalloc_ptr<char> name; 88 89 if (! thread_obj->thread) 90 { 91 PyErr_SetString (PyExc_RuntimeError, _("Thread no longer exists.")); 92 return -1; 93 } 94 95 if (newvalue == NULL) 96 { 97 PyErr_SetString (PyExc_TypeError, 98 _("Cannot delete `name' attribute.")); 99 return -1; 100 } 101 else if (newvalue == Py_None) 102 { 103 /* Nothing. */ 104 } 105 else if (! gdbpy_is_string (newvalue)) 106 { 107 PyErr_SetString (PyExc_TypeError, 108 _("The value of `name' must be a string.")); 109 return -1; 110 } 111 else 112 { 113 name = python_string_to_host_string (newvalue); 114 if (! name) 115 return -1; 116 } 117 118 xfree (thread_obj->thread->name); 119 thread_obj->thread->name = name.release (); 120 121 return 0; 122 } 123 124 /* Getter for InferiorThread.num. */ 125 126 static PyObject * 127 thpy_get_num (PyObject *self, void *closure) 128 { 129 thread_object *thread_obj = (thread_object *) self; 130 131 THPY_REQUIRE_VALID (thread_obj); 132 133 return PyLong_FromLong (thread_obj->thread->per_inf_num); 134 } 135 136 /* Getter for InferiorThread.global_num. */ 137 138 static PyObject * 139 thpy_get_global_num (PyObject *self, void *closure) 140 { 141 thread_object *thread_obj = (thread_object *) self; 142 143 THPY_REQUIRE_VALID (thread_obj); 144 145 return PyLong_FromLong (thread_obj->thread->global_num); 146 } 147 148 /* Getter for InferiorThread.ptid -> (pid, lwp, tid). 149 Returns a tuple with the thread's ptid components. */ 150 151 static PyObject * 152 thpy_get_ptid (PyObject *self, void *closure) 153 { 154 thread_object *thread_obj = (thread_object *) self; 155 156 THPY_REQUIRE_VALID (thread_obj); 157 158 return gdbpy_create_ptid_object (thread_obj->thread->ptid); 159 } 160 161 /* Getter for InferiorThread.inferior -> Inferior. */ 162 163 static PyObject * 164 thpy_get_inferior (PyObject *self, void *ignore) 165 { 166 thread_object *thread_obj = (thread_object *) self; 167 168 THPY_REQUIRE_VALID (thread_obj); 169 Py_INCREF (thread_obj->inf_obj); 170 171 return thread_obj->inf_obj; 172 } 173 174 /* Implementation of InferiorThread.switch (). 175 Makes this the GDB selected thread. */ 176 177 static PyObject * 178 thpy_switch (PyObject *self, PyObject *args) 179 { 180 thread_object *thread_obj = (thread_object *) self; 181 182 THPY_REQUIRE_VALID (thread_obj); 183 184 try 185 { 186 switch_to_thread (thread_obj->thread); 187 } 188 catch (const gdb_exception &except) 189 { 190 GDB_PY_HANDLE_EXCEPTION (except); 191 } 192 193 Py_RETURN_NONE; 194 } 195 196 /* Implementation of InferiorThread.is_stopped () -> Boolean. 197 Return whether the thread is stopped. */ 198 199 static PyObject * 200 thpy_is_stopped (PyObject *self, PyObject *args) 201 { 202 thread_object *thread_obj = (thread_object *) self; 203 204 THPY_REQUIRE_VALID (thread_obj); 205 206 if (thread_obj->thread->state == THREAD_STOPPED) 207 Py_RETURN_TRUE; 208 209 Py_RETURN_FALSE; 210 } 211 212 /* Implementation of InferiorThread.is_running () -> Boolean. 213 Return whether the thread is running. */ 214 215 static PyObject * 216 thpy_is_running (PyObject *self, PyObject *args) 217 { 218 thread_object *thread_obj = (thread_object *) self; 219 220 THPY_REQUIRE_VALID (thread_obj); 221 222 if (thread_obj->thread->state == THREAD_RUNNING) 223 Py_RETURN_TRUE; 224 225 Py_RETURN_FALSE; 226 } 227 228 /* Implementation of InferiorThread.is_exited () -> Boolean. 229 Return whether the thread is exited. */ 230 231 static PyObject * 232 thpy_is_exited (PyObject *self, PyObject *args) 233 { 234 thread_object *thread_obj = (thread_object *) self; 235 236 THPY_REQUIRE_VALID (thread_obj); 237 238 if (thread_obj->thread->state == THREAD_EXITED) 239 Py_RETURN_TRUE; 240 241 Py_RETURN_FALSE; 242 } 243 244 /* Implementation of gdb.InfThread.is_valid (self) -> Boolean. 245 Returns True if this inferior Thread object still exists 246 in GDB. */ 247 248 static PyObject * 249 thpy_is_valid (PyObject *self, PyObject *args) 250 { 251 thread_object *thread_obj = (thread_object *) self; 252 253 if (! thread_obj->thread) 254 Py_RETURN_FALSE; 255 256 Py_RETURN_TRUE; 257 } 258 259 /* Implementation of gdb.InferiorThread.handle (self) -> handle. */ 260 261 static PyObject * 262 thpy_thread_handle (PyObject *self, PyObject *args) 263 { 264 thread_object *thread_obj = (thread_object *) self; 265 THPY_REQUIRE_VALID (thread_obj); 266 267 gdb::byte_vector hv; 268 269 try 270 { 271 hv = target_thread_info_to_thread_handle (thread_obj->thread); 272 } 273 catch (const gdb_exception &except) 274 { 275 GDB_PY_HANDLE_EXCEPTION (except); 276 } 277 278 if (hv.size () == 0) 279 { 280 PyErr_SetString (PyExc_RuntimeError, _("Thread handle not found.")); 281 return NULL; 282 } 283 284 PyObject *object = PyBytes_FromStringAndSize ((const char *) hv.data (), 285 hv.size()); 286 return object; 287 } 288 289 /* Return a reference to a new Python object representing a ptid_t. 290 The object is a tuple containing (pid, lwp, tid). */ 291 PyObject * 292 gdbpy_create_ptid_object (ptid_t ptid) 293 { 294 int pid; 295 long tid, lwp; 296 PyObject *ret; 297 298 ret = PyTuple_New (3); 299 if (!ret) 300 return NULL; 301 302 pid = ptid.pid (); 303 lwp = ptid.lwp (); 304 tid = ptid.tid (); 305 306 PyTuple_SET_ITEM (ret, 0, PyInt_FromLong (pid)); 307 PyTuple_SET_ITEM (ret, 1, PyInt_FromLong (lwp)); 308 PyTuple_SET_ITEM (ret, 2, PyInt_FromLong (tid)); 309 310 return ret; 311 } 312 313 /* Implementation of gdb.selected_thread () -> gdb.InferiorThread. 314 Returns the selected thread object. */ 315 316 PyObject * 317 gdbpy_selected_thread (PyObject *self, PyObject *args) 318 { 319 if (inferior_ptid != null_ptid) 320 return thread_to_thread_object (inferior_thread ()).release (); 321 322 Py_RETURN_NONE; 323 } 324 325 int 326 gdbpy_initialize_thread (void) 327 { 328 if (PyType_Ready (&thread_object_type) < 0) 329 return -1; 330 331 return gdb_pymodule_addobject (gdb_module, "InferiorThread", 332 (PyObject *) &thread_object_type); 333 } 334 335 static gdb_PyGetSetDef thread_object_getset[] = 336 { 337 { "name", thpy_get_name, thpy_set_name, 338 "The name of the thread, as set by the user or the OS.", NULL }, 339 { "num", thpy_get_num, NULL, 340 "Per-inferior number of the thread, as assigned by GDB.", NULL }, 341 { "global_num", thpy_get_global_num, NULL, 342 "Global number of the thread, as assigned by GDB.", NULL }, 343 { "ptid", thpy_get_ptid, NULL, "ID of the thread, as assigned by the OS.", 344 NULL }, 345 { "inferior", thpy_get_inferior, NULL, 346 "The Inferior object this thread belongs to.", NULL }, 347 348 { NULL } 349 }; 350 351 static PyMethodDef thread_object_methods[] = 352 { 353 { "is_valid", thpy_is_valid, METH_NOARGS, 354 "is_valid () -> Boolean.\n\ 355 Return true if this inferior thread is valid, false if not." }, 356 { "switch", thpy_switch, METH_NOARGS, 357 "switch ()\n\ 358 Makes this the GDB selected thread." }, 359 { "is_stopped", thpy_is_stopped, METH_NOARGS, 360 "is_stopped () -> Boolean\n\ 361 Return whether the thread is stopped." }, 362 { "is_running", thpy_is_running, METH_NOARGS, 363 "is_running () -> Boolean\n\ 364 Return whether the thread is running." }, 365 { "is_exited", thpy_is_exited, METH_NOARGS, 366 "is_exited () -> Boolean\n\ 367 Return whether the thread is exited." }, 368 { "handle", thpy_thread_handle, METH_NOARGS, 369 "handle () -> handle\n\ 370 Return thread library specific handle for thread." }, 371 372 { NULL } 373 }; 374 375 PyTypeObject thread_object_type = 376 { 377 PyVarObject_HEAD_INIT (NULL, 0) 378 "gdb.InferiorThread", /*tp_name*/ 379 sizeof (thread_object), /*tp_basicsize*/ 380 0, /*tp_itemsize*/ 381 thpy_dealloc, /*tp_dealloc*/ 382 0, /*tp_print*/ 383 0, /*tp_getattr*/ 384 0, /*tp_setattr*/ 385 0, /*tp_compare*/ 386 0, /*tp_repr*/ 387 0, /*tp_as_number*/ 388 0, /*tp_as_sequence*/ 389 0, /*tp_as_mapping*/ 390 0, /*tp_hash */ 391 0, /*tp_call*/ 392 0, /*tp_str*/ 393 0, /*tp_getattro*/ 394 0, /*tp_setattro*/ 395 0, /*tp_as_buffer*/ 396 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/ 397 "GDB thread object", /* tp_doc */ 398 0, /* tp_traverse */ 399 0, /* tp_clear */ 400 0, /* tp_richcompare */ 401 0, /* tp_weaklistoffset */ 402 0, /* tp_iter */ 403 0, /* tp_iternext */ 404 thread_object_methods, /* tp_methods */ 405 0, /* tp_members */ 406 thread_object_getset, /* tp_getset */ 407 0, /* tp_base */ 408 0, /* tp_dict */ 409 0, /* tp_descr_get */ 410 0, /* tp_descr_set */ 411 0, /* tp_dictoffset */ 412 0, /* tp_init */ 413 0 /* tp_alloc */ 414 }; 415