Commit 905b8615 authored by David Howells's avatar David Howells
Browse files

afs: Rename some fields 



Rename the ->index and ->untried fields of the afs_vl_cursor and
afs_operation struct to ->server_index and ->untried_servers to avoid
confusion with address iteration fields when those get folded in.

Signed-off-by: default avatarDavid Howells <dhowells@redhat.com>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org
parent 1e5d8493

fs/afs/internal.h

+4 −4
Original line number Diff line number Diff line
@@ -747,11 +747,11 @@ struct afs_vl_cursor { 
	struct afs_vlserver_list *server_list;	/* Current server list (pins ref) */

	struct afs_vlserver	*server;	/* Server on which this resides */

	struct key		*key;		/* Key for the server */

	unsigned long		untried;	/* Bitmask of untried servers */

	unsigned long		untried_servers; /* Bitmask of untried servers */

	struct afs_error	cumul_error;	/* Cumulative error */

	s32			call_abort_code;

	short			index;		/* Current server */

	short			call_error;	/* Error from single call */

	short			server_index;	/* Current server */

	unsigned short		flags;

#define AFS_VL_CURSOR_STOP	0x0001		/* Set to cease iteration */

#define AFS_VL_CURSOR_RETRY	0x0002		/* Set to do a retry */
@@ -864,8 +864,8 @@ struct afs_operation { 
	struct afs_server_list	*server_list;	/* Current server list (pins ref) */

	struct afs_server	*server;	/* Server we're using (ref pinned by server_list) */

	struct afs_call		*call;

	unsigned long		untried;	/* Bitmask of untried servers */

	short			index;		/* Current server */

	unsigned long		untried_servers; /* Bitmask of untried servers */

	short			server_index;	/* Current server */

	short			nr_iterations;	/* Number of server iterations */

	bool			call_responded;	/* T if the current address responded */

fs/afs/rotate.c

+18 −18
Original line number Diff line number Diff line
@@ -32,8 +32,8 @@ static bool afs_start_fs_iteration(struct afs_operation *op, 
					  lockdep_is_held(&op->volume->servers_lock)));

	read_unlock(&op->volume->servers_lock);



	op->untried = (1UL << op->server_list->nr_servers) - 1;

	op->index = READ_ONCE(op->server_list->preferred);

	op->untried_servers = (1UL << op->server_list->nr_servers) - 1;

	op->server_index = READ_ONCE(op->server_list->preferred);



	cb_server = vnode->cb_server;

	if (cb_server) {
@@ -41,7 +41,7 @@ static bool afs_start_fs_iteration(struct afs_operation *op, 
		for (i = 0; i < op->server_list->nr_servers; i++) {

			server = op->server_list->servers[i].server;

			if (server == cb_server) {

				op->index = i;

				op->server_index = i;

				goto found_interest;

			}

		}
@@ -120,7 +120,7 @@ bool afs_select_fileserver(struct afs_operation *op) 


	_enter("OP=%x+%x,%llx,%lx[%d],%lx[%d],%d,%d",

	       op->debug_id, op->nr_iterations, op->volume->vid,

	       op->untried, op->index,

	       op->untried_servers, op->server_index,

	       op->ac.tried, op->ac.index,

	       error, abort_code);
@@ -172,7 +172,7 @@ bool afs_select_fileserver(struct afs_operation *op) 
			}



			write_lock(&op->volume->servers_lock);

			op->server_list->vnovol_mask |= 1 << op->index;

			op->server_list->vnovol_mask |= 1 << op->server_index;

			write_unlock(&op->volume->servers_lock);



			set_bit(AFS_VOLUME_NEEDS_UPDATE, &op->volume->flags);
@@ -419,9 +419,9 @@ bool afs_select_fileserver(struct afs_operation *op) 
	_debug("__ VOL %llx __", op->volume->vid);



pick_server:

	_debug("pick [%lx]", op->untried);

	_debug("pick [%lx]", op->untried_servers);



	error = afs_wait_for_fs_probes(op->server_list, op->untried);

	error = afs_wait_for_fs_probes(op->server_list, op->untried_servers);

	if (error < 0) {

		afs_op_set_error(op, error);

		goto failed;
@@ -431,40 +431,40 @@ bool afs_select_fileserver(struct afs_operation *op) 
	 * callbacks, we stick with the server we're already using if we can.

	 */

	if (op->server) {

		_debug("server %u", op->index);

		if (test_bit(op->index, &op->untried))

		_debug("server %u", op->server_index);

		if (test_bit(op->server_index, &op->untried_servers))

			goto selected_server;

		op->server = NULL;

		_debug("no server");

	}



	op->index = -1;

	op->server_index = -1;

	rtt = UINT_MAX;

	for (i = 0; i < op->server_list->nr_servers; i++) {

		struct afs_server *s = op->server_list->servers[i].server;



		if (!test_bit(i, &op->untried) ||

		if (!test_bit(i, &op->untried_servers) ||

		    !test_bit(AFS_SERVER_FL_RESPONDING, &s->flags))

			continue;

		if (s->probe.rtt <= rtt) {

			op->index = i;

			op->server_index = i;

			rtt = s->probe.rtt;

		}

	}



	if (op->index == -1)

	if (op->server_index == -1)

		goto no_more_servers;



selected_server:

	_debug("use %d", op->index);

	__clear_bit(op->index, &op->untried);

	_debug("use %d", op->server_index);

	__clear_bit(op->server_index, &op->untried_servers);



	/* We're starting on a different fileserver from the list.  We need to

	 * check it, create a callback intercept, find its address list and

	 * probe its capabilities before we use it.

	 */

	ASSERTCMP(op->ac.alist, ==, NULL);

	server = op->server_list->servers[op->index].server;

	server = op->server_list->servers[op->server_index].server;



	if (!afs_check_server_record(op, server))

		goto failed;
@@ -506,7 +506,7 @@ bool afs_select_fileserver(struct afs_operation *op) 
		goto out_of_addresses;



	_debug("address [%u] %u/%u %pISp",

	       op->index, op->ac.index, op->ac.alist->nr_addrs,

	       op->server_index, op->ac.index, op->ac.alist->nr_addrs,

	       rxrpc_kernel_remote_addr(op->ac.alist->addrs[op->ac.index].peer));



	op->call_responded = false;
@@ -581,7 +581,7 @@ void afs_dump_edestaddrreq(const struct afs_operation *op) 
		  op->file[0].cb_break_before,

		  op->file[1].cb_break_before, op->flags, op->cumul_error.error);

	pr_notice("OP: ut=%lx ix=%d ni=%u\n",

		  op->untried, op->index, op->nr_iterations);

		  op->untried_servers, op->server_index, op->nr_iterations);

	pr_notice("OP: call  er=%d ac=%d r=%u\n",

		  op->call_error, op->call_abort_code, op->call_responded);

fs/afs/vl_rotate.c

+16 −16
Original line number Diff line number Diff line
@@ -78,8 +78,8 @@ static bool afs_start_vl_iteration(struct afs_vl_cursor *vc) 
	if (!vc->server_list->nr_servers)

		return false;



	vc->untried = (1UL << vc->server_list->nr_servers) - 1;

	vc->index = -1;

	vc->untried_servers = (1UL << vc->server_list->nr_servers) - 1;

	vc->server_index = -1;

	return true;

}
@@ -98,7 +98,7 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc) 
	vc->nr_iterations++;



	_enter("%lx[%d],%lx[%d],%d,%d",

	       vc->untried, vc->index,

	       vc->untried_servers, vc->server_index,

	       vc->ac.tried, vc->ac.index,

	       error, abort_code);
