[fio.git] / server.c

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <limits.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/poll.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <syslog.h>
#include <signal.h>

#include "fio.h"
#include "server.h"
#include "crc/crc16.h"
#include "ieee754.h"

#include "fio_version.h"

int fio_net_port = 8765;

int exit_backend = 0;

static int server_fd = -1;
static char *fio_server_arg;
static char *bind_sock;
static struct sockaddr_in saddr_in;

int fio_send_data(int sk, const void *p, unsigned int len)
{
	assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_PDU);

	do {
		int ret = send(sk, p, len, 0);

		if (ret > 0) {
			len -= ret;
			if (!len)
				break;
			p += ret;
			continue;
		} else if (!ret)
			break;
		else if (errno == EAGAIN || errno == EINTR)
			continue;
	} while (!exit_backend);

	if (!len)
		return 0;

	return 1;
}

int fio_recv_data(int sk, void *p, unsigned int len)
{
	do {
		int ret = recv(sk, p, len, MSG_WAITALL);

		if (ret > 0) {
			len -= ret;
			if (!len)
				break;
			p += ret;
			continue;
		} else if (!ret)
			break;
		else if (errno == EAGAIN || errno == EINTR)
			continue;
	} while (!exit_backend);

	if (!len)
		return 0;

	return -1;
}

static int verify_convert_cmd(struct fio_net_cmd *cmd)
{
	uint16_t crc;

	cmd->cmd_crc16 = le16_to_cpu(cmd->cmd_crc16);
	cmd->pdu_crc16 = le16_to_cpu(cmd->pdu_crc16);

	crc = crc16(cmd, FIO_NET_CMD_CRC_SZ);
	if (crc != cmd->cmd_crc16) {
		log_err("fio: server bad crc on command (got %x, wanted %x)\n",
				cmd->cmd_crc16, crc);
		return 1;
	}

	cmd->version	= le16_to_cpu(cmd->version);
	cmd->opcode	= le16_to_cpu(cmd->opcode);
	cmd->flags	= le32_to_cpu(cmd->flags);
	cmd->serial	= le64_to_cpu(cmd->serial);
	cmd->pdu_len	= le32_to_cpu(cmd->pdu_len);

	switch (cmd->version) {
	case FIO_SERVER_VER3:
		break;
	default:
		log_err("fio: bad server cmd version %d\n", cmd->version);
		return 1;
	}

	if (cmd->pdu_len > FIO_SERVER_MAX_PDU) {
		log_err("fio: command payload too large: %u\n", cmd->pdu_len);
		return 1;
	}

	return 0;
}

/*
 * Read (and defragment, if necessary) incoming commands
 */
struct fio_net_cmd *fio_net_recv_cmd(int sk)
{
	struct fio_net_cmd cmd, *cmdret = NULL;
	size_t cmd_size = 0, pdu_offset = 0;
	uint16_t crc;
	int ret, first = 1;
	void *pdu = NULL;

	do {
		ret = fio_recv_data(sk, &cmd, sizeof(cmd));
		if (ret)
			break;

		/* We have a command, verify it and swap if need be */
		ret = verify_convert_cmd(&cmd);
		if (ret)
			break;

		if (first) {
			/* if this is text, add room for \0 at the end */
			cmd_size = sizeof(cmd) + cmd.pdu_len + 1;
			assert(!cmdret);
		} else
			cmd_size += cmd.pdu_len;

		cmdret = realloc(cmdret, cmd_size);

		if (first)
			memcpy(cmdret, &cmd, sizeof(cmd));
		else
			assert(cmdret->opcode == cmd.opcode);

		if (!cmd.pdu_len)
			break;

		/* There's payload, get it */
		pdu = (void *) cmdret->payload + pdu_offset;
		ret = fio_recv_data(sk, pdu, cmd.pdu_len);
		if (ret)
			break;

		/* Verify payload crc */
		crc = crc16(pdu, cmd.pdu_len);
		if (crc != cmd.pdu_crc16) {
			log_err("fio: server bad crc on payload ");
			log_err("(got %x, wanted %x)\n", cmd.pdu_crc16, crc);
			ret = 1;
			break;
		}

		pdu_offset += cmd.pdu_len;
		if (!first)
			cmdret->pdu_len += cmd.pdu_len;
		first = 0;
	} while (cmd.flags & FIO_NET_CMD_F_MORE);

	if (ret) {
		free(cmdret);
		cmdret = NULL;
	} else if (cmdret) {
		/* zero-terminate text input */
		if (cmdret->pdu_len && (cmdret->opcode == FIO_NET_CMD_TEXT ||
		    cmdret->opcode == FIO_NET_CMD_JOB)) {
			char *buf = (char *) cmdret->payload;

			buf[cmdret->pdu_len ] = '\0';
		}
		/* frag flag is internal */
		cmdret->flags &= ~FIO_NET_CMD_F_MORE;
	}

	return cmdret;
}

void fio_net_cmd_crc(struct fio_net_cmd *cmd)
{
	uint32_t pdu_len;

	cmd->cmd_crc16 = __cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ));

	pdu_len = le32_to_cpu(cmd->pdu_len);
	if (pdu_len)
		cmd->pdu_crc16 = __cpu_to_le16(crc16(cmd->payload, pdu_len));
}

int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size)
{
	struct fio_net_cmd *cmd;
	size_t this_len;
	int ret;

	do {
		this_len = size;
		if (this_len > FIO_SERVER_MAX_PDU)
			this_len = FIO_SERVER_MAX_PDU;

		cmd = malloc(sizeof(*cmd) + this_len);

		fio_init_net_cmd(cmd, opcode, buf, this_len);

		if (this_len < size)
			cmd->flags = __cpu_to_le32(FIO_NET_CMD_F_MORE);

		fio_net_cmd_crc(cmd);

		ret = fio_send_data(fd, cmd, sizeof(*cmd) + this_len);
		free(cmd);
		size -= this_len;
		buf += this_len;
	} while (!ret && size);

	return ret;
}

int fio_net_send_simple_cmd(int sk, uint16_t opcode, uint64_t serial)
{
	struct fio_net_cmd cmd;

	fio_init_net_cmd(&cmd, opcode, NULL, 0);
	fio_net_cmd_crc(&cmd);

	return fio_send_data(sk, &cmd, sizeof(cmd));
}

static int fio_server_send_quit_cmd(void)
{
	dprint(FD_NET, "server: sending quit\n");
	return fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_QUIT, 0);
}

static int handle_job_cmd(struct fio_net_cmd *cmd)
{
	char *buf = (char *) cmd->payload;
	int ret;

	if (parse_jobs_ini(buf, 1, 0)) {
		fio_server_send_quit_cmd();
		return -1;
	}

	fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0);

	ret = exec_run();
	fio_server_send_quit_cmd();
	reset_fio_state();
	return ret;
}

