bsd/kern/kern_synch.c

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
   7  *
   8  * This file contains Original Code and/or Modifications of Original Code
   9  * as defined in and that are subject to the Apple Public Source License
  10  * Version 2.0 (the 'License'). You may not use this file except in
  11  * compliance with the License. Please obtain a copy of the License at
  12  * http://www.opensource.apple.com/apsl/ and read it before using this
  13  * file.
  14  *
  15  * The Original Code and all software distributed under the License are
  16  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  17  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  18  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  20  * Please see the License for the specific language governing rights and
  21  * limitations under the License.
  22  *
  23  * @APPLE_LICENSE_HEADER_END@
  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 #include <sys/param.h>
  33 #include <sys/systm.h>
  34 #include <sys/proc.h>
  35 #include <sys/user.h>
  36 #include <sys/file.h>
  37 #include <sys/vnode.h>
  38 #include <sys/kernel.h>
  39 #include <sys/buf.h>
  40
  41 #include <machine/spl.h>
  42
  43 #include <kern/queue.h>
  44 #include <sys/lock.h>
  45 #include <kern/thread.h>
  46 #include <kern/sched_prim.h>
  47 #include <kern/ast.h>
  48
  49 #include <kern/cpu_number.h>
  50 #include <vm/vm_kern.h>
  51
  52 #include <kern/task.h>
  53 #include <mach/time_value.h>
  54
  55 #if KTRACE
  56 #include <sys/uio.h>
  57 #include <sys/ktrace.h>
  58 #endif
  59
  60 static void
  61 _sleep_continue(void)
  62 {
  63         register struct proc *p;
  64         register thread_t self = current_act();
  65         struct uthread * ut;
  66         int sig, catch;
  67         int error = 0;
  68
  69         ut = get_bsdthread_info(self);
  70         catch = ut->uu_pri & PCATCH;
  71         p = current_proc();
  72
  73         switch (get_thread_waitresult(self)) {
  74                 case THREAD_TIMED_OUT:
  75                         error = EWOULDBLOCK;
  76                         break;
  77                 case THREAD_AWAKENED:
  78                         /*
  79                          * Posix implies any signal should be delivered
  80                          * first, regardless of whether awakened due
  81                          * to receiving event.
  82                          */
  83                         if (!catch)
  84                                 break;
  85                         /* else fall through */
  86                 case THREAD_INTERRUPTED:
  87                         if (catch) {
  88                                 if (thread_should_abort(self)) {
  89                                         error = EINTR;
  90                                 } else if (SHOULDissignal(p,ut)) {
  91                                         if (sig = CURSIG(p)) {
  92                                                 if (p->p_sigacts->ps_sigintr & sigmask(sig))
  93                                                         error = EINTR;
  94                                                 else
  95                                                         error = ERESTART;
  96                                         }
  97                                         if (thread_should_abort(self)) {
  98                                                 error = EINTR;
  99                                         }
 100                                 }
 101                         }  else
 102                                 error = EINTR;
 103                         break;
 104         }
 105
 106         if (error == EINTR || error == ERESTART)
 107                 act_set_astbsd(self);
 108
 109         if (ut->uu_timo)
 110                 thread_cancel_timer();
 111
 112 #if KTRACE
 113         if (KTRPOINT(p, KTR_CSW))
 114                 ktrcsw(p->p_tracep, 0, 0, -1);
 115 #endif
 116
 117         unix_syscall_return((*ut->uu_continuation)(error));
 118 }
 119
 120 /*
 121  * Give up the processor till a wakeup occurs
 122  * on chan, at which time the process
 123  * enters the scheduling queue at priority pri.
 124  * The most important effect of pri is that when
 125  * pri<=PZERO a signal cannot disturb the sleep;
 126  * if pri>PZERO signals will be processed.
 127  * If pri&PCATCH is set, signals will cause sleep
 128  * to return 1, rather than longjmp.
 129  * Callers of this routine must be prepared for
 130  * premature return, and check that the reason for
 131  * sleeping has gone away.
 132  */
 133
 134 static int
 135 _sleep(
 136         caddr_t         chan,
 137         int                     pri,
 138         char            *wmsg,
 139         u_int64_t       abstime,
 140         int                     (*continuation)(int))
 141 {
 142         register struct proc *p;
 143         register thread_t self = current_act();
 144         struct uthread * ut;
 145         int sig, catch = pri & PCATCH;
 146         int sigttblock = pri & PTTYBLOCK;
 147         int wait_result;
 148         int error = 0;
 149         spl_t   s;
 150
 151         s = splhigh();
 152
 153         ut = get_bsdthread_info(self);
 154
 155         p = current_proc();
 156 #if KTRACE
 157         if (KTRPOINT(p, KTR_CSW))
 158                 ktrcsw(p->p_tracep, 1, 0, -1);
 159 #endif
 160         p->p_priority = pri & PRIMASK;
 161
 162         if (chan != NULL)
 163                 assert_wait_prim(chan, NULL, abstime,
 164                                                         (catch) ? THREAD_ABORTSAFE : THREAD_UNINT);
 165         else
 166         if (abstime != 0)
 167                 thread_set_timer_deadline(abstime);
 168
 169         /*
 170          * We start our timeout
 171          * before calling CURSIG, as we could stop there, and a wakeup
 172          * or a SIGCONT (or both) could occur while we were stopped.
 173          * A SIGCONT would cause us to be marked as SSLEEP
 174          * without resuming us, thus we must be ready for sleep
 175          * when CURSIG is called.  If the wakeup happens while we're
 176          * stopped, p->p_wchan will be 0 upon return from CURSIG.
 177          */
 178         if (catch) {
 179                 if (SHOULDissignal(p,ut)) {
 180                         if (sig = CURSIG(p)) {
 181                                 if (clear_wait(self, THREAD_INTERRUPTED) == KERN_FAILURE)
 182                                         goto block;
 183                                 /* if SIGTTOU or SIGTTIN then block till SIGCONT */
 184                                 if (sigttblock && ((sig == SIGTTOU) || (sig == SIGTTIN))) {
 185                                         p->p_flag |= P_TTYSLEEP;
 186                                         /* reset signal bits */
 187                                         clear_procsiglist(p, sig);
 188                                         assert_wait(&p->p_siglist, THREAD_ABORTSAFE);
 189                                         /* assert wait can block and SIGCONT should be checked */
 190                                         if (p->p_flag & P_TTYSLEEP)
 191                                                 thread_block(THREAD_CONTINUE_NULL);
 192                                         /* return with success */
 193                                         error = 0;
 194                                         goto out;
 195                                 }
 196                                 if (p->p_sigacts->ps_sigintr & sigmask(sig))
 197                                         error = EINTR;
 198                                 else
 199                                         error = ERESTART;
 200                                 goto out;
 201                         }
 202                 }
 203                 if (thread_should_abort(self)) {
 204                         if (clear_wait(self, THREAD_INTERRUPTED) == KERN_FAILURE)
 205                                 goto block;
 206                         error = EINTR;
 207                         goto out;
 208                 }
 209                 if (get_thread_waitresult(self) != THREAD_WAITING) {
 210                         /*already happened */
 211                         goto out;
 212                 }
 213         }
 214
 215 block:
 216
 217         splx(s);
 218         p->p_stats->p_ru.ru_nvcsw++;
 219
 220         if ((thread_continue_t)continuation != THREAD_CONTINUE_NULL ) {
 221           ut->uu_continuation = continuation;
 222           ut->uu_pri = pri;
 223           ut->uu_timo = abstime? 1: 0;
 224           (void) thread_block(_sleep_continue);
 225           /* NOTREACHED */
 226         }
 227
 228         wait_result = thread_block(THREAD_CONTINUE_NULL);
 229
 230         switch (wait_result) {
 231                 case THREAD_TIMED_OUT:
 232                         error = EWOULDBLOCK;
 233                         break;
 234                 case THREAD_AWAKENED:
 235                         /*
 236                          * Posix implies any signal should be delivered
 237                          * first, regardless of whether awakened due
 238                          * to receiving event.
 239                          */
 240                         if (!catch)
 241                                 break;
 242                         /* else fall through */
 243                 case THREAD_INTERRUPTED:
 244                         if (catch) {
 245                                 if (thread_should_abort(self)) {
 246                                         error = EINTR;
 247                                 } else if (SHOULDissignal(p,ut)) {
 248                                         if (sig = CURSIG(p)) {
 249                                                 if (p->p_sigacts->ps_sigintr & sigmask(sig))
 250                                                         error = EINTR;
 251                                                 else
 252                                                         error = ERESTART;
 253                                         }
 254                                         if (thread_should_abort(self)) {
 255                                                 error = EINTR;
 256                                         }
 257                                 }
 258                         }  else
 259                                 error = EINTR;
 260                         break;
 261         }
 262 out:
 263         if (error == EINTR || error == ERESTART)
 264                 act_set_astbsd(self);
 265         if (abstime)
 266                 thread_cancel_timer();
 267         (void) splx(s);
 268 #if KTRACE
 269         if (KTRPOINT(p, KTR_CSW))
 270                 ktrcsw(p->p_tracep, 0, 0, -1);
 271 #endif
 272         return (error);
 273 }
 274
 275 int
 276 sleep(
 277         void    *chan,
 278         int             pri)
 279 {
 280         return _sleep((caddr_t)chan, pri, (char *)NULL, 0, (int (*)(int))0);
 281 }
 282
 283 int
 284 tsleep(
 285         void    *chan,
 286         int             pri,
 287         char    *wmsg,
 288         int             timo)
 289 {
 290         u_int64_t       abstime = 0;
 291
 292         if (timo)
 293                 clock_interval_to_deadline(timo, NSEC_PER_SEC / hz, &abstime);
 294         return _sleep((caddr_t)chan, pri, wmsg, abstime, (int (*)(int))0);
 295 }
 296
 297 int
 298 tsleep0(
 299         void    *chan,
 300         int             pri,
 301         char    *wmsg,
 302         int             timo,
 303         int             (*continuation)(int))
 304 {
 305         u_int64_t       abstime = 0;
 306
 307         if (timo)
 308                 clock_interval_to_deadline(timo, NSEC_PER_SEC / hz, &abstime);
 309         return _sleep((caddr_t)chan, pri, wmsg, abstime, continuation);
 310 }
 311
 312 int
 313 tsleep1(
 314         void            *chan,
 315         int                     pri,
 316         char            *wmsg,
 317         u_int64_t       abstime,
 318         int                     (*continuation)(int))
 319 {
 320         return _sleep((caddr_t)chan, pri, wmsg, abstime, continuation);
 321 }
 322
 323 /*
 324  * Wake up all processes sleeping on chan.
 325  */
 326 void
 327 wakeup(chan)
 328         register void *chan;
 329 {
 330         thread_wakeup_prim((caddr_t)chan, FALSE, THREAD_AWAKENED);
 331 }
 332
 333 /*
 334  * Wake up the first process sleeping on chan.
 335  *
 336  * Be very sure that the first process is really
 337  * the right one to wakeup.
 338  */
 339 void
 340 wakeup_one(chan)
 341         register caddr_t chan;
 342 {
 343         thread_wakeup_prim((caddr_t)chan, TRUE, THREAD_AWAKENED);
 344 }
 345
 346 /*
 347  * Compute the priority of a process when running in user mode.
 348  * Arrange to reschedule if the resulting priority is better
 349  * than that of the current process.
 350  */
 351 void
 352 resetpriority(p)
 353         register struct proc *p;
 354 {
 355         (void)task_importance(p->task, -p->p_nice);
 356 }
 357
 358 struct loadavg averunnable =
 359         { {0, 0, 0}, FSCALE };          /* load average, of runnable procs */
 360 /*
 361  * Constants for averages over 1, 5, and 15 minutes
 362  * when sampling at 5 second intervals.
 363  */
 364 static fixpt_t cexp[3] = {
 365     (fixpt_t)(0.9200444146293232 * FSCALE),    /* exp(-1/12) */
 366     (fixpt_t)(0.9834714538216174 * FSCALE),    /* exp(-1/60) */
 367     (fixpt_t)(0.9944598480048967 * FSCALE),    /* exp(-1/180) */
 368 };
 369
 370 void
 371 compute_averunnable(
 372         register int    nrun)
 373 {
 374         register int            i;
 375         struct loadavg          *avg = &averunnable;
 376
 377     for (i = 0; i < 3; i++)
 378         avg->ldavg[i] = (cexp[i] * avg->ldavg[i] +
 379             nrun * FSCALE * (FSCALE - cexp[i])) >> FSHIFT;
 380 }