1 /* Python interface to inferior threads. 2 3 Copyright (C) 2009-2019 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 thread_object * 40 create_thread_object (struct thread_info *tp) 41 { 42 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 = PyObject_New (thread_object, &thread_object_type); 49 if (!thread_obj) 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 (except, RETURN_MASK_ALL) 189 { 190 GDB_PY_HANDLE_EXCEPTION (except); 191 } 192 END_CATCH 193 194 Py_RETURN_NONE; 195 } 196 197 /* Implementation of InferiorThread.is_stopped () -> Boolean. 198 Return whether the thread is stopped. */ 199 200 static PyObject * 201 thpy_is_stopped (PyObject *self, PyObject *args) 202 { 203 thread_object *thread_obj = (thread_object *) self; 204 205 THPY_REQUIRE_VALID (thread_obj); 206 207 if (thread_obj->thread->state == THREAD_STOPPED) 208 Py_RETURN_TRUE; 209 210 Py_RETURN_FALSE; 211 } 212 213 /* Implementation of InferiorThread.is_running () -> Boolean. 214 Return whether the thread is running. */ 215 216 static PyObject * 217 thpy_is_running (PyObject *self, PyObject *args) 218 { 219 thread_object *thread_obj = (thread_object *) self; 220 221 THPY_REQUIRE_VALID (thread_obj); 222 223 if (thread_obj->thread->state == THREAD_RUNNING) 224 Py_RETURN_TRUE; 225 226 Py_RETURN_FALSE; 227 } 228 229 /* Implementation of InferiorThread.is_exited () -> Boolean. 230 Return whether the thread is exited. */ 231 232 static PyObject * 233 thpy_is_exited (PyObject *self, PyObject *args) 234 { 235 thread_object *thread_obj = (thread_object *) self; 236 237 THPY_REQUIRE_VALID (thread_obj); 238 239 if (thread_obj->thread->state == THREAD_EXITED) 240 Py_RETURN_TRUE; 241 242 Py_RETURN_FALSE; 243 } 244 245 /* Implementation of gdb.InfThread.is_valid (self) -> Boolean. 246 Returns True if this inferior Thread object still exists 247 in GDB. */ 248 249 static PyObject * 250 thpy_is_valid (PyObject *self, PyObject *args) 251 { 252 thread_object *thread_obj = (thread_object *) self; 253 254 if (! thread_obj->thread) 255 Py_RETURN_FALSE; 256 257 Py_RETURN_TRUE; 258 } 259 260 /* Return a reference to a new Python object representing a ptid_t. 261 The object is a tuple containing (pid, lwp, tid). */ 262 PyObject * 263 gdbpy_create_ptid_object (ptid_t ptid) 264 { 265 int pid; 266 long tid, lwp; 267 PyObject *ret; 268 269 ret = PyTuple_New (3); 270 if (!ret) 271 return NULL; 272 273 pid = ptid.pid (); 274 lwp = ptid.lwp (); 275 tid = ptid.tid (); 276 277 PyTuple_SET_ITEM (ret, 0, PyInt_FromLong (pid)); 278 PyTuple_SET_ITEM (ret, 1, PyInt_FromLong (lwp)); 279 PyTuple_SET_ITEM (ret, 2, PyInt_FromLong (tid)); 280 281 return ret; 282 } 283 284 /* Implementation of gdb.selected_thread () -> gdb.InferiorThread. 285 Returns the selected thread object. */ 286 287 PyObject * 288 gdbpy_selected_thread (PyObject *self, PyObject *args) 289 { 290 if (inferior_ptid != null_ptid) 291 return thread_to_thread_object (inferior_thread ()).release (); 292 293 Py_RETURN_NONE; 294 } 295 296 int 297 gdbpy_initialize_thread (void) 298 { 299 if (PyType_Ready (&thread_object_type) < 0) 300 return -1; 301 302 return gdb_pymodule_addobject (gdb_module, "InferiorThread", 303 (PyObject *) &thread_object_type); 304 } 305 306 static gdb_PyGetSetDef thread_object_getset[] = 307 { 308 { "name", thpy_get_name, thpy_set_name, 309 "The name of the thread, as set by the user or the OS.", NULL }, 310 { "num", thpy_get_num, NULL, 311 "Per-inferior number of the thread, as assigned by GDB.", NULL }, 312 { "global_num", thpy_get_global_num, NULL, 313 "Global number of the thread, as assigned by GDB.", NULL }, 314 { "ptid", thpy_get_ptid, NULL, "ID of the thread, as assigned by the OS.", 315 NULL }, 316 { "inferior", thpy_get_inferior, NULL, 317 "The Inferior object this thread belongs to.", NULL }, 318 319 { NULL } 320 }; 321 322 static PyMethodDef thread_object_methods[] = 323 { 324 { "is_valid", thpy_is_valid, METH_NOARGS, 325 "is_valid () -> Boolean.\n\ 326 Return true if this inferior thread is valid, false if not." }, 327 { "switch", thpy_switch, METH_NOARGS, 328 "switch ()\n\ 329 Makes this the GDB selected thread." }, 330 { "is_stopped", thpy_is_stopped, METH_NOARGS, 331 "is_stopped () -> Boolean\n\ 332 Return whether the thread is stopped." }, 333 { "is_running", thpy_is_running, METH_NOARGS, 334 "is_running () -> Boolean\n\ 335 Return whether the thread is running." }, 336 { "is_exited", thpy_is_exited, METH_NOARGS, 337 "is_exited () -> Boolean\n\ 338 Return whether the thread is exited." }, 339 340 { NULL } 341 }; 342 343 PyTypeObject thread_object_type = 344 { 345 PyVarObject_HEAD_INIT (NULL, 0) 346 "gdb.InferiorThread", /*tp_name*/ 347 sizeof (thread_object), /*tp_basicsize*/ 348 0, /*tp_itemsize*/ 349 thpy_dealloc, /*tp_dealloc*/ 350 0, /*tp_print*/ 351 0, /*tp_getattr*/ 352 0, /*tp_setattr*/ 353 0, /*tp_compare*/ 354 0, /*tp_repr*/ 355 0, /*tp_as_number*/ 356 0, /*tp_as_sequence*/ 357 0, /*tp_as_mapping*/ 358 0, /*tp_hash */ 359 0, /*tp_call*/ 360 0, /*tp_str*/ 361 0, /*tp_getattro*/ 362 0, /*tp_setattro*/ 363 0, /*tp_as_buffer*/ 364 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /*tp_flags*/ 365 "GDB thread object", /* tp_doc */ 366 0, /* tp_traverse */ 367 0, /* tp_clear */ 368 0, /* tp_richcompare */ 369 0, /* tp_weaklistoffset */ 370 0, /* tp_iter */ 371 0, /* tp_iternext */ 372 thread_object_methods, /* tp_methods */ 373 0, /* tp_members */ 374 thread_object_getset, /* tp_getset */ 375 0, /* tp_base */ 376 0, /* tp_dict */ 377 0, /* tp_descr_get */ 378 0, /* tp_descr_set */ 379 0, /* tp_dictoffset */ 380 0, /* tp_init */ 381 0 /* tp_alloc */ 382 }; 383