interconnect: qcom: icc-rpm: Fix peak rate calculation
[linux-2.6-microblaze.git] / fs / afs / vl_rotate.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Handle vlserver selection and rotation.
3  *
4  * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7
8 #include <linux/kernel.h>
9 #include <linux/sched.h>
10 #include <linux/sched/signal.h>
11 #include "internal.h"
12 #include "afs_vl.h"
13
14 /*
15  * Begin an operation on a volume location server.
16  */
17 bool afs_begin_vlserver_operation(struct afs_vl_cursor *vc, struct afs_cell *cell,
18                                   struct key *key)
19 {
20         memset(vc, 0, sizeof(*vc));
21         vc->cell = cell;
22         vc->key = key;
23         vc->error = -EDESTADDRREQ;
24         vc->ac.error = SHRT_MAX;
25
26         if (signal_pending(current)) {
27                 vc->error = -EINTR;
28                 vc->flags |= AFS_VL_CURSOR_STOP;
29                 return false;
30         }
31
32         return true;
33 }
34
35 /*
36  * Begin iteration through a server list, starting with the last used server if
37  * possible, or the last recorded good server if not.
38  */
39 static bool afs_start_vl_iteration(struct afs_vl_cursor *vc)
40 {
41         struct afs_cell *cell = vc->cell;
42         unsigned int dns_lookup_count;
43
44         if (cell->dns_source == DNS_RECORD_UNAVAILABLE ||
45             cell->dns_expiry <= ktime_get_real_seconds()) {
46                 dns_lookup_count = smp_load_acquire(&cell->dns_lookup_count);
47                 set_bit(AFS_CELL_FL_DO_LOOKUP, &cell->flags);
48                 afs_queue_cell(cell, afs_cell_trace_get_queue_dns);
49
50                 if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
51                         if (wait_var_event_interruptible(
52                                     &cell->dns_lookup_count,
53                                     smp_load_acquire(&cell->dns_lookup_count)
54                                     != dns_lookup_count) < 0) {
55                                 vc->error = -ERESTARTSYS;
56                                 return false;
57                         }
58                 }
59
60                 /* Status load is ordered after lookup counter load */
61                 if (cell->dns_source == DNS_RECORD_UNAVAILABLE) {
62                         vc->error = -EDESTADDRREQ;
63                         return false;
64                 }
65         }
66
67         read_lock(&cell->vl_servers_lock);
68         vc->server_list = afs_get_vlserverlist(
69                 rcu_dereference_protected(cell->vl_servers,
70                                           lockdep_is_held(&cell->vl_servers_lock)));
71         read_unlock(&cell->vl_servers_lock);
72         if (!vc->server_list->nr_servers)
73                 return false;
74
75         vc->untried = (1UL << vc->server_list->nr_servers) - 1;
76         vc->index = -1;
77         return true;
78 }
79
80 /*
81  * Select the vlserver to use.  May be called multiple times to rotate
82  * through the vlservers.
83  */
84 bool afs_select_vlserver(struct afs_vl_cursor *vc)
85 {
86         struct afs_addr_list *alist;
87         struct afs_vlserver *vlserver;
88         struct afs_error e;
89         u32 rtt;
90         int error = vc->ac.error, i;
91
92         _enter("%lx[%d],%lx[%d],%d,%d",
93                vc->untried, vc->index,
94                vc->ac.tried, vc->ac.index,
95                error, vc->ac.abort_code);
96
97         if (vc->flags & AFS_VL_CURSOR_STOP) {
98                 _leave(" = f [stopped]");
99                 return false;
100         }
101
102         vc->nr_iterations++;
103
104         /* Evaluate the result of the previous operation, if there was one. */
105         switch (error) {
106         case SHRT_MAX:
107                 goto start;
108
109         default:
110         case 0:
111                 /* Success or local failure.  Stop. */
112                 vc->error = error;
113                 vc->flags |= AFS_VL_CURSOR_STOP;
114                 _leave(" = f [okay/local %d]", vc->ac.error);
115                 return false;
116
117         case -ECONNABORTED:
118                 /* The far side rejected the operation on some grounds.  This
119                  * might involve the server being busy or the volume having been moved.
120                  */
121                 switch (vc->ac.abort_code) {
122                 case AFSVL_IO:
123                 case AFSVL_BADVOLOPER:
124                 case AFSVL_NOMEM:
125                         /* The server went weird. */
126                         vc->error = -EREMOTEIO;
127                         //write_lock(&vc->cell->vl_servers_lock);
128                         //vc->server_list->weird_mask |= 1 << vc->index;
129                         //write_unlock(&vc->cell->vl_servers_lock);
130                         goto next_server;
131
132                 default:
133                         vc->error = afs_abort_to_error(vc->ac.abort_code);
134                         goto failed;
135                 }
136
137         case -ERFKILL:
138         case -EADDRNOTAVAIL:
139         case -ENETUNREACH:
140         case -EHOSTUNREACH:
141         case -EHOSTDOWN:
142         case -ECONNREFUSED:
143         case -ETIMEDOUT:
144         case -ETIME:
145                 _debug("no conn %d", error);
146                 vc->error = error;
147                 goto iterate_address;
148
149         case -ECONNRESET:
150                 _debug("call reset");
151                 vc->error = error;
152                 vc->flags |= AFS_VL_CURSOR_RETRY;
153                 goto next_server;
154
155         case -EOPNOTSUPP:
156                 _debug("notsupp");
157                 goto next_server;
158         }
159
160 restart_from_beginning:
161         _debug("restart");
162         afs_end_cursor(&vc->ac);
163         afs_put_vlserverlist(vc->cell->net, vc->server_list);
164         vc->server_list = NULL;
165         if (vc->flags & AFS_VL_CURSOR_RETRIED)
166                 goto failed;
167         vc->flags |= AFS_VL_CURSOR_RETRIED;
168 start:
169         _debug("start");
170
171         if (!afs_start_vl_iteration(vc))
172                 goto failed;
173
174         error = afs_send_vl_probes(vc->cell->net, vc->key, vc->server_list);
175         if (error < 0)
176                 goto failed_set_error;
177
178 pick_server:
179         _debug("pick [%lx]", vc->untried);
180
181         error = afs_wait_for_vl_probes(vc->server_list, vc->untried);
182         if (error < 0)
183                 goto failed_set_error;
184
185         /* Pick the untried server with the lowest RTT. */
186         vc->index = vc->server_list->preferred;
187         if (test_bit(vc->index, &vc->untried))
188                 goto selected_server;
189
190         vc->index = -1;
191         rtt = U32_MAX;
192         for (i = 0; i < vc->server_list->nr_servers; i++) {
193                 struct afs_vlserver *s = vc->server_list->servers[i].server;
194
195                 if (!test_bit(i, &vc->untried) ||
196                     !test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))
197                         continue;
198                 if (s->probe.rtt < rtt) {
199                         vc->index = i;
200                         rtt = s->probe.rtt;
201                 }
202         }
203
204         if (vc->index == -1)
205                 goto no_more_servers;
206
207 selected_server:
208         _debug("use %d", vc->index);
209         __clear_bit(vc->index, &vc->untried);
210
211         /* We're starting on a different vlserver from the list.  We need to
212          * check it, find its address list and probe its capabilities before we
213          * use it.
214          */
215         ASSERTCMP(vc->ac.alist, ==, NULL);
216         vlserver = vc->server_list->servers[vc->index].server;
217         vc->server = vlserver;
218
219         _debug("USING VLSERVER: %s", vlserver->name);
220
221         read_lock(&vlserver->lock);
222         alist = rcu_dereference_protected(vlserver->addresses,
223                                           lockdep_is_held(&vlserver->lock));
224         afs_get_addrlist(alist);
225         read_unlock(&vlserver->lock);
226
227         memset(&vc->ac, 0, sizeof(vc->ac));
228
229         if (!vc->ac.alist)
230                 vc->ac.alist = alist;
231         else
232                 afs_put_addrlist(alist);
233
234         vc->ac.index = -1;
235
236 iterate_address:
237         ASSERT(vc->ac.alist);
238         /* Iterate over the current server's address list to try and find an
239          * address on which it will respond to us.
240          */
241         if (!afs_iterate_addresses(&vc->ac))
242                 goto next_server;
243
244         _debug("VL address %d/%d", vc->ac.index, vc->ac.alist->nr_addrs);
245
246         _leave(" = t %pISpc", &vc->ac.alist->addrs[vc->ac.index].transport);
247         return true;
248
249 next_server:
250         _debug("next");
251         afs_end_cursor(&vc->ac);
252         goto pick_server;
253
254 no_more_servers:
255         /* That's all the servers poked to no good effect.  Try again if some
256          * of them were busy.
257          */
258         if (vc->flags & AFS_VL_CURSOR_RETRY)
259                 goto restart_from_beginning;
260
261         e.error = -EDESTADDRREQ;
262         e.responded = false;
263         for (i = 0; i < vc->server_list->nr_servers; i++) {
264                 struct afs_vlserver *s = vc->server_list->servers[i].server;
265
266                 if (test_bit(AFS_VLSERVER_FL_RESPONDING, &s->flags))
267                         e.responded = true;
268                 afs_prioritise_error(&e, READ_ONCE(s->probe.error),
269                                      s->probe.abort_code);
270         }
271
272         error = e.error;
273
274 failed_set_error:
275         vc->error = error;
276 failed:
277         vc->flags |= AFS_VL_CURSOR_STOP;
278         afs_end_cursor(&vc->ac);
279         _leave(" = f [failed %d]", vc->error);
280         return false;
281 }
282
283 /*
284  * Dump cursor state in the case of the error being EDESTADDRREQ.
285  */
286 static void afs_vl_dump_edestaddrreq(const struct afs_vl_cursor *vc)
287 {
288         static int count;
289         int i;
290
291         if (!IS_ENABLED(CONFIG_AFS_DEBUG_CURSOR) || count > 3)
292                 return;
293         count++;
294
295         rcu_read_lock();
296         pr_notice("EDESTADDR occurred\n");
297         pr_notice("VC: ut=%lx ix=%u ni=%hu fl=%hx err=%hd\n",
298                   vc->untried, vc->index, vc->nr_iterations, vc->flags, vc->error);
299
300         if (vc->server_list) {
301                 const struct afs_vlserver_list *sl = vc->server_list;
302                 pr_notice("VC: SL nr=%u ix=%u\n",
303                           sl->nr_servers, sl->index);
304                 for (i = 0; i < sl->nr_servers; i++) {
305                         const struct afs_vlserver *s = sl->servers[i].server;
306                         pr_notice("VC: server %s+%hu fl=%lx E=%hd\n",
307                                   s->name, s->port, s->flags, s->probe.error);
308                         if (s->addresses) {
309                                 const struct afs_addr_list *a =
310                                         rcu_dereference(s->addresses);
311                                 pr_notice("VC:  - nr=%u/%u/%u pf=%u\n",
312                                           a->nr_ipv4, a->nr_addrs, a->max_addrs,
313                                           a->preferred);
314                                 pr_notice("VC:  - R=%lx F=%lx\n",
315                                           a->responded, a->failed);
316                                 if (a == vc->ac.alist)
317                                         pr_notice("VC:  - current\n");
318                         }
319                 }
320         }
321
322         pr_notice("AC: t=%lx ax=%u ac=%d er=%d r=%u ni=%u\n",
323                   vc->ac.tried, vc->ac.index, vc->ac.abort_code, vc->ac.error,
324                   vc->ac.responded, vc->ac.nr_iterations);
325         rcu_read_unlock();
326 }
327
328 /*
329  * Tidy up a volume location server cursor and unlock the vnode.
330  */
331 int afs_end_vlserver_operation(struct afs_vl_cursor *vc)
332 {
333         struct afs_net *net = vc->cell->net;
334
335         if (vc->error == -EDESTADDRREQ ||
336             vc->error == -EADDRNOTAVAIL ||
337             vc->error == -ENETUNREACH ||
338             vc->error == -EHOSTUNREACH)
339                 afs_vl_dump_edestaddrreq(vc);
340
341         afs_end_cursor(&vc->ac);
342         afs_put_vlserverlist(net, vc->server_list);
343
344         if (vc->error == -ECONNABORTED)
345                 vc->error = afs_abort_to_error(vc->ac.abort_code);
346
347         return vc->error;
348 }