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 | * 4. 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 <rtems/bsd/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 <machine/proc.h> /* Machine-dependent proc substruct. */ |
---|
67 | |
---|
68 | /* |
---|
69 | * One structure allocated per session. |
---|
70 | * |
---|
71 | * List of locks |
---|
72 | * (m) locked by s_mtx mtx |
---|
73 | * (e) locked by proctree_lock sx |
---|
74 | * (c) const until freeing |
---|
75 | */ |
---|
76 | struct session { |
---|
77 | u_int s_count; /* Ref cnt; pgrps in session - atomic. */ |
---|
78 | struct proc *s_leader; /* (m + e) Session leader. */ |
---|
79 | struct vnode *s_ttyvp; /* (m) Vnode of controlling tty. */ |
---|
80 | struct tty *s_ttyp; /* (e) Controlling tty. */ |
---|
81 | pid_t s_sid; /* (c) Session ID. */ |
---|
82 | /* (m) Setlogin() name: */ |
---|
83 | char s_login[roundup(MAXLOGNAME, sizeof(long))]; |
---|
84 | struct mtx s_mtx; /* Mutex to protect members. */ |
---|
85 | }; |
---|
86 | |
---|
87 | /* |
---|
88 | * One structure allocated per process group. |
---|
89 | * |
---|
90 | * List of locks |
---|
91 | * (m) locked by pg_mtx mtx |
---|
92 | * (e) locked by proctree_lock sx |
---|
93 | * (c) const until freeing |
---|
94 | */ |
---|
95 | struct pgrp { |
---|
96 | LIST_ENTRY(pgrp) pg_hash; /* (e) Hash chain. */ |
---|
97 | LIST_HEAD(, proc) pg_members; /* (m + e) Pointer to pgrp members. */ |
---|
98 | struct session *pg_session; /* (c) Pointer to session. */ |
---|
99 | struct sigiolst pg_sigiolst; /* (m) List of sigio sources. */ |
---|
100 | pid_t pg_id; /* (c) Process group id. */ |
---|
101 | int pg_jobc; /* (m) Job control process count. */ |
---|
102 | struct mtx pg_mtx; /* Mutex to protect members */ |
---|
103 | }; |
---|
104 | |
---|
105 | /* |
---|
106 | * pargs, used to hold a copy of the command line, if it had a sane length. |
---|
107 | */ |
---|
108 | struct pargs { |
---|
109 | u_int ar_ref; /* Reference count. */ |
---|
110 | u_int ar_length; /* Length. */ |
---|
111 | u_char ar_args[1]; /* Arguments. */ |
---|
112 | }; |
---|
113 | |
---|
114 | /*- |
---|
115 | * Description of a process. |
---|
116 | * |
---|
117 | * This structure contains the information needed to manage a thread of |
---|
118 | * control, known in UN*X as a process; it has references to substructures |
---|
119 | * containing descriptions of things that the process uses, but may share |
---|
120 | * with related processes. The process structure and the substructures |
---|
121 | * are always addressable except for those marked "(CPU)" below, |
---|
122 | * which might be addressable only on a processor on which the process |
---|
123 | * is running. |
---|
124 | * |
---|
125 | * Below is a key of locks used to protect each member of struct proc. The |
---|
126 | * lock is indicated by a reference to a specific character in parens in the |
---|
127 | * associated comment. |
---|
128 | * * - not yet protected |
---|
129 | * a - only touched by curproc or parent during fork/wait |
---|
130 | * b - created at fork, never changes |
---|
131 | * (exception aiods switch vmspaces, but they are also |
---|
132 | * marked 'P_SYSTEM' so hopefully it will be left alone) |
---|
133 | * c - locked by proc mtx |
---|
134 | * d - locked by allproc_lock lock |
---|
135 | * e - locked by proctree_lock lock |
---|
136 | * f - session mtx |
---|
137 | * g - process group mtx |
---|
138 | * h - callout_lock mtx |
---|
139 | * i - by curproc or the master session mtx |
---|
140 | * j - locked by proc slock |
---|
141 | * k - only accessed by curthread |
---|
142 | * k*- only accessed by curthread and from an interrupt |
---|
143 | * l - the attaching proc or attaching proc parent |
---|
144 | * m - Giant |
---|
145 | * n - not locked, lazy |
---|
146 | * o - ktrace lock |
---|
147 | * q - td_contested lock |
---|
148 | * r - p_peers lock |
---|
149 | * t - thread lock |
---|
150 | * x - created at fork, only changes during single threading in exec |
---|
151 | * y - created at first aio, doesn't change until exit or exec at which |
---|
152 | * point we are single-threaded and only curthread changes it |
---|
153 | * z - zombie threads lock |
---|
154 | * |
---|
155 | * If the locking key specifies two identifiers (for example, p_pptr) then |
---|
156 | * either lock is sufficient for read access, but both locks must be held |
---|
157 | * for write access. |
---|
158 | */ |
---|
159 | struct kaudit_record; |
---|
160 | struct td_sched; |
---|
161 | struct nlminfo; |
---|
162 | struct kaioinfo; |
---|
163 | struct p_sched; |
---|
164 | struct proc; |
---|
165 | struct sleepqueue; |
---|
166 | struct thread; |
---|
167 | struct trapframe; |
---|
168 | struct turnstile; |
---|
169 | struct mqueue_notifier; |
---|
170 | struct kdtrace_proc; |
---|
171 | struct kdtrace_thread; |
---|
172 | struct cpuset; |
---|
173 | |
---|
174 | /* |
---|
175 | * XXX: Does this belong in resource.h or resourcevar.h instead? |
---|
176 | * Resource usage extension. The times in rusage structs in the kernel are |
---|
177 | * never up to date. The actual times are kept as runtimes and tick counts |
---|
178 | * (with control info in the "previous" times), and are converted when |
---|
179 | * userland asks for rusage info. Backwards compatibility prevents putting |
---|
180 | * this directly in the user-visible rusage struct. |
---|
181 | * |
---|
182 | * Locking for p_rux: (cj) means (j) for p_rux and (c) for p_crux. |
---|
183 | * Locking for td_rux: (t) for all fields. |
---|
184 | */ |
---|
185 | struct rusage_ext { |
---|
186 | u_int64_t rux_runtime; /* (cj) Real time. */ |
---|
187 | u_int64_t rux_uticks; /* (cj) Statclock hits in user mode. */ |
---|
188 | u_int64_t rux_sticks; /* (cj) Statclock hits in sys mode. */ |
---|
189 | u_int64_t rux_iticks; /* (cj) Statclock hits in intr mode. */ |
---|
190 | u_int64_t rux_uu; /* (c) Previous user time in usec. */ |
---|
191 | u_int64_t rux_su; /* (c) Previous sys time in usec. */ |
---|
192 | u_int64_t rux_tu; /* (c) Previous total time in usec. */ |
---|
193 | }; |
---|
194 | |
---|
195 | /* |
---|
196 | * Kernel runnable context (thread). |
---|
197 | * This is what is put to sleep and reactivated. |
---|
198 | * Thread context. Processes may have multiple threads. |
---|
199 | */ |
---|
200 | struct thread { |
---|
201 | #ifdef __rtems__ |
---|
202 | rtems_chain_node td_node; |
---|
203 | Thread_Control *td_thread; |
---|
204 | char td_name [16]; |
---|
205 | #endif /* __rtems__ */ |
---|
206 | #ifndef __rtems__ |
---|
207 | struct mtx *volatile td_lock; /* replaces sched lock */ |
---|
208 | #endif /* __rtems__ */ |
---|
209 | struct proc *td_proc; /* (*) Associated process. */ |
---|
210 | #ifndef __rtems__ |
---|
211 | TAILQ_ENTRY(thread) td_plist; /* (*) All threads in this proc. */ |
---|
212 | TAILQ_ENTRY(thread) td_runq; /* (t) Run queue. */ |
---|
213 | TAILQ_ENTRY(thread) td_slpq; /* (t) Sleep queue. */ |
---|
214 | TAILQ_ENTRY(thread) td_lockq; /* (t) Lock queue. */ |
---|
215 | struct cpuset *td_cpuset; /* (t) CPU affinity mask. */ |
---|
216 | #endif /* __rtems__ */ |
---|
217 | struct seltd *td_sel; /* Select queue/channel. */ |
---|
218 | #ifndef __rtems__ |
---|
219 | struct sleepqueue *td_sleepqueue; /* (k) Associated sleep queue. */ |
---|
220 | struct turnstile *td_turnstile; /* (k) Associated turnstile. */ |
---|
221 | struct umtx_q *td_umtxq; /* (c?) Link for when we're blocked. */ |
---|
222 | lwpid_t td_tid; /* (b) Thread ID. */ |
---|
223 | sigqueue_t td_sigqueue; /* (c) Sigs arrived, not delivered. */ |
---|
224 | #define td_siglist td_sigqueue.sq_signals |
---|
225 | |
---|
226 | /* Cleared during fork1() */ |
---|
227 | #define td_startzero td_flags |
---|
228 | int td_flags; /* (t) TDF_* flags. */ |
---|
229 | int td_inhibitors; /* (t) Why can not run. */ |
---|
230 | int td_pflags; /* (k) Private thread (TDP_*) flags. */ |
---|
231 | int td_dupfd; /* (k) Ret value from fdopen. XXX */ |
---|
232 | int td_sqqueue; /* (t) Sleepqueue queue blocked on. */ |
---|
233 | void *td_wchan; /* (t) Sleep address. */ |
---|
234 | const char *td_wmesg; /* (t) Reason for sleep. */ |
---|
235 | u_char td_lastcpu; /* (t) Last cpu we were on. */ |
---|
236 | u_char td_oncpu; /* (t) Which cpu we are on. */ |
---|
237 | volatile u_char td_owepreempt; /* (k*) Preempt on last critical_exit */ |
---|
238 | u_char td_tsqueue; /* (t) Turnstile queue blocked on. */ |
---|
239 | short td_locks; /* (k) Count of non-spin locks. */ |
---|
240 | short td_rw_rlocks; /* (k) Count of rwlock read locks. */ |
---|
241 | short td_lk_slocks; /* (k) Count of lockmgr shared locks. */ |
---|
242 | struct turnstile *td_blocked; /* (t) Lock thread is blocked on. */ |
---|
243 | const char *td_lockname; /* (t) Name of lock blocked on. */ |
---|
244 | LIST_HEAD(, turnstile) td_contested; /* (q) Contested locks. */ |
---|
245 | struct lock_list_entry *td_sleeplocks; /* (k) Held sleep locks. */ |
---|
246 | int td_intr_nesting_level; /* (k) Interrupt recursion. */ |
---|
247 | int td_pinned; /* (k) Temporary cpu pin count. */ |
---|
248 | #endif /* __rtems__ */ |
---|
249 | struct ucred *td_ucred; /* (k) Reference to credentials. */ |
---|
250 | #ifndef __rtems__ |
---|
251 | u_int td_estcpu; /* (t) estimated cpu utilization */ |
---|
252 | int td_slptick; /* (t) Time at sleep. */ |
---|
253 | int td_blktick; /* (t) Time spent blocked. */ |
---|
254 | struct rusage td_ru; /* (t) rusage information. */ |
---|
255 | uint64_t td_incruntime; /* (t) Cpu ticks to transfer to proc. */ |
---|
256 | uint64_t td_runtime; /* (t) How many cpu ticks we've run. */ |
---|
257 | u_int td_pticks; /* (t) Statclock hits for profiling */ |
---|
258 | u_int td_sticks; /* (t) Statclock hits in system mode. */ |
---|
259 | u_int td_iticks; /* (t) Statclock hits in intr mode. */ |
---|
260 | u_int td_uticks; /* (t) Statclock hits in user mode. */ |
---|
261 | int td_intrval; /* (t) Return value for sleepq. */ |
---|
262 | sigset_t td_oldsigmask; /* (k) Saved mask from pre sigpause. */ |
---|
263 | sigset_t td_sigmask; /* (c) Current signal mask. */ |
---|
264 | volatile u_int td_generation; /* (k) For detection of preemption */ |
---|
265 | stack_t td_sigstk; /* (k) Stack ptr and on-stack flag. */ |
---|
266 | int td_xsig; /* (c) Signal for ptrace */ |
---|
267 | u_long td_profil_addr; /* (k) Temporary addr until AST. */ |
---|
268 | u_int td_profil_ticks; /* (k) Temporary ticks until AST. */ |
---|
269 | char td_name[MAXCOMLEN + 1]; /* (*) Thread name. */ |
---|
270 | struct file *td_fpop; /* (k) file referencing cdev under op */ |
---|
271 | int td_dbgflags; /* (c) Userland debugger flags */ |
---|
272 | struct ksiginfo td_dbgksi; /* (c) ksi reflected to debugger. */ |
---|
273 | int td_ng_outbound; /* (k) Thread entered ng from above. */ |
---|
274 | struct osd td_osd; /* (k) Object specific data. */ |
---|
275 | #define td_endzero td_base_pri |
---|
276 | |
---|
277 | /* Copied during fork1() or thread_sched_upcall(). */ |
---|
278 | #define td_startcopy td_endzero |
---|
279 | u_char td_rqindex; /* (t) Run queue index. */ |
---|
280 | u_char td_base_pri; /* (t) Thread base kernel priority. */ |
---|
281 | u_char td_priority; /* (t) Thread active priority. */ |
---|
282 | u_char td_pri_class; /* (t) Scheduling class. */ |
---|
283 | u_char td_user_pri; /* (t) User pri from estcpu and nice. */ |
---|
284 | u_char td_base_user_pri; /* (t) Base user pri */ |
---|
285 | #define td_endcopy td_pcb |
---|
286 | |
---|
287 | /* |
---|
288 | * Fields that must be manually set in fork1() or thread_sched_upcall() |
---|
289 | * or already have been set in the allocator, constructor, etc. |
---|
290 | */ |
---|
291 | struct pcb *td_pcb; /* (k) Kernel VA of pcb and kstack. */ |
---|
292 | enum { |
---|
293 | TDS_INACTIVE = 0x0, |
---|
294 | TDS_INHIBITED, |
---|
295 | TDS_CAN_RUN, |
---|
296 | TDS_RUNQ, |
---|
297 | TDS_RUNNING |
---|
298 | } td_state; /* (t) thread state */ |
---|
299 | #endif /* __rtems__ */ |
---|
300 | register_t td_retval[2]; /* (k) Syscall aux returns. */ |
---|
301 | #ifndef __rtems__ |
---|
302 | struct callout td_slpcallout; /* (h) Callout for sleep. */ |
---|
303 | struct trapframe *td_frame; /* (k) */ |
---|
304 | struct vm_object *td_kstack_obj;/* (a) Kstack object. */ |
---|
305 | vm_offset_t td_kstack; /* (a) Kernel VA of kstack. */ |
---|
306 | int td_kstack_pages; /* (a) Size of the kstack. */ |
---|
307 | void *td_unused1; |
---|
308 | vm_offset_t td_unused2; |
---|
309 | int td_unused3; |
---|
310 | volatile u_int td_critnest; /* (k*) Critical section nest level. */ |
---|
311 | struct mdthread td_md; /* (k) Any machine-dependent fields. */ |
---|
312 | struct td_sched *td_sched; /* (*) Scheduler-specific data. */ |
---|
313 | struct kaudit_record *td_ar; /* (k) Active audit record, if any. */ |
---|
314 | int td_syscalls; /* per-thread syscall count (used by NFS :)) */ |
---|
315 | struct lpohead td_lprof[2]; /* (a) lock profiling objects. */ |
---|
316 | struct kdtrace_thread *td_dtrace; /* (*) DTrace-specific data. */ |
---|
317 | int td_errno; /* Error returned by last syscall. */ |
---|
318 | struct vnet *td_vnet; /* (k) Effective vnet. */ |
---|
319 | const char *td_vnet_lpush; /* (k) Debugging vnet push / pop. */ |
---|
320 | struct rusage_ext td_rux; /* (t) Internal rusage information. */ |
---|
321 | struct vm_map_entry *td_map_def_user; /* (k) Deferred entries. */ |
---|
322 | #endif /* __rtems__ */ |
---|
323 | }; |
---|
324 | |
---|
325 | struct mtx *thread_lock_block(struct thread *); |
---|
326 | void thread_lock_unblock(struct thread *, struct mtx *); |
---|
327 | void thread_lock_set(struct thread *, struct mtx *); |
---|
328 | #define THREAD_LOCK_ASSERT(td, type) \ |
---|
329 | do { \ |
---|
330 | struct mtx *__m = (td)->td_lock; \ |
---|
331 | if (__m != &blocked_lock) \ |
---|
332 | mtx_assert(__m, (type)); \ |
---|
333 | } while (0) |
---|
334 | |
---|
335 | #ifdef INVARIANTS |
---|
336 | #define THREAD_LOCKPTR_ASSERT(td, lock) \ |
---|
337 | do { \ |
---|
338 | struct mtx *__m = (td)->td_lock; \ |
---|
339 | KASSERT((__m == &blocked_lock || __m == (lock)), \ |
---|
340 | ("Thread %p lock %p does not match %p", td, __m, (lock))); \ |
---|
341 | } while (0) |
---|
342 | #else |
---|
343 | #define THREAD_LOCKPTR_ASSERT(td, lock) |
---|
344 | #endif |
---|
345 | |
---|
346 | #define CRITICAL_ASSERT(td) \ |
---|
347 | KASSERT((td)->td_critnest >= 1, ("Not in critical section")); |
---|
348 | |
---|
349 | /* |
---|
350 | * Flags kept in td_flags: |
---|
351 | * To change these you MUST have the scheduler lock. |
---|
352 | */ |
---|
353 | #define TDF_BORROWING 0x00000001 /* Thread is borrowing pri from another. */ |
---|
354 | #define TDF_INPANIC 0x00000002 /* Caused a panic, let it drive crashdump. */ |
---|
355 | #define TDF_INMEM 0x00000004 /* Thread's stack is in memory. */ |
---|
356 | #define TDF_SINTR 0x00000008 /* Sleep is interruptible. */ |
---|
357 | #define TDF_TIMEOUT 0x00000010 /* Timing out during sleep. */ |
---|
358 | #define TDF_IDLETD 0x00000020 /* This is a per-CPU idle thread. */ |
---|
359 | #define TDF_CANSWAP 0x00000040 /* Thread can be swapped. */ |
---|
360 | #define TDF_SLEEPABORT 0x00000080 /* sleepq_abort was called. */ |
---|
361 | #define TDF_KTH_SUSP 0x00000100 /* kthread is suspended */ |
---|
362 | #define TDF_UBORROWING 0x00000200 /* Thread is borrowing user pri. */ |
---|
363 | #define TDF_BOUNDARY 0x00000400 /* Thread suspended at user boundary */ |
---|
364 | #define TDF_ASTPENDING 0x00000800 /* Thread has some asynchronous events. */ |
---|
365 | #define TDF_TIMOFAIL 0x00001000 /* Timeout from sleep after we were awake. */ |
---|
366 | #define TDF_SBDRY 0x00002000 /* Stop only on usermode boundary. */ |
---|
367 | #define TDF_UPIBLOCKED 0x00004000 /* Thread blocked on user PI mutex. */ |
---|
368 | #define TDF_NEEDSUSPCHK 0x00008000 /* Thread may need to suspend. */ |
---|
369 | #define TDF_NEEDRESCHED 0x00010000 /* Thread needs to yield. */ |
---|
370 | #define TDF_NEEDSIGCHK 0x00020000 /* Thread may need signal delivery. */ |
---|
371 | #define TDF_UNUSED18 0x00040000 /* --available-- */ |
---|
372 | #define TDF_UNUSED19 0x00080000 /* Thread is sleeping on a umtx. */ |
---|
373 | #define TDF_THRWAKEUP 0x00100000 /* Libthr thread must not suspend itself. */ |
---|
374 | #define TDF_UNUSED21 0x00200000 /* --available-- */ |
---|
375 | #define TDF_SWAPINREQ 0x00400000 /* Swapin request due to wakeup. */ |
---|
376 | #define TDF_UNUSED23 0x00800000 /* --available-- */ |
---|
377 | #define TDF_SCHED0 0x01000000 /* Reserved for scheduler private use */ |
---|
378 | #define TDF_SCHED1 0x02000000 /* Reserved for scheduler private use */ |
---|
379 | #define TDF_SCHED2 0x04000000 /* Reserved for scheduler private use */ |
---|
380 | #define TDF_SCHED3 0x08000000 /* Reserved for scheduler private use */ |
---|
381 | #define TDF_ALRMPEND 0x10000000 /* Pending SIGVTALRM needs to be posted. */ |
---|
382 | #define TDF_PROFPEND 0x20000000 /* Pending SIGPROF needs to be posted. */ |
---|
383 | #define TDF_MACPEND 0x40000000 /* AST-based MAC event pending. */ |
---|
384 | |
---|
385 | /* Userland debug flags */ |
---|
386 | #define TDB_SUSPEND 0x00000001 /* Thread is suspended by debugger */ |
---|
387 | #define TDB_XSIG 0x00000002 /* Thread is exchanging signal under trace */ |
---|
388 | #define TDB_USERWR 0x00000004 /* Debugger modified memory or registers */ |
---|
389 | #define TDB_SCE 0x00000008 /* Thread performs syscall enter */ |
---|
390 | #define TDB_SCX 0x00000010 /* Thread performs syscall exit */ |
---|
391 | #define TDB_EXEC 0x00000020 /* TDB_SCX from exec(2) family */ |
---|
392 | |
---|
393 | /* |
---|
394 | * "Private" flags kept in td_pflags: |
---|
395 | * These are only written by curthread and thus need no locking. |
---|
396 | */ |
---|
397 | #define TDP_OLDMASK 0x00000001 /* Need to restore mask after suspend. */ |
---|
398 | #define TDP_INKTR 0x00000002 /* Thread is currently in KTR code. */ |
---|
399 | #define TDP_INKTRACE 0x00000004 /* Thread is currently in KTRACE code. */ |
---|
400 | #define TDP_BUFNEED 0x00000008 /* Do not recurse into the buf flush */ |
---|
401 | #define TDP_COWINPROGRESS 0x00000010 /* Snapshot copy-on-write in progress. */ |
---|
402 | #define TDP_ALTSTACK 0x00000020 /* Have alternate signal stack. */ |
---|
403 | #define TDP_DEADLKTREAT 0x00000040 /* Lock aquisition - deadlock treatment. */ |
---|
404 | #define TDP_UNUSED80 0x00000080 /* available. */ |
---|
405 | #define TDP_NOSLEEPING 0x00000100 /* Thread is not allowed to sleep on a sq. */ |
---|
406 | #define TDP_OWEUPC 0x00000200 /* Call addupc() at next AST. */ |
---|
407 | #define TDP_ITHREAD 0x00000400 /* Thread is an interrupt thread. */ |
---|
408 | #define TDP_UNUSED800 0x00000800 /* available. */ |
---|
409 | #define TDP_SCHED1 0x00001000 /* Reserved for scheduler private use */ |
---|
410 | #define TDP_SCHED2 0x00002000 /* Reserved for scheduler private use */ |
---|
411 | #define TDP_SCHED3 0x00004000 /* Reserved for scheduler private use */ |
---|
412 | #define TDP_SCHED4 0x00008000 /* Reserved for scheduler private use */ |
---|
413 | #define TDP_GEOM 0x00010000 /* Settle GEOM before finishing syscall */ |
---|
414 | #define TDP_SOFTDEP 0x00020000 /* Stuck processing softdep worklist */ |
---|
415 | #define TDP_NORUNNINGBUF 0x00040000 /* Ignore runningbufspace check */ |
---|
416 | #define TDP_WAKEUP 0x00080000 /* Don't sleep in umtx cond_wait */ |
---|
417 | #define TDP_INBDFLUSH 0x00100000 /* Already in BO_BDFLUSH, do not recurse */ |
---|
418 | #define TDP_KTHREAD 0x00200000 /* This is an official kernel thread */ |
---|
419 | #define TDP_CALLCHAIN 0x00400000 /* Capture thread's callchain */ |
---|
420 | #define TDP_IGNSUSP 0x00800000 /* Permission to ignore the MNTK_SUSPEND* */ |
---|
421 | #define TDP_AUDITREC 0x01000000 /* Audit record pending on thread */ |
---|
422 | |
---|
423 | /* |
---|
424 | * Reasons that the current thread can not be run yet. |
---|
425 | * More than one may apply. |
---|
426 | */ |
---|
427 | #define TDI_SUSPENDED 0x0001 /* On suspension queue. */ |
---|
428 | #define TDI_SLEEPING 0x0002 /* Actually asleep! (tricky). */ |
---|
429 | #define TDI_SWAPPED 0x0004 /* Stack not in mem. Bad juju if run. */ |
---|
430 | #define TDI_LOCK 0x0008 /* Stopped on a lock. */ |
---|
431 | #define TDI_IWAIT 0x0010 /* Awaiting interrupt. */ |
---|
432 | |
---|
433 | #define TD_IS_SLEEPING(td) ((td)->td_inhibitors & TDI_SLEEPING) |
---|
434 | #define TD_ON_SLEEPQ(td) ((td)->td_wchan != NULL) |
---|
435 | #define TD_IS_SUSPENDED(td) ((td)->td_inhibitors & TDI_SUSPENDED) |
---|
436 | #define TD_IS_SWAPPED(td) ((td)->td_inhibitors & TDI_SWAPPED) |
---|
437 | #define TD_ON_LOCK(td) ((td)->td_inhibitors & TDI_LOCK) |
---|
438 | #define TD_AWAITING_INTR(td) ((td)->td_inhibitors & TDI_IWAIT) |
---|
439 | #define TD_IS_RUNNING(td) ((td)->td_state == TDS_RUNNING) |
---|
440 | #define TD_ON_RUNQ(td) ((td)->td_state == TDS_RUNQ) |
---|
441 | #define TD_CAN_RUN(td) ((td)->td_state == TDS_CAN_RUN) |
---|
442 | #define TD_IS_INHIBITED(td) ((td)->td_state == TDS_INHIBITED) |
---|
443 | #define TD_ON_UPILOCK(td) ((td)->td_flags & TDF_UPIBLOCKED) |
---|
444 | #define TD_IS_IDLETHREAD(td) ((td)->td_flags & TDF_IDLETD) |
---|
445 | |
---|
446 | |
---|
447 | #define TD_SET_INHIB(td, inhib) do { \ |
---|
448 | (td)->td_state = TDS_INHIBITED; \ |
---|
449 | (td)->td_inhibitors |= (inhib); \ |
---|
450 | } while (0) |
---|
451 | |
---|
452 | #define TD_CLR_INHIB(td, inhib) do { \ |
---|
453 | if (((td)->td_inhibitors & (inhib)) && \ |
---|
454 | (((td)->td_inhibitors &= ~(inhib)) == 0)) \ |
---|
455 | (td)->td_state = TDS_CAN_RUN; \ |
---|
456 | } while (0) |
---|
457 | |
---|
458 | #define TD_SET_SLEEPING(td) TD_SET_INHIB((td), TDI_SLEEPING) |
---|
459 | #define TD_SET_SWAPPED(td) TD_SET_INHIB((td), TDI_SWAPPED) |
---|
460 | #define TD_SET_LOCK(td) TD_SET_INHIB((td), TDI_LOCK) |
---|
461 | #define TD_SET_SUSPENDED(td) TD_SET_INHIB((td), TDI_SUSPENDED) |
---|
462 | #define TD_SET_IWAIT(td) TD_SET_INHIB((td), TDI_IWAIT) |
---|
463 | #define TD_SET_EXITING(td) TD_SET_INHIB((td), TDI_EXITING) |
---|
464 | |
---|
465 | #define TD_CLR_SLEEPING(td) TD_CLR_INHIB((td), TDI_SLEEPING) |
---|
466 | #define TD_CLR_SWAPPED(td) TD_CLR_INHIB((td), TDI_SWAPPED) |
---|
467 | #define TD_CLR_LOCK(td) TD_CLR_INHIB((td), TDI_LOCK) |
---|
468 | #define TD_CLR_SUSPENDED(td) TD_CLR_INHIB((td), TDI_SUSPENDED) |
---|
469 | #define TD_CLR_IWAIT(td) TD_CLR_INHIB((td), TDI_IWAIT) |
---|
470 | |
---|
471 | #define TD_SET_RUNNING(td) (td)->td_state = TDS_RUNNING |
---|
472 | #define TD_SET_RUNQ(td) (td)->td_state = TDS_RUNQ |
---|
473 | #define TD_SET_CAN_RUN(td) (td)->td_state = TDS_CAN_RUN |
---|
474 | |
---|
475 | /* |
---|
476 | * Process structure. |
---|
477 | */ |
---|
478 | struct proc { |
---|
479 | #ifndef __rtems__ |
---|
480 | LIST_ENTRY(proc) p_list; /* (d) List of all processes. */ |
---|
481 | TAILQ_HEAD(, thread) p_threads; /* (c) all threads. */ |
---|
482 | struct mtx p_slock; /* process spin lock */ |
---|
483 | struct ucred *p_ucred; /* (c) Process owner's identity. */ |
---|
484 | struct filedesc *p_fd; /* (b) Open files. */ |
---|
485 | struct filedesc_to_leader *p_fdtol; /* (b) Tracking node */ |
---|
486 | struct pstats *p_stats; /* (b) Accounting/statistics (CPU). */ |
---|
487 | struct plimit *p_limit; /* (c) Process limits. */ |
---|
488 | struct callout p_limco; /* (c) Limit callout handle */ |
---|
489 | struct sigacts *p_sigacts; /* (x) Signal actions, state (CPU). */ |
---|
490 | |
---|
491 | /* |
---|
492 | * The following don't make too much sense. |
---|
493 | * See the td_ or ke_ versions of the same flags. |
---|
494 | */ |
---|
495 | int p_flag; /* (c) P_* flags. */ |
---|
496 | enum { |
---|
497 | PRS_NEW = 0, /* In creation */ |
---|
498 | PRS_NORMAL, /* threads can be run. */ |
---|
499 | PRS_ZOMBIE |
---|
500 | } p_state; /* (j/c) S* process status. */ |
---|
501 | pid_t p_pid; /* (b) Process identifier. */ |
---|
502 | LIST_ENTRY(proc) p_hash; /* (d) Hash chain. */ |
---|
503 | LIST_ENTRY(proc) p_pglist; /* (g + e) List of processes in pgrp. */ |
---|
504 | struct proc *p_pptr; /* (c + e) Pointer to parent process. */ |
---|
505 | LIST_ENTRY(proc) p_sibling; /* (e) List of sibling processes. */ |
---|
506 | LIST_HEAD(, proc) p_children; /* (e) Pointer to list of children. */ |
---|
507 | struct mtx p_mtx; /* (n) Lock for this struct. */ |
---|
508 | struct ksiginfo *p_ksi; /* Locked by parent proc lock */ |
---|
509 | sigqueue_t p_sigqueue; /* (c) Sigs not delivered to a td. */ |
---|
510 | #define p_siglist p_sigqueue.sq_signals |
---|
511 | |
---|
512 | /* The following fields are all zeroed upon creation in fork. */ |
---|
513 | #define p_startzero p_oppid |
---|
514 | pid_t p_oppid; /* (c + e) Save ppid in ptrace. XXX */ |
---|
515 | struct vmspace *p_vmspace; /* (b) Address space. */ |
---|
516 | u_int p_swtick; /* (c) Tick when swapped in or out. */ |
---|
517 | struct itimerval p_realtimer; /* (c) Alarm timer. */ |
---|
518 | struct rusage p_ru; /* (a) Exit information. */ |
---|
519 | struct rusage_ext p_rux; /* (cj) Internal resource usage. */ |
---|
520 | struct rusage_ext p_crux; /* (c) Internal child resource usage. */ |
---|
521 | int p_profthreads; /* (c) Num threads in addupc_task. */ |
---|
522 | volatile int p_exitthreads; /* (j) Number of threads exiting */ |
---|
523 | int p_traceflag; /* (o) Kernel trace points. */ |
---|
524 | struct vnode *p_tracevp; /* (c + o) Trace to vnode. */ |
---|
525 | struct ucred *p_tracecred; /* (o) Credentials to trace with. */ |
---|
526 | struct vnode *p_textvp; /* (b) Vnode of executable. */ |
---|
527 | u_int p_lock; /* (c) Proclock (prevent swap) count. */ |
---|
528 | struct sigiolst p_sigiolst; /* (c) List of sigio sources. */ |
---|
529 | int p_sigparent; /* (c) Signal to parent on exit. */ |
---|
530 | int p_sig; /* (n) For core dump/debugger XXX. */ |
---|
531 | u_long p_code; /* (n) For core dump/debugger XXX. */ |
---|
532 | u_int p_stops; /* (c) Stop event bitmask. */ |
---|
533 | u_int p_stype; /* (c) Stop event type. */ |
---|
534 | char p_step; /* (c) Process is stopped. */ |
---|
535 | u_char p_pfsflags; /* (c) Procfs flags. */ |
---|
536 | struct nlminfo *p_nlminfo; /* (?) Only used by/for lockd. */ |
---|
537 | struct kaioinfo *p_aioinfo; /* (y) ASYNC I/O info. */ |
---|
538 | struct thread *p_singlethread;/* (c + j) If single threading this is it */ |
---|
539 | int p_suspcount; /* (j) Num threads in suspended mode. */ |
---|
540 | struct thread *p_xthread; /* (c) Trap thread */ |
---|
541 | int p_boundary_count;/* (c) Num threads at user boundary */ |
---|
542 | int p_pendingcnt; /* how many signals are pending */ |
---|
543 | struct itimers *p_itimers; /* (c) POSIX interval timers. */ |
---|
544 | /* End area that is zeroed on creation. */ |
---|
545 | #define p_endzero p_magic |
---|
546 | |
---|
547 | /* The following fields are all copied upon creation in fork. */ |
---|
548 | #define p_startcopy p_endzero |
---|
549 | u_int p_magic; /* (b) Magic number. */ |
---|
550 | int p_osrel; /* (x) osreldate for the |
---|
551 | binary (from ELF note, if any) */ |
---|
552 | char p_comm[MAXCOMLEN + 1]; /* (b) Process name. */ |
---|
553 | struct pgrp *p_pgrp; /* (c + e) Pointer to process group. */ |
---|
554 | struct sysentvec *p_sysent; /* (b) Syscall dispatch info. */ |
---|
555 | struct pargs *p_args; /* (c) Process arguments. */ |
---|
556 | rlim_t p_cpulimit; /* (c) Current CPU limit in seconds. */ |
---|
557 | signed char p_nice; /* (c) Process "nice" value. */ |
---|
558 | int p_fibnum; /* in this routing domain XXX MRT */ |
---|
559 | /* End area that is copied on creation. */ |
---|
560 | #define p_endcopy p_xstat |
---|
561 | |
---|
562 | u_short p_xstat; /* (c) Exit status; also stop sig. */ |
---|
563 | struct knlist p_klist; /* (c) Knotes attached to this proc. */ |
---|
564 | int p_numthreads; /* (c) Number of threads. */ |
---|
565 | struct mdproc p_md; /* Any machine-dependent fields. */ |
---|
566 | struct callout p_itcallout; /* (h + c) Interval timer callout. */ |
---|
567 | u_short p_acflag; /* (c) Accounting flags. */ |
---|
568 | struct proc *p_peers; /* (r) */ |
---|
569 | struct proc *p_leader; /* (b) */ |
---|
570 | void *p_emuldata; /* (c) Emulator state data. */ |
---|
571 | struct label *p_label; /* (*) Proc (not subject) MAC label. */ |
---|
572 | struct p_sched *p_sched; /* (*) Scheduler-specific data. */ |
---|
573 | STAILQ_HEAD(, ktr_request) p_ktr; /* (o) KTR event queue. */ |
---|
574 | LIST_HEAD(, mqueue_notifier) p_mqnotifier; /* (c) mqueue notifiers.*/ |
---|
575 | struct kdtrace_proc *p_dtrace; /* (*) DTrace-specific data. */ |
---|
576 | struct cv p_pwait; /* (*) wait cv for exit/exec */ |
---|
577 | #else /* __rtems__ */ |
---|
578 | struct ucred *p_ucred; /* (c) Process owner's identity. */ |
---|
579 | struct mtx p_mtx; /* (n) Lock for this struct. */ |
---|
580 | rtems_id p_pid; |
---|
581 | int p_fibnum; /* in this routing domain XXX MRT */ |
---|
582 | #endif /* __rtems__ */ |
---|
583 | }; |
---|
584 | |
---|
585 | #define p_session p_pgrp->pg_session |
---|
586 | #define p_pgid p_pgrp->pg_id |
---|
587 | |
---|
588 | #define NOCPU 0xff /* For when we aren't on a CPU. */ |
---|
589 | |
---|
590 | #define PROC_SLOCK(p) mtx_lock_spin(&(p)->p_slock) |
---|
591 | #define PROC_SUNLOCK(p) mtx_unlock_spin(&(p)->p_slock) |
---|
592 | #define PROC_SLOCK_ASSERT(p, type) mtx_assert(&(p)->p_slock, (type)) |
---|
593 | |
---|
594 | /* These flags are kept in p_flag. */ |
---|
595 | #define P_ADVLOCK 0x00001 /* Process may hold a POSIX advisory lock. */ |
---|
596 | #define P_CONTROLT 0x00002 /* Has a controlling terminal. */ |
---|
597 | #define P_KTHREAD 0x00004 /* Kernel thread (*). */ |
---|
598 | #define P_NOLOAD 0x00008 /* Ignore during load avg calculations. */ |
---|
599 | #define P_PPWAIT 0x00010 /* Parent is waiting for child to exec/exit. */ |
---|
600 | #define P_PROFIL 0x00020 /* Has started profiling. */ |
---|
601 | #define P_STOPPROF 0x00040 /* Has thread requesting to stop profiling. */ |
---|
602 | #define P_HADTHREADS 0x00080 /* Has had threads (no cleanup shortcuts) */ |
---|
603 | #define P_SUGID 0x00100 /* Had set id privileges since last exec. */ |
---|
604 | #define P_SYSTEM 0x00200 /* System proc: no sigs, stats or swapping. */ |
---|
605 | #define P_SINGLE_EXIT 0x00400 /* Threads suspending should exit, not wait. */ |
---|
606 | #define P_TRACED 0x00800 /* Debugged process being traced. */ |
---|
607 | #define P_WAITED 0x01000 /* Someone is waiting for us. */ |
---|
608 | #define P_WEXIT 0x02000 /* Working on exiting. */ |
---|
609 | #define P_EXEC 0x04000 /* Process called exec. */ |
---|
610 | #define P_WKILLED 0x08000 /* Killed, go to kernel/user boundary ASAP. */ |
---|
611 | #define P_CONTINUED 0x10000 /* Proc has continued from a stopped state. */ |
---|
612 | #define P_STOPPED_SIG 0x20000 /* Stopped due to SIGSTOP/SIGTSTP. */ |
---|
613 | #define P_STOPPED_TRACE 0x40000 /* Stopped because of tracing. */ |
---|
614 | #define P_STOPPED_SINGLE 0x80000 /* Only 1 thread can continue (not to user). */ |
---|
615 | #define P_PROTECTED 0x100000 /* Do not kill on memory overcommit. */ |
---|
616 | #define P_SIGEVENT 0x200000 /* Process pending signals changed. */ |
---|
617 | #define P_SINGLE_BOUNDARY 0x400000 /* Threads should suspend at user boundary. */ |
---|
618 | #define P_HWPMC 0x800000 /* Process is using HWPMCs */ |
---|
619 | |
---|
620 | #define P_JAILED 0x1000000 /* Process is in jail. */ |
---|
621 | #define P_INEXEC 0x4000000 /* Process is in execve(). */ |
---|
622 | #define P_STATCHILD 0x8000000 /* Child process stopped or exited. */ |
---|
623 | #define P_INMEM 0x10000000 /* Loaded into memory. */ |
---|
624 | #define P_SWAPPINGOUT 0x20000000 /* Process is being swapped out. */ |
---|
625 | #define P_SWAPPINGIN 0x40000000 /* Process is being swapped in. */ |
---|
626 | |
---|
627 | #define P_STOPPED (P_STOPPED_SIG|P_STOPPED_SINGLE|P_STOPPED_TRACE) |
---|
628 | #define P_SHOULDSTOP(p) ((p)->p_flag & P_STOPPED) |
---|
629 | #define P_KILLED(p) ((p)->p_flag & P_WKILLED) |
---|
630 | |
---|
631 | /* |
---|
632 | * These were process status values (p_stat), now they are only used in |
---|
633 | * legacy conversion code. |
---|
634 | */ |
---|
635 | #define SIDL 1 /* Process being created by fork. */ |
---|
636 | #define SRUN 2 /* Currently runnable. */ |
---|
637 | #define SSLEEP 3 /* Sleeping on an address. */ |
---|
638 | #define SSTOP 4 /* Process debugging or suspension. */ |
---|
639 | #define SZOMB 5 /* Awaiting collection by parent. */ |
---|
640 | #define SWAIT 6 /* Waiting for interrupt. */ |
---|
641 | #define SLOCK 7 /* Blocked on a lock. */ |
---|
642 | |
---|
643 | #define P_MAGIC 0xbeefface |
---|
644 | |
---|
645 | #ifdef _KERNEL |
---|
646 | |
---|
647 | /* Types and flags for mi_switch(). */ |
---|
648 | #define SW_TYPE_MASK 0xff /* First 8 bits are switch type */ |
---|
649 | #define SWT_NONE 0 /* Unspecified switch. */ |
---|
650 | #define SWT_PREEMPT 1 /* Switching due to preemption. */ |
---|
651 | #define SWT_OWEPREEMPT 2 /* Switching due to opepreempt. */ |
---|
652 | #define SWT_TURNSTILE 3 /* Turnstile contention. */ |
---|
653 | #define SWT_SLEEPQ 4 /* Sleepq wait. */ |
---|
654 | #define SWT_SLEEPQTIMO 5 /* Sleepq timeout wait. */ |
---|
655 | #define SWT_RELINQUISH 6 /* yield call. */ |
---|
656 | #define SWT_NEEDRESCHED 7 /* NEEDRESCHED was set. */ |
---|
657 | #define SWT_IDLE 8 /* Switching from the idle thread. */ |
---|
658 | #define SWT_IWAIT 9 /* Waiting for interrupts. */ |
---|
659 | #define SWT_SUSPEND 10 /* Thread suspended. */ |
---|
660 | #define SWT_REMOTEPREEMPT 11 /* Remote processor preempted. */ |
---|
661 | #define SWT_REMOTEWAKEIDLE 12 /* Remote processor preempted idle. */ |
---|
662 | #define SWT_COUNT 13 /* Number of switch types. */ |
---|
663 | /* Flags */ |
---|
664 | #define SW_VOL 0x0100 /* Voluntary switch. */ |
---|
665 | #define SW_INVOL 0x0200 /* Involuntary switch. */ |
---|
666 | #define SW_PREEMPT 0x0400 /* The invol switch is a preemption */ |
---|
667 | |
---|
668 | /* How values for thread_single(). */ |
---|
669 | #define SINGLE_NO_EXIT 0 |
---|
670 | #define SINGLE_EXIT 1 |
---|
671 | #define SINGLE_BOUNDARY 2 |
---|
672 | |
---|
673 | #ifdef MALLOC_DECLARE |
---|
674 | MALLOC_DECLARE(M_PARGS); |
---|
675 | MALLOC_DECLARE(M_PGRP); |
---|
676 | MALLOC_DECLARE(M_SESSION); |
---|
677 | MALLOC_DECLARE(M_SUBPROC); |
---|
678 | MALLOC_DECLARE(M_ZOMBIE); |
---|
679 | #endif |
---|
680 | |
---|
681 | #define FOREACH_PROC_IN_SYSTEM(p) \ |
---|
682 | LIST_FOREACH((p), &allproc, p_list) |
---|
683 | #define FOREACH_THREAD_IN_PROC(p, td) \ |
---|
684 | TAILQ_FOREACH((td), &(p)->p_threads, td_plist) |
---|
685 | |
---|
686 | #define FIRST_THREAD_IN_PROC(p) TAILQ_FIRST(&(p)->p_threads) |
---|
687 | |
---|
688 | /* |
---|
689 | * We use process IDs <= PID_MAX; PID_MAX + 1 must also fit in a pid_t, |
---|
690 | * as it is used to represent "no process group". |
---|
691 | */ |
---|
692 | #define PID_MAX 99999 |
---|
693 | #define NO_PID 100000 |
---|
694 | |
---|
695 | #define SESS_LEADER(p) ((p)->p_session->s_leader == (p)) |
---|
696 | |
---|
697 | |
---|
698 | #define STOPEVENT(p, e, v) do { \ |
---|
699 | if ((p)->p_stops & (e)) { \ |
---|
700 | PROC_LOCK(p); \ |
---|
701 | stopevent((p), (e), (v)); \ |
---|
702 | PROC_UNLOCK(p); \ |
---|
703 | } \ |
---|
704 | } while (0) |
---|
705 | #define _STOPEVENT(p, e, v) do { \ |
---|
706 | PROC_LOCK_ASSERT(p, MA_OWNED); \ |
---|
707 | WITNESS_WARN(WARN_GIANTOK | WARN_SLEEPOK, &p->p_mtx.lock_object, \ |
---|
708 | "checking stopevent %d", (e)); \ |
---|
709 | if ((p)->p_stops & (e)) \ |
---|
710 | stopevent((p), (e), (v)); \ |
---|
711 | } while (0) |
---|
712 | |
---|
713 | /* Lock and unlock a process. */ |
---|
714 | #define PROC_LOCK(p) mtx_lock(&(p)->p_mtx) |
---|
715 | #define PROC_TRYLOCK(p) mtx_trylock(&(p)->p_mtx) |
---|
716 | #define PROC_UNLOCK(p) mtx_unlock(&(p)->p_mtx) |
---|
717 | #define PROC_LOCKED(p) mtx_owned(&(p)->p_mtx) |
---|
718 | #define PROC_LOCK_ASSERT(p, type) mtx_assert(&(p)->p_mtx, (type)) |
---|
719 | |
---|
720 | /* Lock and unlock a process group. */ |
---|
721 | #define PGRP_LOCK(pg) mtx_lock(&(pg)->pg_mtx) |
---|
722 | #define PGRP_UNLOCK(pg) mtx_unlock(&(pg)->pg_mtx) |
---|
723 | #define PGRP_LOCKED(pg) mtx_owned(&(pg)->pg_mtx) |
---|
724 | #define PGRP_LOCK_ASSERT(pg, type) mtx_assert(&(pg)->pg_mtx, (type)) |
---|
725 | |
---|
726 | #define PGRP_LOCK_PGSIGNAL(pg) do { \ |
---|
727 | if ((pg) != NULL) \ |
---|
728 | PGRP_LOCK(pg); \ |
---|
729 | } while (0) |
---|
730 | #define PGRP_UNLOCK_PGSIGNAL(pg) do { \ |
---|
731 | if ((pg) != NULL) \ |
---|
732 | PGRP_UNLOCK(pg); \ |
---|
733 | } while (0) |
---|
734 | |
---|
735 | /* Lock and unlock a session. */ |
---|
736 | #define SESS_LOCK(s) mtx_lock(&(s)->s_mtx) |
---|
737 | #define SESS_UNLOCK(s) mtx_unlock(&(s)->s_mtx) |
---|
738 | #define SESS_LOCKED(s) mtx_owned(&(s)->s_mtx) |
---|
739 | #define SESS_LOCK_ASSERT(s, type) mtx_assert(&(s)->s_mtx, (type)) |
---|
740 | |
---|
741 | /* Hold process U-area in memory, normally for ptrace/procfs work. */ |
---|
742 | #define PHOLD(p) do { \ |
---|
743 | PROC_LOCK(p); \ |
---|
744 | _PHOLD(p); \ |
---|
745 | PROC_UNLOCK(p); \ |
---|
746 | } while (0) |
---|
747 | #define _PHOLD(p) do { \ |
---|
748 | PROC_LOCK_ASSERT((p), MA_OWNED); \ |
---|
749 | KASSERT(!((p)->p_flag & P_WEXIT) || (p) == curproc, \ |
---|
750 | ("PHOLD of exiting process")); \ |
---|
751 | (p)->p_lock++; \ |
---|
752 | if (((p)->p_flag & P_INMEM) == 0) \ |
---|
753 | faultin((p)); \ |
---|
754 | } while (0) |
---|
755 | #define PROC_ASSERT_HELD(p) do { \ |
---|
756 | KASSERT((p)->p_lock > 0, ("process not held")); \ |
---|
757 | } while (0) |
---|
758 | |
---|
759 | #define PRELE(p) do { \ |
---|
760 | PROC_LOCK((p)); \ |
---|
761 | _PRELE((p)); \ |
---|
762 | PROC_UNLOCK((p)); \ |
---|
763 | } while (0) |
---|
764 | #define _PRELE(p) do { \ |
---|
765 | PROC_LOCK_ASSERT((p), MA_OWNED); \ |
---|
766 | (--(p)->p_lock); \ |
---|
767 | if (((p)->p_flag & P_WEXIT) && (p)->p_lock == 0) \ |
---|
768 | wakeup(&(p)->p_lock); \ |
---|
769 | } while (0) |
---|
770 | #define PROC_ASSERT_NOT_HELD(p) do { \ |
---|
771 | KASSERT((p)->p_lock == 0, ("process held")); \ |
---|
772 | } while (0) |
---|
773 | |
---|
774 | /* Check whether a thread is safe to be swapped out. */ |
---|
775 | #define thread_safetoswapout(td) ((td)->td_flags & TDF_CANSWAP) |
---|
776 | |
---|
777 | /* Control whether or not it is safe for curthread to sleep. */ |
---|
778 | #define THREAD_NO_SLEEPING() do { \ |
---|
779 | KASSERT(!(curthread->td_pflags & TDP_NOSLEEPING), \ |
---|
780 | ("nested no sleeping")); \ |
---|
781 | curthread->td_pflags |= TDP_NOSLEEPING; \ |
---|
782 | } while (0) |
---|
783 | |
---|
784 | #define THREAD_SLEEPING_OK() do { \ |
---|
785 | KASSERT((curthread->td_pflags & TDP_NOSLEEPING), \ |
---|
786 | ("nested sleeping ok")); \ |
---|
787 | curthread->td_pflags &= ~TDP_NOSLEEPING; \ |
---|
788 | } while (0) |
---|
789 | |
---|
790 | #define PIDHASH(pid) (&pidhashtbl[(pid) & pidhash]) |
---|
791 | extern LIST_HEAD(pidhashhead, proc) *pidhashtbl; |
---|
792 | extern u_long pidhash; |
---|
793 | |
---|
794 | #define PGRPHASH(pgid) (&pgrphashtbl[(pgid) & pgrphash]) |
---|
795 | extern LIST_HEAD(pgrphashhead, pgrp) *pgrphashtbl; |
---|
796 | extern u_long pgrphash; |
---|
797 | |
---|
798 | extern struct sx allproc_lock; |
---|
799 | extern struct sx proctree_lock; |
---|
800 | extern struct mtx ppeers_lock; |
---|
801 | extern struct proc proc0; /* Process slot for swapper. */ |
---|
802 | #ifndef __rtems__ |
---|
803 | extern struct thread thread0; /* Primary thread in proc0. */ |
---|
804 | #else /* __rtems__ */ |
---|
805 | extern struct ucred *rtems_bsd_thread0_ucred; |
---|
806 | #endif /* __rtems__ */ |
---|
807 | extern struct vmspace vmspace0; /* VM space for proc0. */ |
---|
808 | extern int hogticks; /* Limit on kernel cpu hogs. */ |
---|
809 | extern int lastpid; |
---|
810 | extern int nprocs, maxproc; /* Current and max number of procs. */ |
---|
811 | extern int maxprocperuid; /* Max procs per uid. */ |
---|
812 | extern u_long ps_arg_cache_limit; |
---|
813 | |
---|
814 | LIST_HEAD(proclist, proc); |
---|
815 | TAILQ_HEAD(procqueue, proc); |
---|
816 | TAILQ_HEAD(threadqueue, thread); |
---|
817 | extern struct proclist allproc; /* List of all processes. */ |
---|
818 | extern struct proclist zombproc; /* List of zombie processes. */ |
---|
819 | extern struct proc *initproc, *pageproc; /* Process slots for init, pager. */ |
---|
820 | |
---|
821 | extern struct uma_zone *proc_zone; |
---|
822 | |
---|
823 | struct proc *pfind(pid_t); /* Find process by id. */ |
---|
824 | struct pgrp *pgfind(pid_t); /* Find process group by id. */ |
---|
825 | struct proc *zpfind(pid_t); /* Find zombie process by id. */ |
---|
826 | |
---|
827 | void ast(struct trapframe *framep); |
---|
828 | struct thread *choosethread(void); |
---|
829 | int cr_cansignal(struct ucred *cred, struct proc *proc, int signum); |
---|
830 | int enterpgrp(struct proc *p, pid_t pgid, struct pgrp *pgrp, |
---|
831 | struct session *sess); |
---|
832 | int enterthispgrp(struct proc *p, struct pgrp *pgrp); |
---|
833 | void faultin(struct proc *p); |
---|
834 | void fixjobc(struct proc *p, struct pgrp *pgrp, int entering); |
---|
835 | int fork1(struct thread *, int, int, struct proc **); |
---|
836 | void fork_exit(void (*)(void *, struct trapframe *), void *, |
---|
837 | struct trapframe *); |
---|
838 | void fork_return(struct thread *, struct trapframe *); |
---|
839 | int inferior(struct proc *p); |
---|
840 | void kick_proc0(void); |
---|
841 | int leavepgrp(struct proc *p); |
---|
842 | int maybe_preempt(struct thread *td); |
---|
843 | void mi_switch(int flags, struct thread *newtd); |
---|
844 | int p_candebug(struct thread *td, struct proc *p); |
---|
845 | int p_cansee(struct thread *td, struct proc *p); |
---|
846 | int p_cansched(struct thread *td, struct proc *p); |
---|
847 | int p_cansignal(struct thread *td, struct proc *p, int signum); |
---|
848 | int p_canwait(struct thread *td, struct proc *p); |
---|
849 | struct pargs *pargs_alloc(int len); |
---|
850 | void pargs_drop(struct pargs *pa); |
---|
851 | void pargs_hold(struct pargs *pa); |
---|
852 | void procinit(void); |
---|
853 | void proc_linkup0(struct proc *p, struct thread *td); |
---|
854 | void proc_linkup(struct proc *p, struct thread *td); |
---|
855 | void proc_reparent(struct proc *child, struct proc *newparent); |
---|
856 | struct pstats *pstats_alloc(void); |
---|
857 | void pstats_fork(struct pstats *src, struct pstats *dst); |
---|
858 | void pstats_free(struct pstats *ps); |
---|
859 | int securelevel_ge(struct ucred *cr, int level); |
---|
860 | int securelevel_gt(struct ucred *cr, int level); |
---|
861 | void sess_hold(struct session *); |
---|
862 | void sess_release(struct session *); |
---|
863 | int setrunnable(struct thread *); |
---|
864 | void setsugid(struct proc *p); |
---|
865 | int sigonstack(size_t sp); |
---|
866 | void sleepinit(void); |
---|
867 | void stopevent(struct proc *, u_int, u_int); |
---|
868 | void threadinit(void); |
---|
869 | void cpu_idle(int); |
---|
870 | int cpu_idle_wakeup(int); |
---|
871 | extern void (*cpu_idle_hook)(void); /* Hook to machdep CPU idler. */ |
---|
872 | void cpu_switch(struct thread *, struct thread *, struct mtx *); |
---|
873 | void cpu_throw(struct thread *, struct thread *) __dead2; |
---|
874 | void unsleep(struct thread *); |
---|
875 | void userret(struct thread *, struct trapframe *); |
---|
876 | struct syscall_args; |
---|
877 | int syscallenter(struct thread *, struct syscall_args *); |
---|
878 | void syscallret(struct thread *, int, struct syscall_args *); |
---|
879 | |
---|
880 | void cpu_exit(struct thread *); |
---|
881 | void exit1(struct thread *, int) __dead2; |
---|
882 | struct syscall_args; |
---|
883 | int cpu_fetch_syscall_args(struct thread *td, struct syscall_args *sa); |
---|
884 | void cpu_fork(struct thread *, struct proc *, struct thread *, int); |
---|
885 | void cpu_set_fork_handler(struct thread *, void (*)(void *), void *); |
---|
886 | void cpu_set_syscall_retval(struct thread *, int); |
---|
887 | void cpu_set_upcall(struct thread *td, struct thread *td0); |
---|
888 | #ifndef __rtems__ |
---|
889 | void cpu_set_upcall_kse(struct thread *, void (*)(void *), void *, |
---|
890 | stack_t *); |
---|
891 | #endif /* __rtems__ */ |
---|
892 | int cpu_set_user_tls(struct thread *, void *tls_base); |
---|
893 | void cpu_thread_alloc(struct thread *); |
---|
894 | void cpu_thread_clean(struct thread *); |
---|
895 | void cpu_thread_exit(struct thread *); |
---|
896 | void cpu_thread_free(struct thread *); |
---|
897 | void cpu_thread_swapin(struct thread *); |
---|
898 | void cpu_thread_swapout(struct thread *); |
---|
899 | struct thread *thread_alloc(int pages); |
---|
900 | int thread_alloc_stack(struct thread *, int pages); |
---|
901 | void thread_exit(void) __dead2; |
---|
902 | void thread_free(struct thread *td); |
---|
903 | void thread_link(struct thread *td, struct proc *p); |
---|
904 | void thread_reap(void); |
---|
905 | int thread_single(int how); |
---|
906 | void thread_single_end(void); |
---|
907 | void thread_stash(struct thread *td); |
---|
908 | void thread_stopped(struct proc *p); |
---|
909 | void childproc_stopped(struct proc *child, int reason); |
---|
910 | void childproc_continued(struct proc *child); |
---|
911 | void childproc_exited(struct proc *child); |
---|
912 | int thread_suspend_check(int how); |
---|
913 | void thread_suspend_switch(struct thread *); |
---|
914 | void thread_suspend_one(struct thread *td); |
---|
915 | void thread_unlink(struct thread *td); |
---|
916 | void thread_unsuspend(struct proc *p); |
---|
917 | int thread_unsuspend_one(struct thread *td); |
---|
918 | void thread_unthread(struct thread *td); |
---|
919 | void thread_wait(struct proc *p); |
---|
920 | struct thread *thread_find(struct proc *p, lwpid_t tid); |
---|
921 | void thr_exit1(void); |
---|
922 | |
---|
923 | #endif /* _KERNEL */ |
---|
924 | |
---|
925 | #endif /* !_SYS_PROC_H_ */ |
---|