1 /* Continuations for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2013 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 "continuations.h" 24 25 struct continuation 26 { 27 struct continuation *next; 28 continuation_ftype *function; 29 continuation_free_arg_ftype *free_arg; 30 void *arg; 31 }; 32 33 /* Add a new continuation to the continuation chain. Args are 34 FUNCTION to run the continuation up with, and ARG to pass to 35 it. */ 36 37 static void 38 make_continuation (struct continuation **pmy_chain, 39 continuation_ftype *function, 40 void *arg, void (*free_arg) (void *)) 41 { 42 struct continuation *new = XNEW (struct continuation); 43 44 new->next = *pmy_chain; 45 new->function = function; 46 new->free_arg = free_arg; 47 new->arg = arg; 48 *pmy_chain = new; 49 } 50 51 static void 52 do_my_continuations_1 (struct continuation **pmy_chain, int err) 53 { 54 struct continuation *ptr; 55 56 while ((ptr = *pmy_chain) != NULL) 57 { 58 *pmy_chain = ptr->next; /* Do this first in case of recursion. */ 59 (*ptr->function) (ptr->arg, err); 60 if (ptr->free_arg) 61 (*ptr->free_arg) (ptr->arg); 62 xfree (ptr); 63 } 64 } 65 66 static void 67 do_my_continuations (struct continuation **list, int err) 68 { 69 struct continuation *continuations; 70 71 if (*list == NULL) 72 return; 73 74 /* Copy the list header into another pointer, and set the global 75 list header to null, so that the global list can change as a side 76 effect of invoking the continuations and the processing of the 77 preexisting continuations will not be affected. */ 78 79 continuations = *list; 80 *list = NULL; 81 82 /* Work now on the list we have set aside. */ 83 do_my_continuations_1 (&continuations, err); 84 } 85 86 static void 87 discard_my_continuations_1 (struct continuation **pmy_chain) 88 { 89 struct continuation *ptr; 90 91 while ((ptr = *pmy_chain) != NULL) 92 { 93 *pmy_chain = ptr->next; 94 if (ptr->free_arg) 95 (*ptr->free_arg) (ptr->arg); 96 xfree (ptr); 97 } 98 } 99 100 static void 101 discard_my_continuations (struct continuation **list) 102 { 103 discard_my_continuations_1 (list); 104 *list = NULL; 105 } 106 107 /* Add a continuation to the continuation list of INFERIOR. The new 108 continuation will be added at the front. */ 109 110 void 111 add_inferior_continuation (continuation_ftype *hook, void *args, 112 continuation_free_arg_ftype *free_arg) 113 { 114 struct inferior *inf = current_inferior (); 115 116 make_continuation (&inf->continuations, hook, args, free_arg); 117 } 118 119 /* Do all continuations of the current inferior. */ 120 121 void 122 do_all_inferior_continuations (int err) 123 { 124 struct inferior *inf = current_inferior (); 125 do_my_continuations (&inf->continuations, err); 126 } 127 128 /* Get rid of all the inferior-wide continuations of INF. */ 129 130 void 131 discard_all_inferior_continuations (struct inferior *inf) 132 { 133 discard_my_continuations (&inf->continuations); 134 } 135 136 /* Add a continuation to the continuation list of THREAD. The new 137 continuation will be added at the front. */ 138 139 void 140 add_continuation (struct thread_info *thread, 141 continuation_ftype *hook, void *args, 142 continuation_free_arg_ftype *free_arg) 143 { 144 make_continuation (&thread->continuations, hook, args, free_arg); 145 } 146 147 static void 148 restore_thread_cleanup (void *arg) 149 { 150 ptid_t *ptid_p = arg; 151 152 switch_to_thread (*ptid_p); 153 } 154 155 /* Walk down the continuation list of PTID, and execute all the 156 continuations. There is a problem though. In some cases new 157 continuations may be added while we are in the middle of this loop. 158 If this happens they will be added in the front, and done before we 159 have a chance of exhausting those that were already there. We need 160 to then save the beginning of the list in a pointer and do the 161 continuations from there on, instead of using the global beginning 162 of list as our iteration pointer. */ 163 164 static void 165 do_all_continuations_ptid (ptid_t ptid, 166 struct continuation **continuations_p, 167 int err) 168 { 169 struct cleanup *old_chain; 170 ptid_t current_thread; 171 172 if (*continuations_p == NULL) 173 return; 174 175 current_thread = inferior_ptid; 176 177 /* Restore selected thread on exit. Don't try to restore the frame 178 as well, because: 179 180 - When running continuations, the selected frame is always #0. 181 182 - The continuations may trigger symbol file loads, which may 183 change the frame layout (frame ids change), which would trigger 184 a warning if we used make_cleanup_restore_current_thread. */ 185 186 old_chain = make_cleanup (restore_thread_cleanup, ¤t_thread); 187 188 /* Let the continuation see this thread as selected. */ 189 switch_to_thread (ptid); 190 191 do_my_continuations (continuations_p, err); 192 193 do_cleanups (old_chain); 194 } 195 196 /* Callback for iterate over threads. */ 197 198 static int 199 do_all_continuations_thread_callback (struct thread_info *thread, void *data) 200 { 201 int err = * (int *) data; 202 do_all_continuations_ptid (thread->ptid, &thread->continuations, err); 203 return 0; 204 } 205 206 /* Do all continuations of thread THREAD. */ 207 208 void 209 do_all_continuations_thread (struct thread_info *thread, int err) 210 { 211 do_all_continuations_thread_callback (thread, &err); 212 } 213 214 /* Do all continuations of all threads. */ 215 216 void 217 do_all_continuations (int err) 218 { 219 iterate_over_threads (do_all_continuations_thread_callback, &err); 220 } 221 222 /* Callback for iterate over threads. */ 223 224 static int 225 discard_all_continuations_thread_callback (struct thread_info *thread, 226 void *data) 227 { 228 discard_my_continuations (&thread->continuations); 229 return 0; 230 } 231 232 /* Get rid of all the continuations of THREAD. */ 233 234 void 235 discard_all_continuations_thread (struct thread_info *thread) 236 { 237 discard_all_continuations_thread_callback (thread, NULL); 238 } 239 240 /* Get rid of all the continuations of all threads. */ 241 242 void 243 discard_all_continuations (void) 244 { 245 iterate_over_threads (discard_all_continuations_thread_callback, NULL); 246 } 247 248 249 /* Add a continuation to the intermediate continuation list of THREAD. 250 The new continuation will be added at the front. */ 251 252 void 253 add_intermediate_continuation (struct thread_info *thread, 254 continuation_ftype *hook, 255 void *args, 256 continuation_free_arg_ftype *free_arg) 257 { 258 make_continuation (&thread->intermediate_continuations, hook, 259 args, free_arg); 260 } 261 262 /* Walk down the cmd_continuation list, and execute all the 263 continuations. There is a problem though. In some cases new 264 continuations may be added while we are in the middle of this 265 loop. If this happens they will be added in the front, and done 266 before we have a chance of exhausting those that were already 267 there. We need to then save the beginning of the list in a pointer 268 and do the continuations from there on, instead of using the 269 global beginning of list as our iteration pointer. */ 270 271 static int 272 do_all_intermediate_continuations_thread_callback (struct thread_info *thread, 273 void *data) 274 { 275 int err = * (int *) data; 276 277 do_all_continuations_ptid (thread->ptid, 278 &thread->intermediate_continuations, err); 279 return 0; 280 } 281 282 /* Do all intermediate continuations of thread THREAD. */ 283 284 void 285 do_all_intermediate_continuations_thread (struct thread_info *thread, int err) 286 { 287 do_all_intermediate_continuations_thread_callback (thread, &err); 288 } 289 290 /* Do all intermediate continuations of all threads. */ 291 292 void 293 do_all_intermediate_continuations (int err) 294 { 295 iterate_over_threads (do_all_intermediate_continuations_thread_callback, 296 &err); 297 } 298 299 /* Callback for iterate over threads. */ 300 301 static int 302 discard_all_intermediate_continuations_thread_callback (struct thread_info *thread, 303 void *data) 304 { 305 discard_my_continuations (&thread->intermediate_continuations); 306 return 0; 307 } 308 309 /* Get rid of all the intermediate continuations of THREAD. */ 310 311 void 312 discard_all_intermediate_continuations_thread (struct thread_info *thread) 313 { 314 discard_all_intermediate_continuations_thread_callback (thread, NULL); 315 } 316 317 /* Get rid of all the intermediate continuations of all threads. */ 318 319 void 320 discard_all_intermediate_continuations (void) 321 { 322 iterate_over_threads (discard_all_intermediate_continuations_thread_callback, 323 NULL); 324 } 325