1// SPDX-License-Identifier: GPL-2.0-or-later
  2/* AFS vlserver probing
  3 *
  4 * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
  5 * Written by David Howells (dhowells@redhat.com)
  6 */
  7
  8#include <linux/sched.h>
  9#include <linux/slab.h>
 10#include "afs_fs.h"
 11#include "internal.h"
 12#include "protocol_yfs.h"
 13
 14static bool afs_vl_probe_done(struct afs_vlserver *server)
 15{
 16	if (!atomic_dec_and_test(&server->probe_outstanding))
 17		return false;
 18
 19	wake_up_var(&server->probe_outstanding);
 20	clear_bit_unlock(AFS_VLSERVER_FL_PROBING, &server->flags);
 21	wake_up_bit(&server->flags, AFS_VLSERVER_FL_PROBING);
 22	return true;
 23}
 24
 25/*
 26 * Process the result of probing a vlserver.  This is called after successful
 27 * or failed delivery of an VL.GetCapabilities operation.
 28 */
 29void afs_vlserver_probe_result(struct afs_call *call)
 30{
 31	struct afs_addr_list *alist = call->alist;
 32	struct afs_vlserver *server = call->vlserver;
 33	unsigned int server_index = call->server_index;
 34	unsigned int index = call->addr_ix;
 35	unsigned int rtt = UINT_MAX;
 36	bool have_result = false;
 37	u64 _rtt;
 38	int ret = call->error;
 39
 40	_enter("%s,%u,%u,%d,%d", server->name, server_index, index, ret, call->abort_code);
 41
 42	spin_lock(&server->probe_lock);
 43
 44	switch (ret) {
 45	case 0:
 46		server->probe.error = 0;
 47		goto responded;
 48	case -ECONNABORTED:
 49		if (!server->probe.responded) {
 50			server->probe.abort_code = call->abort_code;
 51			server->probe.error = ret;
 52		}
 53		goto responded;
 54	case -ENOMEM:
 55	case -ENONET:
 56		server->probe.local_failure = true;
 57		afs_io_error(call, afs_io_error_vl_probe_fail);
 58		goto out;
 59	case -ECONNRESET: /* Responded, but call expired. */
 60	case -ERFKILL:
 61	case -EADDRNOTAVAIL:
 62	case -ENETUNREACH:
 63	case -EHOSTUNREACH:
 64	case -EHOSTDOWN:
 65	case -ECONNREFUSED:
 66	case -ETIMEDOUT:
 67	case -ETIME:
 68	default:
 69		clear_bit(index, &alist->responded);
 70		set_bit(index, &alist->failed);
 71		if (!server->probe.responded &&
 72		    (server->probe.error == 0 ||
 73		     server->probe.error == -ETIMEDOUT ||
 74		     server->probe.error == -ETIME))
 75			server->probe.error = ret;
 76		afs_io_error(call, afs_io_error_vl_probe_fail);
 77		goto out;
 78	}
 79
 80responded:
 81	set_bit(index, &alist->responded);
 82	clear_bit(index, &alist->failed);
 83
 84	if (call->service_id == YFS_VL_SERVICE) {
 85		server->probe.is_yfs = true;
 86		set_bit(AFS_VLSERVER_FL_IS_YFS, &server->flags);
 87		alist->addrs[index].srx_service = call->service_id;
 88	} else {
 89		server->probe.not_yfs = true;
 90		if (!server->probe.is_yfs) {
 91			clear_bit(AFS_VLSERVER_FL_IS_YFS, &server->flags);
 92			alist->addrs[index].srx_service = call->service_id;
 93		}
 94	}
 95
 96	/* Get the RTT and scale it to fit into a 32-bit value that represents
 97	 * over a minute of time so that we can access it with one instruction
 98	 * on a 32-bit system.
 99	 */
100	_rtt = rxrpc_kernel_get_rtt(call->net->socket, call->rxcall);
101	_rtt /= 64;
102	rtt = (_rtt > UINT_MAX) ? UINT_MAX : _rtt;
103	if (rtt < server->probe.rtt) {
104		server->probe.rtt = rtt;
105		alist->preferred = index;
106		have_result = true;
107	}
108
109	smp_wmb(); /* Set rtt before responded. */
110	server->probe.responded = true;
111	set_bit(AFS_VLSERVER_FL_PROBED, &server->flags);
112out:
113	spin_unlock(&server->probe_lock);
114
115	_debug("probe [%u][%u] %pISpc rtt=%u ret=%d",
116	       server_index, index, &alist->addrs[index].transport,
117	       (unsigned int)rtt, ret);
118
119	have_result |= afs_vl_probe_done(server);
120	if (have_result) {
121		server->probe.have_result = true;
122		wake_up_var(&server->probe.have_result);
123		wake_up_all(&server->probe_wq);
124	}
125}
126
127/*
128 * Probe all of a vlserver's addresses to find out the best route and to
129 * query its capabilities.
130 */
131static bool afs_do_probe_vlserver(struct afs_net *net,
132				  struct afs_vlserver *server,
133				  struct key *key,
134				  unsigned int server_index,
135				  struct afs_error *_e)
136{
137	struct afs_addr_cursor ac = {
138		.index = 0,
139	};
140	struct afs_call *call;
141	bool in_progress = false;
142
143	_enter("%s", server->name);
144
145	read_lock(&server->lock);
146	ac.alist = rcu_dereference_protected(server->addresses,
147					     lockdep_is_held(&server->lock));
148	read_unlock(&server->lock);
149
150	atomic_set(&server->probe_outstanding, ac.alist->nr_addrs);
151	memset(&server->probe, 0, sizeof(server->probe));
152	server->probe.rtt = UINT_MAX;
153
154	for (ac.index = 0; ac.index < ac.alist->nr_addrs; ac.index++) {
155		call = afs_vl_get_capabilities(net, &ac, key, server,
156					       server_index);
157		if (!IS_ERR(call)) {
158			afs_put_call(call);
159			in_progress = true;
160		} else {
161			afs_prioritise_error(_e, PTR_ERR(call), ac.abort_code);
162		}
163	}
164
165	if (!in_progress)
166		afs_vl_probe_done(server);
167	return in_progress;
168}
169
170/*
171 * Send off probes to all unprobed servers.
172 */
173int afs_send_vl_probes(struct afs_net *net, struct key *key,
174		       struct afs_vlserver_list *vllist)
175{
176	struct afs_vlserver *server;
177	struct afs_error e;
178	bool in_progress = false;
179	int i;
180
181	e.error = 0;
182	e.responded = false;
183	for (i = 0; i < vllist->nr_servers; i++) {
184		server = vllist->servers[i].server;
185		if (test_bit(AFS_VLSERVER_FL_PROBED, &server->flags))
186			continue;
187
188		if (!test_and_set_bit_lock(AFS_VLSERVER_FL_PROBING, &server->flags) &&
189		    afs_do_probe_vlserver(net, server, key, i, &e))
190			in_progress = true;
191	}
192
193	return in_progress ? 0 : e.error;
194}
195
196/*
197 * Wait for the first as-yet untried server to respond.
198 */
199int afs_wait_for_vl_probes(struct afs_vlserver_list *vllist,
200			   unsigned long untried)
201{
202	struct wait_queue_entry *waits;
203	struct afs_vlserver *server;
204	unsigned int rtt = UINT_MAX;
205	bool have_responders = false;
206	int pref = -1, i;
207
208	_enter("%u,%lx", vllist->nr_servers, untried);
209
210	/* Only wait for servers that have a probe outstanding. */
211	for (i = 0; i < vllist->nr_servers; i++) {
212		if (test_bit(i, &untried)) {
213			server = vllist->servers[i].server;
214			if (!test_bit(AFS_VLSERVER_FL_PROBING, &server->flags))
215				__clear_bit(i, &untried);
216			if (server->probe.responded)
217				have_responders = true;
218		}
219	}
220	if (have_responders || !untried)
221		return 0;
222
223	waits = kmalloc(array_size(vllist->nr_servers, sizeof(*waits)), GFP_KERNEL);
224	if (!waits)
225		return -ENOMEM;
226
227	for (i = 0; i < vllist->nr_servers; i++) {
228		if (test_bit(i, &untried)) {
229			server = vllist->servers[i].server;
230			init_waitqueue_entry(&waits[i], current);
231			add_wait_queue(&server->probe_wq, &waits[i]);
232		}
233	}
234
235	for (;;) {
236		bool still_probing = false;
237
238		set_current_state(TASK_INTERRUPTIBLE);
239		for (i = 0; i < vllist->nr_servers; i++) {
240			if (test_bit(i, &untried)) {
241				server = vllist->servers[i].server;
242				if (server->probe.responded)
243					goto stop;
244				if (test_bit(AFS_VLSERVER_FL_PROBING, &server->flags))
245					still_probing = true;
246			}
247		}
248
249		if (!still_probing || signal_pending(current))
250			goto stop;
251		schedule();
252	}
253
254stop:
255	set_current_state(TASK_RUNNING);
256
257	for (i = 0; i < vllist->nr_servers; i++) {
258		if (test_bit(i, &untried)) {
259			server = vllist->servers[i].server;
260			if (server->probe.responded &&
261			    server->probe.rtt < rtt) {
262				pref = i;
263				rtt = server->probe.rtt;
264			}
265
266			remove_wait_queue(&server->probe_wq, &waits[i]);
267		}
268	}
269
270	kfree(waits);
271
272	if (pref == -1 && signal_pending(current))
273		return -ERESTARTSYS;
274
275	if (pref >= 0)
276		vllist->preferred = pref;
277
278	_leave(" = 0 [%u]", pref);
279	return 0;
280}