X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=client.c;h=f1675492a6d38775f56aeb99ae91041d67b7b70d;hp=76935ca597b2fd6b17ec2aaa304ccaaa596771a6;hb=52c580272d87d2b9b8a65d317bf7c2d432a30fec;hpb=af9c9fb34e420fc4d9cf317aa0f3cf6795a5a07f

diff --git a/client.c b/client.c
index 76935ca5..f1675492 100644
--- a/client.c
+++ b/client.c
@@ -20,11 +20,20 @@
 #include "flist.h"
 #include "hash.h"
 
+struct client_eta {
+	struct jobs_eta eta;
+	unsigned int pending;
+};
+
 struct fio_client {
 	struct flist_head list;
 	struct flist_head hash_list;
-	struct sockaddr_in addr;
-	struct sockaddr_un addr_un;
+	struct flist_head arg_list;
+	union {
+		struct sockaddr_in addr;
+		struct sockaddr_in6 addr6;
+		struct sockaddr_un addr_un;
+	};
 	char *hostname;
 	int port;
 	int fd;
@@ -35,7 +44,15 @@ struct fio_client {
 
 	int skip_newline;
 	int is_sock;
-	int waiting_eta;
+	int disk_stats_shown;
+	unsigned int jobs;
+	int error;
+	int ipv6;
+
+	struct flist_head eta_list;
+	struct client_eta *eta_in_flight;
+
+	struct flist_head cmd_list;
 
 	uint16_t argc;
 	char **argv;
@@ -47,16 +64,20 @@ enum {
 	Client_created		= 0,
 	Client_connected	= 1,
 	Client_started		= 2,
-	Client_stopped		= 3,
-	Client_exited		= 4,
-};
-
-struct client_eta {
-	struct jobs_eta eta;
-	unsigned int pending;
+	Client_running		= 3,
+	Client_stopped		= 4,
+	Client_exited		= 5,
 };
 
 static FLIST_HEAD(client_list);
+static FLIST_HEAD(eta_list);
+
+static FLIST_HEAD(arg_list);
+
+static struct thread_stat client_ts;
+static struct group_run_stats client_gs;
+static int sum_stat_clients;
+static int sum_stat_nr;
 
 #define FIO_CLIENT_HASH_BITS	7
 #define FIO_CLIENT_HASH_SZ	(1 << FIO_CLIENT_HASH_BITS)
@@ -64,6 +85,7 @@ static FLIST_HEAD(client_list);
 static struct flist_head client_hash[FIO_CLIENT_HASH_SZ];
 
 static int handle_client(struct fio_client *client);
+static void dec_jobs_eta(struct client_eta *eta);
 
 static void fio_client_add_hash(struct fio_client *client)
 {
@@ -110,7 +132,10 @@ static void remove_client(struct fio_client *client)
 
 	fio_client_remove_hash(client);
 
-	/* FIXME: check ->waiting_eta and handle it */
+	if (!flist_empty(&client->eta_list)) {
+		flist_del_init(&client->eta_list);
+		dec_jobs_eta(client->eta_in_flight);
+	}
 
 	free(client->hostname);
 	if (client->argv)
@@ -120,6 +145,7 @@ static void remove_client(struct fio_client *client)
 
 	free(client);
 	nr_clients--;
+	sum_stat_clients--;
 }
 
 static void __fio_client_add_cmd_option(struct fio_client *client,
@@ -136,26 +162,55 @@ static void __fio_client_add_cmd_option(struct fio_client *client,
 void fio_client_add_cmd_option(void *cookie, const char *opt)
 {
 	struct fio_client *client = cookie;
+	struct flist_head *entry;
 
 	if (!client || !opt)
 		return;
 
 	__fio_client_add_cmd_option(client, opt);
+
+	/*
+	 * Duplicate arguments to shared client group
+	 */
+	flist_for_each(entry, &arg_list) {
+		client = flist_entry(entry, struct fio_client, arg_list);
+
+		__fio_client_add_cmd_option(client, opt);
+	}
 }
 
 int fio_client_add(const char *hostname, void **cookie)
 {
+	struct fio_client *existing = *cookie;
 	struct fio_client *client;
 
+	if (existing) {
+		/*
+		 * We always add our "exec" name as the option, hence 1
+		 * means empty.
+		 */
+		if (existing->argc == 1)
+			flist_add_tail(&existing->arg_list, &arg_list);
+		else {
+			while (!flist_empty(&arg_list))
+				flist_del_init(arg_list.next);
+		}
+	}
+
 	client = malloc(sizeof(*client));
 	memset(client, 0, sizeof(*client));
 
 	INIT_FLIST_HEAD(&client->list);
 	INIT_FLIST_HEAD(&client->hash_list);
+	INIT_FLIST_HEAD(&client->arg_list);
+	INIT_FLIST_HEAD(&client->eta_list);
+	INIT_FLIST_HEAD(&client->cmd_list);
 
 	if (fio_server_parse_string(hostname, &client->hostname,
 					&client->is_sock, &client->port,
-					&client->addr.sin_addr))
+					&client->addr.sin_addr,
+					&client->addr6.sin6_addr,
+					&client->ipv6))
 		return -1;
 
 	client->fd = -1;
@@ -171,18 +226,31 @@ int fio_client_add(const char *hostname, void **cookie)
 
 static int fio_client_connect_ip(struct fio_client *client)
 {
-	int fd;
-
-	client->addr.sin_family = AF_INET;
-	client->addr.sin_port = htons(client->port);
+	struct sockaddr *addr;
+	fio_socklen_t socklen;
+	int fd, domain;
+
+	if (client->ipv6) {
+		client->addr6.sin6_family = AF_INET6;
+		client->addr6.sin6_port = htons(client->port);
+		domain = AF_INET6;
+		addr = (struct sockaddr *) &client->addr6;
+		socklen = sizeof(client->addr6);
+	} else {
+		client->addr.sin_family = AF_INET;
+		client->addr.sin_port = htons(client->port);
+		domain = AF_INET;
+		addr = (struct sockaddr *) &client->addr;
+		socklen = sizeof(client->addr);
+	}
 
-	fd = socket(AF_INET, SOCK_STREAM, 0);
+	fd = socket(domain, SOCK_STREAM, 0);
 	if (fd < 0) {
 		log_err("fio: socket: %s\n", strerror(errno));
 		return -1;
 	}
 
-	if (connect(fd, (struct sockaddr *) &client->addr, sizeof(client->addr)) < 0) {
+	if (connect(fd, addr, socklen) < 0) {
 		log_err("fio: connect: %s\n", strerror(errno));
 		log_err("fio: failed to connect to %s:%u\n", client->hostname,
 								client->port);
@@ -230,6 +298,8 @@ static int fio_client_connect(struct fio_client *client)
 	else
 		fd = fio_client_connect_ip(client);
 
+	dprint(FD_NET, "client: %s connected %d\n", client->hostname, fd);
+
 	if (fd < 0)
 		return 1;
 
@@ -249,7 +319,7 @@ void fio_clients_terminate(void)
 	flist_for_each(entry, &client_list) {
 		client = flist_entry(entry, struct fio_client, list);
 
-		fio_net_send_simple_cmd(client->fd, FIO_NET_CMD_QUIT, 0);
+		fio_net_send_simple_cmd(client->fd, FIO_NET_CMD_QUIT, 0, NULL);
 	}
 }
 
@@ -278,8 +348,7 @@ static void probe_client(struct fio_client *client)
 {
 	dprint(FD_NET, "client: send probe\n");
 
-	fio_net_send_simple_cmd(client->fd, FIO_NET_CMD_PROBE, 0);
-	handle_client(client);
+	fio_net_send_simple_cmd(client->fd, FIO_NET_CMD_PROBE, 0, &client->cmd_list);
 }
 
 static int send_client_cmd_line(struct fio_client *client)
@@ -287,17 +356,22 @@ static int send_client_cmd_line(struct fio_client *client)
 	struct cmd_single_line_pdu *cslp;
 	struct cmd_line_pdu *clp;
 	unsigned long offset;
+	unsigned int *lens;
 	void *pdu;
 	size_t mem;
 	int i, ret;
 
 	dprint(FD_NET, "client: send cmdline %d\n", client->argc);
 
+	lens = malloc(client->argc * sizeof(unsigned int));
+
 	/*
 	 * Find out how much mem we need
 	 */
-	for (i = 0, mem = 0; i < client->argc; i++)
-		mem += strlen(client->argv[i]) + 1;
+	for (i = 0, mem = 0; i < client->argc; i++) {
+		lens[i] = strlen(client->argv[i]) + 1;
+		mem += lens[i];
+	}
 
 	/*
 	 * We need one cmd_line_pdu, and argc number of cmd_single_line_pdu
@@ -309,7 +383,7 @@ static int send_client_cmd_line(struct fio_client *client)
 	offset = sizeof(*clp);
 
 	for (i = 0; i < client->argc; i++) {
-		uint16_t arg_len = strlen(client->argv[i]) + 1;
+		uint16_t arg_len = lens[i];
 
 		cslp = pdu + offset;
 		strcpy((char *) cslp->text, client->argv[i]);
@@ -317,6 +391,7 @@ static int send_client_cmd_line(struct fio_client *client)
 		offset += sizeof(*cslp) + arg_len;
 	}
 
+	free(lens);
 	clp->lines = cpu_to_le16(client->argc);
 	ret = fio_net_send_cmd(client->fd, FIO_NET_CMD_JOBLINE, pdu, mem, 0);
 	free(pdu);
@@ -525,6 +600,20 @@ static void handle_ts(struct fio_net_cmd *cmd)
 	convert_gs(&p->rs, &p->rs);
 
 	show_thread_status(&p->ts, &p->rs);
+
+	if (sum_stat_clients == 1)
+		return;
+
+	sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
+	sum_group_stats(&client_gs, &p->rs);
+
+	client_ts.members++;
+	client_ts.groupid = p->ts.groupid;
+
+	if (++sum_stat_nr == sum_stat_clients) {
+		strcpy(client_ts.name, "All clients");
+		show_thread_status(&client_ts, &client_gs);
+	}
 }
 
 static void handle_gs(struct fio_net_cmd *cmd)
@@ -535,6 +624,54 @@ static void handle_gs(struct fio_net_cmd *cmd)
 	show_group_stats(gs);
 }
 
+static void convert_agg(struct disk_util_agg *agg)
+{
+	int i;
+
+	for (i = 0; i < 2; i++) {
+		agg->ios[i]	= le32_to_cpu(agg->ios[i]);
+		agg->merges[i]	= le32_to_cpu(agg->merges[i]);
+		agg->sectors[i]	= le64_to_cpu(agg->sectors[i]);
+		agg->ticks[i]	= le32_to_cpu(agg->ticks[i]);
+	}
+
+	agg->io_ticks		= le32_to_cpu(agg->io_ticks);
+	agg->time_in_queue	= le32_to_cpu(agg->time_in_queue);
+	agg->slavecount		= le32_to_cpu(agg->slavecount);
+	agg->max_util.u.f	= fio_uint64_to_double(__le64_to_cpu(agg->max_util.u.i));
+}
+
+static void convert_dus(struct disk_util_stat *dus)
+{
+	int i;
+
+	for (i = 0; i < 2; i++) {
+		dus->ios[i]	= le32_to_cpu(dus->ios[i]);
+		dus->merges[i]	= le32_to_cpu(dus->merges[i]);
+		dus->sectors[i]	= le64_to_cpu(dus->sectors[i]);
+		dus->ticks[i]	= le32_to_cpu(dus->ticks[i]);
+	}
+
+	dus->io_ticks		= le32_to_cpu(dus->io_ticks);
+	dus->time_in_queue	= le32_to_cpu(dus->time_in_queue);
+	dus->msec		= le64_to_cpu(dus->msec);
+}
+
+static void handle_du(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+	struct cmd_du_pdu *du = (struct cmd_du_pdu *) cmd->payload;
+
+	convert_dus(&du->dus);
+	convert_agg(&du->agg);
+
+	if (!client->disk_stats_shown) {
+		client->disk_stats_shown = 1;
+		log_info("\nDisk stats (read/write):\n");
+	}
+
+	print_disk_util(&du->dus, &du->agg, terse_output);
+}
+
 static void convert_jobs_eta(struct jobs_eta *je)
 {
 	int i;
@@ -581,26 +718,60 @@ static void sum_jobs_eta(struct jobs_eta *dst, struct jobs_eta *je)
 		dst->eta_sec = je->eta_sec;
 }
 
-static void handle_eta(struct fio_net_cmd *cmd)
+static void dec_jobs_eta(struct client_eta *eta)
+{
+	if (!--eta->pending) {
+		display_thread_status(&eta->eta);
+		free(eta);
+	}
+}
+
+static void remove_reply_cmd(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+	struct fio_net_int_cmd *icmd = NULL;
+	struct flist_head *entry;
+
+	flist_for_each(entry, &client->cmd_list) {
+		icmd = flist_entry(entry, struct fio_net_int_cmd, list);
+
+		if (cmd->tag == (uintptr_t) icmd)
+			break;
+
+		icmd = NULL;
+	}
+
+	if (!icmd) {
+		log_err("fio: client: unable to find matching tag\n");
+		return;
+	}
+
+	flist_del(&icmd->list);
+	cmd->tag = icmd->saved_tag;
+	free(icmd);
+}
+
+static void handle_eta(struct fio_client *client, struct fio_net_cmd *cmd)
 {
 	struct jobs_eta *je = (struct jobs_eta *) cmd->payload;
-	struct client_eta *eta = (struct client_eta *) cmd->tag;
+	struct client_eta *eta = (struct client_eta *) (uintptr_t) cmd->tag;
 
 	dprint(FD_NET, "client: got eta tag %p, %d\n", eta, eta->pending);
 
+	assert(client->eta_in_flight == eta);
+
+	client->eta_in_flight = NULL;
+	flist_del_init(&client->eta_list);
+
 	convert_jobs_eta(je);
 	sum_jobs_eta(&eta->eta, je);
-
-	if (!--eta->pending) {
-		display_thread_status(&eta->eta);
-		free(eta);
-	}
+	dec_jobs_eta(eta);
 }
 
 static void handle_probe(struct fio_client *client, struct fio_net_cmd *cmd)
 {
 	struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
 	const char *os, *arch;
+	char bit[16];
 
 	os = fio_get_os_string(probe->os);
 	if (!os)
@@ -610,14 +781,35 @@ static void handle_probe(struct fio_client *client, struct fio_net_cmd *cmd)
 	if (!arch)
 		os = "unknown";
 
-	log_info("hostname=%s, be=%u, os=%s, arch=%s, fio=%u.%u.%u\n",
-		probe->hostname, probe->bigendian, os, arch, probe->fio_major,
-		probe->fio_minor, probe->fio_patch);
+	sprintf(bit, "%d-bit", probe->bpp * 8);
+
+	log_info("hostname=%s, be=%u, %s, os=%s, arch=%s, fio=%u.%u.%u\n",
+		probe->hostname, probe->bigendian, bit, os, arch,
+		probe->fio_major, probe->fio_minor, probe->fio_patch);
 
 	if (!client->name)
 		client->name = strdup((char *) probe->hostname);
 }
 
+static void handle_start(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+	struct cmd_start_pdu *pdu = (struct cmd_start_pdu *) cmd->payload;
+
+	client->state = Client_started;
+	client->jobs = le32_to_cpu(pdu->jobs);
+}
+
+static void handle_stop(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+	struct cmd_end_pdu *pdu = (struct cmd_end_pdu *) cmd->payload;
+
+	client->state = Client_stopped;
+	client->error = le32_to_cpu(pdu->error);
+
+	if (client->error)
+		log_info("client <%s>: exited with error %d\n", client->hostname, client->error);
+}
+
 static int handle_client(struct fio_client *client)
 {
 	struct fio_net_cmd *cmd;
@@ -628,8 +820,8 @@ static int handle_client(struct fio_client *client)
 	if (!cmd)
 		return 0;
 
-	dprint(FD_NET, "client: got cmd op %d from %s\n",
-					cmd->opcode, client->hostname);
+	dprint(FD_NET, "client: got cmd op %s from %s\n",
+				fio_server_op(cmd->opcode), client->hostname);
 
 	switch (cmd->opcode) {
 	case FIO_NET_CMD_QUIT:
@@ -651,6 +843,10 @@ static int handle_client(struct fio_client *client)
 		free(cmd);
 		break;
 		}
+	case FIO_NET_CMD_DU:
+		handle_du(client, cmd);
+		free(cmd);
+		break;
 	case FIO_NET_CMD_TS:
 		handle_ts(cmd);
 		free(cmd);
@@ -660,23 +856,29 @@ static int handle_client(struct fio_client *client)
 		free(cmd);
 		break;
 	case FIO_NET_CMD_ETA:
-		handle_eta(cmd);
+		remove_reply_cmd(client, cmd);
+		handle_eta(client, cmd);
 		free(cmd);
 		break;
 	case FIO_NET_CMD_PROBE:
+		remove_reply_cmd(client, cmd);
 		handle_probe(client, cmd);
 		free(cmd);
 		break;
+	case FIO_NET_CMD_RUN:
+		client->state = Client_running;
+		free(cmd);
+		break;
 	case FIO_NET_CMD_START:
-		client->state = Client_started;
+		handle_start(client, cmd);
 		free(cmd);
 		break;
 	case FIO_NET_CMD_STOP:
-		client->state = Client_stopped;
+		handle_stop(client, cmd);
 		free(cmd);
 		break;
 	default:
-		log_err("fio: unknown client op: %d\n", cmd->opcode);
+		log_err("fio: unknown client op: %s\n", fio_server_op(cmd->opcode));
 		free(cmd);
 		break;
 	}
@@ -689,15 +891,10 @@ static void request_client_etas(void)
 	struct fio_client *client;
 	struct flist_head *entry;
 	struct client_eta *eta;
+	int skipped = 0;
 
 	dprint(FD_NET, "client: request eta (%d)\n", nr_clients);
 
-	/*
-	 * We need to do something more clever about checking status
-	 * of command being send, client haven't sent previous ETA
-	 * already, etc.
-	 */
-
 	eta = malloc(sizeof(*eta));
 	memset(&eta->eta, 0, sizeof(eta->eta));
 	eta->pending = nr_clients;
@@ -705,25 +902,90 @@ static void request_client_etas(void)
 	flist_for_each(entry, &client_list) {
 		client = flist_entry(entry, struct fio_client, list);
 
-		client->waiting_eta = 1;
+		if (!flist_empty(&client->eta_list)) {
+			skipped++;
+			continue;
+		}
+		if (client->state != Client_running)
+			continue;
+
+		assert(!client->eta_in_flight);
+		flist_add_tail(&client->eta_list, &eta_list);
+		client->eta_in_flight = eta;
 		fio_net_send_simple_cmd(client->fd, FIO_NET_CMD_SEND_ETA,
-						(uint64_t) eta);
+					(uintptr_t) eta, &client->cmd_list);
 	}
 
+	while (skipped--)
+		dec_jobs_eta(eta);
+
 	dprint(FD_NET, "client: requested eta tag %p\n", eta);
 }
 
+static int client_check_cmd_timeout(struct fio_client *client,
+				    struct timeval *now)
+{
+	struct fio_net_int_cmd *cmd;
+	struct flist_head *entry, *tmp;
+	int ret = 0;
+
+	flist_for_each_safe(entry, tmp, &client->cmd_list) {
+		cmd = flist_entry(entry, struct fio_net_int_cmd, list);
+
+		if (mtime_since(&cmd->tv, now) < FIO_NET_CLIENT_TIMEOUT)
+			continue;
+
+		log_err("fio: client %s, timeout on cmd %s\n", client->hostname,
+						fio_server_op(cmd->cmd.opcode));
+		flist_del(&cmd->list);
+		free(cmd);
+		ret = 1;
+	}
+
+	return flist_empty(&client->cmd_list) && ret;
+}
+
+static int fio_client_timed_out(void)
+{
+	struct fio_client *client;
+	struct flist_head *entry, *tmp;
+	struct timeval tv;
+	int ret = 0;
+
+	gettimeofday(&tv, NULL);
+
+	flist_for_each_safe(entry, tmp, &client_list) {
+		client = flist_entry(entry, struct fio_client, list);
+
+		if (flist_empty(&client->cmd_list))
+			continue;
+
+		if (!client_check_cmd_timeout(client, &tv))
+			continue;
+
+		log_err("fio: client %s timed out\n", client->hostname);
+		remove_client(client);
+		ret = 1;
+	}
+
+	return ret;
+}
+
 int fio_handle_clients(void)
 {
 	struct fio_client *client;
 	struct flist_head *entry;
 	struct pollfd *pfds;
-	int i, ret = 0;
+	int i, ret = 0, retval = 0;
 
 	gettimeofday(&eta_tv, NULL);
 
 	pfds = malloc(nr_clients * sizeof(struct pollfd));
 
+	sum_stat_clients = nr_clients;
+	init_thread_stat(&client_ts);
+	init_group_run_stat(&client_gs);
+
 	while (!exit_backend && nr_clients) {
 		i = 0;
 		flist_for_each(entry, &client_list) {
@@ -743,6 +1005,9 @@ int fio_handle_clients(void)
 			if (mtime_since(&eta_tv, &tv) >= 900) {
 				request_client_etas();
 				memcpy(&eta_tv, &tv, sizeof(tv));
+
+				if (fio_client_timed_out())
+					break;
 			}
 
 			ret = poll(pfds, nr_clients, 100);
@@ -768,10 +1033,12 @@ int fio_handle_clients(void)
 				log_info("client: host=%s disconnected\n",
 						client->hostname);
 				remove_client(client);
-			}
+				retval = 1;
+			} else if (client->error)
+				retval = 1;
 		}
 	}
 
 	free(pfds);
-	return 0;
+	return retval;
 }