12 #include <netinet/in.h>
13 #include <arpa/inet.h>
18 #include "crc/crc16.h"
20 int fio_net_port = 8765;
25 static unsigned int job_cur_len;
26 static unsigned int job_max_len;
28 static int server_fd = -1;
30 int fio_send_data(int sk, const void *p, unsigned int len)
32 assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_PDU);
35 int ret = send(sk, p, len, 0);
45 else if (errno == EAGAIN || errno == EINTR)
47 } while (!exit_backend);
55 int fio_recv_data(int sk, void *p, unsigned int len)
58 int ret = recv(sk, p, len, MSG_WAITALL);
68 else if (errno == EAGAIN || errno == EINTR)
70 } while (!exit_backend);
78 static int verify_convert_cmd(struct fio_net_cmd *cmd)
82 cmd->cmd_crc16 = le16_to_cpu(cmd->cmd_crc16);
83 cmd->pdu_crc16 = le16_to_cpu(cmd->pdu_crc16);
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",
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);
98 switch (cmd->version) {
102 log_err("fio: bad server cmd version %d\n", cmd->version);
106 if (cmd->pdu_len > FIO_SERVER_MAX_PDU) {
107 log_err("fio: command payload too large: %u\n", cmd->pdu_len);
114 struct fio_net_cmd *fio_net_cmd_read(int sk)
116 struct fio_net_cmd cmd, *ret = NULL;
119 if (fio_recv_data(sk, &cmd, sizeof(cmd)))
122 /* We have a command, verify it and swap if need be */
123 if (verify_convert_cmd(&cmd))
126 /* Command checks out, alloc real command and fill in */
127 ret = malloc(sizeof(cmd) + cmd.pdu_len);
128 memcpy(ret, &cmd, sizeof(cmd));
133 /* There's payload, get it */
134 if (fio_recv_data(sk, (void *) ret + sizeof(*ret), ret->pdu_len)) {
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);
151 void fio_net_cmd_crc(struct fio_net_cmd *cmd)
155 cmd->cmd_crc16 = cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ));
157 pdu_len = le32_to_cpu(cmd->pdu_len);
159 cmd->pdu_crc16 = cpu_to_le16(crc16(cmd->payload, pdu_len));
162 int fio_net_send_cmd(int fd, uint16_t opcode, const char *buf, off_t size)
164 struct fio_net_cmd *cmd;
170 if (this_len > FIO_SERVER_MAX_PDU)
171 this_len = FIO_SERVER_MAX_PDU;
173 cmd = malloc(sizeof(*cmd) + this_len);
175 fio_init_net_cmd(cmd, opcode, buf, this_len);
178 cmd->flags |= FIO_NET_CMD_F_MORE;
180 fio_net_cmd_crc(cmd);
182 ret = fio_send_data(fd, cmd, sizeof(*cmd) + this_len);
186 } while (!ret && size);
191 static int send_simple_command(int sk, uint16_t opcode, uint64_t serial)
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),
199 fio_net_cmd_crc(&cmd);
201 return fio_send_data(sk, &cmd, sizeof(cmd));
205 * Send an ack for this command
207 static int ack_command(int sk, struct fio_net_cmd *cmd)
210 return send_simple_command(sk, FIO_NET_CMD_ACK, cmd->serial);
217 static int nak_command(int sk, struct fio_net_cmd *cmd)
219 return send_simple_command(sk, FIO_NET_CMD_NAK, cmd->serial);
223 static int send_quit_command(void)
225 dprint(FD_NET, "server: sending quit\n");
226 return send_simple_command(server_fd, FIO_NET_CMD_QUIT, 0);
229 static int handle_cur_job(struct fio_net_cmd *cmd)
231 unsigned int left = job_max_len - job_cur_len;
234 if (left < cmd->pdu_len) {
235 job_buf = realloc(job_buf, job_max_len + 2 * cmd->pdu_len);
236 job_max_len += 2 * cmd->pdu_len;
239 memcpy(job_buf + job_cur_len, cmd->payload, cmd->pdu_len);
240 job_cur_len += cmd->pdu_len;
243 * More data coming for this job
245 if (cmd->flags & FIO_NET_CMD_F_MORE)
248 parse_jobs_ini(job_buf, 1, 0);
254 job_cur_len = job_max_len = 0;
258 static int handle_command(struct fio_net_cmd *cmd)
262 dprint(FD_NET, "server: got opcode %d\n", cmd->opcode);
264 switch (cmd->opcode) {
265 case FIO_NET_CMD_QUIT:
268 case FIO_NET_CMD_ACK:
270 case FIO_NET_CMD_NAK:
272 case FIO_NET_CMD_JOB:
273 ret = handle_cur_job(cmd);
276 log_err("fio: unknown opcode: %d\n", cmd->opcode);
283 static int handle_connection(int sk)
285 struct fio_net_cmd *cmd = NULL;
289 while (!exit_backend) {
290 cmd = fio_net_cmd_read(sk);
296 ret = ack_command(sk, cmd);
300 ret = handle_command(cmd);
314 static int accept_loop(int listen_sk)
316 struct sockaddr addr;
317 unsigned int len = sizeof(addr);
319 int ret, sk, flags, exitval = 0;
321 flags = fcntl(listen_sk, F_GETFL);
323 fcntl(listen_sk, F_SETFL, flags);
328 ret = poll(&pfd, 1, 100);
332 log_err("fio: poll: %s\n", strerror(errno));
337 if (pfd.revents & POLLIN)
339 } while (!exit_backend);
344 sk = accept(listen_sk, &addr, &len);
346 log_err("fio: accept: %s\n", strerror(errno));
350 dprint(FD_NET, "server got a connection\n");
354 exitval = handle_connection(sk);
368 struct sockaddr_in saddr_in;
369 struct sockaddr addr;
373 dprint(FD_NET, "starting server\n");
375 sk = socket(AF_INET, SOCK_STREAM, 0);
377 log_err("fio: socket: %s\n", strerror(errno));
382 if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
383 log_err("fio: setsockopt: %s\n", strerror(errno));
387 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
388 log_err("fio: setsockopt: %s\n", strerror(errno));
393 saddr_in.sin_family = AF_INET;
394 saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
395 saddr_in.sin_port = htons(fio_net_port);
397 if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0) {
398 log_err("fio: bind: %s\n", strerror(errno));
402 if (listen(sk, 1) < 0) {
403 log_err("fio: listen: %s\n", strerror(errno));
408 if (getsockname(sk, &addr, &len) < 0) {
409 log_err("fio: getsockname: %s\n", strerror(errno));
413 ret = accept_loop(sk);
418 int fio_server_text_output(const char *buf, unsigned int len)
421 return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len);
426 int fio_server_log(const char *format, ...)
432 va_start(args, format);
433 len = vsnprintf(buffer, sizeof(buffer), format, args);
436 return fio_server_text_output(buffer, len);