fds.c

   1 #include <errno.h>
   2 #include <stdio.h>
   3 #include <stdlib.h>
   4 #include <string.h>
   5 #include <unistd.h>
   6 #include <sys/epoll.h>
   7 #include <sys/eventfd.h>
   8
   9 #include "perf.h"
  10 #include "random.h"
  11 #include "shm.h"
  12 #include "files.h"
  13 #include "pids.h"
  14 #include "net.h"
  15 #include "log.h"
  16 #include "sanitise.h"
  17 #include "params.h"
  18
  19 /* Pipe FD related functions. */
  20 static void open_pipes(void)
  21 {
  22         int pipes[2];
  23         unsigned int i;
  24
  25         for (i = 0; i < MAX_PIPE_FDS; i+=2) {
  26                 if (pipe(pipes) < 0) {
  27                         perror("pipe fail.\n");
  28                         exit(EXIT_FAILURE);
  29                 }
  30                 shm->pipe_fds[i] = pipes[0];
  31                 shm->pipe_fds[i+1] = pipes[1];
  32
  33                 output(2, "fd[%d] = pipe\n", shm->pipe_fds[i]);
  34                 output(2, "fd[%d] = pipe\n", shm->pipe_fds[i+1]);
  35         }
  36 }
  37
  38 static int rand_pipe_fd(void)
  39 {
  40         return shm->pipe_fds[rand() % MAX_PIPE_FDS];
  41 }
  42
  43 /* perf related fds (see also perf.c & syscalls/perf_event_open.c) */
  44 static int rand_perf_fd(void)
  45 {
  46         return shm->perf_fds[rand() % MAX_PERF_FDS];
  47 }
  48
  49 /* epoll related fds */
  50 static void open_epoll_fds(void)
  51 {
  52         unsigned int i = 0;
  53         int fd = -1;
  54
  55         while (i < MAX_EPOLL_FDS) {
  56
  57                 switch (rand_bool()) {
  58                 case 0: fd = epoll_create(1);
  59                         break;
  60                 case 1: fd = epoll_create1(EPOLL_CLOEXEC);
  61                         break;
  62                 default:
  63                          break;
  64                 }
  65
  66                 if (fd != -1) {
  67                         shm->epoll_fds[i] = fd;
  68                         output(2, "fd[%d] = epoll\n", shm->epoll_fds[i]);
  69                         i++;
  70                 }
  71         }
  72 }
  73
  74 static int rand_epoll_fd(void)
  75 {
  76         return shm->epoll_fds[rand() % MAX_EPOLL_FDS];
  77 }
  78
  79 /* eventfd FDs */
  80 static void open_eventfd_fds(void)
  81 {
  82         unsigned int i;
  83
  84         shm->eventfd_fds[0] = eventfd(rand32(), 0);
  85         shm->eventfd_fds[1] = eventfd(rand32(), EFD_CLOEXEC);
  86         shm->eventfd_fds[2] = eventfd(rand32(), EFD_NONBLOCK);
  87         shm->eventfd_fds[3] = eventfd(rand32(), EFD_SEMAPHORE);
  88         shm->eventfd_fds[4] = eventfd(rand32(), EFD_CLOEXEC | EFD_NONBLOCK);
  89         shm->eventfd_fds[5] = eventfd(rand32(), EFD_CLOEXEC | EFD_SEMAPHORE);
  90         shm->eventfd_fds[6] = eventfd(rand32(), EFD_NONBLOCK | EFD_SEMAPHORE);
  91         shm->eventfd_fds[7] = eventfd(rand32(), EFD_CLOEXEC | EFD_NONBLOCK | EFD_SEMAPHORE);
  92
  93         for (i = 0; i < MAX_EVENTFD_FDS; i++)
  94                 output(2, "fd[%d] = eventfd\n", shm->eventfd_fds[i]);
  95 }
  96
  97 static int rand_eventfd_fd(void)
  98 {
  99         return shm->eventfd_fds[rand() % MAX_EVENTFD_FDS];
 100 }
 101
 102 /* regular file FDs  */
 103 unsigned int nr_file_fds = 0;
 104
 105 static int rand_file_fd(void)
 106 {
 107         unsigned int fd_index;
 108
 109         fd_index = rand() % nr_file_fds;
 110         return shm->file_fds[fd_index];
 111 }
 112
 113
 114 static int get_new_random_fd(void)
 115 {
 116         unsigned int i;
 117         int fd = 0;
 118
 119 retry:
 120         i = rand() % 6;
 121
 122         if (do_specific_proto == TRUE)
 123                 i = 1;
 124
 125         if (no_files == TRUE)
 126                 i = 1;
 127
 128         /* Ugly special case.
 129          * Sometimes, we can get here without any fd's setup.
 130          * If this happens, we divide by zero if we pick case 0 because
 131          * nr_file_fds is zero
 132          *
 133          * When this circumstance occurs, we just force it to use another network socket.
 134          *
 135          * FIXME: A better solution would be to like, actually open an fd. duh.
 136          */
 137         if (nr_file_fds == 0)
 138                 i = 1;
 139
 140         switch (i) {
 141         case 0:
 142                 fd = rand_file_fd();
 143                 break;
 144
 145         case 1:
 146                 /* When using victim files, sockets can be 0.
 147                  * Use files as a fallback, or pipes if no files are open.
 148                  */
 149                 if (nr_sockets == 0) {
 150                         if (nr_file_fds > 0)
 151                                 fd = rand_file_fd();
 152                         else
 153                                 fd = rand_pipe_fd();
 154                         return fd;
 155                 }
 156                 fd = shm->socket_fds[rand() % nr_sockets];
 157                 break;
 158
 159         case 2:
 160                 fd = rand_pipe_fd();
 161                 break;
 162
 163         case 3:
 164                 if (shm->perf_fds[0] == 0)      /* perf unavailable/disabled. */
 165                         goto retry;
 166
 167                 fd = rand_perf_fd();
 168                 break;
 169
 170         case 4:
 171                 fd = rand_epoll_fd();
 172                 break;
 173
 174         case 5:
 175                 fd = rand_eventfd_fd();
 176                 break;
 177
 178         default:
 179                 break;
 180         }
 181
 182         return fd;
 183 }
 184
 185 int get_random_fd(void)
 186 {
 187         /* 25% chance of returning something new. */
 188         if ((rand() % 4) == 0)
 189                 return get_new_random_fd();
 190
 191         /* the rest of the time, return the same fd as last time. */
 192 regen:
 193         if (shm->fd_lifetime == 0) {
 194                 shm->current_fd = get_new_random_fd();
 195                 shm->fd_lifetime = (rand() % shm->max_children) + 5;
 196         } else
 197                 shm->fd_lifetime--;
 198
 199         if (shm->current_fd == 0) {
 200                 shm->fd_lifetime = 0;
 201                 goto regen;
 202         }
 203
 204         return shm->current_fd;
 205 }
 206
 207 void setup_fds(void)
 208 {
 209         open_sockets();
 210
 211         open_pipes();
 212
 213         open_perf_fds();
 214
 215         open_epoll_fds();
 216
 217         open_eventfd_fds();
 218
 219         if (no_files == FALSE) {
 220                 generate_filelist();
 221                 if (files_in_index == 0)        /* Something bad happened. Crappy -V maybe? */
 222                         return;                 // FIXME: We should log something here probably.
 223
 224                 open_files();
 225         }
 226 }
 227
 228 void regenerate_fds(void)
 229 {
 230         if (no_files == TRUE)
 231                 return;
 232
 233         close_files();
 234         open_files();
 235 }