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  *  Unregister the fd from the fdset.
 179  *
 180  *  If parameters are invalid, return directly -2.
 181  *  And check whether fd is busy, if yes, return -1.
 182  *  Otherwise, try to delete the fd from fdset and
 183  *  return true.
 184  */
 185 int
 186 fdset_try_del(struct fdset *pfdset, int fd)
 187 {
 188         int i;
 189
 190         if (pfdset == NULL || fd == -1)
 191                 return -2;
 192
 193         pthread_mutex_lock(&pfdset->fd_mutex);
 194         i = fdset_find_fd(pfdset, fd);
 195         if (i != -1 && pfdset->fd[i].busy) {
 196                 pthread_mutex_unlock(&pfdset->fd_mutex);
 197                 return -1;
 198         }
 199
 200         if (i != -1) {
 201                 pfdset->fd[i].fd = -1;
 202                 pfdset->fd[i].rcb = pfdset->fd[i].wcb = NULL;
 203                 pfdset->fd[i].dat = NULL;
 204         }
 205
 206         pthread_mutex_unlock(&pfdset->fd_mutex);
 207         return 0;
 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(void *arg)
 221 {
 222         int i;
 223         struct pollfd *pfd;
 224         struct fdentry *pfdentry;
 225         fd_cb rcb, wcb;
 226         void *dat;
 227         int fd, numfds;
 228         int remove1, remove2;
 229         int need_shrink;
 230         struct fdset *pfdset = arg;
 231         int val;
 232
 233         if (pfdset == NULL)
 234                 return NULL;
 235
 236         while (1) {
 237
 238                 /*
 239                  * When poll is blocked, other threads might unregister
 240                  * listenfds from and register new listenfds into fdset.
 241                  * When poll returns, the entries for listenfds in the fdset
 242                  * might have been updated. It is ok if there is unwanted call
 243                  * for new listenfds.
 244                  */
 245                 pthread_mutex_lock(&pfdset->fd_mutex);
 246                 numfds = pfdset->num;
 247                 pthread_mutex_unlock(&pfdset->fd_mutex);
 248
 249                 val = poll(pfdset->rwfds, numfds, 1000 /* millisecs */);
 250                 if (val < 0)
 251                         continue;
 252
 253                 need_shrink = 0;
 254                 for (i = 0; i < numfds; i++) {
 255                         pthread_mutex_lock(&pfdset->fd_mutex);
 256
 257                         pfdentry = &pfdset->fd[i];
 258                         fd = pfdentry->fd;
 259                         pfd = &pfdset->rwfds[i];
 260
 261                         if (fd < 0) {
 262                                 need_shrink = 1;
 263                                 pthread_mutex_unlock(&pfdset->fd_mutex);
 264                                 continue;
 265                         }
 266
 267                         if (!pfd->revents) {
 268                                 pthread_mutex_unlock(&pfdset->fd_mutex);
 269                                 continue;
 270                         }
 271
 272                         remove1 = remove2 = 0;
 273
 274                         rcb = pfdentry->rcb;
 275                         wcb = pfdentry->wcb;
 276                         dat = pfdentry->dat;
 277                         pfdentry->busy = 1;
 278
 279                         pthread_mutex_unlock(&pfdset->fd_mutex);
 280
 281                         if (rcb && pfd->revents & (POLLIN | FDPOLLERR))
 282                                 rcb(fd, dat, &remove1);
 283                         if (wcb && pfd->revents & (POLLOUT | FDPOLLERR))
 284                                 wcb(fd, dat, &remove2);
 285                         pfdentry->busy = 0;
 286                         /*
 287                          * fdset_del needs to check busy flag.
 288                          * We don't allow fdset_del to be called in callback
 289                          * directly.
 290                          */
 291                         /*
 292                          * When we are to clean up the fd from fdset,
 293                          * because the fd is closed in the cb,
 294                          * the old fd val could be reused by when creates new
 295                          * listen fd in another thread, we couldn't call
 296                          * fdset_del.
 297                          */
 298                         if (remove1 || remove2) {
 299                                 pfdentry->fd = -1;
 300                                 need_shrink = 1;
 301                         }
 302                 }
 303
 304                 if (need_shrink)
 305                         fdset_shrink(pfdset);
 306         }
 307
 308         return NULL;
 309 }
 310
 311 static void
 312 fdset_pipe_read_cb(int readfd, void *dat __rte_unused,
 313                    int *remove __rte_unused)
 314 {
 315         char charbuf[16];
 316         int r = read(readfd, charbuf, sizeof(charbuf));
 317         /*
 318          * Just an optimization, we don't care if read() failed
 319          * so ignore explicitly its return value to make the
 320          * compiler happy
 321          */
 322         RTE_SET_USED(r);
 323 }
 324
 325 void
 326 fdset_pipe_uninit(struct fdset *fdset)
 327 {
 328         fdset_del(fdset, fdset->u.readfd);
 329         close(fdset->u.readfd);
 330         close(fdset->u.writefd);
 331 }
 332
 333 int
 334 fdset_pipe_init(struct fdset *fdset)
 335 {
 336         int ret;
 337
 338         if (pipe(fdset->u.pipefd) < 0) {
 339                 RTE_LOG(ERR, VHOST_FDMAN,
 340                         "failed to create pipe for vhost fdset\n");
 341                 return -1;
 342         }
 343
 344         ret = fdset_add(fdset, fdset->u.readfd,
 345                         fdset_pipe_read_cb, NULL, NULL);
 346
 347         if (ret < 0) {
 348                 RTE_LOG(ERR, VHOST_FDMAN,
 349                         "failed to add pipe readfd %d into vhost server fdset\n",
 350                         fdset->u.readfd);
 351
 352                 fdset_pipe_uninit(fdset);
 353                 return -1;
 354         }
 355
 356         return 0;
 357 }
 358
 359 void
 360 fdset_pipe_notify(struct fdset *fdset)
 361 {
 362         int r = write(fdset->u.writefd, "1", 1);
 363         /*
 364          * Just an optimization, we don't care if write() failed
 365          * so ignore explicitly its return value to make the
 366          * compiler happy
 367          */
 368         RTE_SET_USED(r);
 369
 370 }