static int handle_jobline_cmd(struct fio_net_cmd *cmd)
{
	struct cmd_line_pdu *pdu = (struct cmd_line_pdu *) cmd->payload;
	char *argv[FIO_NET_CMD_JOBLINE_ARGV];
	int ret, i;

	pdu->argc = le16_to_cpu(pdu->argc);

	dprint(FD_NET, "server: %d command line args\n", pdu->argc);

	for (i = 0; i < pdu->argc; i++) {
		argv[i] = (char *) pdu->argv[i];
		dprint(FD_NET, "server: %d: %s\n", i, argv[i]);
	}

	if (parse_cmd_line(pdu->argc, argv)) {
		fio_server_send_quit_cmd();
		return -1;
	}

	fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0);

	ret = exec_run();
	fio_server_send_quit_cmd();
	reset_fio_state();
	return ret;
}

static int handle_probe_cmd(struct fio_net_cmd *cmd)
{
	struct cmd_probe_pdu probe;

	memset(&probe, 0, sizeof(probe));
	gethostname((char *) probe.hostname, sizeof(probe.hostname));
#ifdef FIO_BIG_ENDIAN
	probe.bigendian = 1;
#endif
	probe.fio_major = FIO_MAJOR;
	probe.fio_minor = FIO_MINOR;
	probe.fio_patch = FIO_PATCH;

	probe.os	= FIO_OS;
	probe.arch	= FIO_ARCH;

	return fio_net_send_cmd(server_fd, FIO_NET_CMD_PROBE, &probe, sizeof(probe));
}

static int handle_command(struct fio_net_cmd *cmd)
{
	int ret;

	dprint(FD_NET, "server: got opcode %d\n", cmd->opcode);

	switch (cmd->opcode) {
	case FIO_NET_CMD_QUIT:
		fio_terminate_threads(TERMINATE_ALL);
		return -1;
	case FIO_NET_CMD_EXIT:
		exit_backend = 1;
		return -1;
	case FIO_NET_CMD_JOB:
		ret = handle_job_cmd(cmd);
		break;
	case FIO_NET_CMD_JOBLINE:
		ret = handle_jobline_cmd(cmd);
		break;
	case FIO_NET_CMD_PROBE:
		ret = handle_probe_cmd(cmd);
		break;
	default:
		log_err("fio: unknown opcode: %d\n", cmd->opcode);
		ret = 1;
	}

	return ret;
}

static int handle_connection(int sk, int block)
{
	struct fio_net_cmd *cmd = NULL;
	int ret = 0;

	/* read forever */
	while (!exit_backend) {
		struct pollfd pfd = {
			.fd	= sk,
			.events	= POLLIN,
		};

		ret = 0;
		do {
			ret = poll(&pfd, 1, 100);
			if (ret < 0) {
				if (errno == EINTR)
					break;
				log_err("fio: poll: %s\n", strerror(errno));
				break;
			} else if (!ret) {
				if (!block)
					return 0;
				continue;
			}

			if (pfd.revents & POLLIN)
				break;
			if (pfd.revents & (POLLERR|POLLHUP)) {
				ret = 1;
				break;
			}
		} while (!exit_backend);

		if (ret < 0)
			break;

		cmd = fio_net_recv_cmd(sk);
		if (!cmd) {
			ret = -1;
			break;
		}

		ret = handle_command(cmd);
		if (ret)
			break;

		free(cmd);
		cmd = NULL;
	}

	if (cmd)
		free(cmd);

	return ret;
}

void fio_server_idle_loop(void)
{
	if (server_fd != -1)
		handle_connection(server_fd, 0);
}

static int accept_loop(int listen_sk)
{
	struct sockaddr_in addr;
	fio_socklen_t len = sizeof(addr);
	struct pollfd pfd;
	int ret, sk, flags, exitval = 0;

	dprint(FD_NET, "server enter accept loop\n");

	flags = fcntl(listen_sk, F_GETFL);
	flags |= O_NONBLOCK;
	fcntl(listen_sk, F_SETFL, flags);
again:
	pfd.fd = listen_sk;
	pfd.events = POLLIN;
	do {
		ret = poll(&pfd, 1, 100);
		if (ret < 0) {
			if (errno == EINTR)
				break;
			log_err("fio: poll: %s\n", strerror(errno));
			goto out;
		} else if (!ret)
			continue;

		if (pfd.revents & POLLIN)
			break;
	} while (!exit_backend);

	if (exit_backend)
		goto out;

	sk = accept(listen_sk, (struct sockaddr *) &addr, &len);
	if (sk < 0) {
		log_err("fio: accept: %s\n", strerror(errno));
		return -1;
	}

	dprint(FD_NET, "server: connect from %s\n", inet_ntoa(addr.sin_addr));

	server_fd = sk;

	exitval = handle_connection(sk, 1);

	server_fd = -1;
	close(sk);

	if (!exit_backend)
		goto again;

out:
	return exitval;
}

int fio_server_text_output(const char *buf, unsigned int len)
{
	if (server_fd != -1)
		return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len);

	return fwrite(buf, len, 1, f_err);
}

static void convert_io_stat(struct io_stat *dst, struct io_stat *src)
{
	dst->max_val	= cpu_to_le64(src->max_val);
	dst->min_val	= cpu_to_le64(src->min_val);
	dst->samples	= cpu_to_le64(src->samples);

	/*
	 * Encode to IEEE 754 for network transfer
	 */
	dst->mean.u.i	= __cpu_to_le64(fio_double_to_uint64(src->mean.u.f));
	dst->S.u.i	= __cpu_to_le64(fio_double_to_uint64(src->S.u.f));
}

static void convert_gs(struct group_run_stats *dst, struct group_run_stats *src)
{
	int i;

	for (i = 0; i < 2; i++) {
		dst->max_run[i]		= cpu_to_le64(src->max_run[i]);
		dst->min_run[i]		= cpu_to_le64(src->min_run[i]);
		dst->max_bw[i]		= cpu_to_le64(src->max_bw[i]);
		dst->min_bw[i]		= cpu_to_le64(src->min_bw[i]);
		dst->io_kb[i]		= cpu_to_le64(src->io_kb[i]);
		dst->agg[i]		= cpu_to_le64(src->agg[i]);
	}

	dst->kb_base	= cpu_to_le32(src->kb_base);
	dst->groupid	= cpu_to_le32(src->groupid);
}

/*
 * Send a CMD_TS, which packs struct thread_stat and group_run_stats
 * into a single payload.
 */
