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