sys/ofed/include/linux/completion.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_COMPLETION_H_
  29 #define _LINUX_COMPLETION_H_
  30
  31 #include <linux/errno.h>
  32 #include <linux/sched.h>
  33 #include <linux/wait.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 completion {
  42         unsigned int done;
  43 };
  44
  45 #define INIT_COMPLETION(c)      ((c).done = 0)
  46 #define init_completion(c)      ((c)->done = 0)
  47
  48 static inline void
  49 _complete_common(struct completion *c, int all)
  50 {
  51         int wakeup_swapper;
  52
  53         sleepq_lock(c);
  54         c->done++;
  55         if (all)
  56                 wakeup_swapper = sleepq_broadcast(c, SLEEPQ_SLEEP, 0, 0);
  57         else
  58                 wakeup_swapper = sleepq_signal(c, SLEEPQ_SLEEP, 0, 0);
  59         sleepq_release(c);
  60         if (wakeup_swapper)
  61                 kick_proc0();
  62 }
  63
  64 #define complete(c)     _complete_common(c, 0)
  65 #define complete_all(c) _complete_common(c, 1)
  66
  67 /*
  68  * Indefinite wait for done != 0 with or without signals.
  69  */
  70 static inline long
  71 _wait_for_common(struct completion *c, int flags)
  72 {
  73
  74         flags |= SLEEPQ_SLEEP;
  75         for (;;) {
  76                 sleepq_lock(c);
  77                 if (c->done)
  78                         break;
  79                 sleepq_add(c, NULL, "completion", flags, 0);
  80                 if (flags & SLEEPQ_INTERRUPTIBLE) {
  81                         if (sleepq_wait_sig(c, 0) != 0)
  82                                 return (-ERESTARTSYS);
  83                 } else
  84                         sleepq_wait(c, 0);
  85         }
  86         c->done--;
  87         sleepq_release(c);
  88
  89         return (0);
  90 }
  91
  92 #define wait_for_completion(c)  _wait_for_common(c, 0)
  93 #define wait_for_completion_interuptible(c)                             \
  94         _wait_for_common(c, SLEEPQ_INTERRUPTIBLE)
  95
  96 static inline long
  97 _wait_for_timeout_common(struct completion *c, long timeout, int flags)
  98 {
  99         long end;
 100
 101         end = ticks + timeout;
 102         flags |= SLEEPQ_SLEEP;
 103         for (;;) {
 104                 sleepq_lock(c);
 105                 if (c->done)
 106                         break;
 107                 sleepq_add(c, NULL, "completion", flags, 0);
 108                 sleepq_set_timeout(c, end - ticks);
 109                 if (flags & SLEEPQ_INTERRUPTIBLE) {
 110                         if (sleepq_timedwait_sig(c, 0) != 0)
 111                                 return (-ERESTARTSYS);
 112                 } else
 113                         sleepq_timedwait(c, 0);
 114         }
 115         c->done--;
 116         sleepq_release(c);
 117         timeout = end - ticks;
 118
 119         return (timeout > 0 ? timeout : 1);
 120 }
 121
 122 #define wait_for_completion_timeout(c, timeout)                         \
 123         _wait_for_timeout_common(c, timeout, 0)
 124 #define wait_for_completion_interruptible_timeout(c, timeout)           \
 125         _wait_for_timeout_common(c, timeout, SLEEPQ_INTERRUPTIBLE)
 126
 127 static inline int
 128 try_wait_for_completion(struct completion *c)
 129 {
 130         int isdone;
 131
 132         isdone = 1;
 133         sleepq_lock(c);
 134         if (c->done)
 135                 c->done--;
 136         else
 137                 isdone = 0;
 138         sleepq_release(c);
 139         return (isdone);
 140 }
 141
 142 static inline int
 143 completion_done(struct completion *c)
 144 {
 145         int isdone;
 146
 147         isdone = 1;
 148         sleepq_lock(c);
 149         if (c->done == 0)
 150                 isdone = 0;
 151         sleepq_release(c);
 152         return (isdone);
 153 }
 154
 155 #endif  /* _LINUX_COMPLETION_H_ */