server.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdarg.h>
   4 #include <unistd.h>
   5 #include <limits.h>
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <sys/poll.h>
   9 #include <sys/types.h>
  10 #include <sys/wait.h>
  11 #include <sys/mman.h>
  12 #include <netinet/in.h>
  13 #include <arpa/inet.h>
  14 #include <netdb.h>
  15
  16 #include "fio.h"
  17 #include "server.h"
  18 #include "crc/crc16.h"
  19
  20 int fio_net_port = 8765;
  21
  22 int exit_backend = 0;
  23
  24 static char *job_buf;
  25 static unsigned int job_cur_len;
  26 static unsigned int job_max_len;
  27
  28 static int server_fd;
  29
  30 int fio_send_data(int sk, const void *p, unsigned int len)
  31 {
  32         assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_PDU);
  33
  34         do {
  35                 int ret = send(sk, p, len, 0);
  36
  37                 if (ret > 0) {
  38                         len -= ret;
  39                         if (!len)
  40                                 break;
  41                         p += ret;
  42                         continue;
  43                 } else if (!ret)
  44                         break;
  45                 else if (errno == EAGAIN || errno == EINTR)
  46                         continue;
  47         } while (!exit_backend);
  48
  49         if (!len)
  50                 return 0;
  51
  52         return 1;
  53 }
  54
  55 int fio_recv_data(int sk, void *p, unsigned int len)
  56 {
  57         do {
  58                 int ret = recv(sk, p, len, MSG_WAITALL);
  59
  60                 if (ret > 0) {
  61                         len -= ret;
  62                         if (!len)
  63                                 break;
  64                         p += ret;
  65                         continue;
  66                 } else if (!ret)
  67                         break;
  68                 else if (errno == EAGAIN || errno == EINTR)
  69                         continue;
  70         } while (!exit_backend);
  71
  72         if (!len)
  73                 return 0;
  74
  75         return -1;
  76 }
  77
  78 static int verify_convert_cmd(struct fio_net_cmd *cmd)
  79 {
  80         uint16_t crc;
  81
  82         cmd->cmd_crc16 = le16_to_cpu(cmd->cmd_crc16);
  83         cmd->pdu_crc16 = le16_to_cpu(cmd->pdu_crc16);
  84
  85         crc = crc16(cmd, FIO_NET_CMD_CRC_SZ);
  86         if (crc != cmd->cmd_crc16) {
  87                 log_err("fio: server bad crc on command (got %x, wanted %x)\n",
  88                                 cmd->cmd_crc16, crc);
  89                 return 1;
  90         }
  91
  92         cmd->version    = le16_to_cpu(cmd->version);
  93         cmd->opcode     = le16_to_cpu(cmd->opcode);
  94         cmd->flags      = le32_to_cpu(cmd->flags);
  95         cmd->serial     = le64_to_cpu(cmd->serial);
  96         cmd->pdu_len    = le32_to_cpu(cmd->pdu_len);
  97
  98         switch (cmd->version) {
  99         case FIO_SERVER_VER1:
 100                 break;
 101         default:
 102                 log_err("fio: bad server cmd version %d\n", cmd->version);
 103                 return 1;
 104         }
 105
 106         if (cmd->pdu_len > FIO_SERVER_MAX_PDU) {
 107                 log_err("fio: command payload too large: %u\n", cmd->pdu_len);
 108                 return 1;
 109         }
 110
 111         return 0;
 112 }
 113
 114 struct fio_net_cmd *fio_net_cmd_read(int sk)
 115 {
 116         struct fio_net_cmd cmd, *ret = NULL;
 117         uint16_t crc;
 118
 119         if (fio_recv_data(sk, &cmd, sizeof(cmd)))
 120                 return NULL;
 121
 122         /* We have a command, verify it and swap if need be */
 123         if (verify_convert_cmd(&cmd))
 124                 return NULL;
 125
 126         /* Command checks out, alloc real command and fill in */
 127         ret = malloc(sizeof(cmd) + cmd.pdu_len);
 128         memcpy(ret, &cmd, sizeof(cmd));
 129
 130         if (!ret->pdu_len)
 131                 return ret;
 132
 133         /* There's payload, get it */
 134         if (fio_recv_data(sk, (void *) ret + sizeof(*ret), ret->pdu_len)) {
 135                 free(ret);
 136                 return NULL;
 137         }
 138
 139         /* Verify payload crc */
 140         crc = crc16(ret->payload, ret->pdu_len);
 141         if (crc != ret->pdu_crc16) {
 142                 log_err("fio: server bad crc on payload (got %x, wanted %x)\n",
 143                                 ret->pdu_crc16, crc);
 144                 free(ret);
 145                 return NULL;
 146         }
 147
 148         return ret;
 149 }
 150
 151 void fio_net_cmd_crc(struct fio_net_cmd *cmd)
 152 {
 153         uint32_t pdu_len;
 154
 155         cmd->cmd_crc16 = cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ));
 156
 157         pdu_len = le32_to_cpu(cmd->pdu_len);
 158         if (pdu_len)
 159                 cmd->pdu_crc16 = cpu_to_le16(crc16(cmd->payload, pdu_len));
 160 }
 161
 162 int fio_net_send_cmd(int fd, uint16_t opcode, const char *buf, off_t size)
 163 {
 164         struct fio_net_cmd *cmd;
 165         size_t this_len;
 166         int ret;
 167
 168         do {
 169                 this_len = size;
 170                 if (this_len > FIO_SERVER_MAX_PDU)
 171                         this_len = FIO_SERVER_MAX_PDU;
 172
 173                 cmd = malloc(sizeof(*cmd) + this_len);
 174
 175                 fio_init_net_cmd(cmd, opcode, buf, this_len);
 176
 177                 if (this_len < size)
 178                         cmd->flags |= FIO_NET_CMD_F_MORE;
 179
 180                 fio_net_cmd_crc(cmd);
 181
 182                 ret = fio_send_data(fd, cmd, sizeof(*cmd) + this_len);
 183                 free(cmd);
 184                 size -= this_len;
 185                 buf += this_len;
 186         } while (!ret && size);
 187
 188         return ret;
 189 }
 190
 191 static int send_simple_command(int sk, uint16_t opcode, uint64_t serial)
 192 {
 193         struct fio_net_cmd cmd = {
 194                 .version        = cpu_to_le16(FIO_SERVER_VER1),
 195                 .opcode         = cpu_to_le16(opcode),
 196                 .serial         = cpu_to_le64(serial),
 197         };
 198
 199         fio_net_cmd_crc(&cmd);
 200
 201         return fio_send_data(sk, &cmd, sizeof(cmd));
 202 }
 203
 204 /*
 205  * Send an ack for this command
 206  */
 207 static int ack_command(int sk, struct fio_net_cmd *cmd)
 208 {
 209 #if 0
 210         return send_simple_command(sk, FIO_NET_CMD_ACK, cmd->serial);
 211 #else
 212         return 0;
 213 #endif
 214 }
 215
 216 #if 0
 217 static int nak_command(int sk, struct fio_net_cmd *cmd)
 218 {
 219         return send_simple_command(sk, FIO_NET_CMD_NAK, cmd->serial);
 220 }
 221 #endif
 222
 223 static int send_quit_command(void)
 224 {
 225         return send_simple_command(server_fd, FIO_NET_CMD_QUIT, 0);
 226 }
 227
 228 static int handle_cur_job(struct fio_net_cmd *cmd)
 229 {
 230         unsigned int left = job_max_len - job_cur_len;
 231         int ret = 0;
 232
 233         if (left < cmd->pdu_len) {
 234                 job_buf = realloc(job_buf, job_max_len + 2 * cmd->pdu_len);
 235                 job_max_len += 2 * cmd->pdu_len;
 236         }
 237
 238         memcpy(job_buf + job_cur_len, cmd->payload, cmd->pdu_len);
 239         job_cur_len += cmd->pdu_len;
 240
 241         /*
 242          * More data coming for this job
 243          */
 244         if (cmd->flags & FIO_NET_CMD_F_MORE)
 245                 return 0;
 246
 247         parse_jobs_ini(job_buf, 1, 0);
 248         ret = exec_run();
 249         send_quit_command();
 250         reset_fio_state();
 251         free(job_buf);
 252         job_buf = NULL;
 253         job_cur_len = job_max_len = 0;
 254         return ret;
 255 }
 256
 257 static int handle_command(struct fio_net_cmd *cmd)
 258 {
 259         int ret;
 260
 261         switch (cmd->opcode) {
 262         case FIO_NET_CMD_QUIT:
 263                 exit_backend = 1;
 264                 return 1;
 265         case FIO_NET_CMD_ACK:
 266                 return 0;
 267         case FIO_NET_CMD_NAK:
 268                 return 1;
 269         case FIO_NET_CMD_JOB:
 270                 ret = handle_cur_job(cmd);
 271                 break;
 272         default:
 273                 log_err("fio: unknown opcode: %d\n", cmd->opcode);
 274                 ret = 1;
 275         }
 276
 277         return ret;
 278 }
 279
 280 static int handle_connection(int sk)
 281 {
 282         struct fio_net_cmd *cmd = NULL;
 283         int ret = 0;
 284
 285         /* read forever */
 286         while (!exit_backend) {
 287                 cmd = fio_net_cmd_read(sk);
 288                 if (!cmd) {
 289                         ret = 1;
 290                         break;
 291                 }
 292
 293                 ret = ack_command(sk, cmd);
 294                 if (ret)
 295                         break;
 296
 297                 ret = handle_command(cmd);
 298                 if (ret)
 299                         break;
 300
 301                 free(cmd);
 302         }
 303
 304         if (cmd)
 305                 free(cmd);
 306
 307         return ret;
 308 }
 309
 310 static int accept_loop(int listen_sk)
 311 {
 312         struct sockaddr addr;
 313         unsigned int len = sizeof(addr);
 314         struct pollfd pfd;
 315         int ret, sk, flags, exitval = 0;
 316
 317         flags = fcntl(listen_sk, F_GETFL);
 318         flags |= O_NONBLOCK;
 319         fcntl(listen_sk, F_SETFL, flags);
 320 again:
 321         pfd.fd = listen_sk;
 322         pfd.events = POLLIN;
 323         do {
 324                 ret = poll(&pfd, 1, 100);
 325                 if (ret < 0) {
 326                         if (errno == EINTR)
 327                                 break;
 328                         log_err("fio: poll: %s\n", strerror(errno));
 329                         goto out;
 330                 } else if (!ret)
 331                         continue;
 332
 333                 if (pfd.revents & POLLIN)
 334                         break;
 335         } while (!exit_backend);
 336
 337         if (exit_backend)
 338                 goto out;
 339
 340         sk = accept(listen_sk, &addr, &len);
 341         if (sk < 0) {
 342                 log_err("fio: accept: %s\n", strerror(errno));
 343                 return -1;
 344         }
 345
 346         server_fd = sk;
 347
 348         exitval = handle_connection(sk);
 349
 350         server_fd = -1;
 351         close(sk);
 352
 353         if (!exit_backend)
 354                 goto again;
 355
 356 out:
 357         return exitval;
 358 }
 359
 360 int fio_server(void)
 361 {
 362         struct sockaddr_in saddr_in;
 363         struct sockaddr addr;
 364         unsigned int len;
 365         int sk, opt, ret;
 366
 367         sk = socket(AF_INET, SOCK_STREAM, 0);
 368         if (sk < 0) {
 369                 log_err("fio: socket: %s\n", strerror(errno));
 370                 return -1;
 371         }
 372
 373         opt = 1;
 374         if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
 375                 log_err("fio: setsockopt: %s\n", strerror(errno));
 376                 return -1;
 377         }
 378 #ifdef SO_REUSEPORT
 379         if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
 380                 log_err("fio: setsockopt: %s\n", strerror(errno));
 381                 return 1;
 382         }
 383 #endif
 384
 385         saddr_in.sin_family = AF_INET;
 386         saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
 387         saddr_in.sin_port = htons(fio_net_port);
 388
 389         if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0) {
 390                 log_err("fio: bind: %s\n", strerror(errno));
 391                 return -1;
 392         }
 393
 394         if (listen(sk, 1) < 0) {
 395                 log_err("fio: listen: %s\n", strerror(errno));
 396                 return -1;
 397         }
 398
 399         len = sizeof(addr);
 400         if (getsockname(sk, &addr, &len) < 0) {
 401                 log_err("fio: getsockname: %s\n", strerror(errno));
 402                 return -1;
 403         }
 404
 405         ret = accept_loop(sk);
 406         close(sk);
 407         return ret;
 408 }
 409
 410 int fio_server_text_output(const char *buf, unsigned int len)
 411 {
 412         if (server_fd != -1)
 413                 return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len);
 414
 415         return 0;
 416 }
 417
 418 int fio_server_log(const char *format, ...)
 419 {
 420         char buffer[1024];
 421         va_list args;
 422         size_t len;
 423
 424         va_start(args, format);
 425         len = vsnprintf(buffer, sizeof(buffer), format, args);
 426         va_end(args);
 427
 428         return fio_server_text_output(buffer, len);
 429 }