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