[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/mman.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

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

int fio_net_port = 8765;

int exit_backend = 0;

static char *job_buf;
static unsigned int job_cur_len;
static unsigned int job_max_len;

static int server_fd;

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_VER1:
		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;
}

struct fio_net_cmd *fio_net_cmd_read(int sk)
{
	struct fio_net_cmd cmd, *ret = NULL;
	uint16_t crc;

	if (fio_recv_data(sk, &cmd, sizeof(cmd)))
		return NULL;

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

	/* Command checks out, alloc real command and fill in */
	ret = malloc(sizeof(cmd) + cmd.pdu_len);
	memcpy(ret, &cmd, sizeof(cmd));

	if (!ret->pdu_len)
		return ret;

	/* There's payload, get it */
	if (fio_recv_data(sk, (void *) ret + sizeof(*ret), ret->pdu_len)) {
		free(ret);
		return NULL;
	}

	/* Verify payload crc */
	crc = crc16(ret->payload, ret->pdu_len);
	if (crc != ret->pdu_crc16) {
		log_err("fio: server bad crc on payload (got %x, wanted %x)\n",
				ret->pdu_crc16, crc);
		free(ret);
		return NULL;
	}

	return ret;
}

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 char *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 |= 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;
}

static int send_simple_command(int sk, uint16_t opcode, uint64_t serial)
{
	struct fio_net_cmd cmd = {
		.version	= cpu_to_le16(FIO_SERVER_VER1),
		.opcode		= cpu_to_le16(opcode),
		.serial		= cpu_to_le64(serial),
	};

	fio_net_cmd_crc(&cmd);

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

/*
 * Send an ack for this command
 */
static int ack_command(int sk, struct fio_net_cmd *cmd)
{
#if 0
	return send_simple_command(sk, FIO_NET_CMD_ACK, cmd->serial);
#else
	return 0;
#endif
}

#if 0
static int nak_command(int sk, struct fio_net_cmd *cmd)
{
	return send_simple_command(sk, FIO_NET_CMD_NAK, cmd->serial);
}
#endif

static int send_quit_command(void)
{
	return send_simple_command(server_fd, FIO_NET_CMD_QUIT, 0);
}

static int handle_cur_job(struct fio_net_cmd *cmd)
{
	unsigned int left = job_max_len - job_cur_len;
	int ret = 0;

	if (left < cmd->pdu_len) {
		job_buf = realloc(job_buf, job_max_len + 2 * cmd->pdu_len);
		job_max_len += 2 * cmd->pdu_len;
	}

	memcpy(job_buf + job_cur_len, cmd->payload, cmd->pdu_len);
	job_cur_len += cmd->pdu_len;

	/*
	 * More data coming for this job
	 */
	if (cmd->flags & FIO_NET_CMD_F_MORE)
		return 0;

	parse_jobs_ini(job_buf, 1, 0);
	ret = exec_run();
	send_quit_command();
	reset_fio_state();
	free(job_buf);
	job_buf = NULL;
	job_cur_len = job_max_len = 0;
	return ret;
}

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

	switch (cmd->opcode) {
	case FIO_NET_CMD_QUIT:
		exit_backend = 1;
		return 1;
	case FIO_NET_CMD_ACK:
		return 0;
	case FIO_NET_CMD_NAK:
		return 1;
	case FIO_NET_CMD_JOB:
		ret = handle_cur_job(cmd);
		break;
	default:
		log_err("fio: unknown opcode: %d\n", cmd->opcode);
		ret = 1;
	}

	return ret;
}

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

	/* read forever */
	while (!exit_backend) {
		cmd = fio_net_cmd_read(sk);
		if (!cmd) {
			ret = 1;
			break;
		}

		ret = ack_command(sk, cmd);
		if (ret)
			break;

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

		free(cmd);
	}

	if (cmd)
		free(cmd);

	return ret;
}

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

	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, &addr, &len);
	if (sk < 0) {
		log_err("fio: accept: %s\n", strerror(errno));
		return -1;
	}

	server_fd = sk;

	exitval = handle_connection(sk);

	server_fd = -1;
	close(sk);

	if (!exit_backend)
		goto again;

out:
	return exitval;
}

int fio_server(void)
{
	struct sockaddr_in saddr_in;
	struct sockaddr addr;
	unsigned int len;
	int sk, opt, ret;

	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));
		return -1;
	}
#ifdef SO_REUSEPORT
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
		log_err("fio: setsockopt: %s\n", strerror(errno));
		return 1;
	}
