ceph/src/spdk/dpdk/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                 pthread_mutex_lock(&pfdset->fd_pooling_mutex);
 133                 fdset_shrink_nolock(pfdset);
 134                 pthread_mutex_unlock(&pfdset->fd_pooling_mutex);
 135                 i = pfdset->num < MAX_FDS ? pfdset->num++ : -1;
 136                 if (i == -1) {
 137                         pthread_mutex_unlock(&pfdset->fd_mutex);
 138                         return -2;
 139                 }
 140         }
 141
 142         fdset_add_fd(pfdset, i, fd, rcb, wcb, dat);
 143         pthread_mutex_unlock(&pfdset->fd_mutex);
 144
 145         return 0;
 146 }
 147
 148 /**
 149  *  Unregister the fd from the fdset.
 150  *  Returns context of a given fd or NULL.
 151  */
 152 void *
 153 fdset_del(struct fdset *pfdset, int fd)
 154 {
 155         int i;
 156         void *dat = NULL;
 157
 158         if (pfdset == NULL || fd == -1)
 159                 return NULL;
 160
 161         do {
 162                 pthread_mutex_lock(&pfdset->fd_mutex);
 163
 164                 i = fdset_find_fd(pfdset, fd);
 165                 if (i != -1 && pfdset->fd[i].busy == 0) {
 166                         /* busy indicates r/wcb is executing! */
 167                         dat = pfdset->fd[i].dat;
 168                         pfdset->fd[i].fd = -1;
 169                         pfdset->fd[i].rcb = pfdset->fd[i].wcb = NULL;
 170                         pfdset->fd[i].dat = NULL;
 171                         i = -1;
 172                 }
 173                 pthread_mutex_unlock(&pfdset->fd_mutex);
 174         } while (i != -1);
 175
 176         return dat;
 177 }
 178
 179 /**
 180  *  Unregister the fd from the fdset.
 181  *
 182  *  If parameters are invalid, return directly -2.
 183  *  And check whether fd is busy, if yes, return -1.
 184  *  Otherwise, try to delete the fd from fdset and
 185  *  return true.
 186  */
 187 int
 188 fdset_try_del(struct fdset *pfdset, int fd)
 189 {
 190         int i;
 191
 192         if (pfdset == NULL || fd == -1)
 193                 return -2;
 194
 195         pthread_mutex_lock(&pfdset->fd_mutex);
 196         i = fdset_find_fd(pfdset, fd);
 197         if (i != -1 && pfdset->fd[i].busy) {
 198                 pthread_mutex_unlock(&pfdset->fd_mutex);
 199                 return -1;
 200         }
 201
 202         if (i != -1) {
 203                 pfdset->fd[i].fd = -1;
 204                 pfdset->fd[i].rcb = pfdset->fd[i].wcb = NULL;
 205                 pfdset->fd[i].dat = NULL;
 206         }
 207
 208         pthread_mutex_unlock(&pfdset->fd_mutex);
 209         return 0;
 210 }
 211
 212 /**
 213  * This functions runs in infinite blocking loop until there is no fd in
 214  * pfdset. It calls corresponding r/w handler if there is event on the fd.
 215  *
 216  * Before the callback is called, we set the flag to busy status; If other
 217  * thread(now rte_vhost_driver_unregister) calls fdset_del concurrently, it
 218  * will wait until the flag is reset to zero(which indicates the callback is
 219  * finished), then it could free the context after fdset_del.
 220  */
 221 void *
 222 fdset_event_dispatch(void *arg)
 223 {
 224         int i;
 225         struct pollfd *pfd;
 226         struct fdentry *pfdentry;
 227         fd_cb rcb, wcb;
 228         void *dat;
 229         int fd, numfds;
 230         int remove1, remove2;
 231         int need_shrink;
 232         struct fdset *pfdset = arg;
 233         int val;
 234
 235         if (pfdset == NULL)
 236                 return NULL;
 237
 238         while (1) {
 239
 240                 /*
 241                  * When poll is blocked, other threads might unregister
 242                  * listenfds from and register new listenfds into fdset.
 243                  * When poll returns, the entries for listenfds in the fdset
 244                  * might have been updated. It is ok if there is unwanted call
 245                  * for new listenfds.
 246                  */
 247                 pthread_mutex_lock(&pfdset->fd_mutex);
 248                 numfds = pfdset->num;
 249                 pthread_mutex_unlock(&pfdset->fd_mutex);
 250
 251                 pthread_mutex_lock(&pfdset->fd_pooling_mutex);
 252                 val = poll(pfdset->rwfds, numfds, 1000 /* millisecs */);
 253                 pthread_mutex_unlock(&pfdset->fd_pooling_mutex);
 254                 if (val < 0)
 255                         continue;
 256
 257                 need_shrink = 0;
 258                 for (i = 0; i < numfds; i++) {
 259                         pthread_mutex_lock(&pfdset->fd_mutex);
 260
 261                         pfdentry = &pfdset->fd[i];
 262                         fd = pfdentry->fd;
 263                         pfd = &pfdset->rwfds[i];
 264
 265                         if (fd < 0) {
 266                                 need_shrink = 1;
 267                                 pthread_mutex_unlock(&pfdset->fd_mutex);
 268                                 continue;
 269                         }
 270
 271                         if (!pfd->revents) {
 272                                 pthread_mutex_unlock(&pfdset->fd_mutex);
 273                                 continue;
 274                         }
 275
 276                         remove1 = remove2 = 0;
 277
 278                         rcb = pfdentry->rcb;
 279                         wcb = pfdentry->wcb;
 280                         dat = pfdentry->dat;
 281                         pfdentry->busy = 1;
 282
 283                         pthread_mutex_unlock(&pfdset->fd_mutex);
 284
 285                         if (rcb && pfd->revents & (POLLIN | FDPOLLERR))
 286                                 rcb(fd, dat, &remove1);
 287                         if (wcb && pfd->revents & (POLLOUT | FDPOLLERR))
 288                                 wcb(fd, dat, &remove2);
 289                         pfdentry->busy = 0;
 290                         /*
 291                          * fdset_del needs to check busy flag.
 292                          * We don't allow fdset_del to be called in callback
 293                          * directly.
 294                          */
 295                         /*
 296                          * When we are to clean up the fd from fdset,
 297                          * because the fd is closed in the cb,
 298                          * the old fd val could be reused by when creates new
 299                          * listen fd in another thread, we couldn't call
 300                          * fdset_del.
 301                          */
 302                         if (remove1 || remove2) {
 303                                 pfdentry->fd = -1;
 304                                 need_shrink = 1;
 305                         }
 306                 }
 307
 308                 if (need_shrink)
 309                         fdset_shrink(pfdset);
 310         }
 311
 312         return NULL;
 313 }
 314
 315 static void
 316 fdset_pipe_read_cb(int readfd, void *dat __rte_unused,
 317                    int *remove __rte_unused)
 318 {
 319         char charbuf[16];
 320         int r = read(readfd, charbuf, sizeof(charbuf));
 321         /*
 322          * Just an optimization, we don't care if read() failed
 323          * so ignore explicitly its return value to make the
 324          * compiler happy
 325          */
 326         RTE_SET_USED(r);
 327 }
 328
 329 void
 330 fdset_pipe_uninit(struct fdset *fdset)
 331 {
 332         fdset_del(fdset, fdset->u.readfd);
 333         close(fdset->u.readfd);
 334         close(fdset->u.writefd);
 335 }
 336
 337 int
 338 fdset_pipe_init(struct fdset *fdset)
 339 {
 340         int ret;
 341
 342         if (pipe(fdset->u.pipefd) < 0) {
 343                 RTE_LOG(ERR, VHOST_FDMAN,
 344                         "failed to create pipe for vhost fdset\n");
 345                 return -1;
 346         }
 347
 348         ret = fdset_add(fdset, fdset->u.readfd,
 349                         fdset_pipe_read_cb, NULL, NULL);
 350
 351         if (ret < 0) {
 352                 RTE_LOG(ERR, VHOST_FDMAN,
 353                         "failed to add pipe readfd %d into vhost server fdset\n",
 354                         fdset->u.readfd);
 355
 356                 fdset_pipe_uninit(fdset);
 357                 return -1;
 358         }
 359
 360         return 0;
 361 }
 362
 363 void
 364 fdset_pipe_notify(struct fdset *fdset)
 365 {
 366         int r = write(fdset->u.writefd, "1", 1);
 367         /*
 368          * Just an optimization, we don't care if write() failed
 369          * so ignore explicitly its return value to make the
 370          * compiler happy
 371          */
 372         RTE_SET_USED(r);
 373
 374 }