workbench/network/stacks/AROSTCP/bsdsocket/kern/kern_synch.c

   1 /*
   2  * Copyright (C) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>
   3  *                    Helsinki University of Technology, Finland.
   4  *                    All rights reserved.
   5  * Copyright (C) 2005 - 2007 The AROS Dev Team
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  19  * MA 02111-1307, USA.
  20  *
  21  */
  22
  23 #include <conf.h>
  24
  25 #include <sys/param.h>
  26 #include <sys/systm.h>
  27 #include <sys/synch.h>
  28 #include <sys/queue2.h>
  29 #include <sys/syslog.h>
  30
  31 #include <kern/amiga_includes.h>
  32
  33 #include <api/amiga_api.h>
  34
  35 #include <proto/exec.h>
  36
  37 /*
  38  * Note about spl-functions: this implementation does NOT check for software
  39  * interrupts when returning to level spl 0 (not needed on AmigaOS, see the
  40  * bottom of this file).
  41  */
  42
  43 /*
  44  * Sleeping threads are hashed by 'chan' onto sleep queues.
  45  */
  46
  47 #define SLEEP_QUEUE_SIZE        32      /* power of 2 */
  48 #define SLEEP_HASH(x)   (((IPTR)(x)>>5) & (SLEEP_QUEUE_SIZE - 1))
  49
  50 queue_head_t    sleep_queue[SLEEP_QUEUE_SIZE];
  51
  52 /*
  53  * semaphore protecting sleep queues
  54  */
  55 struct SignalSemaphore sleep_semaphore;
  56 static BOOL sleep_initialized = FALSE;
  57
  58 /*
  59  * Sleep system initialization.
  60  */
  61 BOOL
  62 sleep_init(void)
  63 {
  64   register int i;
  65
  66 #if defined(__AROS__)
  67 D(bug("[AROSTCP](kern_synch.c) sleep_init()\n"));
  68 #endif
  69
  70   if (!sleep_initialized) {
  71     /*
  72      * initialize the semaphore protecting sleep queues
  73      */
  74     InitSemaphore(&sleep_semaphore);
  75
  76     /*
  77      * initialize the sleep queues
  78      */
  79     for (i = 0; i < SLEEP_QUEUE_SIZE; i++)
  80       queue_init(&sleep_queue[i]);
  81
  82     sleep_initialized = TRUE;
  83   }
  84   return TRUE;
  85 }
  86
  87 void
  88 tsleep_send_timeout(struct SocketBase *p,
  89                     const struct timeval *time_out)
  90 {
  91 #if defined(__AROS__)
  92 D(bug("[AROSTCP](kern_synch.c) tsleep_send_timeout()\n"));
  93 #endif
  94   /*
  95    * Make sure that the timer message is back from the timer device
  96    */
  97   if (p->tsleep_timer->tr_node.io_Message.mn_Node.ln_Type != NT_UNKNOWN) {
  98     /*
  99      * abort previous timeout if it has not been completed yet
 100      */
 101     if (p->tsleep_timer->tr_node.io_Message.mn_Node.ln_Type != NT_REPLYMSG) {
 102       AbortIO((struct IORequest *)(p->tsleep_timer));
 103     }
 104     /*
 105      * Remove timerequest from reply port.
 106      */
 107     WaitIO((struct IORequest *)p->tsleep_timer);
 108     /*
 109      * Set the node type to NT_UNKNOWN to mark that it is referenced only by
 110      * the p->tsleep_timer.
 111      */
 112     p->tsleep_timer->tr_node.io_Message.mn_Node.ln_Type = NT_UNKNOWN;
 113 #if 0
 114     /*
 115      * Make sure the signal gets cleared.
 116      *
 117      * if this is not done, the tsleep_main will do one unnecessary round
 118      * IF the signal was set. IS THIS WORTH OF IT?
 119      */
 120     SetSignal(0, 1 << p->timerPort->mp_SigBit);
 121 #endif
 122   }
 123   /*
 124    * send timeout request if necessary
 125    */
 126   if (time_out) {
 127     /*
 128      * set the timeout
 129      */
 130     p->tsleep_timer->tr_time = *time_out;
 131     /*
 132      * Enable signalling again
 133      */
 134     p->timerPort->mp_Flags = PA_SIGNAL;
 135     /*
 136      * send the request to the timer device
 137      */
 138     BeginIO((struct IORequest *)(p->tsleep_timer));
 139   }
 140 }
 141
 142 void
 143 tsleep_abort_timeout(struct SocketBase *p,
 144                      const struct timeval *time_out)
 145 {
 146 #if defined(__AROS__)
 147 D(bug("[AROSTCP](kern_synch.c) tsleep_abort_timeout()\n"));
 148 #endif
 149   if (time_out) {
 150     /* do not signal us any more */
 151     p->timerPort->mp_Flags = PA_IGNORE;
 152   }
 153 }
 154
 155 void
 156 tsleep_enter(struct SocketBase *p,
 157              caddr_t chan,              /* 'channel' to wait on */
 158              const char *wmesg)         /* reason to sleep */
 159 {
 160   register queue_t      q;
 161 #if defined(__AROS__)
 162 D(bug("[AROSTCP](kern_synch.c) tsleep_enter()\n"));
 163 #endif
 164   /*
 165    * Zero is a reserved value, used to indicate
 166    * that we have been woken up and are no longer on
 167    * the sleep queues.
 168    */
 169
 170 #if DIAGNOSTIC
 171   if (chan == 0)
 172     panic("tsleep");
 173 #endif
 174
 175   /*
 176    * The sleep_semaphore protects the sleep queues and
 177    * p_ fields in SocketBases.
 178    *
 179    * When the process is in a sleep queue its p_wchan field is nonzero.
 180    */
 181   ObtainSemaphore(&sleep_semaphore);
 182   p->p_wchan = chan;
 183   p->p_wmesg = wmesg;
 184   q = &sleep_queue[SLEEP_HASH(chan)];
 185   queue_enter(q, p, struct SocketBase *, p_sleep_link);
 186   ReleaseSemaphore(&sleep_semaphore);
 187 }
 188
 189 int
 190 tsleep_main(struct SocketBase *p, ULONG wakemask)
 191 {
 192   ULONG sigmask, bmask, timermask;
 193   struct timerequest *timerReply;
 194   register queue_t q;
 195   int result;
 196 #if defined(__AROS__)
 197 D(bug("[AROSTCP](kern_synch.c) tsleep_main()\n"));
 198 #endif
 199   /*
 200    * Set the signal mask for the wait
 201    */
 202   timermask = 1 << p->timerPort->mp_SigBit;
 203   sigmask = timermask | p->sigIntrMask | wakemask;
 204
 205   for (;;) {
 206     /*
 207      * wait for timeout, wakeup or interrupt
 208      */
 209     bmask = Wait(sigmask);
 210
 211     /*
 212      * Check if we were interrupted
 213      */
 214     if (bmask & p->sigIntrMask & ~wakemask) {
 215       result = EINTR;
 216       break;
 217     }
 218
 219     /*
 220      * Check for user signals
 221      */
 222     if (bmask & wakemask) {
 223       result = ERESTART;
 224       break;
 225     }
 226
 227     /*
 228      * check if we were woken up.
 229      *
 230      * If p->p_chan is zero then the wakener has removed us from
 231      * the sleep queue.
 232      */
 233     if (p->p_wchan == 0) {
 234       /*
 235        * Set back the signals which interrupted us so that user program can
 236        * detect them
 237        */
 238       bmask &= p->sigIntrMask|wakemask;
 239       if (bmask)
 240         SetSignal(bmask, bmask);
 241
 242       return 0;                 /* return success */
 243     }
 244
 245     /*
 246      * check if we got the timer reply signal and message
 247      */
 248     if (bmask & timermask &&
 249         (timerReply = (struct timerequest *)GetMsg(p->timerPort)) &&
 250         timerReply == p->tsleep_timer) { /* sanity check */
 251       /*
 252        * timeout expired.
 253        *
 254        * Set the node type to NT_UNKNOWN to mark that it is referenced only by
 255        * the p->tsleep_timer.
 256        */
 257       timerReply->tr_node.io_Message.mn_Node.ln_Type = NT_UNKNOWN;
 258
 259       result = EWOULDBLOCK;
 260       break;
 261     }
 262
 263   } /* for */
 264
 265   /* Return path when sleeper has to be removed from the sleep queue */
 266
 267   /*
 268    * Set back the signals which interrupted us so that user program can
 269    * detect them
 270    */
 271   bmask &= p->sigIntrMask | wakemask;
 272   if (bmask)
 273     SetSignal(bmask, bmask);
 274
 275   /*
 276    * remove from the sleep queue
 277    */
 278   ObtainSemaphore(&sleep_semaphore);
 279   /*
 280    * If p_chan is nonzero then we still are on the sleep queue and
 281    * need to be removed from there.
 282    */
 283   if (p->p_wchan != 0) {
 284     q = &sleep_queue[SLEEP_HASH(p->p_wchan)];
 285     p->p_wchan = (char *)0;
 286     queue_remove(q, p, struct SocketBase *, p_sleep_link);
 287   }
 288   ReleaseSemaphore(&sleep_semaphore);
 289
 290   return result;
 291 }
 292
 293 /*
 294  * General sleep call.
 295  * NOTE: caller is assumed to hold the syscall_semaphore!         \* XXX *\
 296  * Suspends current process until a wakeup is made on chan.
 297  * Sleeps at most the time specified in a time_out (NULL means no timeout).
 298  * Lowers the current spl-level to 0 while in sleep.
 299  * Returns 0 if awakened, EWOULDBLOCK if the timeout expires and
 300  * EINTR if interrupted.
 301  */
 302 int
 303 tsleep(struct SocketBase *p,  /* Library base through which this call came */
 304        caddr_t chan,          /* 'channel' to wait on */
 305        const char *wmesg,             /* reason to sleep */
 306        const struct timeval *time_out) /* timeout as timeval structure */
 307 {
 308   int result;
 309   spl_t old_spl;
 310 #if defined(__AROS__)
 311 D(bug("[AROSTCP](kern_synch.c) tsleep()\n"));
 312 #endif
 313
 314 #if DIAGNOSTIC
 315   extern struct Task *AROSTCP_Task;
 316   if (FindTask(NULL) == AROSTCP_Task) {
 317     log(LOG_ERR, "TCP/IP stack did tsleep() itself!");
 318     return (-1);
 319   }
 320 #endif
 321
 322 #if DIAGNOSTIC
 323   if (p == NULL) {
 324     log(LOG_ERR, "tsleep() called with NULL SocketBase pointer!");
 325     return (-1);
 326   }
 327 #endif
 328
 329 #if DIAGNOSTIC
 330   if (FindTask(NULL) != syscall_semaphore.ss_Owner) {
 331     log(LOG_ERR, "tsleep() called with NO syscall_semaphore!");
 332     return (-1);
 333   }
 334 #endif
 335
 336   tsleep_send_timeout(p, time_out);
 337
 338   tsleep_enter(p, chan, wmesg);
 339
 340   /*
 341    * release spl-level while in sleep.
 342    *
 343    * NOTE: syscall_semaphore must be freed as well!
 344    */
 345
 346   old_spl = spl0();
 347   ReleaseSemaphore(&syscall_semaphore);                      /* XXX */
 348
 349   result = tsleep_main(p, 0);
 350
 351   /*
 352    * return old spl-level
 353    */
 354   ObtainSemaphore(&syscall_semaphore);                       /* XXX */
 355   splx(old_spl);
 356
 357   /*
 358    * abort the timeout request if necessary
 359    */
 360   if (result != EWOULDBLOCK)
 361     tsleep_abort_timeout(p, time_out);
 362
 363   return (result);
 364 }
 365
 366 void
 367 wakeup(caddr_t chan)
 368 {
 369   register queue_t q;
 370   struct SocketBase *p, *next;
 371 #if defined(__AROS__)
 372 D(bug("[AROSTCP](kern_synch.c) wakeup()\n"));
 373 #endif
 374
 375 #if DIAGNOSTIC
 376   if (chan == 0) {
 377     log(LOG_ERR, "wakeup on chan zero");
 378     return;
 379   }
 380 #endif
 381
 382   ObtainSemaphore(&sleep_semaphore);
 383   q = &sleep_queue[SLEEP_HASH(chan)];
 384
 385   p = (struct SocketBase *)queue_first(q);
 386   while (!queue_end(q, (queue_entry_t)p)) {
 387     next = (struct SocketBase *)queue_next(&p->p_sleep_link);
 388     if (p->p_wchan == chan) {
 389       /*
 390        * mark sleeper as woken up
 391        */
 392       p->p_wchan = NULL;
 393       /*
 394        * remove sleeper from the sleep queue
 395        */
 396       queue_remove(q, p, struct SocketBase *, p_sleep_link);
 397       /*
 398        * signal process to take attention
 399        */
 400       Signal(p->thisTask, 1 << p->timerPort->mp_SigBit);
 401     }
 402     p = next;
 403   }
 404   ReleaseSemaphore(&sleep_semaphore);
 405 }
 406
 407 /*
 408  * Spl-level emulation:
 409  *
 410  * In this implementation the processor priority levels are modelled
 411  * either with one semaphore (ifdef DEBUG) or by Exec Task switch
 412  * disabling feature. Semaphore is used while debugging for security (to
 413  * be able to single step almost everywhere). The production version uses
 414  * ExecBase's TDNestCnt for speed (prevent unnecessary task switches).
 415  *
 416  * Note that both ways lead to the fact that when someone sets, say, splimp()
 417  * he will WAIT for the holder of splnet() to finish.
 418  *
 419  * N.B. The above comments are now out-of-date. The semaphore implementation
 420  * is now always used.
 421  */
 422
 423 /*#ifndef DEBUG*/ /* NC */
 424 #if 1
 425 /*
 426  * spl_semaphore is used as mutex for all spl-levels
 427  *
 428  * Note that InitSemaphore() requires the signalSemaphore to be initialized
 429  * to zero (here done statically).
 430  */
 431 struct SignalSemaphore spl_semaphore = { };
 432
 433 /*
 434  * spl_level holds the current pseudo priority level.
 435  * NOTE: this may be accessed only while holding the spl_semaphore.
 436  */
 437 spl_t spl_level = SPL0;
 438 static BOOL spl_initialized = FALSE;
 439
 440 BOOL
 441 spl_init(void)
 442 {
 443 #if defined(__AROS__)
 444 D(bug("[AROSTCP](kern_synch.c) spl_init()\n"));
 445 #endif
 446   if (!spl_initialized) {
 447     /*
 448      * Initialize spl_semaphore for use. After this call any number of
 449      * tasks may use spl-functions.
 450      */
 451     InitSemaphore(&spl_semaphore);
 452     spl_initialized = TRUE;
 453   }
 454   return TRUE;
 455 }
 456
 457 spl_t
 458 spl_n(spl_t new_level)
 459 {
 460   register spl_t old_level;
 461 /* Uncomment the following lines to get debug - however please note: this func runs often */
 462 //#if defined(__AROS__)
 463 //D(bug("[AROSTCP](kern_synch.c) spl_n()\n"));
 464 //#endif
 465
 466   ObtainSemaphore(&spl_semaphore);
 467   old_level = spl_level;
 468   spl_level = new_level;
 469
 470   if (new_level > old_level) {  /* raise level */
 471     if (old_level == 0)         /* lock when raising over zero */
 472       /*
 473        * so. return without releasing the lock
 474        */
 475       return old_level;
 476   }
 477   else if (new_level < old_level) {     /* lower level */
 478     if (new_level == 0)                 /* unlock when lowering to zero */
 479       /*
 480        * now release the lock kept above
 481        */
 482       ReleaseSemaphore(&spl_semaphore);
 483   }
 484   ReleaseSemaphore(&spl_semaphore);
 485
 486   return old_level;
 487 }
 488
 489 #else
 490
 491 BOOL
 492 spl_init(void)
 493 {
 494 #if defined(__AROS__)
 495 D(bug("[AROSTCP](kern_synch.c) spl_init() VOID\n"));
 496 #endif
 497   return TRUE;
 498 }
 499
 500 /*
 501  * spl_n is defined as an inline in <sys/synch.h>
 502  */
 503 #endif /* DEBUG */