Merge tag 'for-linus-20190524' of git://git.kernel.dk/linux-block
[linux-2.6-microblaze.git] / fs / afs / fs_probe.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* AFS fileserver 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
14 static bool afs_fs_probe_done(struct afs_server *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_SERVER_FL_PROBING, &server->flags);
21         wake_up_bit(&server->flags, AFS_SERVER_FL_PROBING);
22         return true;
23 }
24
25 /*
26  * Process the result of probing a fileserver.  This is called after successful
27  * or failed delivery of an FS.GetCapabilities operation.
28  */
29 void afs_fileserver_probe_result(struct afs_call *call)
30 {
31         struct afs_addr_list *alist = call->alist;
32         struct afs_server *server = call->server;
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("%pU,%u", &server->uuid, index);
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_fs_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_fs_probe_fail);
77                 goto out;
78         }
79
80 responded:
81         set_bit(index, &alist->responded);
82         clear_bit(index, &alist->failed);
83
84         if (call->service_id == YFS_FS_SERVICE) {
85                 server->probe.is_yfs = true;
86                 set_bit(AFS_SERVER_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_SERVER_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_SERVER_FL_PROBED, &server->flags);
112 out:
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_fs_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 fileserver's addresses to find out the best route and to
129  * query its capabilities.
130  */
131 static int afs_do_probe_fileserver(struct afs_net *net,
132                                    struct afs_server *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("%pU", &server->uuid);
144
145         read_lock(&server->fs_lock);
146         ac.alist = rcu_dereference_protected(server->addresses,
147                                              lockdep_is_held(&server->fs_lock));
148         read_unlock(&server->fs_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_fs_get_capabilities(net, server, &ac, key, server_index);
156                 if (!IS_ERR(call)) {
157                         afs_put_call(call);
158                         in_progress = true;
159                 } else {
160                         afs_prioritise_error(_e, PTR_ERR(call), ac.abort_code);
161                 }
162         }
163
164         if (!in_progress)
165                 afs_fs_probe_done(server);
166         return in_progress;
167 }
168
169 /*
170  * Send off probes to all unprobed servers.
171  */
172 int afs_probe_fileservers(struct afs_net *net, struct key *key,
173                           struct afs_server_list *list)
174 {
175         struct afs_server *server;
176         struct afs_error e;
177         bool in_progress = false;
178         int i;
179
180         e.error = 0;
181         e.responded = false;
182         for (i = 0; i < list->nr_servers; i++) {
183                 server = list->servers[i].server;
184                 if (test_bit(AFS_SERVER_FL_PROBED, &server->flags))
185                         continue;
186
187                 if (!test_and_set_bit_lock(AFS_SERVER_FL_PROBING, &server->flags) &&
188                     afs_do_probe_fileserver(net, server, key, i, &e))
189                         in_progress = true;
190         }
191
192         return in_progress ? 0 : e.error;
193 }
194
195 /*
196  * Wait for the first as-yet untried fileserver to respond.
197  */
198 int afs_wait_for_fs_probes(struct afs_server_list *slist, unsigned long untried)
199 {
200         struct wait_queue_entry *waits;
201         struct afs_server *server;
202         unsigned int rtt = UINT_MAX;
203         bool have_responders = false;
204         int pref = -1, i;
205
206         _enter("%u,%lx", slist->nr_servers, untried);
207
208         /* Only wait for servers that have a probe outstanding. */
209         for (i = 0; i < slist->nr_servers; i++) {
210                 if (test_bit(i, &untried)) {
211                         server = slist->servers[i].server;
212                         if (!test_bit(AFS_SERVER_FL_PROBING, &server->flags))
213                                 __clear_bit(i, &untried);
214                         if (server->probe.responded)
215                                 have_responders = true;
216                 }
217         }
218         if (have_responders || !untried)
219                 return 0;
220
221         waits = kmalloc(array_size(slist->nr_servers, sizeof(*waits)), GFP_KERNEL);
222         if (!waits)
223                 return -ENOMEM;
224
225         for (i = 0; i < slist->nr_servers; i++) {
226                 if (test_bit(i, &untried)) {
227                         server = slist->servers[i].server;
228                         init_waitqueue_entry(&waits[i], current);
229                         add_wait_queue(&server->probe_wq, &waits[i]);
230                 }
231         }
232
233         for (;;) {
234                 bool still_probing = false;
235
236                 set_current_state(TASK_INTERRUPTIBLE);
237                 for (i = 0; i < slist->nr_servers; i++) {
238                         if (test_bit(i, &untried)) {
239                                 server = slist->servers[i].server;
240                                 if (server->probe.responded)
241                                         goto stop;
242                                 if (test_bit(AFS_SERVER_FL_PROBING, &server->flags))
243                                         still_probing = true;
244                         }
245                 }
246
247                 if (!still_probing || signal_pending(current))
248                         goto stop;
249                 schedule();
250         }
251
252 stop:
253         set_current_state(TASK_RUNNING);
254
255         for (i = 0; i < slist->nr_servers; i++) {
256                 if (test_bit(i, &untried)) {
257                         server = slist->servers[i].server;
258                         if (server->probe.responded &&
259                             server->probe.rtt < rtt) {
260                                 pref = i;
261                                 rtt = server->probe.rtt;
262                         }
263
264                         remove_wait_queue(&server->probe_wq, &waits[i]);
265                 }
266         }
267
268         kfree(waits);
269
270         if (pref == -1 && signal_pending(current))
271                 return -ERESTARTSYS;
272
273         if (pref >= 0)
274                 slist->preferred = pref;
275         return 0;
276 }