lib/librte_vhost/fd_man.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <stdint.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <sys/socket.h>
   9 #include <sys/time.h>
  10 #include <sys/types.h>
  11 #include <unistd.h>
  12 #include <string.h>
  13
  14 #include <rte_common.h>
  15 #include <rte_log.h>
  16
  17 #include "fd_man.h"
  18
  19
  20 #define RTE_LOGTYPE_VHOST_FDMAN RTE_LOGTYPE_USER1
  21
  22 #define FDPOLLERR (POLLERR | POLLHUP | POLLNVAL)
  23
  24 static int
  25 get_last_valid_idx(struct fdset *pfdset, int last_valid_idx)
  26 {
  27         int i;
  28
  29         for (i = last_valid_idx; i >= 0 && pfdset->fd[i].fd == -1; i--)
  30                 ;
  31
  32         return i;
  33 }
  34
  35 static void
  36 fdset_move(struct fdset *pfdset, int dst, int src)
  37 {
  38         pfdset->fd[dst]    = pfdset->fd[src];
  39         pfdset->rwfds[dst] = pfdset->rwfds[src];
  40 }
  41
  42 static void
  43 fdset_shrink_nolock(struct fdset *pfdset)
  44 {
  45         int i;
  46         int last_valid_idx = get_last_valid_idx(pfdset, pfdset->num - 1);
  47
  48         for (i = 0; i < last_valid_idx; i++) {
  49                 if (pfdset->fd[i].fd != -1)
  50                         continue;
  51
  52                 fdset_move(pfdset, i, last_valid_idx);
  53                 last_valid_idx = get_last_valid_idx(pfdset, last_valid_idx - 1);
  54         }
  55         pfdset->num = last_valid_idx + 1;
  56 }
  57
  58 /*
  59  * Find deleted fd entries and remove them
  60  */
  61 static void
  62 fdset_shrink(struct fdset *pfdset)
  63 {
  64         pthread_mutex_lock(&pfdset->fd_mutex);
  65         fdset_shrink_nolock(pfdset);
  66         pthread_mutex_unlock(&pfdset->fd_mutex);
  67 }
  68
  69 /**
  70  * Returns the index in the fdset for a given fd.
  71  * @return
  72  *   index for the fd, or -1 if fd isn't in the fdset.
  73  */
  74 static int
  75 fdset_find_fd(struct fdset *pfdset, int fd)
  76 {
  77         int i;
  78
  79         for (i = 0; i < pfdset->num && pfdset->fd[i].fd != fd; i++)
  80                 ;
  81
  82         return i == pfdset->num ? -1 : i;
  83 }
  84
  85 static void
  86 fdset_add_fd(struct fdset *pfdset, int idx, int fd,
  87         fd_cb rcb, fd_cb wcb, void *dat)
  88 {
  89         struct fdentry *pfdentry = &pfdset->fd[idx];
  90         struct pollfd *pfd = &pfdset->rwfds[idx];
  91
  92         pfdentry->fd  = fd;
  93         pfdentry->rcb = rcb;
  94         pfdentry->wcb = wcb;
  95         pfdentry->dat = dat;
  96
  97         pfd->fd = fd;
  98         pfd->events  = rcb ? POLLIN : 0;
  99         pfd->events |= wcb ? POLLOUT : 0;
 100         pfd->revents = 0;
 101 }
 102
 103 void
 104 fdset_init(struct fdset *pfdset)
 105 {
 106         int i;
 107
 108         if (pfdset == NULL)
 109                 return;
 110
 111         for (i = 0; i < MAX_FDS; i++) {
 112                 pfdset->fd[i].fd = -1;
 113                 pfdset->fd[i].dat = NULL;
 114         }
 115         pfdset->num = 0;
 116 }
 117
 118 /**
 119  * Register the fd in the fdset with read/write handler and context.
 120  */
 121 int
 122 fdset_add(struct fdset *pfdset, int fd, fd_cb rcb, fd_cb wcb, void *dat)
 123 {
 124         int i;
 125
 126         if (pfdset == NULL || fd == -1)
 127                 return -1;
 128
 129         pthread_mutex_lock(&pfdset->fd_mutex);
 130         i = pfdset->num < MAX_FDS ? pfdset->num++ : -1;
 131         if (i == -1) {
 132                 fdset_shrink_nolock(pfdset);
 133                 i = pfdset->num < MAX_FDS ? pfdset->num++ : -1;
 134                 if (i == -1) {
 135                         pthread_mutex_unlock(&pfdset->fd_mutex);
 136                         return -2;
 137                 }
 138         }
 139
 140         fdset_add_fd(pfdset, i, fd, rcb, wcb, dat);
 141         pthread_mutex_unlock(&pfdset->fd_mutex);
 142
 143         return 0;
 144 }
 145
 146 /**
 147  *  Unregister the fd from the fdset.
 148  *  Returns context of a given fd or NULL.
 149  */
 150 void *
 151 fdset_del(struct fdset *pfdset, int fd)
 152 {
 153         int i;
 154         void *dat = NULL;
 155
 156         if (pfdset == NULL || fd == -1)
 157                 return NULL;
 158
 159         do {
 160                 pthread_mutex_lock(&pfdset->fd_mutex);
 161
 162                 i = fdset_find_fd(pfdset, fd);
 163                 if (i != -1 && pfdset->fd[i].busy == 0) {
 164                         /* busy indicates r/wcb is executing! */
 165                         dat = pfdset->fd[i].dat;
 166                         pfdset->fd[i].fd = -1;
 167                         pfdset->fd[i].rcb = pfdset->fd[i].wcb = NULL;
 168                         pfdset->fd[i].dat = NULL;
 169                         i = -1;
 170                 }
 171                 pthread_mutex_unlock(&pfdset->fd_mutex);
 172         } while (i != -1);
 173
 174         return dat;
 175 }
 176
 177
 178 /**
 179  * This functions runs in infinite blocking loop until there is no fd in
 180  * pfdset. It calls corresponding r/w handler if there is event on the fd.
 181  *
 182  * Before the callback is called, we set the flag to busy status; If other
 183  * thread(now rte_vhost_driver_unregister) calls fdset_del concurrently, it
 184  * will wait until the flag is reset to zero(which indicates the callback is
 185  * finished), then it could free the context after fdset_del.
 186  */
 187 void *
 188 fdset_event_dispatch(void *arg)
 189 {
 190         int i;
 191         struct pollfd *pfd;
 192         struct fdentry *pfdentry;
 193         fd_cb rcb, wcb;
 194         void *dat;
 195         int fd, numfds;
 196         int remove1, remove2;
 197         int need_shrink;
 198         struct fdset *pfdset = arg;
 199         int val;
 200
 201         if (pfdset == NULL)
 202                 return NULL;
 203
 204         while (1) {
 205
 206                 /*
 207                  * When poll is blocked, other threads might unregister
 208                  * listenfds from and register new listenfds into fdset.
 209                  * When poll returns, the entries for listenfds in the fdset
 210                  * might have been updated. It is ok if there is unwanted call
 211                  * for new listenfds.
 212                  */
 213                 pthread_mutex_lock(&pfdset->fd_mutex);
 214                 numfds = pfdset->num;
 215                 pthread_mutex_unlock(&pfdset->fd_mutex);
 216
 217                 val = poll(pfdset->rwfds, numfds, 1000 /* millisecs */);
 218                 if (val < 0)
 219                         continue;
 220
 221                 need_shrink = 0;
 222                 for (i = 0; i < numfds; i++) {
 223                         pthread_mutex_lock(&pfdset->fd_mutex);
 224
 225                         pfdentry = &pfdset->fd[i];
 226                         fd = pfdentry->fd;
 227                         pfd = &pfdset->rwfds[i];
 228
 229                         if (fd < 0) {
 230                                 need_shrink = 1;
 231                                 pthread_mutex_unlock(&pfdset->fd_mutex);
 232                                 continue;
 233                         }
 234
 235                         if (!pfd->revents) {
 236                                 pthread_mutex_unlock(&pfdset->fd_mutex);
 237                                 continue;
 238                         }
 239
 240                         remove1 = remove2 = 0;
 241
 242                         rcb = pfdentry->rcb;
 243                         wcb = pfdentry->wcb;
 244                         dat = pfdentry->dat;
 245                         pfdentry->busy = 1;
 246
 247                         pthread_mutex_unlock(&pfdset->fd_mutex);
 248
 249                         if (rcb && pfd->revents & (POLLIN | FDPOLLERR))
 250                                 rcb(fd, dat, &remove1);
 251                         if (wcb && pfd->revents & (POLLOUT | FDPOLLERR))
 252                                 wcb(fd, dat, &remove2);
 253                         pfdentry->busy = 0;
 254                         /*
 255                          * fdset_del needs to check busy flag.
 256                          * We don't allow fdset_del to be called in callback
 257                          * directly.
 258                          */
 259                         /*
 260                          * When we are to clean up the fd from fdset,
 261                          * because the fd is closed in the cb,
 262                          * the old fd val could be reused by when creates new
 263                          * listen fd in another thread, we couldn't call
 264                          * fd_set_del.
 265                          */
 266                         if (remove1 || remove2) {
 267                                 pfdentry->fd = -1;
 268                                 need_shrink = 1;
 269                         }
 270                 }
 271
 272                 if (need_shrink)
 273                         fdset_shrink(pfdset);
 274         }
 275
 276         return NULL;
 277 }
 278
 279 static void
 280 fdset_pipe_read_cb(int readfd, void *dat __rte_unused,
 281                    int *remove __rte_unused)
 282 {
 283         char charbuf[16];
 284         int r = read(readfd, charbuf, sizeof(charbuf));
 285         /*
 286          * Just an optimization, we don't care if read() failed
 287          * so ignore explicitly its return value to make the
 288          * compiler happy
 289          */
 290         RTE_SET_USED(r);
 291 }
 292
 293 void
 294 fdset_pipe_uninit(struct fdset *fdset)
 295 {
 296         fdset_del(fdset, fdset->u.readfd);
 297         close(fdset->u.readfd);
 298         close(fdset->u.writefd);
 299 }
 300
 301 int
 302 fdset_pipe_init(struct fdset *fdset)
 303 {
 304         int ret;
 305
 306         if (pipe(fdset->u.pipefd) < 0) {
 307                 RTE_LOG(ERR, VHOST_FDMAN,
 308                         "failed to create pipe for vhost fdset\n");
 309                 return -1;
 310         }
 311
 312         ret = fdset_add(fdset, fdset->u.readfd,
 313                         fdset_pipe_read_cb, NULL, NULL);
 314
 315         if (ret < 0) {
 316                 RTE_LOG(ERR, VHOST_FDMAN,
 317                         "failed to add pipe readfd %d into vhost server fdset\n",
 318                         fdset->u.readfd);
 319
 320                 fdset_pipe_uninit(fdset);
 321                 return -1;
 322         }
 323
 324         return 0;
 325 }
 326
 327 void
 328 fdset_pipe_notify(struct fdset *fdset)
 329 {
 330         int r = write(fdset->u.writefd, "1", 1);
 331         /*
 332          * Just an optimization, we don't care if write() failed
 333          * so ignore explicitly its return value to make the
 334          * compiler happy
 335          */
 336         RTE_SET_USED(r);
 337
 338 }