lib/librte_vhost/vhost_user/fd_man.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   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  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <stdint.h>
  35 #include <stdio.h>
  36 #include <stdlib.h>
  37 #include <sys/socket.h>
  38 #include <sys/select.h>
  39 #include <sys/time.h>
  40 #include <sys/types.h>
  41 #include <unistd.h>
  42
  43 #include <rte_common.h>
  44 #include <rte_log.h>
  45
  46 #include "fd_man.h"
  47
  48 /**
  49  * Returns the index in the fdset for a given fd.
  50  * If fd is -1, it means to search for a free entry.
  51  * @return
  52  *   index for the fd, or -1 if fd isn't in the fdset.
  53  */
  54 static int
  55 fdset_find_fd(struct fdset *pfdset, int fd)
  56 {
  57         int i;
  58
  59         if (pfdset == NULL)
  60                 return -1;
  61
  62         for (i = 0; i < MAX_FDS && pfdset->fd[i].fd != fd; i++)
  63                 ;
  64
  65         return i ==  MAX_FDS ? -1 : i;
  66 }
  67
  68 static int
  69 fdset_find_free_slot(struct fdset *pfdset)
  70 {
  71         return fdset_find_fd(pfdset, -1);
  72 }
  73
  74 static void
  75 fdset_add_fd(struct fdset  *pfdset, int idx, int fd,
  76         fd_cb rcb, fd_cb wcb, void *dat)
  77 {
  78         struct fdentry *pfdentry;
  79
  80         if (pfdset == NULL || idx >= MAX_FDS)
  81                 return;
  82
  83         pfdentry = &pfdset->fd[idx];
  84         pfdentry->fd = fd;
  85         pfdentry->rcb = rcb;
  86         pfdentry->wcb = wcb;
  87         pfdentry->dat = dat;
  88 }
  89
  90 /**
  91  * Fill the read/write fd_set with the fds in the fdset.
  92  * @return
  93  *  the maximum fds filled in the read/write fd_set.
  94  */
  95 static int
  96 fdset_fill(fd_set *rfset, fd_set *wfset, struct fdset *pfdset)
  97 {
  98         struct fdentry *pfdentry;
  99         int i, maxfds = -1;
 100         int num = MAX_FDS;
 101
 102         if (pfdset == NULL)
 103                 return -1;
 104
 105         for (i = 0; i < num; i++) {
 106                 pfdentry = &pfdset->fd[i];
 107                 if (pfdentry->fd != -1) {
 108                         int added = 0;
 109                         if (pfdentry->rcb && rfset) {
 110                                 FD_SET(pfdentry->fd, rfset);
 111                                 added = 1;
 112                         }
 113                         if (pfdentry->wcb && wfset) {
 114                                 FD_SET(pfdentry->fd, wfset);
 115                                 added = 1;
 116                         }
 117                         if (added)
 118                                 maxfds = pfdentry->fd < maxfds ?
 119                                         maxfds : pfdentry->fd;
 120                 }
 121         }
 122         return maxfds;
 123 }
 124
 125 void
 126 fdset_init(struct fdset *pfdset)
 127 {
 128         int i;
 129
 130         if (pfdset == NULL)
 131                 return;
 132
 133         for (i = 0; i < MAX_FDS; i++)
 134                 pfdset->fd[i].fd = -1;
 135         pfdset->num = 0;
 136 }
 137
 138 /**
 139  * Register the fd in the fdset with read/write handler and context.
 140  */
 141 int
 142 fdset_add(struct fdset *pfdset, int fd, fd_cb rcb, fd_cb wcb, void *dat)
 143 {
 144         int i;
 145
 146         if (pfdset == NULL || fd == -1)
 147                 return -1;
 148
 149         pthread_mutex_lock(&pfdset->fd_mutex);
 150
 151         /* Find a free slot in the list. */
 152         i = fdset_find_free_slot(pfdset);
 153         if (i == -1) {
 154                 pthread_mutex_unlock(&pfdset->fd_mutex);
 155                 return -2;
 156         }
 157
 158         fdset_add_fd(pfdset, i, fd, rcb, wcb, dat);
 159         pfdset->num++;
 160
 161         pthread_mutex_unlock(&pfdset->fd_mutex);
 162
 163         return 0;
 164 }
 165
 166 /**
 167  *  Unregister the fd from the fdset.
 168  */
 169 void
 170 fdset_del(struct fdset *pfdset, int fd)
 171 {
 172         int i;
 173
 174         if (pfdset == NULL || fd == -1)
 175                 return;
 176
 177         do {
 178                 pthread_mutex_lock(&pfdset->fd_mutex);
 179
 180                 i = fdset_find_fd(pfdset, fd);
 181                 if (i != -1 && pfdset->fd[i].busy == 0) {
 182                         /* busy indicates r/wcb is executing! */
 183                         pfdset->fd[i].fd = -1;
 184                         pfdset->fd[i].rcb = pfdset->fd[i].wcb = NULL;
 185                         pfdset->num--;
 186                         i = -1;
 187                 }
 188                 pthread_mutex_unlock(&pfdset->fd_mutex);
 189         } while (i != -1);
 190 }
 191
 192 /**
 193  *  Unregister the fd at the specified slot from the fdset.
 194  */
 195 static void
 196 fdset_del_slot(struct fdset *pfdset, int index)
 197 {
 198         if (pfdset == NULL || index < 0 || index >= MAX_FDS)
 199                 return;
 200
 201         pthread_mutex_lock(&pfdset->fd_mutex);
 202
 203         pfdset->fd[index].fd = -1;
 204         pfdset->fd[index].rcb = pfdset->fd[index].wcb = NULL;
 205         pfdset->num--;
 206
 207         pthread_mutex_unlock(&pfdset->fd_mutex);
 208 }
 209
 210 /**
 211  * This functions runs in infinite blocking loop until there is no fd in
 212  * pfdset. It calls corresponding r/w handler if there is event on the fd.
 213  *
 214  * Before the callback is called, we set the flag to busy status; If other
 215  * thread(now rte_vhost_driver_unregister) calls fdset_del concurrently, it
 216  * will wait until the flag is reset to zero(which indicates the callback is
 217  * finished), then it could free the context after fdset_del.
 218  */
 219 void
 220 fdset_event_dispatch(struct fdset *pfdset)
 221 {
 222         fd_set rfds, wfds;
 223         int i, maxfds;
 224         struct fdentry *pfdentry;
 225         int num = MAX_FDS;
 226         fd_cb rcb, wcb;
 227         void *dat;
 228         int fd;
 229         int remove1, remove2;
 230         int ret;
 231
 232         if (pfdset == NULL)
 233                 return;
 234
 235         while (1) {
 236                 struct timeval tv;
 237                 tv.tv_sec = 1;
 238                 tv.tv_usec = 0;
 239                 FD_ZERO(&rfds);
 240                 FD_ZERO(&wfds);
 241                 pthread_mutex_lock(&pfdset->fd_mutex);
 242
 243                 maxfds = fdset_fill(&rfds, &wfds, pfdset);
 244
 245                 pthread_mutex_unlock(&pfdset->fd_mutex);
 246
 247                 /*
 248                  * When select is blocked, other threads might unregister
 249                  * listenfds from and register new listenfds into fdset.
 250                  * When select returns, the entries for listenfds in the fdset
 251                  * might have been updated. It is ok if there is unwanted call
 252                  * for new listenfds.
 253                  */
 254                 ret = select(maxfds + 1, &rfds, &wfds, NULL, &tv);
 255                 if (ret <= 0)
 256                         continue;
 257
 258                 for (i = 0; i < num; i++) {
 259                         remove1 = remove2 = 0;
 260                         pthread_mutex_lock(&pfdset->fd_mutex);
 261                         pfdentry = &pfdset->fd[i];
 262                         fd = pfdentry->fd;
 263                         rcb = pfdentry->rcb;
 264                         wcb = pfdentry->wcb;
 265                         dat = pfdentry->dat;
 266                         pfdentry->busy = 1;
 267                         pthread_mutex_unlock(&pfdset->fd_mutex);
 268                         if (fd >= 0 && FD_ISSET(fd, &rfds) && rcb)
 269                                 rcb(fd, dat, &remove1);
 270                         if (fd >= 0 && FD_ISSET(fd, &wfds) && wcb)
 271                                 wcb(fd, dat, &remove2);
 272                         pfdentry->busy = 0;
 273                         /*
 274                          * fdset_del needs to check busy flag.
 275                          * We don't allow fdset_del to be called in callback
 276                          * directly.
 277                          */
 278                         /*
 279                          * When we are to clean up the fd from fdset,
 280                          * because the fd is closed in the cb,
 281                          * the old fd val could be reused by when creates new
 282                          * listen fd in another thread, we couldn't call
 283                          * fd_set_del.
 284                          */
 285                         if (remove1 || remove2)
 286                                 fdset_del_slot(pfdset, i);
 287                 }
 288         }
 289 }