#endif

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

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

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

	len = sizeof(addr);
	if (getsockname(sk, &addr, &len) < 0) {
		log_err("fio: getsockname: %s\n", strerror(errno));
		return -1;
	}

	ret = accept_loop(sk);
	close(sk);
	return ret;
}

int fio_server_text_output(const char *buf, unsigned int len)
{
	return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len);
}

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

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

	return fio_server_text_output(buffer, len);
}
Commit	Line	Data
50d16976 JA	1	#include <stdio.h>
50d16976 JA	2	#include <stdlib.h>
142575e6	3	#include <stdarg.h>
50d16976 JA	4	#include <unistd.h>
50d16976 JA	5	#include <limits.h>
50d16976 JA	6	#include <errno.h>
	7	#include <fcntl.h>
	8	#include <sys/poll.h>
50d16976 JA	9	#include <sys/types.h>
50d16976 JA	10	#include <sys/wait.h>
50d16976	11	#include <sys/mman.h>
50d16976 JA	12	#include <netinet/in.h>
	13	#include <arpa/inet.h>
	14	#include <netdb.h>
	15
	16	#include "fio.h"
132159a5	17	#include "server.h"
fcee5ff6	18	#include "crc/crc16.h"
50d16976	19
132159a5	20	int fio_net_port = 8765;
50d16976	21
009b1be4 JA	22	int exit_backend = 0;
009b1be4 JA	23
132159a5 JA	24	static char *job_buf;
	25	static unsigned int job_cur_len;
	26	static unsigned int job_max_len;
	27
