fs/afs/vl_rotate.c - third_party/linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-or-later
 /* Handle vlserver selection and rotation.
  *
  * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
  */

 #include <linux/kernel.h>
 #include <linux/sched.h>
 #include <linux/sched/signal.h>
 #include "internal.h"
 #include "afs_vl.h"

 /*
  * Begin an operation on a volume location server.
  */
 bool afs_begin_vlserver_operation(struct afs_vl_cursor *vc, struct afs_cell *cell,
 				  struct key *key)
 {
 	static atomic_t debug_ids;

 	memset(vc, 0, sizeof(*vc));
 	vc->cell = cell;
 	vc->key = key;
 	vc->cumul_error.error = -EDESTADDRREQ;
 	vc->nr_iterations = -1;

 	if (signal_pending(current)) {
 		vc->cumul_error.error = -EINTR;
 		vc->flags |= AFS_VL_CURSOR_STOP;
 		return false;
 	}

 	vc->debug_id = atomic_inc_return(&debug_ids);
 	return true;
 }

 /*
  * Begin iteration through a server list, starting with the last used server if
  * possible, or the last recorded good server if not.
  */
 static bool afs_start_vl_iteration(struct afs_vl_cursor *vc)
 {
 	struct afs_cell *cell = vc->cell;
 	unsigned int dns_lookup_count;

 	if (cell->dns_source == DNS_RECORD_UNAVAILABLE ||
 	    cell->dns_expiry <= ktime_get_real_seconds()) {
 		dns_lookup_count = smp_load_acquire(&cell->dns_lookup_count);
 		set_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags);
 		afs_queue_cell(cell, afs_cell_trace_get_queue_dns);

 		if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
 			if (wait_var_event_interruptible(
 				    &cell->dns_lookup_count,
 				    smp_load_acquire(&cell->dns_lookup_count)
 				    != dns_lookup_count) < 0) {
 				vc->cumul_error.error = -ERESTARTSYS;
 				return false;
 			}
 		}

 		/* Status load is ordered after lookup counter load */
 		if (cell->dns_status == DNS_LOOKUP_GOT_NOT_FOUND) {
 			pr_warn("No record of cell %s\n", cell->name);
 			vc->cumul_error.error = -ENOENT;
 			return false;
 		}

 		if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
 			vc->cumul_error.error = -EDESTADDRREQ;
 			return false;
 		}
 	}

 	read_lock(&cell->vl_servers_lock);
 	vc->server_list = afs_get_vlserverlist(
 		rcu_dereference_protected(cell->vl_servers,
 					  lockdep_is_held(&cell->vl_servers_lock)));
 	read_unlock(&cell->vl_servers_lock);
 	if (!vc->server_list->nr_servers)
 		return false;

 	vc->untried_servers = (1UL << vc->server_list->nr_servers) - 1;
 	vc->server_index = -1;
 	return true;
 }

 /*
  * Select the vlserver to use.  May be called multiple times to rotate
  * through the vlservers.
  */
 bool afs_select_vlserver(struct afs_vl_cursor *vc)
 {
 	struct afs_addr_list *alist = vc->alist;
 	struct afs_vlserver *vlserver;
 	unsigned long set, failed;
 	unsigned int rtt;
 	s32 abort_code = vc->call_abort_code;
 	int error = vc->call_error, i;

 	vc->nr_iterations++;

 	_enter("VC=%x+%x,%d{%lx},%d{%lx},%d,%d",
 	       vc->debug_id, vc->nr_iterations, vc->server_index, vc->untried_servers,
 	       vc->addr_index, vc->addr_tried,
 	       error, abort_code);

 	if (vc->flags & AFS_VL_CURSOR_STOP) {
 		_leave(" = f [stopped]");
 		return false;
 	}

 	if (vc->nr_iterations == 0)
 		goto start;

 	WRITE_ONCE(alist->addrs[vc->addr_index].last_error, error);

 	/* Evaluate the result of the previous operation, if there was one. */
 	switch (error) {
 	default:
 	case 0:
 		/* Success or local failure.  Stop. */
 		vc->cumul_error.error = error;
 		vc->flags |= AFS_VL_CURSOR_STOP;
 		_leave(" = f [okay/local %d]", vc->cumul_error.error);
 		return false;

 	case -ECONNABORTED:
 		/* The far side rejected the operation on some grounds.  This
 		 * might involve the server being busy or the volume having been moved.
 		 */
 		switch (abort_code) {
 		case AFSVL_IO:
 		case AFSVL_BADVOLOPER:
 		case AFSVL_NOMEM:
 			/* 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->server_index;
 			//write_unlock(&vc->cell->vl_servers_lock);
 			goto next_server;

 		default:
 			afs_prioritise_error(&vc->cumul_error, error, abort_code);
 			goto failed;
 		}

 	case -ERFKILL:
 	case -EADDRNOTAVAIL:
 	case -ENETUNREACH:
 	case -EHOSTUNREACH:
 	case -EHOSTDOWN:
 	case -ECONNREFUSED:
 	case -ETIMEDOUT:
 	case -ETIME:
 		_debug("no conn %d", error);
 		afs_prioritise_error(&vc->cumul_error, error, 0);
 		goto iterate_address;

 	case -ECONNRESET:
 		_debug("call reset");
 		afs_prioritise_error(&vc->cumul_error, error, 0);
 		vc->flags |= AFS_VL_CURSOR_RETRY;
 		goto next_server;

 	case -EOPNOTSUPP:
 		_debug("notsupp");
 		goto next_server;
 	}

 restart_from_beginning:
 	_debug("restart");
 	if (vc->call_responded &&
 	    vc->addr_index != vc->alist->preferred &&
 	    test_bit(alist->preferred, &vc->addr_tried))
 		WRITE_ONCE(alist->preferred, vc->addr_index);
 	afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_restart);
 	alist = vc->alist = NULL;

 	afs_put_vlserverlist(vc->cell->net, vc->server_list);
 	vc->server_list = NULL;
 	if (vc->flags & AFS_VL_CURSOR_RETRIED)
 		goto failed;
 	vc->flags |= AFS_VL_CURSOR_RETRIED;
 start:
 	_debug("start");
 	ASSERTCMP(alist, ==, NULL);

 	if (!afs_start_vl_iteration(vc))
 		goto failed;

 	error = afs_send_vl_probes(vc->cell->net, vc->key, vc->server_list);
 	if (error < 0) {
 		afs_prioritise_error(&vc->cumul_error, error, 0);
 		goto failed;
 	}

 pick_server:
 	_debug("pick [%lx]", vc->untried_servers);
 	ASSERTCMP(alist, ==, NULL);

 	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->server_index = vc->server_list->preferred;
 	if (test_bit(vc->server_index, &vc->untried_servers))
 		goto selected_server;

 	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_servers) ||
 		    !test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))
 			continue;
 		if (s->probe.rtt <= rtt) {
 			vc->server_index = i;
 			rtt = s->probe.rtt;
 		}
 	}

 	if (vc->server_index == -1)
 		goto no_more_servers;

 selected_server:
 	_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.
 	 */
 	vlserver = vc->server_list->servers[vc->server_index].server;
 	vc->server = vlserver;

 	_debug("USING VLSERVER: %s", vlserver->name);

 	read_lock(&vlserver->lock);
 	alist = rcu_dereference_protected(vlserver->addresses,
 					  lockdep_is_held(&vlserver->lock));
 	vc->alist = afs_get_addrlist(alist, afs_alist_trace_get_vlrotate_set);
 	read_unlock(&vlserver->lock);

 	vc->addr_tried = 0;
 	vc->addr_index = -1;

 iterate_address:
 	/* Iterate over the current server's address list to try and find an
 	 * address on which it will respond to us.
 	 */
 	set = READ_ONCE(alist->responded);
 	failed = READ_ONCE(alist->probe_failed);
 	vc->addr_index = READ_ONCE(alist->preferred);

 	_debug("%lx-%lx-%lx,%d", set, failed, vc->addr_tried, vc->addr_index);

 	set &= ~(failed | vc->addr_tried);

 	if (!set)
 		goto next_server;

 	if (!test_bit(vc->addr_index, &set))
 		vc->addr_index = __ffs(set);

 	set_bit(vc->addr_index, &vc->addr_tried);
 	vc->alist = alist;

 	_debug("VL address %d/%d", vc->addr_index, alist->nr_addrs);

 	vc->call_responded = false;
 	_leave(" = t %pISpc", rxrpc_kernel_remote_addr(alist->addrs[vc->addr_index].peer));
 	return true;

 next_server:
 	_debug("next");
 	ASSERT(alist);
 	if (vc->call_responded &&
 	    vc->addr_index != alist->preferred &&
 	    test_bit(alist->preferred, &vc->addr_tried))
 		WRITE_ONCE(alist->preferred, vc->addr_index);
 	afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_next);
 	alist = vc->alist = NULL;
 	goto pick_server;

 no_more_servers:
 	/* That's all the servers poked to no good effect.  Try again if some
 	 * of them were busy.
 	 */
 	if (vc->flags & AFS_VL_CURSOR_RETRY)
 		goto restart_from_beginning;

 	for (i = 0; i < vc->server_list->nr_servers; i++) {
 		struct afs_vlserver *s = vc->server_list->servers[i].server;

 		if (test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))
 			vc->cumul_error.responded = true;
 		afs_prioritise_error(&vc->cumul_error, READ_ONCE(s->probe.error),
 				     s->probe.abort_code);
 	}

 failed:
 	if (alist) {
 		if (vc->call_responded &&
 		    vc->addr_index != alist->preferred &&
 		    test_bit(alist->preferred, &vc->addr_tried))
 			WRITE_ONCE(alist->preferred, vc->addr_index);
 		afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_fail);
 		alist = vc->alist = NULL;
 	}
 	vc->flags |= AFS_VL_CURSOR_STOP;
 	_leave(" = f [failed %d]", vc->cumul_error.error);
 	return false;
 }

 /*
  * Dump cursor state in the case of the error being EDESTADDRREQ.
  */
 static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
 {
 	struct afs_cell *cell = vc->cell;
 	static int count;
 	int i;

 	if (!IS_ENABLED(CONFIG_AFS_DEBUG_CURSOR) || count > 3)
 		return;
 	count++;

 	rcu_read_lock();
 	pr_notice("EDESTADDR occurred\n");
 	pr_notice("CELL: %s err=%d\n", cell->name, cell->error);
 	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_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);

 	if (vc->server_list) {
 		const struct afs_vlserver_list *sl = vc->server_list;
 		pr_notice("VC: SL nr=%u ix=%u\n",
 			  sl->nr_servers, sl->index);
 		for (i = 0; i < sl->nr_servers; i++) {
 			const struct afs_vlserver *s = sl->servers[i].server;
 			pr_notice("VC: server %s+%hu fl=%lx E=%hd\n",
 				  s->name, s->port, s->flags, s->probe.error);
 			if (s->addresses) {
 				const struct afs_addr_list *a =
 					rcu_dereference(s->addresses);
 				pr_notice("VC:  - nr=%u/%u/%u pf=%u\n",
 					  a->nr_ipv4, a->nr_addrs, a->max_addrs,
 					  a->preferred);
 				pr_notice("VC:  - R=%lx F=%lx\n",
 					  a->responded, a->probe_failed);
 				if (a == vc->alist)
 					pr_notice("VC:  - current\n");
 			}
 		}
 	}

 	pr_notice("AC: t=%lx ax=%u\n", vc->addr_tried, vc->addr_index);
 	rcu_read_unlock();
 }

 /*
  * Tidy up a volume location server cursor and unlock the vnode.
  */
 int afs_end_vlserver_operation(struct afs_vl_cursor *vc)
 {
 	struct afs_net *net = vc->cell->net;

 	_enter("VC=%x+%x", vc->debug_id, vc->nr_iterations);

 	switch (vc->cumul_error.error) {
 	case -EDESTADDRREQ:
 	case -EADDRNOTAVAIL:
 	case -ENETUNREACH:
 	case -EHOSTUNREACH:
 		afs_vl_dump_edestaddrreq(vc);
 		break;
 	}

 	if (vc->alist) {
 		if (vc->call_responded &&
 		    vc->addr_index != vc->alist->preferred &&
 		    test_bit(vc->alist->preferred, &vc->addr_tried))
 			WRITE_ONCE(vc->alist->preferred, vc->addr_index);
 		afs_put_addrlist(vc->alist, afs_alist_trace_put_vlrotate_end);
 		vc->alist = NULL;
 	}
 	afs_put_vlserverlist(net, vc->server_list);
 	return vc->cumul_error.error;
 }
	// SPDX-License-Identifier: GPL-2.0-or-later
	/* Handle vlserver selection and rotation.
	*
	* Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
	* Written by David Howells (dhowells@redhat.com)
	*/

	#include <linux/kernel.h>
	#include <linux/sched.h>
	#include <linux/sched/signal.h>
	#include "internal.h"
	#include "afs_vl.h"

	/*
	* Begin an operation on a volume location server.
	*/
	bool afs_begin_vlserver_operation(struct afs_vl_cursor vc, struct afs_cell cell,
	struct key *key)
	{
	static atomic_t debug_ids;

	memset(vc, 0, sizeof(*vc));
	vc->cell = cell;
	vc->key = key;
	vc->cumul_error.error = -EDESTADDRREQ;
	vc->nr_iterations = -1;

	if (signal_pending(current)) {
	vc->cumul_error.error = -EINTR;
	vc->flags \|= AFS_VL_CURSOR_STOP;
	return false;
	}

	vc->debug_id = atomic_inc_return(&debug_ids);
	return true;
	}

	/*
	* Begin iteration through a server list, starting with the last used server if
	* possible, or the last recorded good server if not.
	*/
	static bool afs_start_vl_iteration(struct afs_vl_cursor *vc)
	{
	struct afs_cell *cell = vc->cell;
	unsigned int dns_lookup_count;

	if (cell->dns_source == DNS_RECORD_UNAVAILABLE \|\|
	cell->dns_expiry <= ktime_get_real_seconds()) {
	dns_lookup_count = smp_load_acquire(&cell->dns_lookup_count);
	set_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags);
	afs_queue_cell(cell, afs_cell_trace_get_queue_dns);

	if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
	if (wait_var_event_interruptible(
	&cell->dns_lookup_count,
	smp_load_acquire(&cell->dns_lookup_count)
	!= dns_lookup_count) < 0) {
	vc->cumul_error.error = -ERESTARTSYS;
	return false;
	}
	}

	/* Status load is ordered after lookup counter load */
	if (cell->dns_status == DNS_LOOKUP_GOT_NOT_FOUND) {
	pr_warn("No record of cell %s\n", cell->name);
	vc->cumul_error.error = -ENOENT;
	return false;
	}

	if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
	vc->cumul_error.error = -EDESTADDRREQ;
	return false;
	}
	}

	read_lock(&cell->vl_servers_lock);
	vc->server_list = afs_get_vlserverlist(
	rcu_dereference_protected(cell->vl_servers,
	lockdep_is_held(&cell->vl_servers_lock)));
	read_unlock(&cell->vl_servers_lock);
	if (!vc->server_list->nr_servers)
	return false;

	vc->untried_servers = (1UL << vc->server_list->nr_servers) - 1;
	vc->server_index = -1;
	return true;
	}

	/*
	* Select the vlserver to use. May be called multiple times to rotate
	* through the vlservers.
	*/
	bool afs_select_vlserver(struct afs_vl_cursor *vc)
	{
	struct afs_addr_list *alist = vc->alist;
	struct afs_vlserver *vlserver;
	unsigned long set, failed;
	unsigned int rtt;
	s32 abort_code = vc->call_abort_code;
	int error = vc->call_error, i;

	vc->nr_iterations++;

	_enter("VC=%x+%x,%d{%lx},%d{%lx},%d,%d",
	vc->debug_id, vc->nr_iterations, vc->server_index, vc->untried_servers,
	vc->addr_index, vc->addr_tried,
	error, abort_code);

	if (vc->flags & AFS_VL_CURSOR_STOP) {
	_leave(" = f [stopped]");
	return false;
	}

	if (vc->nr_iterations == 0)
	goto start;

	WRITE_ONCE(alist->addrs[vc->addr_index].last_error, error);

	/* Evaluate the result of the previous operation, if there was one. */
	switch (error) {
	default:
	case 0:
	/* Success or local failure. Stop. */
	vc->cumul_error.error = error;
	vc->flags \|= AFS_VL_CURSOR_STOP;
	_leave(" = f [okay/local %d]", vc->cumul_error.error);
	return false;

	case -ECONNABORTED:
	/* The far side rejected the operation on some grounds. This
	* might involve the server being busy or the volume having been moved.
	*/
	switch (abort_code) {
	case AFSVL_IO:
	case AFSVL_BADVOLOPER:
	case AFSVL_NOMEM:
	/* 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->server_index;
	//write_unlock(&vc->cell->vl_servers_lock);
	goto next_server;

	default:
	afs_prioritise_error(&vc->cumul_error, error, abort_code);
	goto failed;
	}

	case -ERFKILL:
	case -EADDRNOTAVAIL:
	case -ENETUNREACH:
	case -EHOSTUNREACH:
	case -EHOSTDOWN:
	case -ECONNREFUSED:
	case -ETIMEDOUT:
	case -ETIME:
	_debug("no conn %d", error);
	afs_prioritise_error(&vc->cumul_error, error, 0);
	goto iterate_address;

	case -ECONNRESET:
	_debug("call reset");
	afs_prioritise_error(&vc->cumul_error, error, 0);
	vc->flags \|= AFS_VL_CURSOR_RETRY;
	goto next_server;

	case -EOPNOTSUPP:
	_debug("notsupp");
	goto next_server;
	}

	restart_from_beginning:
	_debug("restart");
	if (vc->call_responded &&
	vc->addr_index != vc->alist->preferred &&
	test_bit(alist->preferred, &vc->addr_tried))
	WRITE_ONCE(alist->preferred, vc->addr_index);
	afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_restart);
	alist = vc->alist = NULL;

	afs_put_vlserverlist(vc->cell->net, vc->server_list);
	vc->server_list = NULL;
	if (vc->flags & AFS_VL_CURSOR_RETRIED)
	goto failed;
	vc->flags \|= AFS_VL_CURSOR_RETRIED;
	start:
	_debug("start");
	ASSERTCMP(alist, ==, NULL);

	if (!afs_start_vl_iteration(vc))
	goto failed;

	error = afs_send_vl_probes(vc->cell->net, vc->key, vc->server_list);
	if (error < 0) {
	afs_prioritise_error(&vc->cumul_error, error, 0);
	goto failed;
	}

	pick_server:
	_debug("pick [%lx]", vc->untried_servers);
	ASSERTCMP(alist, ==, NULL);

	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->server_index = vc->server_list->preferred;
	if (test_bit(vc->server_index, &vc->untried_servers))
	goto selected_server;

	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_servers) \|\|
	!test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))
	continue;
	if (s->probe.rtt <= rtt) {
	vc->server_index = i;
	rtt = s->probe.rtt;
	}
	}

	if (vc->server_index == -1)
	goto no_more_servers;

	selected_server:
	_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.
	*/
	vlserver = vc->server_list->servers[vc->server_index].server;
	vc->server = vlserver;

	_debug("USING VLSERVER: %s", vlserver->name);

	read_lock(&vlserver->lock);
	alist = rcu_dereference_protected(vlserver->addresses,
	lockdep_is_held(&vlserver->lock));
	vc->alist = afs_get_addrlist(alist, afs_alist_trace_get_vlrotate_set);
	read_unlock(&vlserver->lock);

	vc->addr_tried = 0;
	vc->addr_index = -1;

	iterate_address:
	/* Iterate over the current server's address list to try and find an
	* address on which it will respond to us.
	*/
	set = READ_ONCE(alist->responded);
	failed = READ_ONCE(alist->probe_failed);
	vc->addr_index = READ_ONCE(alist->preferred);

	_debug("%lx-%lx-%lx,%d", set, failed, vc->addr_tried, vc->addr_index);

	set &= ~(failed \| vc->addr_tried);

	if (!set)
	goto next_server;

	if (!test_bit(vc->addr_index, &set))
	vc->addr_index = __ffs(set);

	set_bit(vc->addr_index, &vc->addr_tried);
	vc->alist = alist;

	_debug("VL address %d/%d", vc->addr_index, alist->nr_addrs);

	vc->call_responded = false;
	_leave(" = t %pISpc", rxrpc_kernel_remote_addr(alist->addrs[vc->addr_index].peer));
	return true;

	next_server:
	_debug("next");
	ASSERT(alist);
	if (vc->call_responded &&
	vc->addr_index != alist->preferred &&
	test_bit(alist->preferred, &vc->addr_tried))
	WRITE_ONCE(alist->preferred, vc->addr_index);
	afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_next);
	alist = vc->alist = NULL;
	goto pick_server;

	no_more_servers:
	/* That's all the servers poked to no good effect. Try again if some
	* of them were busy.
	*/
	if (vc->flags & AFS_VL_CURSOR_RETRY)
	goto restart_from_beginning;

	for (i = 0; i < vc->server_list->nr_servers; i++) {
	struct afs_vlserver *s = vc->server_list->servers[i].server;

	if (test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))
	vc->cumul_error.responded = true;
	afs_prioritise_error(&vc->cumul_error, READ_ONCE(s->probe.error),
	s->probe.abort_code);
	}

	failed:
	if (alist) {
	if (vc->call_responded &&
	vc->addr_index != alist->preferred &&
	test_bit(alist->preferred, &vc->addr_tried))
	WRITE_ONCE(alist->preferred, vc->addr_index);
	afs_put_addrlist(alist, afs_alist_trace_put_vlrotate_fail);
	alist = vc->alist = NULL;
	}
	vc->flags \|= AFS_VL_CURSOR_STOP;
	_leave(" = f [failed %d]", vc->cumul_error.error);
	return false;
	}

	/*
	* Dump cursor state in the case of the error being EDESTADDRREQ.
	*/
	static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
	{
	struct afs_cell *cell = vc->cell;
	static int count;
	int i;

	if (!IS_ENABLED(CONFIG_AFS_DEBUG_CURSOR) \|\| count > 3)
	return;
	count++;

	rcu_read_lock();
	pr_notice("EDESTADDR occurred\n");
	pr_notice("CELL: %s err=%d\n", cell->name, cell->error);
	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_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);

	if (vc->server_list) {
	const struct afs_vlserver_list *sl = vc->server_list;
	pr_notice("VC: SL nr=%u ix=%u\n",
	sl->nr_servers, sl->index);
	for (i = 0; i < sl->nr_servers; i++) {
	const struct afs_vlserver *s = sl->servers[i].server;
	pr_notice("VC: server %s+%hu fl=%lx E=%hd\n",
	s->name, s->port, s->flags, s->probe.error);
	if (s->addresses) {
	const struct afs_addr_list *a =
	rcu_dereference(s->addresses);
	pr_notice("VC: - nr=%u/%u/%u pf=%u\n",
	a->nr_ipv4, a->nr_addrs, a->max_addrs,
	a->preferred);
	pr_notice("VC: - R=%lx F=%lx\n",
	a->responded, a->probe_failed);
	if (a == vc->alist)
	pr_notice("VC: - current\n");
	}
	}
	}

	pr_notice("AC: t=%lx ax=%u\n", vc->addr_tried, vc->addr_index);
	rcu_read_unlock();
	}

	/*
	* Tidy up a volume location server cursor and unlock the vnode.
	*/
	int afs_end_vlserver_operation(struct afs_vl_cursor *vc)
	{
	struct afs_net *net = vc->cell->net;

	_enter("VC=%x+%x", vc->debug_id, vc->nr_iterations);

	switch (vc->cumul_error.error) {
	case -EDESTADDRREQ:
	case -EADDRNOTAVAIL:
	case -ENETUNREACH:
	case -EHOSTUNREACH:
	afs_vl_dump_edestaddrreq(vc);
	break;
	}

	if (vc->alist) {
	if (vc->call_responded &&
	vc->addr_index != vc->alist->preferred &&
	test_bit(vc->alist->preferred, &vc->addr_tried))
	WRITE_ONCE(vc->alist->preferred, vc->addr_index);
	afs_put_addrlist(vc->alist, afs_alist_trace_put_vlrotate_end);
	vc->alist = NULL;
	}
	afs_put_vlserverlist(net, vc->server_list);
	return vc->cumul_error.error;
	}