sys/ofed/include/linux/wait.h

   1 /*-
   2  * Copyright (c) 2010 Isilon Systems, Inc.
   3  * Copyright (c) 2010 iX Systems, Inc.
   4  * Copyright (c) 2010 Panasas, Inc.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice unmodified, this list of conditions, and the following
  12  *    disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28 #ifndef _LINUX_WAIT_H_
  29 #define _LINUX_WAIT_H_
  30
  31 #include <linux/spinlock.h>
  32 #include <linux/sched.h>
  33 #include <linux/list.h>
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/sleepqueue.h>
  38 #include <sys/kernel.h>
  39 #include <sys/proc.h>
  40
  41 struct __wait_queue_head {
  42         unsigned int    wchan;
  43 };
  44 typedef struct __wait_queue_head wait_queue_head_t;
  45
  46 #define init_waitqueue_head(x)
  47
  48 static inline void
  49 __wake_up(struct __wait_queue_head *q, int all)
  50 {
  51         int wakeup_swapper;
  52         void *c;
  53
  54         c = &q->wchan;
  55         sleepq_lock(c);
  56         if (all)
  57                 wakeup_swapper = sleepq_broadcast(c, SLEEPQ_SLEEP, 0, 0);
  58         else
  59                 wakeup_swapper = sleepq_signal(c, SLEEPQ_SLEEP, 0, 0);
  60         sleepq_release(c);
  61         if (wakeup_swapper)
  62                 kick_proc0();
  63 }
  64
  65 #define wake_up(q)                              __wake_up(q, 0)
  66 #define wake_up_nr(q, nr)                       __wake_up(q, 1)
  67 #define wake_up_all(q)                          __wake_up(q, 1)
  68 #define wake_up_interruptible(q)                __wake_up(q, 0)
  69 #define wake_up_interruptible_nr(q, nr)         __wake_up(q, 1)
  70 #define wake_up_interruptible_all(q, nr)        __wake_up(q, 1)
  71
  72 #define wait_event(q, cond)                                             \
  73 do {                                                                    \
  74         void *c = &(q).wchan;                                           \
  75         if (!(cond)) {                                                  \
  76                 for (;;) {                                              \
  77                         sleepq_lock(c);                                 \
  78                         if (cond) {                                     \
  79                                 sleepq_release(c);                      \
  80                                 break;                                  \
  81                         }                                               \
  82                         sleepq_add(c, NULL, "completion", SLEEPQ_SLEEP, 0); \
  83                         sleepq_wait(c, 0);                              \
  84                 }                                                       \
  85         }                                                               \
  86 } while (0)
  87
  88 #define wait_event_interruptible(q, cond)                               \
  89 ({                                                                      \
  90         void *c = &(q).wchan;                                           \
  91         int _error;                                                     \
  92                                                                         \
  93         _error = 0;                                                     \
  94         if (!(cond)) {                                                  \
  95                 for (; _error == 0;) {                                  \
  96                         sleepq_lock(c);                                 \
  97                         if (cond) {                                     \
  98                                 sleepq_release(c);                      \
  99                                 break;                                  \
 100                         }                                               \
 101                         sleepq_add(c, NULL, "completion",               \
 102                             SLEEPQ_SLEEP | SLEEPQ_INTERRUPTIBLE, 0);    \
 103                         if (sleepq_wait_sig(c, 0))                      \
 104                                 _error = -ERESTARTSYS;                  \
 105                 }                                                       \
 106         }                                                               \
 107         -_error;                                                        \
 108 })
 109
 110 #define DEFINE_WAIT(x)
 111
 112 #endif  /* _LINUX_WAIT_H_ */