@@ -131,7 +131,7 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc) 
			/* The server went weird. */

			afs_prioritise_error(&vc->cumul_error, -EREMOTEIO, abort_code);

			//write_lock(&vc->cell->vl_servers_lock);

			//vc->server_list->weird_mask |= 1 << vc->index;

			//vc->server_list->weird_mask |= 1 << vc->server_index;

			//write_unlock(&vc->cell->vl_servers_lock);

			goto next_server;
@@ -184,46 +184,46 @@ bool afs_select_vlserver(struct afs_vl_cursor *vc) 
	}



pick_server:

	_debug("pick [%lx]", vc->untried);

	_debug("pick [%lx]", vc->untried_servers);



	error = afs_wait_for_vl_probes(vc->server_list, vc->untried);

	error = afs_wait_for_vl_probes(vc->server_list, vc->untried_servers);

	if (error < 0) {

		afs_prioritise_error(&vc->cumul_error, error, 0);

		goto failed;

	}



	/* Pick the untried server with the lowest RTT. */

	vc->index = vc->server_list->preferred;

	if (test_bit(vc->index, &vc->untried))

	vc->server_index = vc->server_list->preferred;

	if (test_bit(vc->server_index, &vc->untried_servers))

		goto selected_server;



	vc->index = -1;

	vc->server_index = -1;

	rtt = UINT_MAX;

	for (i = 0; i < vc->server_list->nr_servers; i++) {

		struct afs_vlserver *s = vc->server_list->servers[i].server;



		if (!test_bit(i, &vc->untried) ||

		if (!test_bit(i, &vc->untried_servers) ||

		    !test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))

			continue;

		if (s->probe.rtt <= rtt) {

			vc->index = i;

			vc->server_index = i;

			rtt = s->probe.rtt;

		}

	}



	if (vc->index == -1)

	if (vc->server_index == -1)

		goto no_more_servers;



selected_server:

	_debug("use %d", vc->index);

	__clear_bit(vc->index, &vc->untried);

	_debug("use %d", vc->server_index);

	__clear_bit(vc->server_index, &vc->untried_servers);



	/* We're starting on a different vlserver from the list.  We need to

	 * check it, find its address list and probe its capabilities before we

	 * use it.

	 */

	ASSERTCMP(vc->ac.alist, ==, NULL);

	vlserver = vc->server_list->servers[vc->index].server;

	vlserver = vc->server_list->servers[vc->server_index].server;

	vc->server = vlserver;



	_debug("USING VLSERVER: %s", vlserver->name);
@@ -299,7 +299,7 @@ static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc) 
	pr_notice("DNS: src=%u st=%u lc=%x\n",

		  cell->dns_source, cell->dns_status, cell->dns_lookup_count);

	pr_notice("VC: ut=%lx ix=%u ni=%hu fl=%hx err=%hd\n",

		  vc->untried, vc->index, vc->nr_iterations, vc->flags,

		  vc->untried_servers, vc->server_index, vc->nr_iterations, vc->flags,

		  vc->cumul_error.error);

	pr_notice("VC: call  er=%d ac=%d r=%u\n",

		  vc->call_error, vc->call_abort_code, vc->call_responded);