1 | /*- |
---|
2 | * Copyright (c) 1986, 1989, 1991, 1993 |
---|
3 | * The Regents of the University of California. All rights reserved. |
---|
4 | * (c) UNIX System Laboratories, Inc. |
---|
5 | * All or some portions of this file are derived from material licensed |
---|
6 | * to the University of California by American Telephone and Telegraph |
---|
7 | * Co. or Unix System Laboratories, Inc. and are reproduced herein with |
---|
8 | * the permission of UNIX System Laboratories, Inc. |
---|
9 | * |
---|
10 | * Redistribution and use in source and binary forms, with or without |
---|
11 | * modification, are permitted provided that the following conditions |
---|
12 | * are met: |
---|
13 | * 1. Redistributions of source code must retain the above copyright |
---|
14 | * notice, this list of conditions and the following disclaimer. |
---|
15 | * 2. Redistributions in binary form must reproduce the above copyright |
---|
16 | * notice, this list of conditions and the following disclaimer in the |
---|
17 | * documentation and/or other materials provided with the distribution. |
---|
18 | * 3. Neither the name of the University nor the names of its contributors |
---|
19 | * may be used to endorse or promote products derived from this software |
---|
20 | * without specific prior written permission. |
---|
21 | * |
---|
22 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
---|
23 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
---|
24 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
---|
25 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
---|
26 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
---|
27 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
---|
28 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
---|
29 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
---|
30 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
---|
31 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
---|
32 | * SUCH DAMAGE. |
---|
33 | * |
---|
34 | * @(#)proc.h 8.15 (Berkeley) 5/19/95 |
---|
35 | * $FreeBSD$ |
---|
36 | */ |
---|
37 | |
---|
38 | #ifndef _SYS_PROC_H_ |
---|
39 | #define _SYS_PROC_H_ |
---|
40 | |
---|
41 | #include <sys/callout.h> /* For struct callout. */ |
---|
42 | #include <sys/event.h> /* For struct klist. */ |
---|
43 | #include <sys/condvar.h> |
---|
44 | #ifndef _KERNEL |
---|
45 | #include <sys/filedesc.h> |
---|
46 | #endif |
---|
47 | #include <sys/queue.h> |
---|
48 | #include <sys/_lock.h> |
---|
49 | #include <sys/lock_profile.h> |
---|
50 | #include <sys/_mutex.h> |
---|
51 | #include <sys/osd.h> |
---|
52 | #include <sys/priority.h> |
---|
53 | #include <sys/rtprio.h> /* XXX. */ |
---|
54 | #include <sys/runq.h> |
---|
55 | #include <rtems/bsd/sys/resource.h> |
---|
56 | #include <sys/sigio.h> |
---|
57 | #include <sys/signal.h> |
---|
58 | #include <sys/signalvar.h> |
---|
59 | #ifndef _KERNEL |
---|
60 | #include <sys/time.h> /* For structs itimerval, timeval. */ |
---|
61 | #else |
---|
62 | #include <sys/pcpu.h> |
---|
63 | #endif |
---|
64 | #include <sys/ucontext.h> |
---|
65 | #include <sys/ucred.h> |
---|
66 | #include <sys/_vm_domain.h> |
---|
67 | #include <machine/proc.h> /* Machine-dependent proc substruct. */ |
---|
68 | |
---|
69 | /* |
---|
70 | * One structure allocated per session. |
---|
71 | * |
---|
72 | * List of locks |
---|
73 | * (m) locked by s_mtx mtx |
---|
74 | * (e) locked by proctree_lock sx |
---|
75 | * (c) const until freeing |
---|
76 | */ |
---|
77 | struct session { |
---|
78 | u_int s_count; /* Ref cnt; pgrps in session - atomic. */ |
---|
79 | struct proc *s_leader; /* (m + e) Session leader. */ |
---|
80 | struct vnode *s_ttyvp; /* (m) Vnode of controlling tty. */ |
---|
81 | struct cdev_priv *s_ttydp; /* (m) Device of controlling tty. */ |
---|
82 | struct tty *s_ttyp; /* (e) Controlling tty. */ |
---|
83 | pid_t s_sid; /* (c) Session ID. */ |
---|
84 | /* (m) Setlogin() name: */ |
---|
85 | char s_login[roundup(MAXLOGNAME, sizeof(long))]; |
---|
86 | struct mtx s_mtx; /* Mutex to protect members. */ |
---|
87 | }; |
---|
88 | |
---|
89 | /* |
---|
90 | * One structure allocated per process group. |
---|
91 | * |
---|
92 | * List of locks |
---|
93 | * (m) locked by pg_mtx mtx |
---|
94 | * (e) locked by proctree_lock sx |
---|
95 | * (c) const until freeing |
---|
96 | */ |
---|
97 | struct pgrp { |
---|
98 | LIST_ENTRY(pgrp) pg_hash; /* (e) Hash chain. */ |
---|
99 | LIST_HEAD(, proc) pg_members; /* (m + e) Pointer to pgrp members. */ |
---|
100 | struct session *pg_session; /* (c) Pointer to session. */ |
---|
101 | struct sigiolst pg_sigiolst; /* (m) List of sigio sources. */ |
---|
102 | pid_t pg_id; /* (c) Process group id. */ |
---|
103 | int pg_jobc; /* (m) Job control process count. */ |
---|
104 | struct mtx pg_mtx; /* Mutex to protect members */ |
---|
105 | }; |
---|
106 | |
---|
107 | /* |
---|
108 | * pargs, used to hold a copy of the command line, if it had a sane length. |
---|
109 | */ |
---|
110 | struct pargs { |
---|
111 | u_int ar_ref; /* Reference count. */ |
---|
112 | u_int ar_length; /* Length. */ |
---|
113 | u_char ar_args[1]; /* Arguments. */ |
---|
114 | }; |
---|
115 | |
---|
116 | /*- |
---|
117 | * Description of a process. |
---|
118 | * |
---|
119 | * This structure contains the information needed to manage a thread of |
---|
120 | * control, known in UN*X as a process; it has references to substructures |
---|
121 | * containing descriptions of things that the process uses, but may share |
---|
122 | * with related processes. The process structure and the substructures |
---|
123 | * are always addressable except for those marked "(CPU)" below, |
---|
124 | * which might be addressable only on a processor on which the process |
---|
125 | * is running. |
---|
126 | * |
---|
127 | * Below is a key of locks used to protect each member of struct proc. The |
---|
128 | * lock is indicated by a reference to a specific character in parens in the |
---|
129 | * associated comment. |
---|
130 | * * - not yet protected |
---|
131 | * a - only touched by curproc or parent during fork/wait |
---|
132 | * b - created at fork, never changes |
---|
133 | * (exception aiods switch vmspaces, but they are also |
---|
134 | * marked 'P_SYSTEM' so hopefully it will be left alone) |
---|
135 | * c - locked by proc mtx |
---|
136 | * d - locked by allproc_lock lock |
---|
137 | * e - locked by proctree_lock lock |
---|
138 | * f - session mtx |
---|
139 | * g - process group mtx |
---|
140 | * h - callout_lock mtx |
---|
141 | * i - by curproc or the master session mtx |
---|
142 | * j - locked by proc slock |
---|
143 | * k - only accessed by curthread |
---|
144 | * k*- only accessed by curthread and from an interrupt |
---|
145 | * l - the attaching proc or attaching proc parent |
---|
146 | * m - Giant |
---|
147 | * n - not locked, lazy |
---|
148 | * o - ktrace lock |
---|
149 | * q - td_contested lock |
---|
150 | * r - p_peers lock |
---|
151 | * s - see sleepq_switch(), sleeping_on_old_rtc(), and sleep(9) |
---|
152 | * t - thread lock |
---|
153 | * u - process stat lock |
---|
154 | * w - process timer lock |
---|
155 | * x - created at fork, only changes during single threading in exec |
---|
156 | * y - created at first aio, doesn't change until exit or exec at which |
---|
157 | * point we are single-threaded and only curthread changes it |
---|
158 | * z - zombie threads lock |
---|
159 | * |
---|
160 | * If the locking key specifies two identifiers (for example, p_pptr) then |
---|
161 | * either lock is sufficient for read access, but both locks must be held |
---|
162 | * for write access. |
---|
163 | */ |
---|
164 | struct cpuset; |
---|
165 | struct filecaps; |
---|
166 | struct filemon; |
---|
167 | struct kaioinfo; |
---|
168 | struct kaudit_record; |
---|
169 | struct kdtrace_proc; |
---|
170 | struct kdtrace_thread; |
---|
171 | struct mqueue_notifier; |
---|
172 | struct nlminfo; |
---|
173 | struct p_sched; |
---|
174 | struct proc; |
---|
175 | struct procdesc; |
---|
176 | struct racct; |
---|
177 | struct sbuf; |
---|
178 | struct sleepqueue; |
---|
179 | struct syscall_args; |
---|
180 | struct td_sched; |
---|
181 | struct thread; |
---|
182 | struct trapframe; |
---|
183 | struct turnstile; |
---|
184 | |
---|
185 | /* |
---|
186 | * XXX: Does this belong in resource.h or resourcevar.h instead? |
---|
187 | * Resource usage extension. The times in rusage structs in the kernel are |
---|
188 | * never up to date. The actual times are kept as runtimes and tick counts |
---|
189 | * (with control info in the "previous" times), and are converted when |
---|
190 | * userland asks for rusage info. Backwards compatibility prevents putting |
---|
191 | * this directly in the user-visible rusage struct. |
---|
192 | * |
---|
193 | * Locking for p_rux: (cu) means (u) for p_rux and (c) for p_crux. |
---|
194 | * Locking for td_rux: (t) for all fields. |
---|
195 | */ |
---|
196 | struct rusage_ext { |
---|
197 | uint64_t rux_runtime; /* (cu) Real time. */ |
---|
198 | uint64_t rux_uticks; /* (cu) Statclock hits in user mode. */ |
---|
199 | uint64_t rux_sticks; /* (cu) Statclock hits in sys mode. */ |
---|
200 | uint64_t rux_iticks; /* (cu) Statclock hits in intr mode. */ |
---|
201 | uint64_t rux_uu; /* (c) Previous user time in usec. */ |
---|
202 | uint64_t rux_su; /* (c) Previous sys time in usec. */ |
---|
203 | uint64_t rux_tu; /* (c) Previous total time in usec. */ |
---|
204 | }; |
---|
205 | #ifdef __rtems__ |
---|
206 | #include <errno.h> |
---|
207 | |
---|
208 | enum thread_sq_states { |
---|
209 | TD_SQ_WAKEUP, |
---|
210 | TD_SQ_PANIC = EWOULDBLOCK, |
---|
211 | TD_SQ_TIRED, |
---|
212 | TD_SQ_SLEEPY, |
---|
213 | TD_SQ_SLEEPING, |
---|
214 | TD_SQ_NIGHTMARE |
---|
215 | }; |
---|
216 | #endif /* __rtems__ */ |
---|
217 | |
---|
218 | /* |
---|
219 | * Kernel runnable context (thread). |
---|
220 | * This is what is put to sleep and reactivated. |
---|
221 | * Thread context. Processes may have multiple threads. |
---|
222 | */ |
---|
223 | struct thread { |
---|
224 | #ifdef __rtems__ |
---|
225 | Thread_Control *td_thread; |
---|
226 | struct rtems_bsd_program_control *td_prog_ctrl; |
---|
227 | #endif /* __rtems__ */ |
---|
228 | #ifndef __rtems__ |
---|
229 | struct mtx *volatile td_lock; /* replaces sched lock */ |
---|
230 | struct proc *td_proc; /* (*) Associated process. */ |
---|
231 | TAILQ_ENTRY(thread) td_plist; /* (*) All threads in this proc. */ |
---|
232 | TAILQ_ENTRY(thread) td_runq; /* (t) Run queue. */ |
---|
233 | #endif /* __rtems__ */ |
---|
234 | TAILQ_ENTRY(thread) td_slpq; /* (t) Sleep queue. */ |
---|
235 | #ifndef __rtems__ |
---|
236 | TAILQ_ENTRY(thread) td_lockq; /* (t) Lock queue. */ |
---|
237 | LIST_ENTRY(thread) td_hash; /* (d) Hash chain. */ |
---|
238 | struct cpuset *td_cpuset; /* (t) CPU affinity mask. */ |
---|
239 | #endif /* __rtems__ */ |
---|
240 | struct seltd *td_sel; /* Select queue/channel. */ |
---|
241 | struct sleepqueue *td_sleepqueue; /* (k) Associated sleep queue. */ |
---|
242 | #ifndef __rtems__ |
---|
243 | struct turnstile *td_turnstile; /* (k) Associated turnstile. */ |
---|
244 | struct rl_q_entry *td_rlqe; /* (k) Associated range lock entry. */ |
---|
245 | struct umtx_q *td_umtxq; /* (c?) Link for when we're blocked. */ |
---|
246 | struct vm_domain_policy td_vm_dom_policy; /* (c) current numa domain policy */ |
---|
247 | lwpid_t td_tid; /* (b) Thread ID. */ |
---|
248 | sigqueue_t td_sigqueue; /* (c) Sigs arrived, not delivered. */ |
---|
249 | #define td_siglist td_sigqueue.sq_signals |
---|
250 | u_char td_lend_user_pri; /* (t) Lend user pri. */ |
---|
251 | |
---|
252 | /* Cleared during fork1() */ |
---|
253 | #define td_startzero td_flags |
---|
254 | int td_flags; /* (t) TDF_* flags. */ |
---|
255 | int td_inhibitors; /* (t) Why can not run. */ |
---|
256 | int td_pflags; /* (k) Private thread (TDP_*) flags. */ |
---|
257 | int td_dupfd; /* (k) Ret value from fdopen. XXX */ |
---|
258 | #endif /* __rtems__ */ |
---|
259 | #ifdef __rtems__ |
---|
260 | enum thread_sq_states td_sq_state; |
---|
261 | #endif /* __rtems__ */ |
---|
262 | int td_sqqueue; /* (t) Sleepqueue queue blocked on. */ |
---|
263 | void *td_wchan; /* (t) Sleep address. */ |
---|
264 | #ifndef __rtems__ |
---|
265 | const char *td_wmesg; /* (t) Reason for sleep. */ |
---|
266 | volatile u_char td_owepreempt; /* (k*) Preempt on last critical_exit */ |
---|
267 | u_char td_tsqueue; /* (t) Turnstile queue blocked on. */ |
---|
268 | short td_locks; /* (k) Debug: count of non-spin locks */ |
---|
269 | short td_rw_rlocks; /* (k) Count of rwlock read locks. */ |
---|
270 | short td_lk_slocks; /* (k) Count of lockmgr shared locks. */ |
---|
271 | short td_stopsched; /* (k) Scheduler stopped. */ |
---|
272 | struct turnstile *td_blocked; /* (t) Lock thread is blocked on. */ |
---|
273 | const char *td_lockname; /* (t) Name of lock blocked on. */ |
---|
274 | LIST_HEAD(, turnstile) td_contested; /* (q) Contested locks. */ |
---|
275 | struct lock_list_entry *td_sleeplocks; /* (k) Held sleep locks. */ |
---|
276 | int td_intr_nesting_level; /* (k) Interrupt recursion. */ |
---|
277 | int td_pinned; /* (k) Temporary cpu pin count. */ |
---|
278 | #endif /* __rtems__ */ |
---|
279 | struct ucred *td_ucred; /* (k) Reference to credentials. */ |
---|
280 | #ifndef __rtems__ |
---|
281 | struct plimit *td_limit; /* (k) Resource limits. */ |
---|
282 | u_int td_estcpu; /* (t) estimated cpu utilization */ |
---|
283 | int td_slptick; /* (t) Time at sleep. */ |
---|
284 | int td_blktick; /* (t) Time spent blocked. */ |
---|
285 | int td_swvoltick; /* (t) Time at last SW_VOL switch. */ |
---|
286 | int td_swinvoltick; /* (t) Time at last SW_INVOL switch. */ |
---|
287 | u_int td_cow; /* (*) Number of copy-on-write faults */ |
---|
288 | struct rusage td_ru; /* (t) rusage information. */ |
---|
289 | struct rusage_ext td_rux; /* (t) Internal rusage information. */ |
---|
290 | uint64_t td_incruntime; /* (t) Cpu ticks to transfer to proc. */ |
---|
291 | uint64_t td_runtime; /* (t) How many cpu ticks we've run. */ |
---|
292 | u_int td_pticks; /* (t) Statclock hits for profiling */ |
---|
293 | u_int td_sticks; /* (t) Statclock hits in system mode. */ |
---|
294 | u_int td_iticks; /* (t) Statclock hits in intr mode. */ |
---|
295 | u_int td_uticks; /* (t) Statclock hits in user mode. */ |
---|
296 | int td_intrval; /* (t) Return value for sleepq. */ |
---|
297 | sigset_t td_oldsigmask; /* (k) Saved mask from pre sigpause. */ |
---|
298 | volatile u_int td_generation; /* (k) For detection of preemption */ |
---|
299 | stack_t td_sigstk; /* (k) Stack ptr and on-stack flag. */ |
---|
300 | int td_xsig; /* (c) Signal for ptrace */ |
---|
301 | u_long td_profil_addr; /* (k) Temporary addr until AST. */ |
---|
302 | u_int td_profil_ticks; /* (k) Temporary ticks until AST. */ |
---|
303 | char td_name[MAXCOMLEN + 1]; /* (*) Thread name. */ |
---|
304 | struct file *td_fpop; /* (k) file referencing cdev under op */ |
---|
305 | int td_dbgflags; /* (c) Userland debugger flags */ |
---|
306 | siginfo_t td_si; /* (c) For debugger or core file */ |
---|
307 | int td_ng_outbound; /* (k) Thread entered ng from above. */ |
---|
308 | struct osd td_osd; /* (k) Object specific data. */ |
---|
309 | struct vm_map_entry *td_map_def_user; /* (k) Deferred entries. */ |
---|
310 | pid_t td_dbg_forked; /* (c) Child pid for debugger. */ |
---|
311 | u_int td_vp_reserv; /* (k) Count of reserved vnodes. */ |
---|
312 | int td_no_sleeping; /* (k) Sleeping disabled count. */ |
---|
313 | int td_dom_rr_idx; /* (k) RR Numa domain selection. */ |
---|
314 | void *td_su; /* (k) FFS SU private */ |
---|
315 | sbintime_t td_sleeptimo; /* (t) Sleep timeout. */ |
---|
316 | int td_rtcgen; /* (s) rtc_generation of abs. sleep */ |
---|
317 | #define td_endzero td_sigmask |
---|
318 | |
---|
319 | /* Copied during fork1() or create_thread(). */ |
---|
320 | #define td_startcopy td_endzero |
---|
321 | sigset_t td_sigmask; /* (c) Current signal mask. */ |
---|
322 | u_char td_rqindex; /* (t) Run queue index. */ |
---|
323 | u_char td_base_pri; /* (t) Thread base kernel priority. */ |
---|
324 | u_char td_priority; /* (t) Thread active priority. */ |
---|
325 | u_char td_pri_class; /* (t) Scheduling class. */ |
---|
326 | u_char td_user_pri; /* (t) User pri from estcpu and nice. */ |
---|
327 | u_char td_base_user_pri; /* (t) Base user pri */ |
---|
328 | u_int td_dbg_sc_code; /* (c) Syscall code to debugger. */ |
---|
329 | u_int td_dbg_sc_narg; /* (c) Syscall arg count to debugger.*/ |
---|
330 | uintptr_t td_rb_list; /* (k) Robust list head. */ |
---|
331 | uintptr_t td_rbp_list; /* (k) Robust priv list head. */ |
---|
332 | uintptr_t td_rb_inact; /* (k) Current in-action mutex loc. */ |
---|
333 | #define td_endcopy td_pcb |
---|
334 | |
---|
335 | /* |
---|
336 | * Fields that must be manually set in fork1() or create_thread() |
---|
337 | * or already have been set in the allocator, constructor, etc. |
---|
338 | */ |
---|
339 | struct pcb *td_pcb; /* (k) Kernel VA of pcb and kstack. */ |
---|
340 | enum { |
---|
341 | TDS_INACTIVE = 0x0, |
---|
342 | TDS_INHIBITED, |
---|
343 | TDS_CAN_RUN, |
---|
344 | TDS_RUNQ, |
---|
345 | TDS_RUNNING |
---|
346 | } td_state; /* (t) thread state */ |
---|
347 | union { |
---|
348 | register_t tdu_retval[2]; |
---|
349 | off_t tdu_off; |
---|
350 | } td_uretoff; /* (k) Syscall aux returns. */ |
---|
351 | #else /* __rtems__ */ |
---|
352 | register_t td_retval[2]; /* (k) Syscall aux returns. */ |
---|
353 | #endif /* __rtems__ */ |
---|
354 | #ifndef __rtems__ |
---|
355 | #define td_retval td_uretoff.tdu_retval |
---|
356 | u_int td_cowgen; /* (k) Generation of COW pointers. */ |
---|
357 | struct callout td_slpcallout; /* (h) Callout for sleep. */ |
---|
358 | struct trapframe *td_frame; /* (k) */ |
---|
359 | struct vm_object *td_kstack_obj;/* (a) Kstack object. */ |
---|
360 | vm_offset_t td_kstack; /* (a) Kernel VA of kstack. */ |
---|
361 | int td_kstack_pages; /* (a) Size of the kstack. */ |
---|
362 | volatile u_int td_critnest; /* (k*) Critical section nest level. */ |
---|
363 | struct mdthread td_md; /* (k) Any machine-dependent fields. */ |
---|
364 | struct kaudit_record *td_ar; /* (k) Active audit record, if any. */ |
---|
365 | struct lpohead td_lprof[2]; /* (a) lock profiling objects. */ |
---|
366 | struct kdtrace_thread *td_dtrace; /* (*) DTrace-specific data. */ |
---|
367 | int td_errno; /* Error returned by last syscall. */ |
---|
368 | struct vnet *td_vnet; /* (k) Effective vnet. */ |
---|
369 | const char *td_vnet_lpush; /* (k) Debugging vnet push / pop. */ |
---|
370 | struct trapframe *td_intr_frame;/* (k) Frame of the current irq */ |
---|
371 | struct proc *td_rfppwait_p; /* (k) The vforked child */ |
---|
372 | struct vm_page **td_ma; /* (k) uio pages held */ |
---|
373 | int td_ma_cnt; /* (k) size of *td_ma */ |
---|
374 | void *td_emuldata; /* Emulator state data */ |
---|
375 | int td_lastcpu; /* (t) Last cpu we were on. */ |
---|
376 | int td_oncpu; /* (t) Which cpu we are on. */ |
---|
377 | void *td_lkpi_task; /* LinuxKPI task struct pointer */ |
---|
378 | #endif /* __rtems__ */ |
---|
379 | }; |
---|
380 | |
---|
381 | struct thread0_storage { |
---|
382 | struct thread t0st_thread; |
---|
383 | uint64_t t0st_sched[10]; |
---|
384 | }; |
---|
385 | |
---|
386 | struct mtx *thread_lock_block(struct thread *); |
---|
387 | void thread_lock_unblock(struct thread *, struct mtx *); |
---|
388 | void thread_lock_set(struct thread *, struct mtx *); |
---|
389 | #ifndef __rtems__ |
---|
390 | #define THREAD_LOCK_ASSERT(td, type) \ |
---|
391 | do { \ |
---|
392 | struct mtx *__m = (td)->td_lock; \ |
---|
393 | if (__m != &blocked_lock) \ |
---|
394 | mtx_assert(__m, (type)); \ |
---|
395 | } while (0) |
---|
396 | #else /* __rtems__ */ |
---|
397 | #define THREAD_LOCK_ASSERT(td, type) |
---|
398 | #endif /* __rtems__ */ |
---|
399 | |
---|
400 | #ifdef INVARIANTS |
---|
401 | #define THREAD_LOCKPTR_ASSERT(td, lock) \ |
---|
402 | do { \ |
---|
403 | struct mtx *__m = (td)->td_lock; \ |
---|
404 | KASSERT((__m == &blocked_lock || __m == (lock)), \ |
---|
405 | ("Thread %p lock %p does not match %p", td, __m, (lock))); \ |
---|
406 | } while (0) |
---|
407 | |
---|
408 | #define TD_LOCKS_INC(td) ((td)->td_locks++) |
---|
409 | #define TD_LOCKS_DEC(td) ((td)->td_locks--) |
---|
410 | #else |
---|
411 | #define THREAD_LOCKPTR_ASSERT(td, lock) |
---|
412 | |
---|
413 | #define TD_LOCKS_INC(td) |
---|
414 | #define TD_LOCKS_DEC(td) |
---|
415 | #endif |
---|
416 | |
---|
417 | /* |
---|
418 | * Flags kept in td_flags: |
---|
419 | * To change these you MUST have the scheduler lock. |
---|
420 | */ |
---|
421 | #define TDF_BORROWING 0x00000001 /* Thread is borrowing pri from another. */ |
---|
422 | #define TDF_INPANIC 0x00000002 /* Caused a panic, let it drive crashdump. */ |
---|
423 | #define TDF_INMEM 0x00000004 /* Thread's stack is in memory. */ |
---|
424 | #define TDF_SINTR 0x00000008 /* Sleep is interruptible. */ |
---|
425 | #define TDF_TIMEOUT 0x00000010 /* Timing out during sleep. */ |
---|
426 | #define TDF_IDLETD 0x00000020 /* This is a per-CPU idle thread. */ |
---|
427 | #define TDF_CANSWAP 0x00000040 /* Thread can be swapped. */ |
---|
428 | #define TDF_SLEEPABORT 0x00000080 /* sleepq_abort was called. */ |
---|
429 | #define TDF_KTH_SUSP 0x00000100 /* kthread is suspended */ |
---|
430 | #define TDF_ALLPROCSUSP 0x00000200 /* suspended by SINGLE_ALLPROC */ |
---|
431 | #define TDF_BOUNDARY 0x00000400 /* Thread suspended at user boundary */ |
---|
432 | #define TDF_ASTPENDING 0x00000800 /* Thread has some asynchronous events. */ |
---|
433 | #define TDF_UNUSED12 0x00001000 /* --available-- */ |
---|
434 | #define TDF_SBDRY 0x00002000 /* Stop only on usermode boundary. */ |
---|
435 | #define TDF_UPIBLOCKED 0x00004000 /* Thread blocked on user PI mutex. */ |
---|
436 | #define TDF_NEEDSUSPCHK 0x00008000 /* Thread may need to suspend. */ |
---|
437 | #define TDF_NEEDRESCHED 0x00010000 /* Thread needs to yield. */ |
---|
438 | #define TDF_NEEDSIGCHK 0x00020000 /* Thread may need signal delivery. */ |
---|
439 | #define TDF_NOLOAD 0x00040000 /* Ignore during load avg calculations. */ |
---|
440 | #define TDF_SERESTART 0x00080000 /* ERESTART on stop attempts. */ |
---|
441 | #define TDF_THRWAKEUP 0x00100000 /* Libthr thread must not suspend itself. */ |
---|
442 | #define TDF_SEINTR 0x00200000 /* EINTR on stop attempts. */ |
---|
443 | #define TDF_SWAPINREQ 0x00400000 /* Swapin request due to wakeup. */ |
---|
444 | #define TDF_UNUSED23 0x00800000 /* --available-- */ |
---|
445 | #define TDF_SCHED0 0x01000000 /* Reserved for scheduler private use */ |
---|
446 | #define TDF_SCHED1 0x02000000 /* Reserved for scheduler private use */ |
---|
447 | #define TDF_SCHED2 0x04000000 /* Reserved for scheduler private use */ |
---|
448 | #define TDF_SCHED3 0x08000000 /* Reserved for scheduler private use */ |
---|
449 | #define TDF_ALRMPEND 0x10000000 /* Pending SIGVTALRM needs to be posted. */ |
---|
450 | #define TDF_PROFPEND 0x20000000 /* Pending SIGPROF needs to be posted. */ |
---|
451 | #define TDF_MACPEND 0x40000000 /* AST-based MAC event pending. */ |
---|
452 | |
---|
453 | /* Userland debug flags */ |
---|
454 | #define TDB_SUSPEND 0x00000001 /* Thread is suspended by debugger */ |
---|
455 | #define TDB_XSIG 0x00000002 /* Thread is exchanging signal under trace */ |
---|
456 | #define TDB_USERWR 0x00000004 /* Debugger modified memory or registers */ |
---|
457 | #define TDB_SCE 0x00000008 /* Thread performs syscall enter */ |
---|
458 | #define TDB_SCX 0x00000010 /* Thread performs syscall exit */ |
---|
459 | #define TDB_EXEC 0x00000020 /* TDB_SCX from exec(2) family */ |
---|
460 | #define TDB_FORK 0x00000040 /* TDB_SCX from fork(2) that created new |
---|
461 | process */ |
---|
462 | #define TDB_STOPATFORK 0x00000080 /* Stop at the return from fork (child |
---|
463 | only) */ |
---|
464 | #define TDB_CHILD 0x00000100 /* New child indicator for ptrace() */ |
---|
465 | #define TDB_BORN 0x00000200 /* New LWP indicator for ptrace() */ |
---|
466 | #define TDB_EXIT 0x00000400 /* Exiting LWP indicator for ptrace() */ |
---|
467 | #define TDB_VFORK 0x00000800 /* vfork indicator for ptrace() */ |
---|
468 | #define TDB_FSTP 0x00001000 /* The thread is PT_ATTACH leader */ |
---|
469 | |
---|
470 | /* |
---|
471 | * "Private" flags kept in td_pflags: |
---|
472 | * These are only written by curthread and thus need no locking. |
---|
473 | */ |
---|
474 | #define TDP_OLDMASK 0x00000001 /* Need to restore mask after suspend. */ |
---|
475 | #define TDP_INKTR 0x00000002 /* Thread is currently in KTR code. */ |
---|
476 | #define TDP_INKTRACE 0x00000004 /* Thread is currently in KTRACE code. */ |
---|
477 | #define TDP_BUFNEED 0x00000008 /* Do not recurse into the buf flush */ |
---|
478 | #define TDP_COWINPROGRESS 0x00000010 /* Snapshot copy-on-write in progress. */ |
---|
479 | #define TDP_ALTSTACK 0x00000020 /* Have alternate signal stack. */ |
---|
480 | #define TDP_DEADLKTREAT 0x00000040 /* Lock acquisition - deadlock treatment. */ |
---|
481 | #define TDP_NOFAULTING 0x00000080 /* Do not handle page faults. */ |
---|
482 | #define TDP_UNUSED9 0x00000100 /* --available-- */ |
---|
483 | #define TDP_OWEUPC 0x00000200 /* Call addupc() at next AST. */ |
---|
484 | #define TDP_ITHREAD 0x00000400 /* Thread is an interrupt thread. */ |
---|
485 | #define TDP_SYNCIO 0x00000800 /* Local override, disable async i/o. */ |
---|
486 | #define TDP_SCHED1 0x00001000 /* Reserved for scheduler private use */ |
---|
487 | #define TDP_SCHED2 0x00002000 /* Reserved for scheduler private use */ |
---|
488 | #define TDP_SCHED3 0x00004000 /* Reserved for scheduler private use */ |
---|
489 | #define TDP_SCHED4 0x00008000 /* Reserved for scheduler private use */ |
---|
490 | #define TDP_GEOM 0x00010000 /* Settle GEOM before finishing syscall */ |
---|
491 | #define TDP_SOFTDEP 0x00020000 /* Stuck processing softdep worklist */ |
---|
492 | #define TDP_NORUNNINGBUF 0x00040000 /* Ignore runningbufspace check */ |
---|
493 | #define TDP_WAKEUP 0x00080000 /* Don't sleep in umtx cond_wait */ |
---|
494 | #define TDP_INBDFLUSH 0x00100000 /* Already in BO_BDFLUSH, do not recurse */ |
---|
495 | #define TDP_KTHREAD 0x00200000 /* This is an official kernel thread */ |
---|
496 | #define TDP_CALLCHAIN 0x00400000 /* Capture thread's callchain */ |
---|
497 | #define TDP_IGNSUSP 0x00800000 /* Permission to ignore the MNTK_SUSPEND* */ |
---|
498 | #define TDP_AUDITREC 0x01000000 /* Audit record pending on thread */ |
---|
499 | #define TDP_RFPPWAIT 0x02000000 /* Handle RFPPWAIT on syscall exit */ |
---|
500 | #define TDP_RESETSPUR 0x04000000 /* Reset spurious page fault history. */ |
---|
501 | #define TDP_NERRNO 0x08000000 /* Last errno is already in td_errno */ |
---|
502 | #define TDP_UIOHELD 0x10000000 /* Current uio has pages held in td_ma */ |
---|
503 | #define TDP_FORKING 0x20000000 /* Thread is being created through fork() */ |
---|
504 | #define TDP_EXECVMSPC 0x40000000 /* Execve destroyed old vmspace */ |
---|
505 | |
---|
506 | /* |
---|
507 | * Reasons that the current thread can not be run yet. |
---|
508 | * More than one may apply. |
---|
509 | */ |
---|
510 | #define TDI_SUSPENDED 0x0001 /* On suspension queue. */ |
---|
511 | #define TDI_SLEEPING 0x0002 /* Actually asleep! (tricky). */ |
---|
512 | #define TDI_SWAPPED 0x0004 /* Stack not in mem. Bad juju if run. */ |
---|
513 | #define TDI_LOCK 0x0008 /* Stopped on a lock. */ |
---|
514 | #define TDI_IWAIT 0x0010 /* Awaiting interrupt. */ |
---|
515 | |
---|
516 | #define TD_IS_SLEEPING(td) ((td)->td_inhibitors & TDI_SLEEPING) |
---|
517 | #define TD_ON_SLEEPQ(td) ((td)->td_wchan != NULL) |
---|
518 | #define TD_IS_SUSPENDED(td) ((td)->td_inhibitors & TDI_SUSPENDED) |
---|
519 | #define TD_IS_SWAPPED(td) ((td)->td_inhibitors & TDI_SWAPPED) |
---|
520 | #define TD_ON_LOCK(td) ((td)->td_inhibitors & TDI_LOCK) |
---|
521 | #define TD_AWAITING_INTR(td) ((td)->td_inhibitors & TDI_IWAIT) |
---|
522 | #ifndef __rtems__ |
---|
523 | #define TD_IS_RUNNING(td) ((td)->td_state == TDS_RUNNING) |
---|
524 | #else /* __rtems__ */ |
---|
525 | #define TD_IS_RUNNING(td) (1) |
---|
526 | #endif /* __rtems__ */ |
---|
527 | #define TD_ON_RUNQ(td) ((td)->td_state == TDS_RUNQ) |
---|
528 | #define TD_CAN_RUN(td) ((td)->td_state == TDS_CAN_RUN) |
---|
529 | #define TD_IS_INHIBITED(td) ((td)->td_state == TDS_INHIBITED) |
---|
530 | #define TD_ON_UPILOCK(td) ((td)->td_flags & TDF_UPIBLOCKED) |
---|
531 | #define TD_IS_IDLETHREAD(td) ((td)->td_flags & TDF_IDLETD) |
---|
532 | |
---|
533 | #define KTDSTATE(td) \ |
---|
534 | (((td)->td_inhibitors & TDI_SLEEPING) != 0 ? "sleep" : \ |
---|
535 | ((td)->td_inhibitors & TDI_SUSPENDED) != 0 ? "suspended" : \ |
---|
536 | ((td)->td_inhibitors & TDI_SWAPPED) != 0 ? "swapped" : \ |
---|
537 | ((td)->td_inhibitors & TDI_LOCK) != 0 ? "blocked" : \ |
---|
538 | ((td)->td_inhibitors & TDI_IWAIT) != 0 ? "iwait" : "yielding") |
---|
539 | |
---|
540 | #define TD_SET_INHIB(td, inhib) do { \ |
---|
541 | (td)->td_state = TDS_INHIBITED; \ |
---|
542 | (td)->td_inhibitors |= (inhib); \ |
---|
543 | } while (0) |
---|
544 | |
---|
545 | #define TD_CLR_INHIB(td, inhib) do { \ |
---|
546 | if (((td)->td_inhibitors & (inhib)) && \ |
---|
547 | (((td)->td_inhibitors &= ~(inhib)) == 0)) \ |
---|
548 | (td)->td_state = TDS_CAN_RUN; \ |
---|
549 | } while (0) |
---|
550 | |
---|
551 | #define TD_SET_SLEEPING(td) TD_SET_INHIB((td), TDI_SLEEPING) |
---|
552 | #define TD_SET_SWAPPED(td) TD_SET_INHIB((td), TDI_SWAPPED) |
---|
553 | #define TD_SET_LOCK(td) TD_SET_INHIB((td), TDI_LOCK) |
---|
554 | #define TD_SET_SUSPENDED(td) TD_SET_INHIB((td), TDI_SUSPENDED) |
---|
555 | #define TD_SET_IWAIT(td) TD_SET_INHIB((td), TDI_IWAIT) |
---|
556 | #define TD_SET_EXITING(td) TD_SET_INHIB((td), TDI_EXITING) |
---|
557 | |
---|
558 | #define TD_CLR_SLEEPING(td) TD_CLR_INHIB((td), TDI_SLEEPING) |
---|
559 | #define TD_CLR_SWAPPED(td) TD_CLR_INHIB((td), TDI_SWAPPED) |
---|
560 | #define TD_CLR_LOCK(td) TD_CLR_INHIB((td), TDI_LOCK) |
---|
561 | #define TD_CLR_SUSPENDED(td) TD_CLR_INHIB((td), TDI_SUSPENDED) |
---|
562 | #define TD_CLR_IWAIT(td) TD_CLR_INHIB((td), TDI_IWAIT) |
---|
563 | |
---|
564 | #define TD_SET_RUNNING(td) (td)->td_state = TDS_RUNNING |
---|
565 | #define TD_SET_RUNQ(td) (td)->td_state = TDS_RUNQ |
---|
566 | #define TD_SET_CAN_RUN(td) (td)->td_state = TDS_CAN_RUN |
---|
567 | |
---|
568 | #define TD_SBDRY_INTR(td) \ |
---|
569 | (((td)->td_flags & (TDF_SEINTR | TDF_SERESTART)) != 0) |
---|
570 | #define TD_SBDRY_ERRNO(td) \ |
---|
571 | (((td)->td_flags & TDF_SEINTR) != 0 ? EINTR : ERESTART) |
---|
572 | |
---|
573 | /* |
---|
574 | * Process structure. |
---|
575 | */ |
---|
576 | struct proc { |
---|
577 | #ifndef __rtems__ |
---|
578 | LIST_ENTRY(proc) p_list; /* (d) List of all processes. */ |
---|
579 | TAILQ_HEAD(, thread) p_threads; /* (c) all threads. */ |
---|
580 | struct mtx p_slock; /* process spin lock */ |
---|
581 | struct ucred *p_ucred; /* (c) Process owner's identity. */ |
---|
582 | struct filedesc *p_fd; /* (b) Open files. */ |
---|
583 | struct filedesc_to_leader *p_fdtol; /* (b) Tracking node */ |
---|
584 | struct pstats *p_stats; /* (b) Accounting/statistics (CPU). */ |
---|
585 | struct plimit *p_limit; /* (c) Resource limits. */ |
---|
586 | struct callout p_limco; /* (c) Limit callout handle */ |
---|
587 | struct sigacts *p_sigacts; /* (x) Signal actions, state (CPU). */ |
---|
588 | |
---|
589 | int p_flag; /* (c) P_* flags. */ |
---|
590 | int p_flag2; /* (c) P2_* flags. */ |
---|
591 | enum { |
---|
592 | PRS_NEW = 0, /* In creation */ |
---|
593 | PRS_NORMAL, /* threads can be run. */ |
---|
594 | PRS_ZOMBIE |
---|
595 | } p_state; /* (j/c) Process status. */ |
---|
596 | pid_t p_pid; /* (b) Process identifier. */ |
---|
597 | LIST_ENTRY(proc) p_hash; /* (d) Hash chain. */ |
---|
598 | LIST_ENTRY(proc) p_pglist; /* (g + e) List of processes in pgrp. */ |
---|
599 | struct proc *p_pptr; /* (c + e) Pointer to parent process. */ |
---|
600 | LIST_ENTRY(proc) p_sibling; /* (e) List of sibling processes. */ |
---|
601 | LIST_HEAD(, proc) p_children; /* (e) Pointer to list of children. */ |
---|
602 | struct proc *p_reaper; /* (e) My reaper. */ |
---|
603 | LIST_HEAD(, proc) p_reaplist; /* (e) List of my descendants |
---|
604 | (if I am reaper). */ |
---|
605 | LIST_ENTRY(proc) p_reapsibling; /* (e) List of siblings - descendants of |
---|
606 | the same reaper. */ |
---|
607 | struct mtx p_mtx; /* (n) Lock for this struct. */ |
---|
608 | struct mtx p_statmtx; /* Lock for the stats */ |
---|
609 | struct mtx p_itimmtx; /* Lock for the virt/prof timers */ |
---|
610 | struct mtx p_profmtx; /* Lock for the profiling */ |
---|
611 | struct ksiginfo *p_ksi; /* Locked by parent proc lock */ |
---|
612 | sigqueue_t p_sigqueue; /* (c) Sigs not delivered to a td. */ |
---|
613 | #define p_siglist p_sigqueue.sq_signals |
---|
614 | |
---|
615 | /* The following fields are all zeroed upon creation in fork. */ |
---|
616 | #define p_startzero p_oppid |
---|
617 | pid_t p_oppid; /* (c + e) Save ppid in ptrace. XXX */ |
---|
618 | struct vmspace *p_vmspace; /* (b) Address space. */ |
---|
619 | u_int p_swtick; /* (c) Tick when swapped in or out. */ |
---|
620 | u_int p_cowgen; /* (c) Generation of COW pointers. */ |
---|
621 | struct itimerval p_realtimer; /* (c) Alarm timer. */ |
---|
622 | struct rusage p_ru; /* (a) Exit information. */ |
---|
623 | struct rusage_ext p_rux; /* (cu) Internal resource usage. */ |
---|
624 | struct rusage_ext p_crux; /* (c) Internal child resource usage. */ |
---|
625 | int p_profthreads; /* (c) Num threads in addupc_task. */ |
---|
626 | volatile int p_exitthreads; /* (j) Number of threads exiting */ |
---|
627 | int p_traceflag; /* (o) Kernel trace points. */ |
---|
628 | struct vnode *p_tracevp; /* (c + o) Trace to vnode. */ |
---|
629 | struct ucred *p_tracecred; /* (o) Credentials to trace with. */ |
---|
630 | struct vnode *p_textvp; /* (b) Vnode of executable. */ |
---|
631 | u_int p_lock; /* (c) Proclock (prevent swap) count. */ |
---|
632 | struct sigiolst p_sigiolst; /* (c) List of sigio sources. */ |
---|
633 | int p_sigparent; /* (c) Signal to parent on exit. */ |
---|
634 | int p_sig; /* (n) For core dump/debugger XXX. */ |
---|
635 | u_long p_code; /* (n) For core dump/debugger XXX. */ |
---|
636 | u_int p_stops; /* (c) Stop event bitmask. */ |
---|
637 | u_int p_stype; /* (c) Stop event type. */ |
---|
638 | char p_step; /* (c) Process is stopped. */ |
---|
639 | u_char p_pfsflags; /* (c) Procfs flags. */ |
---|
640 | u_int p_ptevents; /* (c) ptrace() event mask. */ |
---|
641 | struct nlminfo *p_nlminfo; /* (?) Only used by/for lockd. */ |
---|
642 | struct kaioinfo *p_aioinfo; /* (y) ASYNC I/O info. */ |
---|
643 | struct thread *p_singlethread;/* (c + j) If single threading this is it */ |
---|
644 | int p_suspcount; /* (j) Num threads in suspended mode. */ |
---|
645 | struct thread *p_xthread; /* (c) Trap thread */ |
---|
646 | int p_boundary_count;/* (j) Num threads at user boundary */ |
---|
647 | int p_pendingcnt; /* how many signals are pending */ |
---|
648 | struct itimers *p_itimers; /* (c) POSIX interval timers. */ |
---|
649 | struct procdesc *p_procdesc; /* (e) Process descriptor, if any. */ |
---|
650 | u_int p_treeflag; /* (e) P_TREE flags */ |
---|
651 | int p_pendingexits; /* (c) Count of pending thread exits. */ |
---|
652 | struct filemon *p_filemon; /* (c) filemon-specific data. */ |
---|
653 | /* End area that is zeroed on creation. */ |
---|
654 | #define p_endzero p_magic |
---|
655 | |
---|
656 | /* The following fields are all copied upon creation in fork. */ |
---|
657 | #define p_startcopy p_endzero |
---|
658 | u_int p_magic; /* (b) Magic number. */ |
---|
659 | int p_osrel; /* (x) osreldate for the |
---|
660 | binary (from ELF note, if any) */ |
---|
661 | char p_comm[MAXCOMLEN + 1]; /* (x) Process name. */ |
---|
662 | struct sysentvec *p_sysent; /* (b) Syscall dispatch info. */ |
---|
663 | struct pargs *p_args; /* (c) Process arguments. */ |
---|
664 | rlim_t p_cpulimit; /* (c) Current CPU limit in seconds. */ |
---|
665 | signed char p_nice; /* (c) Process "nice" value. */ |
---|
666 | int p_fibnum; /* in this routing domain XXX MRT */ |
---|
667 | pid_t p_reapsubtree; /* (e) Pid of the direct child of the |
---|
668 | reaper which spawned |
---|
669 | our subtree. */ |
---|
670 | u_int p_xexit; /* (c) Exit code. */ |
---|
671 | u_int p_xsig; /* (c) Stop/kill sig. */ |
---|
672 | uint16_t p_elf_machine; /* (x) ELF machine type */ |
---|
673 | uint64_t p_elf_flags; /* (x) ELF flags */ |
---|
674 | |
---|
675 | /* End area that is copied on creation. */ |
---|
676 | #define p_endcopy p_elf_flags |
---|
677 | struct pgrp *p_pgrp; /* (c + e) Pointer to process group. */ |
---|
678 | struct knlist *p_klist; /* (c) Knotes attached to this proc. */ |
---|
679 | int p_numthreads; /* (c) Number of threads. */ |
---|
680 | struct mdproc p_md; /* Any machine-dependent fields. */ |
---|
681 | struct callout p_itcallout; /* (h + c) Interval timer callout. */ |
---|
682 | u_short p_acflag; /* (c) Accounting flags. */ |
---|
683 | struct proc *p_peers; /* (r) */ |
---|
684 | struct proc *p_leader; /* (b) */ |
---|
685 | void *p_emuldata; /* (c) Emulator state data. */ |
---|
686 | struct label *p_label; /* (*) Proc (not subject) MAC label. */ |
---|
687 | STAILQ_HEAD(, ktr_request) p_ktr; /* (o) KTR event queue. */ |
---|
688 | LIST_HEAD(, mqueue_notifier) p_mqnotifier; /* (c) mqueue notifiers.*/ |
---|
689 | struct kdtrace_proc *p_dtrace; /* (*) DTrace-specific data. */ |
---|
690 | struct cv p_pwait; /* (*) wait cv for exit/exec. */ |
---|
691 | struct cv p_dbgwait; /* (*) wait cv for debugger attach |
---|
692 | after fork. */ |
---|
693 | uint64_t p_prev_runtime; /* (c) Resource usage accounting. */ |
---|
694 | struct racct *p_racct; /* (b) Resource accounting. */ |
---|
695 | int p_throttled; /* (c) Flag for racct pcpu throttling */ |
---|
696 | struct vm_domain_policy p_vm_dom_policy; /* (c) process default VM domain, or -1 */ |
---|
697 | /* |
---|
698 | * An orphan is the child that has beed re-parented to the |
---|
699 | * debugger as a result of attaching to it. Need to keep |
---|
700 | * track of them for parent to be able to collect the exit |
---|
701 | * status of what used to be children. |
---|
702 | */ |
---|
703 | LIST_ENTRY(proc) p_orphan; /* (e) List of orphan processes. */ |
---|
704 | LIST_HEAD(, proc) p_orphans; /* (e) Pointer to list of orphans. */ |
---|
705 | #endif /* __rtems__ */ |
---|
706 | }; |
---|
707 | |
---|
708 | #define p_session p_pgrp->pg_session |
---|
709 | #define p_pgid p_pgrp->pg_id |
---|
710 | |
---|
711 | #define NOCPU (-1) /* For when we aren't on a CPU. */ |
---|
712 | #define NOCPU_OLD (255) |
---|
713 | #define MAXCPU_OLD (254) |
---|
714 | |
---|
715 | #define PROC_SLOCK(p) mtx_lock_spin(&(p)->p_slock) |
---|
716 | #define PROC_SUNLOCK(p) mtx_unlock_spin(&(p)->p_slock) |
---|
717 | #define PROC_SLOCK_ASSERT(p, type) mtx_assert(&(p)->p_slock, (type)) |
---|
718 | |
---|
719 | #define PROC_STATLOCK(p) mtx_lock_spin(&(p)->p_statmtx) |
---|
720 | #define PROC_STATUNLOCK(p) mtx_unlock_spin(&(p)->p_statmtx) |
---|
721 | #define PROC_STATLOCK_ASSERT(p, type) mtx_assert(&(p)->p_statmtx, (type)) |
---|
722 | |
---|
723 | #define PROC_ITIMLOCK(p) mtx_lock_spin(&(p)->p_itimmtx) |
---|
724 | #define PROC_ITIMUNLOCK(p) mtx_unlock_spin(&(p)->p_itimmtx) |
---|
725 | #define PROC_ITIMLOCK_ASSERT(p, type) mtx_assert(&(p)->p_itimmtx, (type)) |
---|
726 | |
---|
727 | #define PROC_PROFLOCK(p) mtx_lock_spin(&(p)->p_profmtx) |
---|
728 | #define PROC_PROFUNLOCK(p) mtx_unlock_spin(&(p)->p_profmtx) |
---|
729 | #define PROC_PROFLOCK_ASSERT(p, type) mtx_assert(&(p)->p_profmtx, (type)) |
---|
730 | |
---|
731 | /* These flags are kept in p_flag. */ |
---|
732 | #define P_ADVLOCK 0x00001 /* Process may hold a POSIX advisory lock. */ |
---|
733 | #define P_CONTROLT 0x00002 /* Has a controlling terminal. */ |
---|
734 | #define P_KPROC 0x00004 /* Kernel process. */ |
---|
735 | #define P_UNUSED3 0x00008 /* --available-- */ |
---|
736 | #define P_PPWAIT 0x00010 /* Parent is waiting for child to exec/exit. */ |
---|
737 | #define P_PROFIL 0x00020 /* Has started profiling. */ |
---|
738 | #define P_STOPPROF 0x00040 /* Has thread requesting to stop profiling. */ |
---|
739 | #define P_HADTHREADS 0x00080 /* Has had threads (no cleanup shortcuts) */ |
---|
740 | #define P_SUGID 0x00100 /* Had set id privileges since last exec. */ |
---|
741 | #define P_SYSTEM 0x00200 /* System proc: no sigs, stats or swapping. */ |
---|
742 | #define P_SINGLE_EXIT 0x00400 /* Threads suspending should exit, not wait. */ |
---|
743 | #define P_TRACED 0x00800 /* Debugged process being traced. */ |
---|
744 | #define P_WAITED 0x01000 /* Someone is waiting for us. */ |
---|
745 | #define P_WEXIT 0x02000 /* Working on exiting. */ |
---|
746 | #define P_EXEC 0x04000 /* Process called exec. */ |
---|
747 | #define P_WKILLED 0x08000 /* Killed, go to kernel/user boundary ASAP. */ |
---|
748 | #define P_CONTINUED 0x10000 /* Proc has continued from a stopped state. */ |
---|
749 | #define P_STOPPED_SIG 0x20000 /* Stopped due to SIGSTOP/SIGTSTP. */ |
---|
750 | #define P_STOPPED_TRACE 0x40000 /* Stopped because of tracing. */ |
---|
751 | #define P_STOPPED_SINGLE 0x80000 /* Only 1 thread can continue (not to user). */ |
---|
752 | #define P_PROTECTED 0x100000 /* Do not kill on memory overcommit. */ |
---|
753 | #define P_SIGEVENT 0x200000 /* Process pending signals changed. */ |
---|
754 | #define P_SINGLE_BOUNDARY 0x400000 /* Threads should suspend at user boundary. */ |
---|
755 | #define P_HWPMC 0x800000 /* Process is using HWPMCs */ |
---|
756 | #define P_JAILED 0x1000000 /* Process is in jail. */ |
---|
757 | #define P_TOTAL_STOP 0x2000000 /* Stopped in stop_all_proc. */ |
---|
758 | #define P_INEXEC 0x4000000 /* Process is in execve(). */ |
---|
759 | #define P_STATCHILD 0x8000000 /* Child process stopped or exited. */ |
---|
760 | #define P_INMEM 0x10000000 /* Loaded into memory. */ |
---|
761 | #define P_SWAPPINGOUT 0x20000000 /* Process is being swapped out. */ |
---|
762 | #define P_SWAPPINGIN 0x40000000 /* Process is being swapped in. */ |
---|
763 | #define P_PPTRACE 0x80000000 /* PT_TRACEME by vforked child. */ |
---|
764 | |
---|
765 | #define P_STOPPED (P_STOPPED_SIG|P_STOPPED_SINGLE|P_STOPPED_TRACE) |
---|
766 | #define P_SHOULDSTOP(p) ((p)->p_flag & P_STOPPED) |
---|
767 | #define P_KILLED(p) ((p)->p_flag & P_WKILLED) |
---|
768 | |
---|
769 | /* These flags are kept in p_flag2. */ |
---|
770 | #define P2_INHERIT_PROTECTED 0x00000001 /* New children get P_PROTECTED. */ |
---|
771 | #define P2_NOTRACE 0x00000002 /* No ptrace(2) attach or coredumps. */ |
---|
772 | #define P2_NOTRACE_EXEC 0x00000004 /* Keep P2_NOPTRACE on exec(2). */ |
---|
773 | #define P2_AST_SU 0x00000008 /* Handles SU ast for kthreads. */ |
---|
774 | #define P2_PTRACE_FSTP 0x00000010 /* SIGSTOP from PT_ATTACH not yet handled. */ |
---|
775 | #define P2_TRAPCAP 0x00000020 /* SIGTRAP on ENOTCAPABLE */ |
---|
776 | |
---|
777 | /* Flags protected by proctree_lock, kept in p_treeflags. */ |
---|
778 | #define P_TREE_ORPHANED 0x00000001 /* Reparented, on orphan list */ |
---|
779 | #define P_TREE_FIRST_ORPHAN 0x00000002 /* First element of orphan |
---|
780 | list */ |
---|
781 | #define P_TREE_REAPER 0x00000004 /* Reaper of subtree */ |
---|
782 | |
---|
783 | /* |
---|
784 | * These were process status values (p_stat), now they are only used in |
---|
785 | * legacy conversion code. |
---|
786 | */ |
---|
787 | #define SIDL 1 /* Process being created by fork. */ |
---|
788 | #define SRUN 2 /* Currently runnable. */ |
---|
789 | #define SSLEEP 3 /* Sleeping on an address. */ |
---|
790 | #define SSTOP 4 /* Process debugging or suspension. */ |
---|
791 | #define SZOMB 5 /* Awaiting collection by parent. */ |
---|
792 | #define SWAIT 6 /* Waiting for interrupt. */ |
---|
793 | #define SLOCK 7 /* Blocked on a lock. */ |
---|
794 | |
---|
795 | #define P_MAGIC 0xbeefface |
---|
796 | |
---|
797 | #ifdef _KERNEL |
---|
798 | |
---|
799 | /* Types and flags for mi_switch(). */ |
---|
800 | #define SW_TYPE_MASK 0xff /* First 8 bits are switch type */ |
---|
801 | #define SWT_NONE 0 /* Unspecified switch. */ |
---|
802 | #define SWT_PREEMPT 1 /* Switching due to preemption. */ |
---|
803 | #define SWT_OWEPREEMPT 2 /* Switching due to owepreempt. */ |
---|
804 | #define SWT_TURNSTILE 3 /* Turnstile contention. */ |
---|
805 | #define SWT_SLEEPQ 4 /* Sleepq wait. */ |
---|
806 | #define SWT_SLEEPQTIMO 5 /* Sleepq timeout wait. */ |
---|
807 | #define SWT_RELINQUISH 6 /* yield call. */ |
---|
808 | #define SWT_NEEDRESCHED 7 /* NEEDRESCHED was set. */ |
---|
809 | #define SWT_IDLE 8 /* Switching from the idle thread. */ |
---|
810 | #define SWT_IWAIT 9 /* Waiting for interrupts. */ |
---|
811 | #define SWT_SUSPEND 10 /* Thread suspended. */ |
---|
812 | #define SWT_REMOTEPREEMPT 11 /* Remote processor preempted. */ |
---|
813 | #define SWT_REMOTEWAKEIDLE 12 /* Remote processor preempted idle. */ |
---|
814 | #define SWT_COUNT 13 /* Number of switch types. */ |
---|
815 | /* Flags */ |
---|
816 | #define SW_VOL 0x0100 /* Voluntary switch. */ |
---|
817 | #define SW_INVOL 0x0200 /* Involuntary switch. */ |
---|
818 | #define SW_PREEMPT 0x0400 /* The invol switch is a preemption */ |
---|
819 | |
---|
820 | /* How values for thread_single(). */ |
---|
821 | #define SINGLE_NO_EXIT 0 |
---|
822 | #define SINGLE_EXIT 1 |
---|
823 | #define SINGLE_BOUNDARY 2 |
---|
824 | #define SINGLE_ALLPROC 3 |
---|
825 | |
---|
826 | #ifdef MALLOC_DECLARE |
---|
827 | MALLOC_DECLARE(M_PARGS); |
---|
828 | MALLOC_DECLARE(M_PGRP); |
---|
829 | MALLOC_DECLARE(M_SESSION); |
---|
830 | MALLOC_DECLARE(M_SUBPROC); |
---|
831 | #endif |
---|
832 | |
---|
833 | #define FOREACH_PROC_IN_SYSTEM(p) \ |
---|
834 | LIST_FOREACH((p), &allproc, p_list) |
---|
835 | #define FOREACH_THREAD_IN_PROC(p, td) \ |
---|
836 | TAILQ_FOREACH((td), &(p)->p_threads, td_plist) |
---|
837 | |
---|
838 | #define FIRST_THREAD_IN_PROC(p) TAILQ_FIRST(&(p)->p_threads) |
---|
839 | |
---|
840 | /* |
---|
841 | * We use process IDs <= pid_max <= PID_MAX; PID_MAX + 1 must also fit |
---|
842 | * in a pid_t, as it is used to represent "no process group". |
---|
843 | */ |
---|
844 | #define PID_MAX 99999 |
---|
845 | #define NO_PID 100000 |
---|
846 | extern pid_t pid_max; |
---|
847 | |
---|
848 | #define SESS_LEADER(p) ((p)->p_session->s_leader == (p)) |
---|
849 | |
---|
850 | |
---|
851 | #define STOPEVENT(p, e, v) do { \ |
---|
852 | WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, NULL, \ |
---|
853 | "checking stopevent %d", (e)); \ |
---|
854 | if ((p)->p_stops & (e)) { \ |
---|
855 | PROC_LOCK(p); \ |
---|
856 | stopevent((p), (e), (v)); \ |
---|
857 | PROC_UNLOCK(p); \ |
---|
858 | } \ |
---|
859 | } while (0) |
---|
860 | #define _STOPEVENT(p, e, v) do { \ |
---|
861 | PROC_LOCK_ASSERT(p, MA_OWNED); \ |
---|
862 | WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, &p->p_mtx.lock_object, \ |
---|
863 | "checking stopevent %d", (e)); \ |
---|
864 | if ((p)->p_stops & (e)) \ |
---|
865 | stopevent((p), (e), (v)); \ |
---|
866 | } while (0) |
---|
867 | |
---|
868 | /* Lock and unlock a process. */ |
---|
869 | #define PROC_LOCK(p) mtx_lock(&(p)->p_mtx) |
---|
870 | #define PROC_TRYLOCK(p) mtx_trylock(&(p)->p_mtx) |
---|
871 | #define PROC_UNLOCK(p) mtx_unlock(&(p)->p_mtx) |
---|
872 | #define PROC_LOCKED(p) mtx_owned(&(p)->p_mtx) |
---|
873 | #define PROC_LOCK_ASSERT(p, type) mtx_assert(&(p)->p_mtx, (type)) |
---|
874 | |
---|
875 | /* Lock and unlock a process group. */ |
---|
876 | #define PGRP_LOCK(pg) mtx_lock(&(pg)->pg_mtx) |
---|
877 | #define PGRP_UNLOCK(pg) mtx_unlock(&(pg)->pg_mtx) |
---|
878 | #define PGRP_LOCKED(pg) mtx_owned(&(pg)->pg_mtx) |
---|
879 | #define PGRP_LOCK_ASSERT(pg, type) mtx_assert(&(pg)->pg_mtx, (type)) |
---|
880 | |
---|
881 | #define PGRP_LOCK_PGSIGNAL(pg) do { \ |
---|
882 | if ((pg) != NULL) \ |
---|
883 | PGRP_LOCK(pg); \ |
---|
884 | } while (0) |
---|
885 | #define PGRP_UNLOCK_PGSIGNAL(pg) do { \ |
---|
886 | if ((pg) != NULL) \ |
---|
887 | PGRP_UNLOCK(pg); \ |
---|
888 | } while (0) |
---|
889 | |
---|
890 | /* Lock and unlock a session. */ |
---|
891 | #define SESS_LOCK(s) mtx_lock(&(s)->s_mtx) |
---|
892 | #define SESS_UNLOCK(s) mtx_unlock(&(s)->s_mtx) |
---|
893 | #define SESS_LOCKED(s) mtx_owned(&(s)->s_mtx) |
---|
894 | #define SESS_LOCK_ASSERT(s, type) mtx_assert(&(s)->s_mtx, (type)) |
---|
895 | |
---|
896 | /* |
---|
897 | * Non-zero p_lock ensures that: |
---|
898 | * - exit1() is not performed until p_lock reaches zero; |
---|
899 | * - the process' threads stack are not swapped out if they are currently |
---|
900 | * not (P_INMEM). |
---|
901 | * |
---|
902 | * PHOLD() asserts that the process (except the current process) is |
---|
903 | * not exiting, increments p_lock and swaps threads stacks into memory, |
---|
904 | * if needed. |
---|
905 | * _PHOLD() is same as PHOLD(), it takes the process locked. |
---|
906 | * _PHOLD_LITE() also takes the process locked, but comparing with |
---|
907 | * _PHOLD(), it only guarantees that exit1() is not executed, |
---|
908 | * faultin() is not called. |
---|
909 | */ |
---|
910 | #ifndef __rtems__ |
---|
911 | #define PHOLD(p) do { \ |
---|
912 | PROC_LOCK(p); \ |
---|
913 | _PHOLD(p); \ |
---|
914 | PROC_UNLOCK(p); \ |
---|
915 | } while (0) |
---|
916 | #define _PHOLD(p) do { \ |
---|
917 | PROC_LOCK_ASSERT((p), MA_OWNED); \ |
---|
918 | KASSERT(!((p)->p_flag & P_WEXIT) || (p) == curproc, \ |
---|
919 | ("PHOLD of exiting process %p", p)); \ |
---|
920 | (p)->p_lock++; \ |
---|
921 | if (((p)->p_flag & P_INMEM) == 0) \ |
---|
922 | faultin((p)); \ |
---|
923 | } while (0) |
---|
924 | #define _PHOLD_LITE(p) do { \ |
---|
925 | PROC_LOCK_ASSERT((p), MA_OWNED); \ |
---|
926 | KASSERT(!((p)->p_flag & P_WEXIT) || (p) == curproc, \ |
---|
927 | ("PHOLD of exiting process %p", p)); \ |
---|
928 | (p)->p_lock++; \ |
---|
929 | } while (0) |
---|
930 | #define PROC_ASSERT_HELD(p) do { \ |
---|
931 | KASSERT((p)->p_lock > 0, ("process %p not held", p)); \ |
---|
932 | } while (0) |
---|
933 | |
---|
934 | #define PRELE(p) do { \ |
---|
935 | PROC_LOCK((p)); \ |
---|
936 | _PRELE((p)); \ |
---|
937 | PROC_UNLOCK((p)); \ |
---|
938 | } while (0) |
---|
939 | #define _PRELE(p) do { \ |
---|
940 | PROC_LOCK_ASSERT((p), MA_OWNED); \ |
---|
941 | PROC_ASSERT_HELD(p); \ |
---|
942 | (--(p)->p_lock); \ |
---|
943 | if (((p)->p_flag & P_WEXIT) && (p)->p_lock == 0) \ |
---|
944 | wakeup(&(p)->p_lock); \ |
---|
945 | } while (0) |
---|
946 | #define PROC_ASSERT_NOT_HELD(p) do { \ |
---|
947 | KASSERT((p)->p_lock == 0, ("process %p held", p)); \ |
---|
948 | } while (0) |
---|
949 | |
---|
950 | #define PROC_UPDATE_COW(p) do { \ |
---|
951 | PROC_LOCK_ASSERT((p), MA_OWNED); \ |
---|
952 | (p)->p_cowgen++; \ |
---|
953 | } while (0) |
---|
954 | #else /* __rtems__ */ |
---|
955 | #define PHOLD(x) do { } while (0) |
---|
956 | #define PRELE(x) do { } while (0) |
---|
957 | #endif /* __rtems__ */ |
---|
958 | |
---|
959 | /* Check whether a thread is safe to be swapped out. */ |
---|
960 | #define thread_safetoswapout(td) ((td)->td_flags & TDF_CANSWAP) |
---|
961 | |
---|
962 | /* Control whether or not it is safe for curthread to sleep. */ |
---|
963 | #define THREAD_NO_SLEEPING() ((curthread)->td_no_sleeping++) |
---|
964 | |
---|
965 | #define THREAD_SLEEPING_OK() ((curthread)->td_no_sleeping--) |
---|
966 | |
---|
967 | #define THREAD_CAN_SLEEP() ((curthread)->td_no_sleeping == 0) |
---|
968 | |
---|
969 | #define PIDHASH(pid) (&pidhashtbl[(pid) & pidhash]) |
---|
970 | extern LIST_HEAD(pidhashhead, proc) *pidhashtbl; |
---|
971 | extern u_long pidhash; |
---|
972 | #define TIDHASH(tid) (&tidhashtbl[(tid) & tidhash]) |
---|
973 | extern LIST_HEAD(tidhashhead, thread) *tidhashtbl; |
---|
974 | extern u_long tidhash; |
---|
975 | extern struct rwlock tidhash_lock; |
---|
976 | |
---|
977 | #define PGRPHASH(pgid) (&pgrphashtbl[(pgid) & pgrphash]) |
---|
978 | extern LIST_HEAD(pgrphashhead, pgrp) *pgrphashtbl; |
---|
979 | extern u_long pgrphash; |
---|
980 | |
---|
981 | extern struct sx allproc_lock; |
---|
982 | extern int allproc_gen; |
---|
983 | extern struct sx proctree_lock; |
---|
984 | extern struct mtx ppeers_lock; |
---|
985 | extern struct proc proc0; /* Process slot for swapper. */ |
---|
986 | extern struct thread0_storage thread0_st; /* Primary thread in proc0. */ |
---|
987 | #define thread0 (thread0_st.t0st_thread) |
---|
988 | extern struct vmspace vmspace0; /* VM space for proc0. */ |
---|
989 | extern int hogticks; /* Limit on kernel cpu hogs. */ |
---|
990 | extern int lastpid; |
---|
991 | extern int nprocs, maxproc; /* Current and max number of procs. */ |
---|
992 | extern int maxprocperuid; /* Max procs per uid. */ |
---|
993 | extern u_long ps_arg_cache_limit; |
---|
994 | |
---|
995 | LIST_HEAD(proclist, proc); |
---|
996 | TAILQ_HEAD(procqueue, proc); |
---|
997 | TAILQ_HEAD(threadqueue, thread); |
---|
998 | extern struct proclist allproc; /* List of all processes. */ |
---|
999 | extern struct proclist zombproc; /* List of zombie processes. */ |
---|
1000 | extern struct proc *initproc, *pageproc; /* Process slots for init, pager. */ |
---|
1001 | |
---|
1002 | extern struct uma_zone *proc_zone; |
---|
1003 | |
---|
1004 | struct proc *pfind(pid_t); /* Find process by id. */ |
---|
1005 | struct proc *pfind_locked(pid_t pid); |
---|
1006 | struct pgrp *pgfind(pid_t); /* Find process group by id. */ |
---|
1007 | struct proc *zpfind(pid_t); /* Find zombie process by id. */ |
---|
1008 | |
---|
1009 | struct fork_req { |
---|
1010 | int fr_flags; |
---|
1011 | int fr_pages; |
---|
1012 | int *fr_pidp; |
---|
1013 | struct proc **fr_procp; |
---|
1014 | int *fr_pd_fd; |
---|
1015 | int fr_pd_flags; |
---|
1016 | struct filecaps *fr_pd_fcaps; |
---|
1017 | }; |
---|
1018 | |
---|
1019 | /* |
---|
1020 | * pget() flags. |
---|
1021 | */ |
---|
1022 | #define PGET_HOLD 0x00001 /* Hold the process. */ |
---|
1023 | #define PGET_CANSEE 0x00002 /* Check against p_cansee(). */ |
---|
1024 | #define PGET_CANDEBUG 0x00004 /* Check against p_candebug(). */ |
---|
1025 | #define PGET_ISCURRENT 0x00008 /* Check that the found process is current. */ |
---|
1026 | #define PGET_NOTWEXIT 0x00010 /* Check that the process is not in P_WEXIT. */ |
---|
1027 | #define PGET_NOTINEXEC 0x00020 /* Check that the process is not in P_INEXEC. */ |
---|
1028 | #define PGET_NOTID 0x00040 /* Do not assume tid if pid > PID_MAX. */ |
---|
1029 | |
---|
1030 | #define PGET_WANTREAD (PGET_HOLD | PGET_CANDEBUG | PGET_NOTWEXIT) |
---|
1031 | |
---|
1032 | int pget(pid_t pid, int flags, struct proc **pp); |
---|
1033 | |
---|
1034 | void ast(struct trapframe *framep); |
---|
1035 | struct thread *choosethread(void); |
---|
1036 | #ifndef __rtems__ |
---|
1037 | int cr_cansee(struct ucred *u1, struct ucred *u2); |
---|
1038 | int cr_canseesocket(struct ucred *cred, struct socket *so); |
---|
1039 | #else /* __rtems__ */ |
---|
1040 | #define cr_cansee(u1, u2) 0 |
---|
1041 | #define cr_canseesocket(cred, so) 0 |
---|
1042 | #endif /* __rtems__ */ |
---|
1043 | int cr_canseeothergids(struct ucred *u1, struct ucred *u2); |
---|
1044 | int cr_canseeotheruids(struct ucred *u1, struct ucred *u2); |
---|
1045 | int cr_cansignal(struct ucred *cred, struct proc *proc, int signum); |
---|
1046 | int enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, |
---|
1047 | struct session *sess); |
---|
1048 | int enterthispgrp(struct proc *p, struct pgrp *pgrp); |
---|
1049 | void faultin(struct proc *p); |
---|
1050 | void fixjobc(struct proc *p, struct pgrp *pgrp, int entering); |
---|
1051 | int fork1(struct thread *, struct fork_req *); |
---|
1052 | void fork_exit(void (*)(void *, struct trapframe *), void *, |
---|
1053 | struct trapframe *); |
---|
1054 | void fork_return(struct thread *, struct trapframe *); |
---|
1055 | int inferior(struct proc *p); |
---|
1056 | void kern_yield(int); |
---|
1057 | #ifndef __rtems__ |
---|
1058 | void kick_proc0(void); |
---|
1059 | #else /* __rtems__ */ |
---|
1060 | #define kick_proc0() |
---|
1061 | #endif /* __rtems__ */ |
---|
1062 | void killjobc(void); |
---|
1063 | int leavepgrp(struct proc *p); |
---|
1064 | int maybe_preempt(struct thread *td); |
---|
1065 | void maybe_yield(void); |
---|
1066 | void mi_switch(int flags, struct thread *newtd); |
---|
1067 | int p_candebug(struct thread *td, struct proc *p); |
---|
1068 | int p_cansee(struct thread *td, struct proc *p); |
---|
1069 | int p_cansched(struct thread *td, struct proc *p); |
---|
1070 | int p_cansignal(struct thread *td, struct proc *p, int signum); |
---|
1071 | int p_canwait(struct thread *td, struct proc *p); |
---|
1072 | struct pargs *pargs_alloc(int len); |
---|
1073 | void pargs_drop(struct pargs *pa); |
---|
1074 | void pargs_hold(struct pargs *pa); |
---|
1075 | int proc_getargv(struct thread *td, struct proc *p, struct sbuf *sb); |
---|
1076 | int proc_getauxv(struct thread *td, struct proc *p, struct sbuf *sb); |
---|
1077 | int proc_getenvv(struct thread *td, struct proc *p, struct sbuf *sb); |
---|
1078 | void procinit(void); |
---|
1079 | void proc_linkup0(struct proc *p, struct thread *td); |
---|
1080 | void proc_linkup(struct proc *p, struct thread *td); |
---|
1081 | struct proc *proc_realparent(struct proc *child); |
---|
1082 | void proc_reap(struct thread *td, struct proc *p, int *status, int options); |
---|
1083 | void proc_reparent(struct proc *child, struct proc *newparent); |
---|
1084 | void proc_set_traced(struct proc *p, bool stop); |
---|
1085 | struct pstats *pstats_alloc(void); |
---|
1086 | void pstats_fork(struct pstats *src, struct pstats *dst); |
---|
1087 | void pstats_free(struct pstats *ps); |
---|
1088 | void reaper_abandon_children(struct proc *p, bool exiting); |
---|
1089 | #ifndef __rtems__ |
---|
1090 | int securelevel_ge(struct ucred *cr, int level); |
---|
1091 | int securelevel_gt(struct ucred *cr, int level); |
---|
1092 | #else /* __rtems__ */ |
---|
1093 | #define securelevel_ge(x, y) 0 |
---|
1094 | #define securelevel_gt(x, y) 0 |
---|
1095 | #endif /* __rtems__ */ |
---|
1096 | void sess_hold(struct session *); |
---|
1097 | void sess_release(struct session *); |
---|
1098 | int setrunnable(struct thread *); |
---|
1099 | void setsugid(struct proc *p); |
---|
1100 | int should_yield(void); |
---|
1101 | int sigonstack(size_t sp); |
---|
1102 | void stopevent(struct proc *, u_int, u_int); |
---|
1103 | struct thread *tdfind(lwpid_t, pid_t); |
---|
1104 | void threadinit(void); |
---|
1105 | void tidhash_add(struct thread *); |
---|
1106 | void tidhash_remove(struct thread *); |
---|
1107 | void cpu_idle(int); |
---|
1108 | int cpu_idle_wakeup(int); |
---|
1109 | extern void (*cpu_idle_hook)(sbintime_t); /* Hook to machdep CPU idler. */ |
---|
1110 | void cpu_switch(struct thread *, struct thread *, struct mtx *); |
---|
1111 | void cpu_throw(struct thread *, struct thread *) __dead2; |
---|
1112 | void unsleep(struct thread *); |
---|
1113 | void userret(struct thread *, struct trapframe *); |
---|
1114 | |
---|
1115 | void cpu_exit(struct thread *); |
---|
1116 | void exit1(struct thread *, int, int) __dead2; |
---|
1117 | void cpu_copy_thread(struct thread *td, struct thread *td0); |
---|
1118 | int cpu_fetch_syscall_args(struct thread *td, struct syscall_args *sa); |
---|
1119 | void cpu_fork(struct thread *, struct proc *, struct thread *, int); |
---|
1120 | void cpu_fork_kthread_handler(struct thread *, void (*)(void *), void *); |
---|
1121 | void cpu_set_syscall_retval(struct thread *, int); |
---|
1122 | #ifndef __rtems__ |
---|
1123 | void cpu_set_upcall(struct thread *, void (*)(void *), void *, |
---|
1124 | stack_t *); |
---|
1125 | #endif /* __rtems__ */ |
---|
1126 | int cpu_set_user_tls(struct thread *, void *tls_base); |
---|
1127 | void cpu_thread_alloc(struct thread *); |
---|
1128 | void cpu_thread_clean(struct thread *); |
---|
1129 | void cpu_thread_exit(struct thread *); |
---|
1130 | void cpu_thread_free(struct thread *); |
---|
1131 | void cpu_thread_swapin(struct thread *); |
---|
1132 | void cpu_thread_swapout(struct thread *); |
---|
1133 | struct thread *thread_alloc(int pages); |
---|
1134 | int thread_alloc_stack(struct thread *, int pages); |
---|
1135 | void thread_cow_get_proc(struct thread *newtd, struct proc *p); |
---|
1136 | void thread_cow_get(struct thread *newtd, struct thread *td); |
---|
1137 | void thread_cow_free(struct thread *td); |
---|
1138 | void thread_cow_update(struct thread *td); |
---|
1139 | int thread_create(struct thread *td, struct rtprio *rtp, |
---|
1140 | int (*initialize_thread)(struct thread *, void *), void *thunk); |
---|
1141 | void thread_exit(void) __dead2; |
---|
1142 | void thread_free(struct thread *td); |
---|
1143 | void thread_link(struct thread *td, struct proc *p); |
---|
1144 | void thread_reap(void); |
---|
1145 | int thread_single(struct proc *p, int how); |
---|
1146 | void thread_single_end(struct proc *p, int how); |
---|
1147 | void thread_stash(struct thread *td); |
---|
1148 | void thread_stopped(struct proc *p); |
---|
1149 | void childproc_stopped(struct proc *child, int reason); |
---|
1150 | void childproc_continued(struct proc *child); |
---|
1151 | void childproc_exited(struct proc *child); |
---|
1152 | int thread_suspend_check(int how); |
---|
1153 | bool thread_suspend_check_needed(void); |
---|
1154 | void thread_suspend_switch(struct thread *, struct proc *p); |
---|
1155 | void thread_suspend_one(struct thread *td); |
---|
1156 | void thread_unlink(struct thread *td); |
---|
1157 | void thread_unsuspend(struct proc *p); |
---|
1158 | void thread_wait(struct proc *p); |
---|
1159 | struct thread *thread_find(struct proc *p, lwpid_t tid); |
---|
1160 | |
---|
1161 | void stop_all_proc(void); |
---|
1162 | void resume_all_proc(void); |
---|
1163 | |
---|
1164 | #ifndef __rtems__ |
---|
1165 | static __inline int |
---|
1166 | curthread_pflags_set(int flags) |
---|
1167 | { |
---|
1168 | struct thread *td; |
---|
1169 | int save; |
---|
1170 | |
---|
1171 | td = curthread; |
---|
1172 | save = ~flags | (td->td_pflags & flags); |
---|
1173 | td->td_pflags |= flags; |
---|
1174 | return (save); |
---|
1175 | } |
---|
1176 | |
---|
1177 | static __inline void |
---|
1178 | curthread_pflags_restore(int save) |
---|
1179 | { |
---|
1180 | |
---|
1181 | curthread->td_pflags &= save; |
---|
1182 | } |
---|
1183 | |
---|
1184 | static __inline __pure2 struct td_sched * |
---|
1185 | td_get_sched(struct thread *td) |
---|
1186 | { |
---|
1187 | |
---|
1188 | return ((struct td_sched *)&td[1]); |
---|
1189 | } |
---|
1190 | |
---|
1191 | extern void (*softdep_ast_cleanup)(struct thread *); |
---|
1192 | static __inline void |
---|
1193 | td_softdep_cleanup(struct thread *td) |
---|
1194 | { |
---|
1195 | |
---|
1196 | if (td->td_su != NULL && softdep_ast_cleanup != NULL) |
---|
1197 | softdep_ast_cleanup(td); |
---|
1198 | } |
---|
1199 | #endif /* __rtems__ */ |
---|
1200 | |
---|
1201 | #endif /* _KERNEL */ |
---|
1202 | |
---|
1203 | #endif /* !_SYS_PROC_H_ */ |
---|