![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_synch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / kern|
Return to kern_synch.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Mach Operating System
27: * Copyright (c) 1987 Carnegie-Mellon University
28: * All rights reserved. The CMU software License Agreement specifies
29: * the terms and conditions for use and redistribution.
30: */
31:
32: #import <cputypes.h>
33: #import <cpus.h>
34:
35: #import <sys/param.h>
36: #import <sys/systm.h>
37: #import <sys/proc.h>
38: #import <sys/user.h>
39: #import <sys/file.h>
40: #import <sys/vnode.h>
41: #import <sys/kernel.h>
42: #import <sys/buf.h>
43:
44: #import <machine/spl.h>
45:
46: #import <kern/ast.h>
47: #import <sys/callout.h>
48: #import <kern/queue.h>
49: #import <kern/lock.h>
50: #import <kern/thread.h>
51: #import <kern/sched.h>
52: #import <kern/sched_prim.h>
53: #import <mach/machine.h>
54: #import <kern/parallel.h>
55: #import <kern/processor.h>
56:
57: #import <machine/cpu.h>
58: #import <vm/pmap.h>
59: #import <vm/vm_kern.h>
60:
61: #import <kern/task.h>
62: #import <mach/time_value.h>
63:
64: /*
65: * Give up the processor till a wakeup occurs
66: * on chan, at which time the process
67: * enters the scheduling queue at priority pri.
68: * The most important effect of pri is that when
69: * pri<=PZERO a signal cannot disturb the sleep;
70: * if pri>PZERO signals will be processed.
71: * If pri&PCATCH is set, signals will cause sleep
72: * to return 1, rather than longjmp.
73: * Callers of this routine must be prepared for
74: * premature return, and check that the reason for
75: * sleeping has gone away.
76: */
77:
78: static __inline__
79: int _sleep(chan, pri, wmsg, timo)
80: caddr_t chan;
81: int pri;
82: char *wmsg;
83: int timo;
84: {
85: register struct proc *p;
86: register thread_t thread = current_thread();
87: int sig, catch = pri & PCATCH;
88: int error = 0;
89: spl_t s;
90:
91: s = splhigh();
92:
93: p = current_proc();
94: #if KTRACE
95: if (KTRPOINT(p, KTR_CSW))
96: ktrcsw(p->p_tracep, 1, 0);
97: #endif
98: p->p_priority = pri & PRIMASK;
99:
100: if (chan)
101: assert_wait(chan, (catch ? TRUE : FALSE));
102:
103: if (timo)
104: thread_set_timeout(timo);
105: /*
106: * We start our timeout
107: * before calling CURSIG, as we could stop there, and a wakeup
108: * or a SIGCONT (or both) could occur while we were stopped.
109: * A SIGCONT would cause us to be marked as SSLEEP
110: * without resuming us, thus we must be ready for sleep
111: * when CURSIG is called. If the wakeup happens while we're
112: * stopped, p->p_wchan will be 0 upon return from CURSIG.
113: */
114:
115: if (catch) {
116: unix_master();
117: if (SHOULDissignal(p,thread->_uthread)) {
118: if (sig = CURSIG(p)) {
119: clear_wait(thread, THREAD_INTERRUPTED, TRUE);
120: if (p->p_sigacts->ps_sigintr & sigmask(sig))
121: error = EINTR;
122: else
123: error = ERESTART;
124: unix_release();
125: goto out;
126: }
127: }
128: if (thread_should_halt(thread)) {
129: clear_wait(thread, THREAD_SHOULD_TERMINATE, TRUE);
130: error = EINTR;
131: unix_release();
132: goto out;
133: }
134: if (thread->wait_event == 0) { // already happened
135: unix_release();
136: goto out;
137: }
138: unix_release();
139: }
140:
141: thread->wait_mesg = wmsg;
142: (void) spl0();
143: p->p_stats->p_ru.ru_nvcsw++;
144:
145: thread_block();
146:
147: thread->wait_mesg = NULL;
148: switch (thread->wait_result) {
149: case THREAD_TIMED_OUT:
150: error = EWOULDBLOCK;
151: break;
152: case THREAD_AWAKENED:
153: /*
154: * Posix implies any signal should be delivered
155: * first, regardless of whether awakened due
156: * to receiving event.
157: */
158: if (!catch)
159: break;
160: /* else fall through */
161: case THREAD_INTERRUPTED:
162: case THREAD_SHOULD_TERMINATE:
163: if (catch) {
164: unix_master();
165: if (thread_should_halt(thread)) {
166: error = EINTR;
167: } else if (SHOULDissignal(p,thread->_uthread)) {
168: if (sig = CURSIG(p)) {
169: if (p->p_sigacts->ps_sigintr & sigmask(sig))
170: error = EINTR;
171: else
172: error = ERESTART;
173: }
174: if (thread_should_halt(thread)) {
175: error = EINTR;
176: }
177: }
178: unix_release();
179: }
180: break;
181: }
182: out:
183: (void) splx(s);
184: return (error);
185: }
186:
187: int sleep(chan, pri)
188: void *chan;
189: int pri;
190: {
191:
192: return (_sleep((caddr_t)chan, pri, (char *)NULL, 0));
193:
194: }
195:
196: int tsleep(chan, pri, wmsg, timo)
197: void *chan;
198: int pri;
199: char * wmsg;
200: int timo;
201: {
202: return(_sleep((caddr_t)chan, pri, wmsg, timo));
203: }
204:
205: /*
206: * Wake up all processes sleeping on chan.
207: */
208: void
209: wakeup(chan)
210: register void *chan;
211: {
212: int s;
213:
214: s = splhigh();
215: thread_wakeup((caddr_t)chan);
216: splx(s);
217: }
218:
219: /*
220: * Wake up the first process sleeping on chan.
221: *
222: * Be very sure that the first process is really
223: * the right one to wakeup.
224: */
225: wakeup_one(chan)
226: register caddr_t chan;
227: {
228: int s;
229:
230: s = splhigh();
231: thread_wakeup_one(chan);
232: splx(s);
233: }
234:
235: /*
236: * Compute the priority of a process when running in user mode.
237: * Arrange to reschedule if the resulting priority is better
238: * than that of the current process.
239: */
240: void
241: resetpriority(p)
242: register struct proc *p;
243: {
244: int newpri;
245:
246: if (p->p_nice < 0)
247: newpri = BASEPRI_USER +
248: (p->p_nice * (MAXPRI_USER - BASEPRI_USER)) / PRIO_MIN;
249: else
250: newpri = BASEPRI_USER -
251: (p->p_nice * BASEPRI_USER) / PRIO_MAX;
252:
253: (void)task_priority(p->task, newpri, TRUE);
254: }
255:
256: #if NCPUS > 1
257:
258: slave_start()
259: {
260: register struct thread *th;
261: register int mycpu;
262:
263: /* Find a thread to execute */
264:
265: mycpu = cpu_number();
266:
267: splhigh();
268: th = choose_thread(current_processor());
269: if (th == NULL) {
270: printf("Slave %d failed to find any threads.\n", mycpu);
271: printf("Should have at least found idle thread.\n");
272: halt_cpu();
273: }
274:
275: /*
276: * Show that this cpu is using the kernel pmap
277: */
278: PMAP_ACTIVATE(kernel_pmap, th, mycpu);
279:
280: active_threads[mycpu] = th;
281:
282: if (th->task->kernel_vm_space == FALSE) {
283: PMAP_ACTIVATE(vm_map_pmap(th->task->map), th, mycpu);
284: }
285:
286: /*
287: * Clock interrupt requires that this cpu have an active
288: * thread, hence it can't be done before this.
289: */
290: #if NeXT
291: #else NeXT
292: startrtclock();
293: #endif /* NeXT */
294: ast_context(th, mycpu);
295: load_context(th);
296: /*NOTREACHED*/
297: }
298: #endif /* NCPUS > 1 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.