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 int
  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 || fd >= FD_SETSIZE)
  81                 return -1;
  82
  83         pfdentry = &pfdset->fd[idx];
  84         pfdentry->fd = fd;
  85         pfdentry->rcb = rcb;
  86         pfdentry->wcb = wcb;
  87         pfdentry->dat = dat;
  88
  89         return 0;
  90 }
  91
  92 /**
  93  * Fill the read/write fd_set with the fds in the fdset.
  94  * @return
  95  *  the maximum fds filled in the read/write fd_set.
  96  */
  97 static int
  98 fdset_fill(fd_set *rfset, fd_set *wfset, struct fdset *pfdset)
  99 {
 100         struct fdentry *pfdentry;
 101         int i, maxfds = -1;
 102         int num = MAX_FDS;
 103
 104         if (pfdset == NULL)
 105                 return -1;
 106
 107         for (i = 0; i < num; i++) {
 108                 pfdentry = &pfdset->fd[i];
 109                 if (pfdentry->fd != -1) {
 110                         int added = 0;
 111                         if (pfdentry->rcb && rfset) {
 112                                 FD_SET(pfdentry->fd, rfset);
 113                                 added = 1;
 114                         }
 115                         if (pfdentry->wcb && wfset) {
 116                                 FD_SET(pfdentry->fd, wfset);
 117                                 added = 1;
 118                         }
 119                         if (added)
 120                                 maxfds = pfdentry->fd < maxfds ?
 121                                         maxfds : pfdentry->fd;
 122                 }
 123         }
 124         return maxfds;
 125 }
 126
 127 void
 128 fdset_init(struct fdset *pfdset)
 129 {
 130         int i;
 131
 132         if (pfdset == NULL)
 133                 return;
 134
 135         for (i = 0; i < MAX_FDS; i++)
 136                 pfdset->fd[i].fd = -1;
 137         pfdset->num = 0;
 138 }
 139
 140 /**
 141  * Register the fd in the fdset with read/write handler and context.
 142  */
 143 int
 144 fdset_add(struct fdset *pfdset, int fd, fd_cb rcb, fd_cb wcb, void *dat)
 145 {
 146         int i;
 147
 148         if (pfdset == NULL || fd == -1)
 149                 return -1;
 150
 151         pthread_mutex_lock(&pfdset->fd_mutex);
 152
 153         /* Find a free slot in the list. */
 154         i = fdset_find_free_slot(pfdset);
 155         if (i == -1 || fdset_add_fd(pfdset, i, fd, rcb, wcb, dat) < 0) {
 156                 pthread_mutex_unlock(&pfdset->fd_mutex);
 157                 return -2;
 158         }
 159
 160         pfdset->num++;
 161
 162         pthread_mutex_unlock(&pfdset->fd_mutex);
 163
 164         return 0;
 165 }
 166
 167 /**
 168  *  Unregister the fd from the fdset.
 169  */
 170 void
 171 fdset_del(struct fdset *pfdset, int fd)
 172 {
 173         int i;
 174
 175         if (pfdset == NULL || fd == -1)
 176                 return;
 177
 178         do {
 179                 pthread_mutex_lock(&pfdset->fd_mutex);
 180
 181                 i = fdset_find_fd(pfdset, fd);
 182                 if (i != -1 && pfdset->fd[i].busy == 0) {
 183                         /* busy indicates r/wcb is executing! */
 184                         pfdset->fd[i].fd = -1;
 185                         pfdset->fd[i].rcb = pfdset->fd[i].wcb = NULL;
 186                         pfdset->num--;
 187                         i = -1;
 188                 }
 189                 pthread_mutex_unlock(&pfdset->fd_mutex);
 190         } while (i != -1);
 191 }
 192
 193 /**
 194  *  Unregister the fd at the specified slot from the fdset.
 195  */
 196 static void
 197 fdset_del_slot(struct fdset *pfdset, int index)
 198 {
 199         if (pfdset == NULL || index < 0 || index >= MAX_FDS)
 200                 return;
 201
 202         pthread_mutex_lock(&pfdset->fd_mutex);
 203
 204         pfdset->fd[index].fd = -1;
 205         pfdset->fd[index].rcb = pfdset->fd[index].wcb = NULL;
 206         pfdset->num--;
 207
 208         pthread_mutex_unlock(&pfdset->fd_mutex);
 209 }
 210
 211 /**
 212  * This functions runs in infinite blocking loop until there is no fd in
 213  * pfdset. It calls corresponding r/w handler if there is event on the fd.
 214  *
 215  * Before the callback is called, we set the flag to busy status; If other
 216  * thread(now rte_vhost_driver_unregister) calls fdset_del concurrently, it
 217  * will wait until the flag is reset to zero(which indicates the callback is
 218  * finished), then it could free the context after fdset_del.
 219  */
 220 void
 221 fdset_event_dispatch(struct fdset *pfdset)
 222 {
 223         fd_set rfds, wfds;
 224         int i, maxfds;
 225         struct fdentry *pfdentry;
 226         int num = MAX_FDS;
 227         fd_cb rcb, wcb;
 228         void *dat;
 229         int fd;
 230         int remove1, remove2;
 231         int ret;
 232
 233         if (pfdset == NULL)
 234                 return;
 235
 236         while (1) {
 237                 struct timeval tv;
 238                 tv.tv_sec = 1;
 239                 tv.tv_usec = 0;
 240                 FD_ZERO(&rfds);
 241                 FD_ZERO(&wfds);
 242                 pthread_mutex_lock(&pfdset->fd_mutex);
 243
 244                 maxfds = fdset_fill(&rfds, &wfds, pfdset);
 245
 246                 pthread_mutex_unlock(&pfdset->fd_mutex);
 247
 248                 /*
 249                  * When select is blocked, other threads might unregister
 250                  * listenfds from and register new listenfds into fdset.
 251                  * When select returns, the entries for listenfds in the fdset
 252                  * might have been updated. It is ok if there is unwanted call
 253                  * for new listenfds.
 254                  */
 255                 ret = select(maxfds + 1, &rfds, &wfds, NULL, &tv);
 256                 if (ret <= 0)
 257                         continue;
 258
 259                 for (i = 0; i < num; i++) {
 260                         remove1 = remove2 = 0;
 261                         pthread_mutex_lock(&pfdset->fd_mutex);
 262                         pfdentry = &pfdset->fd[i];
 263                         fd = pfdentry->fd;
 264                         rcb = pfdentry->rcb;
 265                         wcb = pfdentry->wcb;
 266                         dat = pfdentry->dat;
 267                         pfdentry->busy = 1;
 268                         pthread_mutex_unlock(&pfdset->fd_mutex);
 269                         if (fd >= 0 && FD_ISSET(fd, &rfds) && rcb)
 270                                 rcb(fd, dat, &remove1);
 271                         if (fd >= 0 && FD_ISSET(fd, &wfds) && wcb)
 272                                 wcb(fd, dat, &remove2);
 273                         pfdentry->busy = 0;
 274                         /*
 275                          * fdset_del needs to check busy flag.
 276                          * We don't allow fdset_del to be called in callback
 277                          * directly.
 278                          */
 279                         /*
 280                          * When we are to clean up the fd from fdset,
 281                          * because the fd is closed in the cb,
 282                          * the old fd val could be reused by when creates new
 283                          * listen fd in another thread, we couldn't call
 284                          * fd_set_del.
 285                          */
 286                         if (remove1 || remove2)
 287                                 fdset_del_slot(pfdset, i);
 288                 }
 289         }
 290 }