gdb/gdbserver/fbsd-low.c

46    ``all_processes'' is keyed by the process ID - which on Linux is (presently)
79 /* This function should only be called if the process got a SIGTRAP.
83    If we were single-stepping this process using PT_STEP,
87    If we continue the process using PTRACE_CONT, we will get a
115   struct process_info *process;
117   process = (struct process_info *) malloc (sizeof (*process));
118   memset (process, 0, sizeof (*process));
120   process->head.id = pid;
123   process->tid = pid;
124   process->lwpid = pid;
126   add_inferior_to_list (&all_processes, &process->head);
128   return process;
131 /* Start an inferior process and returns its pid.
164 /* Attach to an inferior process.  */
173       fprintf (stderr, "Cannot attach to process %d: %s (%d)\n", pid,
187      brings it to a halt.  We should ignore that SIGSTOP and resume the process
188      (unless this is the first process, in which case the flag will be cleared
203   struct process_info *process;
207   /* Don't ignore the initial SIGSTOP if we just attached to this process.  */
208   process = (struct process_info *) find_inferior_id (&all_processes, pid);
209   process->stop_expected = 0;
214 /* Kill the inferior process.  Make us have no inferior.  */
220   struct process_info *process = get_thread_process (thread);
225       ptrace (PT_KILL, pid_of (process), 0, 0);
242   struct process_info *process = get_thread_process (thread);
244   ptrace (PT_DETACH, pid_of (process), 0, 0);
263 /* Return nonzero if this process stopped at a breakpoint which
323 /* Return 1 if this process has an interesting status pending.  This function
324    may silently resume an inferior process.  */
328   struct process_info *process = (struct process_info *) entry;
330   if (process->status_pending_p)
331     if (check_removed_breakpoint (process))
338 	   before; resume the process.  */
339 	fbsd_resume_one_process (&process->head, 0, 0);
343   return process->status_pending_p;
400   /* Check for a process with a pending status.  */
434   /* We only enter this loop if no process has a pending wait status.  Thus
522 	 Notice that we will resume the process after hitting
565 	     process.  */
598 	 Check if it is a breakpoint, and if so mark the process information
618 /* Wait for process, returns status.  */
700   struct process_info *process = (struct process_info *) entry;
702   if (process->stopped)
705   /* If we already have a pending stop signal for this process, don't
707   if (process->stop_expected)
709       process->stop_expected = 0;
714     fprintf (stderr, "Sending sigstop to process %d\n", process->head.id);
716   kill (process->head.id, SIGSTOP);
717   process->sigstop_sent = 1;
723   struct process_info *process = (struct process_info *) entry;
727   if (process->stopped)
733 						    process->tid);
737      and record the pending SIGSTOP.  If the process exited, just
744       process->status_pending_p = 1;
745       process->status_pending = wstat;
746       process->stop_expected = 1;
770 /* Resume execution of the inferior process.
778   struct process_info *process = (struct process_info *) entry;
781   if (process->stopped == 0)
788       && (process->status_pending_p || process->pending_signals != NULL
789 	  || process->bp_reinsert != 0))
793       p_sig->prev = process->pending_signals;
795       process->pending_signals = p_sig;
798   if (process->status_pending_p && !check_removed_breakpoint (process))
802   current_inferior = get_process_thread (process);
805     fprintf (stderr, "Resuming process %d (%s, signal %d, stop %s)\n", inferior_pid,
807 	     process->stop_expected ? "expected" : "not expected");
819   if (process->bp_reinsert != 0)
822 	fprintf (stderr, "  pending reinsert at %08lx", (long)process->bp_reinsert);
831   check_removed_breakpoint (process);
841   if (process->pending_signals != NULL && process->bp_reinsert == 0)
845       p_sig = &process->pending_signals;
855 			   get_process_thread (process));
857   process->stopped = 0;
858   process->stepping = step;
859   ptrace (step ? PT_STEP : PT_CONTINUE, process->lwpid, (PTRACE_ARG3_TYPE) 1, signal);
878   struct process_info *process;
883   process = get_thread_process (thread);
889   process->resume = &resume_ptr[ndx];
901   struct process_info *process;
906   process = get_thread_process (thread);
908   if (process->resume->leave_stopped)
911   if (process->resume->thread == -1)
912     step = process->stepping || process->resume->step;
914     step = process->resume->step;
916   fbsd_resume_one_process (&process->head, step, process->resume->sig);
918   process->resume = NULL;
931   struct process_info *process;
935   process = get_thread_process (thread);
937   if (process->resume->leave_stopped)
941   if (process->resume->sig != 0)
945       p_sig->prev = process->pending_signals;
946       p_sig->signal = process->resume->sig;
947       process->pending_signals = p_sig;
950   process->resume = NULL;
953 /* Set DUMMY if this process has an interesting status pending.  */
957   struct process_info *process = (struct process_info *) entry;
961   if (process->resume->leave_stopped)
972   if (process->status_pending_p)
973     check_removed_breakpoint (process);
975   if (process->status_pending_p)
1198       struct process_info *process;
1200       process = get_thread_process (current_inferior);
1201       kill (process->lwpid, signum);