void fio_server_send_ts(struct thread_stat *ts, struct group_run_stats *rs)
{
	struct cmd_ts_pdu p;
	int i, j;

	dprint(FD_NET, "server sending end stats\n");

	memset(&p, 0, sizeof(p));

	strcpy(p.ts.name, ts->name);
	strcpy(p.ts.verror, ts->verror);
	strcpy(p.ts.description, ts->description);

	p.ts.error	= cpu_to_le32(ts->error);
	p.ts.groupid	= cpu_to_le32(ts->groupid);
	p.ts.pid	= cpu_to_le32(ts->pid);
	p.ts.members	= cpu_to_le32(ts->members);

	for (i = 0; i < 2; i++) {
		convert_io_stat(&p.ts.clat_stat[i], &ts->clat_stat[i]);
		convert_io_stat(&p.ts.slat_stat[i], &ts->slat_stat[i]);
		convert_io_stat(&p.ts.lat_stat[i], &ts->lat_stat[i]);
		convert_io_stat(&p.ts.bw_stat[i], &ts->bw_stat[i]);
	}

	p.ts.usr_time		= cpu_to_le64(ts->usr_time);
	p.ts.sys_time		= cpu_to_le64(ts->sys_time);
	p.ts.ctx		= cpu_to_le64(ts->ctx);
	p.ts.minf		= cpu_to_le64(ts->minf);
	p.ts.majf		= cpu_to_le64(ts->majf);
	p.ts.clat_percentiles	= cpu_to_le64(ts->clat_percentiles);

	for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) {
		fio_fp64_t *fp = &p.ts.percentile_list[i];

		fp->u.i = __cpu_to_le64(fio_double_to_uint64(fp->u.f));
	}

	for (i = 0; i < FIO_IO_U_MAP_NR; i++) {
		p.ts.io_u_map[i]	= cpu_to_le32(ts->io_u_map[i]);
		p.ts.io_u_submit[i]	= cpu_to_le32(ts->io_u_submit[i]);
		p.ts.io_u_complete[i]	= cpu_to_le32(ts->io_u_complete[i]);
	}

	for (i = 0; i < FIO_IO_U_LAT_U_NR; i++) {
		p.ts.io_u_lat_u[i]	= cpu_to_le32(ts->io_u_lat_u[i]);
		p.ts.io_u_lat_m[i]	= cpu_to_le32(ts->io_u_lat_m[i]);
	}

	for (i = 0; i < 2; i++)
		for (j = 0; j < FIO_IO_U_PLAT_NR; j++)
			p.ts.io_u_plat[i][j] = cpu_to_le32(ts->io_u_plat[i][j]);

	for (i = 0; i < 3; i++) {
		p.ts.total_io_u[i]	= cpu_to_le64(ts->total_io_u[i]);
		p.ts.short_io_u[i]	= cpu_to_le64(ts->short_io_u[i]);
	}

	p.ts.total_submit	= cpu_to_le64(ts->total_submit);
	p.ts.total_complete	= cpu_to_le64(ts->total_complete);

	for (i = 0; i < 2; i++) {
		p.ts.io_bytes[i]	= cpu_to_le64(ts->io_bytes[i]);
		p.ts.runtime[i]		= cpu_to_le64(ts->runtime[i]);
	}

	p.ts.total_run_time	= cpu_to_le64(ts->total_run_time);
	p.ts.continue_on_error	= cpu_to_le16(ts->continue_on_error);
	p.ts.total_err_count	= cpu_to_le64(ts->total_err_count);
	p.ts.first_error	= cpu_to_le32(ts->first_error);
	p.ts.kb_base		= cpu_to_le32(ts->kb_base);

	convert_gs(&p.rs, rs);

	fio_net_send_cmd(server_fd, FIO_NET_CMD_TS, &p, sizeof(p));
}

void fio_server_send_gs(struct group_run_stats *rs)
{
	struct group_run_stats gs;

	dprint(FD_NET, "server sending group run stats\n");

	convert_gs(&gs, rs);
	fio_net_send_cmd(server_fd, FIO_NET_CMD_GS, &gs, sizeof(gs));
}

void fio_server_send_status(void)
{
	struct jobs_eta *je;
	size_t size;
	void *buf;
	int i;

	size = sizeof(*je) + thread_number * sizeof(char);
	buf = malloc(size);
	memset(buf, 0, size);
	je = buf;

	if (!calc_thread_status(je)) {
		free(je);
		return;
	}

	dprint(FD_NET, "server sending status\n");

	je->nr_running		= cpu_to_le32(je->nr_running);
	je->nr_ramp		= cpu_to_le32(je->nr_ramp);
	je->nr_pending		= cpu_to_le32(je->nr_pending);
	je->files_open		= cpu_to_le32(je->files_open);
	je->m_rate		= cpu_to_le32(je->m_rate);
	je->t_rate		= cpu_to_le32(je->t_rate);
	je->m_iops		= cpu_to_le32(je->m_iops);
	je->t_iops		= cpu_to_le32(je->t_iops);

	for (i = 0; i < 2; i++) {
		je->rate[i]	= cpu_to_le32(je->rate[i]);
		je->iops[i]	= cpu_to_le32(je->iops[i]);
	}

	je->elapsed_sec		= cpu_to_le32(je->nr_running);
	je->eta_sec		= cpu_to_le64(je->eta_sec);

	fio_net_send_cmd(server_fd, FIO_NET_CMD_ETA, buf, size);
	free(je);
}

int fio_server_log(const char *format, ...)
{
	char buffer[1024];
	va_list args;
	size_t len;

	dprint(FD_NET, "server log\n");

	va_start(args, format);
	len = vsnprintf(buffer, sizeof(buffer), format, args);
	va_end(args);

	return fio_server_text_output(buffer, len);
}

static int fio_init_server_ip(void)
{
	int sk, opt;

	sk = socket(AF_INET, SOCK_STREAM, 0);
	if (sk < 0) {
		log_err("fio: socket: %s\n", strerror(errno));
		return -1;
	}

	opt = 1;
	if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
		log_err("fio: setsockopt: %s\n", strerror(errno));
		close(sk);
		return -1;
	}
#ifdef SO_REUSEPORT
	if (setsockopt(sk, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
		log_err("fio: setsockopt: %s\n", strerror(errno));
		close(sk);
		return -1;
	}
#endif

	saddr_in.sin_family = AF_INET;

	if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0) {
		log_err("fio: bind: %s\n", strerror(errno));
		close(sk);
		return -1;
	}

	return sk;
}

static int fio_init_server_sock(void)
{
	struct sockaddr_un addr;
	fio_socklen_t len;
	mode_t mode;
	int sk;

	sk = socket(AF_UNIX, SOCK_STREAM, 0);
	if (sk < 0) {
		log_err("fio: socket: %s\n", strerror(errno));
		return -1;
	}

	mode = umask(000);

	memset(&addr, 0, sizeof(addr));
	addr.sun_family = AF_UNIX;
	strcpy(addr.sun_path, bind_sock);
	unlink(bind_sock);

	len = sizeof(addr.sun_family) + strlen(bind_sock) + 1;

	if (bind(sk, (struct sockaddr *) &addr, len) < 0) {
		log_err("fio: bind: %s\n", strerror(errno));
		close(sk);
		return -1;
	}

	umask(mode);
	return sk;
}

static int fio_init_server_connection(void)
{
	char bind_str[128];
	int sk;

	dprint(FD_NET, "starting server\n");

	if (!bind_sock)
		sk = fio_init_server_ip();
	else
		sk = fio_init_server_sock();

	if (sk < 0)
		return sk;

	if (!bind_sock)
		sprintf(bind_str, "%s:%u", inet_ntoa(saddr_in.sin_addr), fio_net_port);
	else
		strcpy(bind_str, bind_sock);

	log_info("fio: server listening on %s\n", bind_str);

	if (listen(sk, 1) < 0) {
		log_err("fio: listen: %s\n", strerror(errno));
		return -1;
	}

	return sk;
}

int fio_server_parse_string(const char *str, char **ptr, int *is_sock,
			    int *port, struct in_addr *inp)
{
	*ptr = NULL;
	*is_sock = 0;
	*port = 0;

	if (!strncmp(str, "sock:", 5)) {
		*ptr = strdup(str + 5);
		*is_sock = 1;
	} else {
		const char *host = str;
		char *portp;
		int lport = 0;

		/*
		 * Is it ip:<ip or host>:port
		 */
		if (!strncmp(host, "ip:", 3))
			host += 3;
		else if (host[0] == ':') {
			/* String is :port */
			host++;
			lport = atoi(host);
			if (!lport || lport > 65535) {
				log_err("fio: bad server port %u\n", port);
				return 1;
			}
			/* no hostname given, we are done */
			*port = lport;
			return 0;
		}

		/*
		 * If no port seen yet, check if there's a last ':' at the end
		 */
		if (!lport) {
			portp = strchr(host, ':');
			if (portp) {
				*portp = '\0';
				portp++;
				lport = atoi(portp);
				if (!lport || lport > 65535) {
					log_err("fio: bad server port %u\n", port);
					return 1;
				}
			}
		}

		if (lport)
			*port = lport;

		*ptr = strdup(host);

		if (inet_aton(host, inp) != 1) {
			struct hostent *hent;

			hent = gethostbyname(host);
			if (!hent) {
				printf("FAIL\n");
				free(*ptr);
				*ptr = NULL;
				return 1;
			}

			memcpy(inp, hent->h_addr, 4);
		}
	}

	if (*port == 0)
		*port = fio_net_port;

	return 0;
}

/*
 * Server arg should be one of:
 *
 * sock:/path/to/socket
 *   ip:1.2.3.4
 *      1.2.3.4
 *
 * Where sock uses unix domain sockets, and ip binds the server to
 * a specific interface. If no arguments are given to the server, it
 * uses IP and binds to 0.0.0.0.
 *
 */
static int fio_handle_server_arg(void)
{
	int is_sock, ret;

	saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
	saddr_in.sin_port = htons(fio_net_port);

	if (!fio_server_arg)
		return 0;

	ret = fio_server_parse_string(fio_server_arg, &bind_sock, &is_sock,
					&fio_net_port, &saddr_in.sin_addr);

	if (!is_sock && bind_sock) {
		free(bind_sock);
		bind_sock = NULL;
	}

	return ret;
}

static int fio_server(void)
{
	int sk, ret;

	dprint(FD_NET, "starting server\n");

	if (fio_handle_server_arg())
		return -1;

	sk = fio_init_server_connection();
	if (sk < 0)
		return -1;

	ret = accept_loop(sk);

	close(sk);

	if (fio_server_arg) {
		free(fio_server_arg);
		fio_server_arg = NULL;
	}
	if (bind_sock)
		free(bind_sock);

	return ret;
}

static void sig_int(int sig)
{
	fio_terminate_threads(TERMINATE_ALL);
	exit_backend = 1;
}

static void server_signal_handler(void)
{
	struct sigaction act;

	memset(&act, 0, sizeof(act));
	act.sa_handler = sig_int;
	act.sa_flags = SA_RESTART;
	sigaction(SIGINT, &act, NULL);

	memset(&act, 0, sizeof(act));
	act.sa_handler = sig_int;
	act.sa_flags = SA_RESTART;
	sigaction(SIGTERM, &act, NULL);
}

int fio_start_server(int daemonize)
{
	pid_t pid;

	server_signal_handler();

	if (!daemonize)
		return fio_server();

	openlog("fio", LOG_NDELAY|LOG_NOWAIT|LOG_PID, LOG_USER);
	pid = fork();
	if (pid < 0) {
		syslog(LOG_ERR, "failed server fork");
		return -1;
	} else if (pid)
		exit(0);

	setsid();
	close(STDIN_FILENO);
	close(STDOUT_FILENO);
	close(STDERR_FILENO);
	f_out = NULL;
	f_err = NULL;
	log_syslog = 1;
	return fio_server();
}

void fio_server_set_arg(const char *arg)
{
	fio_server_arg = strdup(arg);
}
Commit	Line	Data
	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/socket.h>
	12	#include <sys/stat.h>
	13	#include <sys/un.h>
	14	#include <netinet/in.h>
	15	#include <arpa/inet.h>
	16	#include <netdb.h>
	17	#include <syslog.h>
	18	#include <signal.h>
	19
	20	#include "fio.h"
	21	#include "server.h"
	22	#include "crc/crc16.h"
	23	#include "ieee754.h"
	24
	25	#include "fio_version.h"
	26
	27	int fio_net_port = 8765;
	28
	29	int exit_backend = 0;
	30
	31	static int server_fd = -1;
	32	static char *fio_server_arg;
	33	static char *bind_sock;
	34	static struct sockaddr_in saddr_in;
	35
	36	int fio_send_data(int sk, const void *p, unsigned int len)
	37	{
	38	assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_PDU);
	39
	40	do {
	41	int ret = send(sk, p, len, 0);
	42
	43	if (ret > 0) {
	44	len -= ret;
	45	if (!len)
	46	break;
	47	p += ret;
	48	continue;
	49	} else if (!ret)
	50	break;
	51	else if (errno == EAGAIN \|\| errno == EINTR)
	52	continue;
	53	} while (!exit_backend);
	54
	55	if (!len)
	56	return 0;
	57
	58	return 1;
	59	}
	60
	61	int fio_recv_data(int sk, void *p, unsigned int len)
	62	{
	63	do {
	64	int ret = recv(sk, p, len, MSG_WAITALL);
	65
	66	if (ret > 0) {
	67	len -= ret;
	68	if (!len)
	69	break;
	70	p += ret;
	71	continue;
	72	} else if (!ret)
	73	break;
	74	else if (errno == EAGAIN \|\| errno == EINTR)
	75	continue;
	76	} while (!exit_backend);
	77
	78	if (!len)
	79	return 0;
	80
	81	return -1;
	82	}
	83
	84	static int verify_convert_cmd(struct fio_net_cmd *cmd)
	85	{
	86	uint16_t crc;
	87
	88	cmd->cmd_crc16 = le16_to_cpu(cmd->cmd_crc16);
	89	cmd->pdu_crc16 = le16_to_cpu(cmd->pdu_crc16);
	90
	91	crc = crc16(cmd, FIO_NET_CMD_CRC_SZ);
	92	if (crc != cmd->cmd_crc16) {
	93	log_err("fio: server bad crc on command (got %x, wanted %x)\n",
	94	cmd->cmd_crc16, crc);
	95	return 1;
	96	}
	97
	98	cmd->version = le16_to_cpu(cmd->version);
	99	cmd->opcode = le16_to_cpu(cmd->opcode);
	100	cmd->flags = le32_to_cpu(cmd->flags);
	101	cmd->serial = le64_to_cpu(cmd->serial);
	102	cmd->pdu_len = le32_to_cpu(cmd->pdu_len);
	103
	104	switch (cmd->version) {
	105	case FIO_SERVER_VER3:
	106	break;
	107	default:
	108	log_err("fio: bad server cmd version %d\n", cmd->version);
	109	return 1;
	110	}
	111
	112	if (cmd->pdu_len > FIO_SERVER_MAX_PDU) {
	113	log_err("fio: command payload too large: %u\n", cmd->pdu_len);
	114	return 1;
	115	}
	116
	117	return 0;
	118	}
	119
	120	/*
	121	* Read (and defragment, if necessary) incoming commands
	122	*/
	123	struct fio_net_cmd *fio_net_recv_cmd(int sk)
	124	{
	125	struct fio_net_cmd cmd, *cmdret = NULL;
	126	size_t cmd_size = 0, pdu_offset = 0;
	127	uint16_t crc;
	128	int ret, first = 1;
	129	void *pdu = NULL;
	130
	131	do {
	132	ret = fio_recv_data(sk, &cmd, sizeof(cmd));
	133	if (ret)
	134	break;
	135
	136	/* We have a command, verify it and swap if need be */
	137	ret = verify_convert_cmd(&cmd);
	138	if (ret)
	139	break;
	140
	141	if (first) {
	142	/* if this is text, add room for \0 at the end */
	143	cmd_size = sizeof(cmd) + cmd.pdu_len + 1;
	144	assert(!cmdret);
	145	} else
	146	cmd_size += cmd.pdu_len;
	147
	148	cmdret = realloc(cmdret, cmd_size);
	149
	150	if (first)
	151	memcpy(cmdret, &cmd, sizeof(cmd));
	152	else
	153	assert(cmdret->opcode == cmd.opcode);
	154
	155	if (!cmd.pdu_len)
	156	break;
	157
	158	/* There's payload, get it */
	159	pdu = (void *) cmdret->payload + pdu_offset;
	160	ret = fio_recv_data(sk, pdu, cmd.pdu_len);
	161	if (ret)
	162	break;
	163
	164	/* Verify payload crc */
	165	crc = crc16(pdu, cmd.pdu_len);
	166	if (crc != cmd.pdu_crc16) {
	167	log_err("fio: server bad crc on payload ");
	168	log_err("(got %x, wanted %x)\n", cmd.pdu_crc16, crc);
	169	ret = 1;
	170	break;
	171	}
	172
	173	pdu_offset += cmd.pdu_len;
	174	if (!first)
	175	cmdret->pdu_len += cmd.pdu_len;
	176	first = 0;
	177	} while (cmd.flags & FIO_NET_CMD_F_MORE);
	178
	179	if (ret) {
	180	free(cmdret);
	181	cmdret = NULL;
	182	} else if (cmdret) {
	183	/* zero-terminate text input */
	184	if (cmdret->pdu_len && (cmdret->opcode == FIO_NET_CMD_TEXT \|\|
	185	cmdret->opcode == FIO_NET_CMD_JOB)) {
	186	char buf = (char ) cmdret->payload;
	187
	188	buf[cmdret->pdu_len ] = '\0';
	189	}
	190	/* frag flag is internal */
	191	cmdret->flags &= ~FIO_NET_CMD_F_MORE;
	192	}
	193
	194	return cmdret;
	195	}
	196
	197	void fio_net_cmd_crc(struct fio_net_cmd *cmd)
	198	{
	199	uint32_t pdu_len;
	200
	201	cmd->cmd_crc16 = __cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ));
	202
	203	pdu_len = le32_to_cpu(cmd->pdu_len);
	204	if (pdu_len)
	205	cmd->pdu_crc16 = __cpu_to_le16(crc16(cmd->payload, pdu_len));
	206	}
	207
	208	int fio_net_send_cmd(int fd, uint16_t opcode, const void *buf, off_t size)
	209	{
	210	struct fio_net_cmd *cmd;
	211	size_t this_len;
	212	int ret;
	213
	214	do {
	215	this_len = size;
	216	if (this_len > FIO_SERVER_MAX_PDU)
	217	this_len = FIO_SERVER_MAX_PDU;
	218
	219	cmd = malloc(sizeof(*cmd) + this_len);
	220
	221	fio_init_net_cmd(cmd, opcode, buf, this_len);
	222
	223	if (this_len < size)
	224	cmd->flags = __cpu_to_le32(FIO_NET_CMD_F_MORE);
	225
	226	fio_net_cmd_crc(cmd);
	227
	228	ret = fio_send_data(fd, cmd, sizeof(*cmd) + this_len);
	229	free(cmd);
	230	size -= this_len;
	231	buf += this_len;
	232	} while (!ret && size);
	233
	234	return ret;
	235	}
	236
	237	int fio_net_send_simple_cmd(int sk, uint16_t opcode, uint64_t serial)
	238	{
	239	struct fio_net_cmd cmd;
	240
	241	fio_init_net_cmd(&cmd, opcode, NULL, 0);
	242	fio_net_cmd_crc(&cmd);
	243
	244	return fio_send_data(sk, &cmd, sizeof(cmd));
	245	}
	246
	247	static int fio_server_send_quit_cmd(void)
	248	{
	249	dprint(FD_NET, "server: sending quit\n");
	250	return fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_QUIT, 0);
	251	}
	252
	253	static int handle_job_cmd(struct fio_net_cmd *cmd)
	254	{
	255	char buf = (char ) cmd->payload;
	256	int ret;
	257
	258	if (parse_jobs_ini(buf, 1, 0)) {
	259	fio_server_send_quit_cmd();
	260	return -1;
	261	}
	262
	263	fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0);
	264
	265	ret = exec_run();
	266	fio_server_send_quit_cmd();
	267	reset_fio_state();
	268	return ret;
	269	}
	270
	271	static int handle_jobline_cmd(struct fio_net_cmd *cmd)
	272	{
	273	struct cmd_line_pdu pdu = (struct cmd_line_pdu ) cmd->payload;
	274	char *argv[FIO_NET_CMD_JOBLINE_ARGV];
	275	int ret, i;
	276
	277	pdu->argc = le16_to_cpu(pdu->argc);
	278
	279	dprint(FD_NET, "server: %d command line args\n", pdu->argc);
	280
	281	for (i = 0; i < pdu->argc; i++) {
	282	argv[i] = (char *) pdu->argv[i];
	283	dprint(FD_NET, "server: %d: %s\n", i, argv[i]);
	284	}
	285
	286	if (parse_cmd_line(pdu->argc, argv)) {
	287	fio_server_send_quit_cmd();
	288	return -1;
	289	}
	290
	291	fio_net_send_simple_cmd(server_fd, FIO_NET_CMD_START, 0);
	292
	293	ret = exec_run();
	294	fio_server_send_quit_cmd();
	295	reset_fio_state();
	296	return ret;
	297	}
	298
	299	static int handle_probe_cmd(struct fio_net_cmd *cmd)
	300	{
	301	struct cmd_probe_pdu probe;
	302
	303	memset(&probe, 0, sizeof(probe));
	304	gethostname((char *) probe.hostname, sizeof(probe.hostname));
	305	#ifdef FIO_BIG_ENDIAN
	306	probe.bigendian = 1;
	307	#endif
	308	probe.fio_major = FIO_MAJOR;
	309	probe.fio_minor = FIO_MINOR;
	310	probe.fio_patch = FIO_PATCH;
	311
	312	probe.os = FIO_OS;
	313	probe.arch = FIO_ARCH;
	314
	315	return fio_net_send_cmd(server_fd, FIO_NET_CMD_PROBE, &probe, sizeof(probe));
	316	}
	317
	318	static int handle_command(struct fio_net_cmd *cmd)
	319	{
	320	int ret;
	321
	322	dprint(FD_NET, "server: got opcode %d\n", cmd->opcode);
	323
	324	switch (cmd->opcode) {
	325	case FIO_NET_CMD_QUIT:
	326	fio_terminate_threads(TERMINATE_ALL);
	327	return -1;
	328	case FIO_NET_CMD_EXIT:
	329	exit_backend = 1;
	330	return -1;
	331	case FIO_NET_CMD_JOB:
	332	ret = handle_job_cmd(cmd);
	333	break;
	334	case FIO_NET_CMD_JOBLINE:
	335	ret = handle_jobline_cmd(cmd);
	336	break;
	337	case FIO_NET_CMD_PROBE:
	338	ret = handle_probe_cmd(cmd);
	339	break;
	340	default:
	341	log_err("fio: unknown opcode: %d\n", cmd->opcode);
	342	ret = 1;
	343	}
	344
	345	return ret;
	346	}
	347
	348	static int handle_connection(int sk, int block)
	349	{
	350	struct fio_net_cmd *cmd = NULL;
	351	int ret = 0;
	352
	353	/* read forever */
	354	while (!exit_backend) {
	355	struct pollfd pfd = {
	356	.fd = sk,
	357	.events = POLLIN,
	358	};
	359
	360	ret = 0;
	361	do {
	362	ret = poll(&pfd, 1, 100);
	363	if (ret < 0) {
	364	if (errno == EINTR)
	365	break;
	366	log_err("fio: poll: %s\n", strerror(errno));
	367	break;
	368	} else if (!ret) {
	369	if (!block)
	370	return 0;
	371	continue;
	372	}
	373
	374	if (pfd.revents & POLLIN)
	375	break;
	376	if (pfd.revents & (POLLERR\|POLLHUP)) {
	377	ret = 1;
	378	break;
	379	}
	380	} while (!exit_backend);
	381
	382	if (ret < 0)
	383	break;
	384
	385	cmd = fio_net_recv_cmd(sk);
	386	if (!cmd) {
	387	ret = -1;
	388	break;
	389	}
	390
	391	ret = handle_command(cmd);
	392	if (ret)
	393	break;
	394
	395	free(cmd);
	396	cmd = NULL;
	397	}
	398
	399	if (cmd)
	400	free(cmd);
	401
	402	return ret;
	403	}
	404
	405	void fio_server_idle_loop(void)
	406	{
	407	if (server_fd != -1)
	408	handle_connection(server_fd, 0);
	409	}
	410
	411	static int accept_loop(int listen_sk)
	412	{
	413	struct sockaddr_in addr;
	414	fio_socklen_t len = sizeof(addr);
	415	struct pollfd pfd;
	416	int ret, sk, flags, exitval = 0;
	417
	418	dprint(FD_NET, "server enter accept loop\n");
	419
	420	flags = fcntl(listen_sk, F_GETFL);
	421	flags \|= O_NONBLOCK;
	422	fcntl(listen_sk, F_SETFL, flags);
	423	again:
	424	pfd.fd = listen_sk;
	425	pfd.events = POLLIN;
	426	do {
	427	ret = poll(&pfd, 1, 100);
	428	if (ret < 0) {
	429	if (errno == EINTR)
	430	break;
	431	log_err("fio: poll: %s\n", strerror(errno));
	432	goto out;
	433	} else if (!ret)
	434	continue;
	435
	436	if (pfd.revents & POLLIN)
	437	break;
	438	} while (!exit_backend);
	439
	440	if (exit_backend)
	441	goto out;
	442
	443	sk = accept(listen_sk, (struct sockaddr *) &addr, &len);
	444	if (sk < 0) {
	445	log_err("fio: accept: %s\n", strerror(errno));
	446	return -1;
	447	}
	448
	449	dprint(FD_NET, "server: connect from %s\n", inet_ntoa(addr.sin_addr));
	450
	451	server_fd = sk;
	452
	453	exitval = handle_connection(sk, 1);
	454
	455	server_fd = -1;
	456	close(sk);
	457
	458	if (!exit_backend)
	459	goto again;
	460
	461	out:
	462	return exitval;
	463	}
	464
	465	int fio_server_text_output(const char *buf, unsigned int len)
	466	{
	467	if (server_fd != -1)
	468	return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len);
	469
	470	return fwrite(buf, len, 1, f_err);
	471	}
	472
	473	static void convert_io_stat(struct io_stat dst, struct io_stat src)
	474	{
	475	dst->max_val = cpu_to_le64(src->max_val);
	476	dst->min_val = cpu_to_le64(src->min_val);
	477	dst->samples = cpu_to_le64(src->samples);
	478
	479	/*
	480	* Encode to IEEE 754 for network transfer
	481	*/
	482	dst->mean.u.i = __cpu_to_le64(fio_double_to_uint64(src->mean.u.f));
	483	dst->S.u.i = __cpu_to_le64(fio_double_to_uint64(src->S.u.f));
	484	}
	485
	486	static void convert_gs(struct group_run_stats dst, struct group_run_stats src)
	487	{
	488	int i;
	489
	490	for (i = 0; i < 2; i++) {
	491	dst->max_run[i] = cpu_to_le64(src->max_run[i]);
	492	dst->min_run[i] = cpu_to_le64(src->min_run[i]);
	493	dst->max_bw[i] = cpu_to_le64(src->max_bw[i]);
	494	dst->min_bw[i] = cpu_to_le64(src->min_bw[i]);
	495	dst->io_kb[i] = cpu_to_le64(src->io_kb[i]);
	496	dst->agg[i] = cpu_to_le64(src->agg[i]);
	497	}
	498
	499	dst->kb_base = cpu_to_le32(src->kb_base);
	500	dst->groupid = cpu_to_le32(src->groupid);
	501	}
	502
	503	/*
	504	* Send a CMD_TS, which packs struct thread_stat and group_run_stats
	505	* into a single payload.
	506	*/
	507	void fio_server_send_ts(struct thread_stat ts, struct group_run_stats rs)
	508	{
	509	struct cmd_ts_pdu p;
	510	int i, j;
	511
	512	dprint(FD_NET, "server sending end stats\n");
	513
	514	memset(&p, 0, sizeof(p));
	515
	516	strcpy(p.ts.name, ts->name);
	517	strcpy(p.ts.verror, ts->verror);
	518	strcpy(p.ts.description, ts->description);
	519
	520	p.ts.error = cpu_to_le32(ts->error);
	521	p.ts.groupid = cpu_to_le32(ts->groupid);
	522	p.ts.pid = cpu_to_le32(ts->pid);
	523	p.ts.members = cpu_to_le32(ts->members);
	524
	525	for (i = 0; i < 2; i++) {
	526	convert_io_stat(&p.ts.clat_stat[i], &ts->clat_stat[i]);
	527	convert_io_stat(&p.ts.slat_stat[i], &ts->slat_stat[i]);
	528	convert_io_stat(&p.ts.lat_stat[i], &ts->lat_stat[i]);
	529	convert_io_stat(&p.ts.bw_stat[i], &ts->bw_stat[i]);
	530	}
	531
	532	p.ts.usr_time = cpu_to_le64(ts->usr_time);
	533	p.ts.sys_time = cpu_to_le64(ts->sys_time);
	534	p.ts.ctx = cpu_to_le64(ts->ctx);
	535	p.ts.minf = cpu_to_le64(ts->minf);
	536	p.ts.majf = cpu_to_le64(ts->majf);
	537	p.ts.clat_percentiles = cpu_to_le64(ts->clat_percentiles);
	538
	539	for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) {
	540	fio_fp64_t *fp = &p.ts.percentile_list[i];
	541
	542	fp->u.i = __cpu_to_le64(fio_double_to_uint64(fp->u.f));
	543	}
	544
	545	for (i = 0; i < FIO_IO_U_MAP_NR; i++) {
	546	p.ts.io_u_map[i] = cpu_to_le32(ts->io_u_map[i]);
	547	p.ts.io_u_submit[i] = cpu_to_le32(ts->io_u_submit[i]);
	548	p.ts.io_u_complete[i] = cpu_to_le32(ts->io_u_complete[i]);
	549	}
	550
	551	for (i = 0; i < FIO_IO_U_LAT_U_NR; i++) {
	552	p.ts.io_u_lat_u[i] = cpu_to_le32(ts->io_u_lat_u[i]);
	553	p.ts.io_u_lat_m[i] = cpu_to_le32(ts->io_u_lat_m[i]);
	554	}
	555
	556	for (i = 0; i < 2; i++)
	557	for (j = 0; j < FIO_IO_U_PLAT_NR; j++)
	558	p.ts.io_u_plat[i][j] = cpu_to_le32(ts->io_u_plat[i][j]);
	559
	560	for (i = 0; i < 3; i++) {
	561	p.ts.total_io_u[i] = cpu_to_le64(ts->total_io_u[i]);
	562	p.ts.short_io_u[i] = cpu_to_le64(ts->short_io_u[i]);
	563	}
	564
	565	p.ts.total_submit = cpu_to_le64(ts->total_submit);
	566	p.ts.total_complete = cpu_to_le64(ts->total_complete);
	567
	568	for (i = 0; i < 2; i++) {
	569	p.ts.io_bytes[i] = cpu_to_le64(ts->io_bytes[i]);
	570	p.ts.runtime[i] = cpu_to_le64(ts->runtime[i]);
	571	}
	572
	573	p.ts.total_run_time = cpu_to_le64(ts->total_run_time);
	574	p.ts.continue_on_error = cpu_to_le16(ts->continue_on_error);
	575	p.ts.total_err_count = cpu_to_le64(ts->total_err_count);
	576	p.ts.first_error = cpu_to_le32(ts->first_error);
	577	p.ts.kb_base = cpu_to_le32(ts->kb_base);
	578
	579	convert_gs(&p.rs, rs);
	580
	581	fio_net_send_cmd(server_fd, FIO_NET_CMD_TS, &p, sizeof(p));
	582	}
	583
	584	void fio_server_send_gs(struct group_run_stats *rs)
	585	{
	586	struct group_run_stats gs;
	587
	588	dprint(FD_NET, "server sending group run stats\n");
	589
	590	convert_gs(&gs, rs);
	591	fio_net_send_cmd(server_fd, FIO_NET_CMD_GS, &gs, sizeof(gs));
	592	}
	593
	594	void fio_server_send_status(void)
	595	{
	596	struct jobs_eta *je;
	597	size_t size;
	598	void *buf;
	599	int i;
	600
	601	size = sizeof(je) + thread_number sizeof(char);
	602	buf = malloc(size);
	603	memset(buf, 0, size);
	604	je = buf;
	605
	606	if (!calc_thread_status(je)) {
	607	free(je);
	608	return;
	609	}
	610
	611	dprint(FD_NET, "server sending status\n");
	612
	613	je->nr_running = cpu_to_le32(je->nr_running);
	614	je->nr_ramp = cpu_to_le32(je->nr_ramp);
	615	je->nr_pending = cpu_to_le32(je->nr_pending);
	616	je->files_open = cpu_to_le32(je->files_open);
	617	je->m_rate = cpu_to_le32(je->m_rate);
	618	je->t_rate = cpu_to_le32(je->t_rate);
	619	je->m_iops = cpu_to_le32(je->m_iops);
	620	je->t_iops = cpu_to_le32(je->t_iops);
	621
	622	for (i = 0; i < 2; i++) {
	623	je->rate[i] = cpu_to_le32(je->rate[i]);
	624	je->iops[i] = cpu_to_le32(je->iops[i]);
	625	}
	626
	627	je->elapsed_sec = cpu_to_le32(je->nr_running);
	628	je->eta_sec = cpu_to_le64(je->eta_sec);
	629
	630	fio_net_send_cmd(server_fd, FIO_NET_CMD_ETA, buf, size);
	631	free(je);
	632	}
	633
	634	int fio_server_log(const char *format, ...)
	635	{
	636	char buffer[1024];
	637	va_list args;
	638	size_t len;
	639
	640	dprint(FD_NET, "server log\n");
	641
	642	va_start(args, format);
	643	len = vsnprintf(buffer, sizeof(buffer), format, args);
	644	va_end(args);
	645
	646	return fio_server_text_output(buffer, len);
	647	}
	648
	649	static int fio_init_server_ip(void)
	650	{
	651	int sk, opt;
	652
	653	sk = socket(AF_INET, SOCK_STREAM, 0);
	654	if (sk < 0) {
	655	log_err("fio: socket: %s\n", strerror(errno));
	656	return -1;
	657	}
	658
	659	opt = 1;
	660	if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
	661	log_err("fio: setsockopt: %s\n", strerror(errno));
	662	close(sk);
	663	return -1;
	664	}
	665	#ifdef SO_REUSEPORT
	666	if (setsockopt(sk, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
	667	log_err("fio: setsockopt: %s\n", strerror(errno));
	668	close(sk);
	669	return -1;
	670	}
	671	#endif
	672
	673	saddr_in.sin_family = AF_INET;
	674
	675	if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0) {
	676	log_err("fio: bind: %s\n", strerror(errno));
	677	close(sk);
	678	return -1;
	679	}
	680
	681	return sk;
	682	}
	683
	684	static int fio_init_server_sock(void)
	685	{
	686	struct sockaddr_un addr;
	687	fio_socklen_t len;
	688	mode_t mode;
	689	int sk;
	690
	691	sk = socket(AF_UNIX, SOCK_STREAM, 0);
	692	if (sk < 0) {
	693	log_err("fio: socket: %s\n", strerror(errno));
	694	return -1;
	695	}
	696
	697	mode = umask(000);
	698
	699	memset(&addr, 0, sizeof(addr));
	700	addr.sun_family = AF_UNIX;
	701	strcpy(addr.sun_path, bind_sock);
	702	unlink(bind_sock);
	703
	704	len = sizeof(addr.sun_family) + strlen(bind_sock) + 1;
	705
	706	if (bind(sk, (struct sockaddr *) &addr, len) < 0) {
	707	log_err("fio: bind: %s\n", strerror(errno));
	708	close(sk);
	709	return -1;
	710	}
	711
	712	umask(mode);
	713	return sk;
	714	}
	715
	716	static int fio_init_server_connection(void)
	717	{
	718	char bind_str[128];
	719	int sk;
	720
	721	dprint(FD_NET, "starting server\n");
	722
	723	if (!bind_sock)
	724	sk = fio_init_server_ip();
	725	else
	726	sk = fio_init_server_sock();
	727
	728	if (sk < 0)
	729	return sk;
	730
	731	if (!bind_sock)
	732	sprintf(bind_str, "%s:%u", inet_ntoa(saddr_in.sin_addr), fio_net_port);
	733	else
	734	strcpy(bind_str, bind_sock);
	735
	736	log_info("fio: server listening on %s\n", bind_str);
	737
	738	if (listen(sk, 1) < 0) {
	739	log_err("fio: listen: %s\n", strerror(errno));
	740	return -1;
	741	}
	742
	743	return sk;
	744	}
	745
	746	int fio_server_parse_string(const char str, char ptr, int is_sock,
	747	int port, struct in_addr inp)
	748	{
	749	*ptr = NULL;
	750	*is_sock = 0;
	751	*port = 0;
	752
	753	if (!strncmp(str, "sock:", 5)) {
	754	*ptr = strdup(str + 5);
	755	*is_sock = 1;
	756	} else {
	757	const char *host = str;
	758	char *portp;
	759	int lport = 0;
	760
	761	/*
	762	* Is it ip:<ip or host>:port
	763	*/
	764	if (!strncmp(host, "ip:", 3))
	765	host += 3;
	766	else if (host[0] == ':') {
	767	/* String is :port */
	768	host++;
	769	lport = atoi(host);
	770	if (!lport \|\| lport > 65535) {
	771	log_err("fio: bad server port %u\n", port);
	772	return 1;
	773	}
	774	/* no hostname given, we are done */
	775	*port = lport;
	776	return 0;
	777	}
	778
	779	/*
	780	* If no port seen yet, check if there's a last ':' at the end
	781	*/
	782	if (!lport) {
	783	portp = strchr(host, ':');
	784	if (portp) {
	785	*portp = '\0';
	786	portp++;
	787	lport = atoi(portp);
	788	if (!lport \|\| lport > 65535) {
	789	log_err("fio: bad server port %u\n", port);
	790	return 1;
	791	}
	792	}
	793	}
	794
	795	if (lport)
	796	*port = lport;
	797
	798	*ptr = strdup(host);
	799
	800	if (inet_aton(host, inp) != 1) {
	801	struct hostent *hent;
	802
	803	hent = gethostbyname(host);
	804	if (!hent) {
	805	printf("FAIL\n");
	806	free(*ptr);
	807	*ptr = NULL;
	808	return 1;
	809	}
	810
	811	memcpy(inp, hent->h_addr, 4);
	812	}
	813	}
	814
	815	if (*port == 0)
	816	*port = fio_net_port;
	817
	818	return 0;
	819	}
	820
	821	/*
	822	* Server arg should be one of:
	823	*
	824	* sock:/path/to/socket
	825	* ip:1.2.3.4
	826	* 1.2.3.4
	827	*
	828	* Where sock uses unix domain sockets, and ip binds the server to
	829	* a specific interface. If no arguments are given to the server, it
	830	* uses IP and binds to 0.0.0.0.
	831	*
	832	*/
	833	static int fio_handle_server_arg(void)
	834	{
	835	int is_sock, ret;
	836
	837	saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
	838	saddr_in.sin_port = htons(fio_net_port);
	839
	840	if (!fio_server_arg)
	841	return 0;
	842
	843	ret = fio_server_parse_string(fio_server_arg, &bind_sock, &is_sock,
	844	&fio_net_port, &saddr_in.sin_addr);
	845
	846	if (!is_sock && bind_sock) {
	847	free(bind_sock);
	848	bind_sock = NULL;
	849	}
	850
	851	return ret;
	852	}
	853
	854	static int fio_server(void)
	855	{
	856	int sk, ret;
	857
	858	dprint(FD_NET, "starting server\n");
	859
	860	if (fio_handle_server_arg())
	861	return -1;
	862
	863	sk = fio_init_server_connection();
	864	if (sk < 0)
	865	return -1;
	866
	867	ret = accept_loop(sk);
	868
	869	close(sk);
	870
	871	if (fio_server_arg) {
	872	free(fio_server_arg);
	873	fio_server_arg = NULL;
	874	}
	875	if (bind_sock)
	876	free(bind_sock);
	877
	878	return ret;
	879	}
	880
	881	static void sig_int(int sig)
	882	{
	883	fio_terminate_threads(TERMINATE_ALL);
	884	exit_backend = 1;
	885	}
	886
	887	static void server_signal_handler(void)
	888	{
	889	struct sigaction act;
	890
	891	memset(&act, 0, sizeof(act));
	892	act.sa_handler = sig_int;
	893	act.sa_flags = SA_RESTART;
	894	sigaction(SIGINT, &act, NULL);
	895
	896	memset(&act, 0, sizeof(act));
	897	act.sa_handler = sig_int;
	898	act.sa_flags = SA_RESTART;
	899	sigaction(SIGTERM, &act, NULL);
	900	}
	901
	902	int fio_start_server(int daemonize)
	903	{
	904	pid_t pid;
	905
	906	server_signal_handler();
	907
	908	if (!daemonize)
	909	return fio_server();
	910
	911	openlog("fio", LOG_NDELAY\|LOG_NOWAIT\|LOG_PID, LOG_USER);
	912	pid = fork();
	913	if (pid < 0) {
	914	syslog(LOG_ERR, "failed server fork");
	915	return -1;
	916	} else if (pid)
	917	exit(0);
	918
	919	setsid();
	920	close(STDIN_FILENO);
	921	close(STDOUT_FILENO);
	922	close(STDERR_FILENO);
	923	f_out = NULL;
	924	f_err = NULL;
	925	log_syslog = 1;
	926	return fio_server();
	927	}
	928
	929	void fio_server_set_arg(const char *arg)
	930	{
	931	fio_server_arg = strdup(arg);
	932	}