37db14fe JA	28	static int server_fd;
37db14fe JA	29
132159a5 JA	30	int fio_send_data(int sk, const void *p, unsigned int len)
132159a5 JA	31	{
794d69ca JA	32	assert(len <= sizeof(struct fio_net_cmd) + FIO_SERVER_MAX_PDU);
794d69ca JA	33
132159a5 JA	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	{
fcee5ff6	80	uint16_t crc;
132159a5	81
fcee5ff6 JA	82	cmd->cmd_crc16 = le16_to_cpu(cmd->cmd_crc16);
fcee5ff6 JA	83	cmd->pdu_crc16 = le16_to_cpu(cmd->pdu_crc16);
132159a5	84
fcee5ff6 JA	85	crc = crc16(cmd, FIO_NET_CMD_CRC_SZ);
fcee5ff6 JA	86	if (crc != cmd->cmd_crc16) {
132159a5	87	log_err("fio: server bad crc on command (got %x, wanted %x)\n",
fcee5ff6	88	cmd->cmd_crc16, crc);
132159a5 JA	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
37db14fe	114	struct fio_net_cmd *fio_net_cmd_read(int sk)
132159a5 JA	115	{
132159a5 JA	116	struct fio_net_cmd cmd, *ret = NULL;
fcee5ff6	117	uint16_t crc;
132159a5 JA	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 */
fcee5ff6 JA	140	crc = crc16(ret->payload, ret->pdu_len);
fcee5ff6 JA	141	if (crc != ret->pdu_crc16) {
132159a5	142	log_err("fio: server bad crc on payload (got %x, wanted %x)\n",
fcee5ff6	143	ret->pdu_crc16, crc);
132159a5 JA	144	free(ret);
	145	return NULL;
	146	}
	147
132159a5 JA	148	return ret;
	149	}
	150
	151	void fio_net_cmd_crc(struct fio_net_cmd *cmd)
	152	{
	153	uint32_t pdu_len;
	154
fcee5ff6	155	cmd->cmd_crc16 = cpu_to_le16(crc16(cmd, FIO_NET_CMD_CRC_SZ));
132159a5 JA	156
	157	pdu_len = le32_to_cpu(cmd->pdu_len);
	158	if (pdu_len)
fcee5ff6	159	cmd->pdu_crc16 = cpu_to_le16(crc16(cmd->payload, pdu_len));
132159a5 JA	160	}
132159a5 JA	161
794d69ca JA	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
132159a5 JA	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),
bdab4441	196	.serial = cpu_to_le64(serial),
132159a5 JA	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	{
fcee5ff6	209	#if 0
132159a5	210	return send_simple_command(sk, FIO_NET_CMD_ACK, cmd->serial);
fcee5ff6 JA	211	#else
	212	return 0;
	213	#endif
132159a5 JA	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
437377e1 JA	223	static int send_quit_command(void)
	224	{
	225	return send_simple_command(server_fd, FIO_NET_CMD_QUIT, 0);
	226	}
	227
794d69ca	228	static int handle_cur_job(struct fio_net_cmd *cmd)
132159a5 JA	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
794d69ca JA	241	/*
	242	* More data coming for this job
	243	*/
	244	if (cmd->flags & FIO_NET_CMD_F_MORE)
	245	return 0;
132159a5	246
794d69ca JA	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;
132159a5 JA	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:
794d69ca	270	ret = handle_cur_job(cmd);
132159a5 JA	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) {
37db14fe	287	cmd = fio_net_cmd_read(sk);
132159a5 JA	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
50d16976 JA	310	static int accept_loop(int listen_sk)
	311	{
	312	struct sockaddr addr;
	313	unsigned int len = sizeof(addr);
009b1be4	314	struct pollfd pfd;
132159a5	315	int ret, sk, flags, exitval = 0;
50d16976	316
009b1be4 JA	317	flags = fcntl(listen_sk, F_GETFL);
	318	flags \|= O_NONBLOCK;
	319	fcntl(listen_sk, F_SETFL, flags);
50d16976	320	again:
009b1be4 JA	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;
fcee5ff6	328	log_err("fio: poll: %s\n", strerror(errno));
009b1be4 JA	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
50d16976	340	sk = accept(listen_sk, &addr, &len);
50d16976	341	if (sk < 0) {
690e09ae	342	log_err("fio: accept: %s\n", strerror(errno));
50d16976 JA	343	return -1;
	344	}
	345
37db14fe JA	346	server_fd = sk;
37db14fe JA	347
132159a5	348	exitval = handle_connection(sk);
50d16976	349
37db14fe	350	server_fd = -1;
50d16976	351	close(sk);
5c341e9a	352
009b1be4	353	if (!exit_backend)
5c341e9a JA	354	goto again;
5c341e9a JA	355
009b1be4	356	out:
132159a5	357	return exitval;
50d16976 JA	358	}
	359
	360	int fio_server(void)
	361	{
	362	struct sockaddr_in saddr_in;
	363	struct sockaddr addr;
	364	unsigned int len;
afcf7758	365	int sk, opt, ret;
50d16976 JA	366
	367	sk = socket(AF_INET, SOCK_STREAM, 0);
	368	if (sk < 0) {
690e09ae	369	log_err("fio: socket: %s\n", strerror(errno));
50d16976 JA	370	return -1;
	371	}
	372
	373	opt = 1;
	374	if (setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
690e09ae	375	log_err("fio: setsockopt: %s\n", strerror(errno));
50d16976 JA	376	return -1;
	377	}
	378	#ifdef SO_REUSEPORT
	379	if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &opt, sizeof(opt)) < 0) {
690e09ae	380	log_err("fio: setsockopt: %s\n", strerror(errno));
50d16976 JA	381	return 1;
	382	}
	383	#endif
	384
	385	saddr_in.sin_family = AF_INET;
	386	saddr_in.sin_addr.s_addr = htonl(INADDR_ANY);
132159a5	387	saddr_in.sin_port = htons(fio_net_port);
50d16976 JA	388
50d16976 JA	389	if (bind(sk, (struct sockaddr *) &saddr_in, sizeof(saddr_in)) < 0) {
690e09ae	390	log_err("fio: bind: %s\n", strerror(errno));
50d16976 JA	391	return -1;
	392	}
	393
	394	if (listen(sk, 1) < 0) {
690e09ae	395	log_err("fio: listen: %s\n", strerror(errno));
50d16976 JA	396	return -1;
	397	}
	398
	399	len = sizeof(addr);
	400	if (getsockname(sk, &addr, &len) < 0) {
690e09ae	401	log_err("fio: getsockname: %s\n", strerror(errno));
50d16976 JA	402	return -1;
	403	}
	404
afcf7758 JA	405	ret = accept_loop(sk);
	406	close(sk);
	407	return ret;
50d16976	408	}
37db14fe	409
142575e6	410	int fio_server_text_output(const char *buf, unsigned int len)
37db14fe	411	{
794d69ca	412	return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len);
142575e6 JA	413	}
	414
	415	int fio_server_log(const char *format, ...)
	416	{
	417	char buffer[1024];
	418	va_list args;
82fa6b21	419	size_t len;
142575e6 JA	420
142575e6 JA	421	va_start(args, format);
82fa6b21	422	len = vsnprintf(buffer, sizeof(buffer), format, args);
142575e6 JA	423	va_end(args);
142575e6 JA	424
82fa6b21	425	return fio_server_text_output(buffer, len);
37db14fe	426	}