lib/ioq.c

   1 /*
   2  * Copyright 2009 Novell.  All Rights Reserved.
   3  *
   4  * See include/linux/ioq.h for documentation
   5  *
   6  * Author:
   7  *      Gregory Haskins <ghaskins@novell.com>
   8  *
   9  * This file is free software; you can redistribute it and/or modify
  10  * it under the terms of version 2 of the GNU General Public License
  11  * as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
  21  */
  22
  23 #include <linux/sched.h>
  24 #include <linux/ioq.h>
  25 #include <linux/bitops.h>
  26 #include <linux/module.h>
  27
  28 #ifndef NULL
  29 #define NULL 0
  30 #endif
  31
  32 static int ioq_iter_setpos(struct ioq_iterator *iter, u32 pos)
  33 {
  34         struct ioq *ioq = iter->ioq;
  35
  36         BUG_ON(pos >= ioq->count);
  37
  38         iter->pos  = pos;
  39         iter->desc = &ioq->ring[pos];
  40
  41         return 0;
  42 }
  43
  44 static inline u32 modulo_inc(u32 val, u32 mod)
  45 {
  46         BUG_ON(val >= mod);
  47
  48         if (val == (mod - 1))
  49                 return 0;
  50
  51         return val + 1;
  52 }
  53
  54 static inline int idx_full(struct ioq_ring_idx *idx)
  55 {
  56         return idx->full && (idx->head == idx->tail);
  57 }
  58
  59 int ioq_iter_seek(struct ioq_iterator *iter, enum ioq_seek_type type,
  60                   long offset, int flags)
  61 {
  62         struct ioq_ring_idx *idx = iter->idx;
  63         u32 pos;
  64
  65         switch (type) {
  66         case ioq_seek_next:
  67                 pos = modulo_inc(iter->pos, iter->ioq->count);
  68                 break;
  69         case ioq_seek_tail:
  70                 pos = idx->tail;
  71                 break;
  72         case ioq_seek_head:
  73                 pos = idx->head;
  74                 break;
  75         case ioq_seek_set:
  76                 if (offset >= iter->ioq->count)
  77                         return -1;
  78                 pos = offset;
  79                 break;
  80         default:
  81                 return -EINVAL;
  82         }
  83
  84         return ioq_iter_setpos(iter, pos);
  85 }
  86 EXPORT_SYMBOL_GPL(ioq_iter_seek);
  87
  88 static int ioq_ring_count(struct ioq_ring_idx *idx, int count)
  89 {
  90         if (idx->full && (idx->head == idx->tail))
  91                 return count;
  92         else if (idx->tail >= idx->head)
  93                 return idx->tail - idx->head;
  94         else
  95                 return (idx->tail + count) - idx->head;
  96 }
  97
  98 static void idx_tail_push(struct ioq_ring_idx *idx, int count)
  99 {
 100         u32 tail = modulo_inc(idx->tail, count);
 101
 102         if (idx->head == tail) {
 103                 rmb();
 104
 105                 /*
 106                  * Setting full here may look racy, but note that we havent
 107                  * flipped the owner bit yet.  So it is impossible for the
 108                  * remote locale to move head in such a way that this operation
 109                  * becomes invalid
 110                  */
 111                 idx->full = 1;
 112                 wmb();
 113         }
 114
 115         idx->tail = tail;
 116 }
 117
 118 int ioq_iter_push(struct ioq_iterator *iter, int flags)
 119 {
 120         struct ioq_ring_head *head_desc = iter->ioq->head_desc;
 121         struct ioq_ring_idx  *idx  = iter->idx;
 122         int ret;
 123
 124         /*
 125          * Its only valid to push if we are currently pointed at the tail
 126          */
 127         if (iter->pos != idx->tail || iter->desc->sown != iter->ioq->locale)
 128                 return -EINVAL;
 129
 130         idx_tail_push(idx, iter->ioq->count);
 131         if (iter->dualidx) {
 132                 idx_tail_push(&head_desc->idx[ioq_idxtype_inuse],
 133                               iter->ioq->count);
 134                 if (head_desc->idx[ioq_idxtype_inuse].tail !=
 135                     head_desc->idx[ioq_idxtype_valid].tail) {
 136                         SHM_SIGNAL_FAULT(iter->ioq->signal,
 137                                          "Tails not synchronized");
 138                         return -EINVAL;
 139                 }
 140         }
 141
 142         wmb(); /* the index must be visible before the sown, or signal */
 143
 144         if (iter->flipowner) {
 145                 iter->desc->sown = !iter->ioq->locale;
 146                 wmb(); /* sown must be visible before we signal */
 147         }
 148
 149         ret = ioq_iter_seek(iter, ioq_seek_next, 0, flags);
 150
 151         if (iter->update)
 152                 ioq_signal(iter->ioq, 0);
 153
 154         return ret;
 155 }
 156 EXPORT_SYMBOL_GPL(ioq_iter_push);
 157
 158 int ioq_iter_pop(struct ioq_iterator *iter,  int flags)
 159 {
 160         struct ioq_ring_idx *idx = iter->idx;
 161         int ret;
 162
 163         /*
 164          * Its only valid to pop if we are currently pointed at the head
 165          */
 166         if (iter->pos != idx->head || iter->desc->sown != iter->ioq->locale)
 167                 return -EINVAL;
 168
 169         idx->head = modulo_inc(idx->head, iter->ioq->count);
 170         wmb(); /* head must be visible before full */
 171
 172         if (idx->full) {
 173                 idx->full = 0;
 174                 wmb(); /* full must be visible before sown */
 175         }
 176
 177         if (iter->flipowner) {
 178                 iter->desc->sown = !iter->ioq->locale;
 179                 wmb(); /* sown must be visible before we signal */
 180         }
 181
 182         ret = ioq_iter_seek(iter, ioq_seek_next, 0, flags);
 183
 184         if (iter->update)
 185                 ioq_signal(iter->ioq, 0);
 186
 187         return ret;
 188 }
 189 EXPORT_SYMBOL_GPL(ioq_iter_pop);
 190
 191 static struct ioq_ring_idx *idxtype_to_idx(struct ioq *ioq,
 192                                            enum ioq_idx_type type)
 193 {
 194         struct ioq_ring_idx *idx;
 195
 196         switch (type) {
 197         case ioq_idxtype_valid:
 198         case ioq_idxtype_inuse:
 199                 idx = &ioq->head_desc->idx[type];
 200                 break;
 201         default:
 202                 panic("IOQ: illegal index type: %d", type);
 203                 break;
 204         }
 205
 206         return idx;
 207 }
 208
 209 int ioq_iter_init(struct ioq *ioq, struct ioq_iterator *iter,
 210                   enum ioq_idx_type type, int flags)
 211 {
 212         iter->ioq        = ioq;
 213         iter->update     = (flags & IOQ_ITER_AUTOUPDATE);
 214         iter->flipowner  = !(flags & IOQ_ITER_NOFLIPOWNER);
 215         iter->pos        = -1;
 216         iter->desc       = NULL;
 217         iter->dualidx    = 0;
 218
 219         if (type == ioq_idxtype_both) {
 220                 /*
 221                  * "both" is a special case, so we set the dualidx flag.
 222                  *
 223                  * However, we also just want to use the valid-index
 224                  * for normal processing, so override that here
 225                  */
 226                 type = ioq_idxtype_valid;
 227                 iter->dualidx = 1;
 228         }
 229
 230         iter->idx = idxtype_to_idx(ioq, type);
 231
 232         return 0;
 233 }
 234 EXPORT_SYMBOL_GPL(ioq_iter_init);
 235
 236 int ioq_count(struct ioq *ioq, enum ioq_idx_type type)
 237 {
 238         return ioq_ring_count(idxtype_to_idx(ioq, type), ioq->count);
 239 }
 240 EXPORT_SYMBOL_GPL(ioq_count);
 241
 242 int ioq_remain(struct ioq *ioq, enum ioq_idx_type type)
 243 {
 244         int count = ioq_ring_count(idxtype_to_idx(ioq, type), ioq->count);
 245
 246         return ioq->count - count;
 247 }
 248 EXPORT_SYMBOL_GPL(ioq_remain);
 249
 250 int ioq_size(struct ioq *ioq)
 251 {
 252         return ioq->count;
 253 }
 254 EXPORT_SYMBOL_GPL(ioq_size);
 255
 256 int ioq_full(struct ioq *ioq, enum ioq_idx_type type)
 257 {
 258         struct ioq_ring_idx *idx = idxtype_to_idx(ioq, type);
 259
 260         return idx_full(idx);
 261 }
 262 EXPORT_SYMBOL_GPL(ioq_full);
 263
 264 static void ioq_shm_signal(struct shm_signal_notifier *notifier)
 265 {
 266         struct ioq *ioq = container_of(notifier, struct ioq, shm_notifier);
 267
 268         if (waitqueue_active(&ioq->wq))
 269                 wake_up(&ioq->wq);
 270
 271         if (ioq->notifier)
 272                 ioq->notifier->signal(ioq->notifier);
 273 }
 274
 275 void ioq_init(struct ioq *ioq,
 276               struct ioq_ops *ops,
 277               enum ioq_locality locale,
 278               struct ioq_ring_head *head,
 279               struct shm_signal *signal,
 280               size_t count)
 281 {
 282         memset(ioq, 0, sizeof(*ioq));
 283         kref_init(&ioq->kref);
 284         init_waitqueue_head(&ioq->wq);
 285
 286         ioq->ops         = ops;
 287         ioq->locale      = locale;
 288         ioq->head_desc   = head;
 289         ioq->ring        = &head->ring[0];
 290         ioq->count       = count;
 291         ioq->signal      = signal;
 292
 293         ioq->shm_notifier.signal = &ioq_shm_signal;
 294         signal->notifier         = &ioq->shm_notifier;
 295 }
 296 EXPORT_SYMBOL_GPL(ioq_init);