Annotation of sys/kern/kern_synch.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: kern_synch.c,v 1.80 2007/05/16 17:27:30 art Exp $ */
2: /* $NetBSD: kern_synch.c,v 1.37 1996/04/22 01:38:37 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1990, 1991, 1993
6: * The Regents of the University of California. All rights reserved.
7: * (c) UNIX System Laboratories, Inc.
8: * All or some portions of this file are derived from material licensed
9: * to the University of California by American Telephone and Telegraph
10: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
11: * the permission of UNIX System Laboratories, Inc.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. Neither the name of the University nor the names of its contributors
22: * may be used to endorse or promote products derived from this software
23: * without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35: * SUCH DAMAGE.
36: *
37: * @(#)kern_synch.c 8.6 (Berkeley) 1/21/94
38: */
39:
40: #include <sys/param.h>
41: #include <sys/systm.h>
42: #include <sys/proc.h>
43: #include <sys/kernel.h>
44: #include <sys/buf.h>
45: #include <sys/signalvar.h>
46: #include <sys/resourcevar.h>
47: #include <uvm/uvm_extern.h>
48: #include <sys/sched.h>
49: #include <sys/timeout.h>
50: #include <sys/mount.h>
51: #include <sys/syscallargs.h>
52: #include <sys/pool.h>
53:
54: #include <machine/spinlock.h>
55:
56: #ifdef KTRACE
57: #include <sys/ktrace.h>
58: #endif
59:
60: void updatepri(struct proc *);
61: void endtsleep(void *);
62:
63: /*
64: * We're only looking at 7 bits of the address; everything is
65: * aligned to 4, lots of things are aligned to greater powers
66: * of 2. Shift right by 8, i.e. drop the bottom 256 worth.
67: */
68: #define TABLESIZE 128
69: #define LOOKUP(x) (((long)(x) >> 8) & (TABLESIZE - 1))
70: struct slpque {
71: struct proc *sq_head;
72: struct proc **sq_tailp;
73: } slpque[TABLESIZE];
74:
75: /*
76: * During autoconfiguration or after a panic, a sleep will simply
77: * lower the priority briefly to allow interrupts, then return.
78: * The priority to be used (safepri) is machine-dependent, thus this
79: * value is initialized and maintained in the machine-dependent layers.
80: * This priority will typically be 0, or the lowest priority
81: * that is safe for use on the interrupt stack; it can be made
82: * higher to block network software interrupts after panics.
83: */
84: int safepri;
85:
86: /*
87: * General sleep call. Suspends the current process until a wakeup is
88: * performed on the specified identifier. The process will then be made
89: * runnable with the specified priority. Sleeps at most timo/hz seconds
90: * (0 means no timeout). If pri includes PCATCH flag, signals are checked
91: * before and after sleeping, else signals are not checked. Returns 0 if
92: * awakened, EWOULDBLOCK if the timeout expires. If PCATCH is set and a
93: * signal needs to be delivered, ERESTART is returned if the current system
94: * call should be restarted if possible, and EINTR is returned if the system
95: * call should be interrupted by the signal (return EINTR).
96: */
97: int
98: tsleep(void *ident, int priority, const char *wmesg, int timo)
99: {
100: struct sleep_state sls;
101: int error, error1;
102:
103: if (cold || panicstr) {
104: int s;
105: /*
106: * After a panic, or during autoconfiguration,
107: * just give interrupts a chance, then just return;
108: * don't run any other procs or panic below,
109: * in case this is the idle process and already asleep.
110: */
111: s = splhigh();
112: splx(safepri);
113: splx(s);
114: return (0);
115: }
116:
117: sleep_setup(&sls, ident, priority, wmesg);
118: sleep_setup_timeout(&sls, timo);
119: sleep_setup_signal(&sls, priority);
120:
121: sleep_finish(&sls, 1);
122: error1 = sleep_finish_timeout(&sls);
123: error = sleep_finish_signal(&sls);
124:
125: /* Signal errors are higher priority than timeouts. */
126: if (error == 0 && error1 != 0)
127: error = error1;
128:
129: return (error);
130: }
131:
132: void
133: sleep_setup(struct sleep_state *sls, void *ident, int prio, const char *wmesg)
134: {
135: struct proc *p = curproc;
136: struct slpque *qp;
137:
138: #ifdef DIAGNOSTIC
139: if (ident == NULL)
140: panic("tsleep: no ident");
141: if (p->p_stat != SONPROC)
142: panic("tsleep: not SONPROC");
143: if (p->p_back != NULL)
144: panic("tsleep: p_back not NULL");
145: #endif
146:
147: #ifdef KTRACE
148: if (KTRPOINT(p, KTR_CSW))
149: ktrcsw(p, 1, 0);
150: #endif
151:
152: sls->sls_catch = 0;
153: sls->sls_do_sleep = 1;
154: sls->sls_sig = 1;
155:
156: SCHED_LOCK(sls->sls_s);
157:
158: p->p_wchan = ident;
159: p->p_wmesg = wmesg;
160: p->p_slptime = 0;
161: p->p_priority = prio & PRIMASK;
162: qp = &slpque[LOOKUP(ident)];
163: if (qp->sq_head == 0)
164: qp->sq_head = p;
165: else
166: *qp->sq_tailp = p;
167: *(qp->sq_tailp = &p->p_forw) = NULL;
168: }
169:
170: void
171: sleep_finish(struct sleep_state *sls, int do_sleep)
172: {
173: struct proc *p = curproc;
174:
175: if (sls->sls_do_sleep && do_sleep) {
176: p->p_stat = SSLEEP;
177: p->p_stats->p_ru.ru_nvcsw++;
178: SCHED_ASSERT_LOCKED();
179: mi_switch();
180: } else if (!do_sleep) {
181: unsleep(p);
182: #ifdef DIAGNOSTIC
183: if (p->p_stat != SONPROC)
184: panic("sleep_finish !SONPROC");
185: #endif
186: }
187:
188: p->p_cpu->ci_schedstate.spc_curpriority = p->p_usrpri;
189: SCHED_UNLOCK(sls->sls_s);
190:
191: /*
192: * Even though this belongs to the signal handling part of sleep,
193: * we need to clear it before the ktrace.
194: */
195: atomic_clearbits_int(&p->p_flag, P_SINTR);
196:
197: #ifdef KTRACE
198: if (KTRPOINT(p, KTR_CSW))
199: ktrcsw(p, 0, 0);
200: #endif
201: }
202:
203: void
204: sleep_setup_timeout(struct sleep_state *sls, int timo)
205: {
206: if (timo)
207: timeout_add(&curproc->p_sleep_to, timo);
208: }
209:
210: int
211: sleep_finish_timeout(struct sleep_state *sls)
212: {
213: struct proc *p = curproc;
214:
215: if (p->p_flag & P_TIMEOUT) {
216: atomic_clearbits_int(&p->p_flag, P_TIMEOUT);
217: return (EWOULDBLOCK);
218: } else if (timeout_pending(&p->p_sleep_to)) {
219: timeout_del(&p->p_sleep_to);
220: }
221:
222: return (0);
223: }
224:
225: void
226: sleep_setup_signal(struct sleep_state *sls, int prio)
227: {
228: struct proc *p = curproc;
229:
230: if ((sls->sls_catch = (prio & PCATCH)) == 0)
231: return;
232:
233: /*
234: * We put ourselves on the sleep queue and start our timeout
235: * before calling CURSIG, as we could stop there, and a wakeup
236: * or a SIGCONT (or both) could occur while we were stopped.
237: * A SIGCONT would cause us to be marked as SSLEEP
238: * without resuming us, thus we must be ready for sleep
239: * when CURSIG is called. If the wakeup happens while we're
240: * stopped, p->p_wchan will be 0 upon return from CURSIG.
241: */
242: atomic_setbits_int(&p->p_flag, P_SINTR);
243: if ((sls->sls_sig = CURSIG(p)) != 0) {
244: if (p->p_wchan)
245: unsleep(p);
246: p->p_stat = SONPROC;
247: sls->sls_do_sleep = 0;
248: } else if (p->p_wchan == 0) {
249: sls->sls_catch = 0;
250: sls->sls_do_sleep = 0;
251: }
252: }
253:
254: int
255: sleep_finish_signal(struct sleep_state *sls)
256: {
257: struct proc *p = curproc;
258:
259: if (sls->sls_catch != 0) {
260: if (sls->sls_sig != 0 || (sls->sls_sig = CURSIG(p)) != 0) {
261: if (p->p_sigacts->ps_sigintr & sigmask(sls->sls_sig))
262: return (EINTR);
263: return (ERESTART);
264: }
265: }
266:
267: return (0);
268: }
269:
270: /*
271: * Implement timeout for tsleep.
272: * If process hasn't been awakened (wchan non-zero),
273: * set timeout flag and undo the sleep. If proc
274: * is stopped, just unsleep so it will remain stopped.
275: */
276: void
277: endtsleep(void *arg)
278: {
279: struct proc *p = arg;
280: int s;
281:
282: SCHED_LOCK(s);
283: if (p->p_wchan) {
284: if (p->p_stat == SSLEEP)
285: setrunnable(p);
286: else
287: unsleep(p);
288: atomic_setbits_int(&p->p_flag, P_TIMEOUT);
289: }
290: SCHED_UNLOCK(s);
291: }
292:
293: /*
294: * Remove a process from its wait queue
295: */
296: void
297: unsleep(struct proc *p)
298: {
299: struct slpque *qp;
300: struct proc **hp;
301:
302: if (p->p_wchan) {
303: hp = &(qp = &slpque[LOOKUP(p->p_wchan)])->sq_head;
304: while (*hp != p)
305: hp = &(*hp)->p_forw;
306: *hp = p->p_forw;
307: if (qp->sq_tailp == &p->p_forw)
308: qp->sq_tailp = hp;
309: p->p_wchan = 0;
310: }
311: }
312:
313: /*
314: * Make a number of processes sleeping on the specified identifier runnable.
315: */
316: void
317: wakeup_n(void *ident, int n)
318: {
319: struct slpque *qp;
320: struct proc *p, **q;
321: int s;
322:
323: SCHED_LOCK(s);
324: qp = &slpque[LOOKUP(ident)];
325: restart:
326: for (q = &qp->sq_head; (p = *q) != NULL; ) {
327: #ifdef DIAGNOSTIC
328: if (p->p_back)
329: panic("wakeup: p_back not NULL");
330: if (p->p_stat != SSLEEP && p->p_stat != SSTOP)
331: panic("wakeup: p_stat is %d", (int)p->p_stat);
332: #endif
333: if (p->p_wchan == ident) {
334: --n;
335: p->p_wchan = 0;
336: *q = p->p_forw;
337: if (qp->sq_tailp == &p->p_forw)
338: qp->sq_tailp = q;
339: if (p->p_stat == SSLEEP) {
340: /* OPTIMIZED EXPANSION OF setrunnable(p); */
341: if (p->p_slptime > 1)
342: updatepri(p);
343: p->p_slptime = 0;
344: p->p_stat = SRUN;
345:
346: /*
347: * Since curpriority is a user priority,
348: * p->p_priority is always better than
349: * curpriority on the last CPU on
350: * which it ran.
351: *
352: * XXXSMP See affinity comment in
353: * resched_proc().
354: */
355: setrunqueue(p);
356: KASSERT(p->p_cpu != NULL);
357: need_resched(p->p_cpu);
358: /* END INLINE EXPANSION */
359:
360: if (n != 0)
361: goto restart;
362: else
363: break;
364: }
365: } else
366: q = &p->p_forw;
367: }
368: SCHED_UNLOCK(s);
369: }
370:
371: /*
372: * Make all processes sleeping on the specified identifier runnable.
373: */
374: void
375: wakeup(void *chan)
376: {
377: wakeup_n(chan, -1);
378: }
379:
380: int
381: sys_sched_yield(struct proc *p, void *v, register_t *retval)
382: {
383: yield();
384: return (0);
385: }
386:
387: #ifdef RTHREADS
388:
389: int
390: sys_thrsleep(struct proc *p, void *v, register_t *revtal)
391: {
392: struct sys_thrsleep_args *uap = v;
393: long ident = (long)SCARG(uap, ident);
394: int timo = SCARG(uap, timeout);
395: _spinlock_lock_t *lock = SCARG(uap, lock);
396: _spinlock_lock_t unlocked = _SPINLOCK_UNLOCKED;
397: int error;
398:
399: p->p_thrslpid = ident;
400:
401: if (lock)
402: copyout(&unlocked, lock, sizeof(unlocked));
403: if (hz > 1000)
404: timo = timo * (hz / 1000);
405: else
406: timo = timo / (1000 / hz);
407: if (timo < 0)
408: timo = 0;
409: error = tsleep(&p->p_thrslpid, PUSER | PCATCH, "thrsleep", timo);
410:
411: if (error == ERESTART)
412: error = EINTR;
413:
414: return (error);
415:
416: }
417:
418: int
419: sys_thrwakeup(struct proc *p, void *v, register_t *retval)
420: {
421: struct sys_thrwakeup_args *uap = v;
422: long ident = (long)SCARG(uap, ident);
423: int n = SCARG(uap, n);
424: struct proc *q;
425: int found = 0;
426:
427: TAILQ_FOREACH(q, &p->p_p->ps_threads, p_thr_link) {
428: if (q->p_thrslpid == ident) {
429: wakeup(&q->p_thrslpid);
430: q->p_thrslpid = 0;
431: if (++found == n)
432: return (0);
433: }
434: }
435: if (!found)
436: return (ESRCH);
437:
438: return (0);
439: }
440: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_synch.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern