[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 <syslog.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 = -1;

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)
{
	dprint(FD_NET, "server: sending quit\n");
	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;

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

	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);
		cmd = NULL;
	}

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

	dprint(FD_NET, "server got a connection\n");

	server_fd = sk;

	exitval = handle_connection(sk);

	server_fd = -1;
	close(sk);

	if (!exit_backend)
		goto again;

out:
	return exitval;
}

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

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

	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)
{
	if (server_fd != -1)
		return fio_net_send_cmd(server_fd, FIO_NET_CMD_TEXT, buf, len);

	return 0;
}

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);
}

int fio_start_server(int daemonize)
{
	pid_t pid;

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