rxrpc: Move the cwnd degradation after transmitting packets
[platform/kernel/linux-rpi.git] / net / rxrpc / proc.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* /proc/net/ support for AF_RXRPC
3  *
4  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
5  * Written by David Howells (dhowells@redhat.com)
6  */
7
8 #include <linux/module.h>
9 #include <net/sock.h>
10 #include <net/af_rxrpc.h>
11 #include "ar-internal.h"
12
13 static const char *const rxrpc_conn_states[RXRPC_CONN__NR_STATES] = {
14         [RXRPC_CONN_UNUSED]                     = "Unused  ",
15         [RXRPC_CONN_CLIENT]                     = "Client  ",
16         [RXRPC_CONN_SERVICE_PREALLOC]           = "SvPrealc",
17         [RXRPC_CONN_SERVICE_UNSECURED]          = "SvUnsec ",
18         [RXRPC_CONN_SERVICE_CHALLENGING]        = "SvChall ",
19         [RXRPC_CONN_SERVICE]                    = "SvSecure",
20         [RXRPC_CONN_REMOTELY_ABORTED]           = "RmtAbort",
21         [RXRPC_CONN_LOCALLY_ABORTED]            = "LocAbort",
22 };
23
24 /*
25  * generate a list of extant and dead calls in /proc/net/rxrpc_calls
26  */
27 static void *rxrpc_call_seq_start(struct seq_file *seq, loff_t *_pos)
28         __acquires(rcu)
29 {
30         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
31
32         rcu_read_lock();
33         return seq_list_start_head_rcu(&rxnet->calls, *_pos);
34 }
35
36 static void *rxrpc_call_seq_next(struct seq_file *seq, void *v, loff_t *pos)
37 {
38         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
39
40         return seq_list_next_rcu(v, &rxnet->calls, pos);
41 }
42
43 static void rxrpc_call_seq_stop(struct seq_file *seq, void *v)
44         __releases(rcu)
45 {
46         rcu_read_unlock();
47 }
48
49 static int rxrpc_call_seq_show(struct seq_file *seq, void *v)
50 {
51         struct rxrpc_local *local;
52         struct rxrpc_call *call;
53         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
54         unsigned long timeout = 0;
55         rxrpc_seq_t acks_hard_ack;
56         char lbuff[50], rbuff[50];
57         u64 wtmp;
58
59         if (v == &rxnet->calls) {
60                 seq_puts(seq,
61                          "Proto Local                                          "
62                          " Remote                                         "
63                          " SvID ConnID   CallID   End Use State    Abort   "
64                          " DebugId  TxSeq    TW RxSeq    RW RxSerial CW RxTimo\n");
65                 return 0;
66         }
67
68         call = list_entry(v, struct rxrpc_call, link);
69
70         local = call->local;
71         if (local)
72                 sprintf(lbuff, "%pISpc", &local->srx.transport);
73         else
74                 strcpy(lbuff, "no_local");
75
76         sprintf(rbuff, "%pISpc", &call->dest_srx.transport);
77
78         if (call->state != RXRPC_CALL_SERVER_PREALLOC) {
79                 timeout = READ_ONCE(call->expect_rx_by);
80                 timeout -= jiffies;
81         }
82
83         acks_hard_ack = READ_ONCE(call->acks_hard_ack);
84         wtmp   = atomic64_read_acquire(&call->ackr_window);
85         seq_printf(seq,
86                    "UDP   %-47.47s %-47.47s %4x %08x %08x %s %3u"
87                    " %-8.8s %08x %08x %08x %02x %08x %02x %08x %02x %06lx\n",
88                    lbuff,
89                    rbuff,
90                    call->dest_srx.srx_service,
91                    call->cid,
92                    call->call_id,
93                    rxrpc_is_service_call(call) ? "Svc" : "Clt",
94                    refcount_read(&call->ref),
95                    rxrpc_call_states[call->state],
96                    call->abort_code,
97                    call->debug_id,
98                    acks_hard_ack, READ_ONCE(call->tx_top) - acks_hard_ack,
99                    lower_32_bits(wtmp), upper_32_bits(wtmp) - lower_32_bits(wtmp),
100                    call->rx_serial,
101                    call->cong_cwnd,
102                    timeout);
103
104         return 0;
105 }
106
107 const struct seq_operations rxrpc_call_seq_ops = {
108         .start  = rxrpc_call_seq_start,
109         .next   = rxrpc_call_seq_next,
110         .stop   = rxrpc_call_seq_stop,
111         .show   = rxrpc_call_seq_show,
112 };
113
114 /*
115  * generate a list of extant virtual connections in /proc/net/rxrpc_conns
116  */
117 static void *rxrpc_connection_seq_start(struct seq_file *seq, loff_t *_pos)
118         __acquires(rxnet->conn_lock)
119 {
120         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
121
122         read_lock(&rxnet->conn_lock);
123         return seq_list_start_head(&rxnet->conn_proc_list, *_pos);
124 }
125
126 static void *rxrpc_connection_seq_next(struct seq_file *seq, void *v,
127                                        loff_t *pos)
128 {
129         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
130
131         return seq_list_next(v, &rxnet->conn_proc_list, pos);
132 }
133
134 static void rxrpc_connection_seq_stop(struct seq_file *seq, void *v)
135         __releases(rxnet->conn_lock)
136 {
137         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
138
139         read_unlock(&rxnet->conn_lock);
140 }
141
142 static int rxrpc_connection_seq_show(struct seq_file *seq, void *v)
143 {
144         struct rxrpc_connection *conn;
145         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
146         char lbuff[50], rbuff[50];
147
148         if (v == &rxnet->conn_proc_list) {
149                 seq_puts(seq,
150                          "Proto Local                                          "
151                          " Remote                                         "
152                          " SvID ConnID   End Ref Act State    Key     "
153                          " Serial   ISerial  CallId0  CallId1  CallId2  CallId3\n"
154                          );
155                 return 0;
156         }
157
158         conn = list_entry(v, struct rxrpc_connection, proc_link);
159         if (conn->state == RXRPC_CONN_SERVICE_PREALLOC) {
160                 strcpy(lbuff, "no_local");
161                 strcpy(rbuff, "no_connection");
162                 goto print;
163         }
164
165         sprintf(lbuff, "%pISpc", &conn->local->srx.transport);
166
167         sprintf(rbuff, "%pISpc", &conn->peer->srx.transport);
168 print:
169         seq_printf(seq,
170                    "UDP   %-47.47s %-47.47s %4x %08x %s %3u %3d"
171                    " %s %08x %08x %08x %08x %08x %08x %08x\n",
172                    lbuff,
173                    rbuff,
174                    conn->service_id,
175                    conn->proto.cid,
176                    rxrpc_conn_is_service(conn) ? "Svc" : "Clt",
177                    refcount_read(&conn->ref),
178                    atomic_read(&conn->active),
179                    rxrpc_conn_states[conn->state],
180                    key_serial(conn->key),
181                    atomic_read(&conn->serial),
182                    conn->hi_serial,
183                    conn->channels[0].call_id,
184                    conn->channels[1].call_id,
185                    conn->channels[2].call_id,
186                    conn->channels[3].call_id);
187
188         return 0;
189 }
190
191 const struct seq_operations rxrpc_connection_seq_ops = {
192         .start  = rxrpc_connection_seq_start,
193         .next   = rxrpc_connection_seq_next,
194         .stop   = rxrpc_connection_seq_stop,
195         .show   = rxrpc_connection_seq_show,
196 };
197
198 /*
199  * generate a list of extant virtual peers in /proc/net/rxrpc/peers
200  */
201 static int rxrpc_peer_seq_show(struct seq_file *seq, void *v)
202 {
203         struct rxrpc_peer *peer;
204         time64_t now;
205         char lbuff[50], rbuff[50];
206
207         if (v == SEQ_START_TOKEN) {
208                 seq_puts(seq,
209                          "Proto Local                                          "
210                          " Remote                                         "
211                          " Use SST   MTU LastUse      RTT      RTO\n"
212                          );
213                 return 0;
214         }
215
216         peer = list_entry(v, struct rxrpc_peer, hash_link);
217
218         sprintf(lbuff, "%pISpc", &peer->local->srx.transport);
219
220         sprintf(rbuff, "%pISpc", &peer->srx.transport);
221
222         now = ktime_get_seconds();
223         seq_printf(seq,
224                    "UDP   %-47.47s %-47.47s %3u"
225                    " %3u %5u %6llus %8u %8u\n",
226                    lbuff,
227                    rbuff,
228                    refcount_read(&peer->ref),
229                    peer->cong_ssthresh,
230                    peer->mtu,
231                    now - peer->last_tx_at,
232                    peer->srtt_us >> 3,
233                    jiffies_to_usecs(peer->rto_j));
234
235         return 0;
236 }
237
238 static void *rxrpc_peer_seq_start(struct seq_file *seq, loff_t *_pos)
239         __acquires(rcu)
240 {
241         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
242         unsigned int bucket, n;
243         unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash);
244         void *p;
245
246         rcu_read_lock();
247
248         if (*_pos >= UINT_MAX)
249                 return NULL;
250
251         n = *_pos & ((1U << shift) - 1);
252         bucket = *_pos >> shift;
253         for (;;) {
254                 if (bucket >= HASH_SIZE(rxnet->peer_hash)) {
255                         *_pos = UINT_MAX;
256                         return NULL;
257                 }
258                 if (n == 0) {
259                         if (bucket == 0)
260                                 return SEQ_START_TOKEN;
261                         *_pos += 1;
262                         n++;
263                 }
264
265                 p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);
266                 if (p)
267                         return p;
268                 bucket++;
269                 n = 1;
270                 *_pos = (bucket << shift) | n;
271         }
272 }
273
274 static void *rxrpc_peer_seq_next(struct seq_file *seq, void *v, loff_t *_pos)
275 {
276         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
277         unsigned int bucket, n;
278         unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash);
279         void *p;
280
281         if (*_pos >= UINT_MAX)
282                 return NULL;
283
284         bucket = *_pos >> shift;
285
286         p = seq_hlist_next_rcu(v, &rxnet->peer_hash[bucket], _pos);
287         if (p)
288                 return p;
289
290         for (;;) {
291                 bucket++;
292                 n = 1;
293                 *_pos = (bucket << shift) | n;
294
295                 if (bucket >= HASH_SIZE(rxnet->peer_hash)) {
296                         *_pos = UINT_MAX;
297                         return NULL;
298                 }
299                 if (n == 0) {
300                         *_pos += 1;
301                         n++;
302                 }
303
304                 p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1);
305                 if (p)
306                         return p;
307         }
308 }
309
310 static void rxrpc_peer_seq_stop(struct seq_file *seq, void *v)
311         __releases(rcu)
312 {
313         rcu_read_unlock();
314 }
315
316
317 const struct seq_operations rxrpc_peer_seq_ops = {
318         .start  = rxrpc_peer_seq_start,
319         .next   = rxrpc_peer_seq_next,
320         .stop   = rxrpc_peer_seq_stop,
321         .show   = rxrpc_peer_seq_show,
322 };
323
324 /*
325  * Generate a list of extant virtual local endpoints in /proc/net/rxrpc/locals
326  */
327 static int rxrpc_local_seq_show(struct seq_file *seq, void *v)
328 {
329         struct rxrpc_local *local;
330         char lbuff[50];
331
332         if (v == SEQ_START_TOKEN) {
333                 seq_puts(seq,
334                          "Proto Local                                          "
335                          " Use Act RxQ\n");
336                 return 0;
337         }
338
339         local = hlist_entry(v, struct rxrpc_local, link);
340
341         sprintf(lbuff, "%pISpc", &local->srx.transport);
342
343         seq_printf(seq,
344                    "UDP   %-47.47s %3u %3u %3u\n",
345                    lbuff,
346                    refcount_read(&local->ref),
347                    atomic_read(&local->active_users),
348                    local->rx_queue.qlen);
349
350         return 0;
351 }
352
353 static void *rxrpc_local_seq_start(struct seq_file *seq, loff_t *_pos)
354         __acquires(rcu)
355 {
356         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
357         unsigned int n;
358
359         rcu_read_lock();
360
361         if (*_pos >= UINT_MAX)
362                 return NULL;
363
364         n = *_pos;
365         if (n == 0)
366                 return SEQ_START_TOKEN;
367
368         return seq_hlist_start_rcu(&rxnet->local_endpoints, n - 1);
369 }
370
371 static void *rxrpc_local_seq_next(struct seq_file *seq, void *v, loff_t *_pos)
372 {
373         struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq));
374
375         if (*_pos >= UINT_MAX)
376                 return NULL;
377
378         return seq_hlist_next_rcu(v, &rxnet->local_endpoints, _pos);
379 }
380
381 static void rxrpc_local_seq_stop(struct seq_file *seq, void *v)
382         __releases(rcu)
383 {
384         rcu_read_unlock();
385 }
386
387 const struct seq_operations rxrpc_local_seq_ops = {
388         .start  = rxrpc_local_seq_start,
389         .next   = rxrpc_local_seq_next,
390         .stop   = rxrpc_local_seq_stop,
391         .show   = rxrpc_local_seq_show,
392 };
393
394 /*
395  * Display stats in /proc/net/rxrpc/stats
396  */
397 int rxrpc_stats_show(struct seq_file *seq, void *v)
398 {
399         struct rxrpc_net *rxnet = rxrpc_net(seq_file_single_net(seq));
400
401         seq_printf(seq,
402                    "Data     : send=%u sendf=%u fail=%u\n",
403                    atomic_read(&rxnet->stat_tx_data_send),
404                    atomic_read(&rxnet->stat_tx_data_send_frag),
405                    atomic_read(&rxnet->stat_tx_data_send_fail));
406         seq_printf(seq,
407                    "Data-Tx  : nr=%u retrans=%u uf=%u cwr=%u\n",
408                    atomic_read(&rxnet->stat_tx_data),
409                    atomic_read(&rxnet->stat_tx_data_retrans),
410                    atomic_read(&rxnet->stat_tx_data_underflow),
411                    atomic_read(&rxnet->stat_tx_data_cwnd_reset));
412         seq_printf(seq,
413                    "Data-Rx  : nr=%u reqack=%u jumbo=%u\n",
414                    atomic_read(&rxnet->stat_rx_data),
415                    atomic_read(&rxnet->stat_rx_data_reqack),
416                    atomic_read(&rxnet->stat_rx_data_jumbo));
417         seq_printf(seq,
418                    "Ack      : fill=%u send=%u skip=%u\n",
419                    atomic_read(&rxnet->stat_tx_ack_fill),
420                    atomic_read(&rxnet->stat_tx_ack_send),
421                    atomic_read(&rxnet->stat_tx_ack_skip));
422         seq_printf(seq,
423                    "Ack-Tx   : req=%u dup=%u oos=%u exw=%u nos=%u png=%u prs=%u dly=%u idl=%u\n",
424                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_REQUESTED]),
425                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_DUPLICATE]),
426                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_OUT_OF_SEQUENCE]),
427                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_EXCEEDS_WINDOW]),
428                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_NOSPACE]),
429                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_PING]),
430                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_PING_RESPONSE]),
431                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_DELAY]),
432                    atomic_read(&rxnet->stat_tx_acks[RXRPC_ACK_IDLE]));
433         seq_printf(seq,
434                    "Ack-Rx   : req=%u dup=%u oos=%u exw=%u nos=%u png=%u prs=%u dly=%u idl=%u\n",
435                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_REQUESTED]),
436                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_DUPLICATE]),
437                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_OUT_OF_SEQUENCE]),
438                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_EXCEEDS_WINDOW]),
439                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_NOSPACE]),
440                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_PING]),
441                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_PING_RESPONSE]),
442                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_DELAY]),
443                    atomic_read(&rxnet->stat_rx_acks[RXRPC_ACK_IDLE]));
444         seq_printf(seq,
445                    "Why-Req-A: acklost=%u already=%u mrtt=%u ortt=%u\n",
446                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_ack_lost]),
447                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_already_on]),
448                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_more_rtt]),
449                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_old_rtt]));
450         seq_printf(seq,
451                    "Why-Req-A: nolast=%u retx=%u slows=%u smtxw=%u\n",
452                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_no_srv_last]),
453                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_retrans]),
454                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_slow_start]),
455                    atomic_read(&rxnet->stat_why_req_ack[rxrpc_reqack_small_txwin]));
456         seq_printf(seq,
457                    "Buffers  : txb=%u rxb=%u\n",
458                    atomic_read(&rxrpc_nr_txbuf),
459                    atomic_read(&rxrpc_n_rx_skbs));
460         seq_printf(seq,
461                    "IO-thread: loops=%u\n",
462                    atomic_read(&rxnet->stat_io_loop));
463         return 0;
464 }
465
466 /*
467  * Clear stats if /proc/net/rxrpc/stats is written to.
468  */
469 int rxrpc_stats_clear(struct file *file, char *buf, size_t size)
470 {
471         struct seq_file *m = file->private_data;
472         struct rxrpc_net *rxnet = rxrpc_net(seq_file_single_net(m));
473
474         if (size > 1 || (size == 1 && buf[0] != '\n'))
475                 return -EINVAL;
476
477         atomic_set(&rxnet->stat_tx_data, 0);
478         atomic_set(&rxnet->stat_tx_data_retrans, 0);
479         atomic_set(&rxnet->stat_tx_data_underflow, 0);
480         atomic_set(&rxnet->stat_tx_data_cwnd_reset, 0);
481         atomic_set(&rxnet->stat_tx_data_send, 0);
482         atomic_set(&rxnet->stat_tx_data_send_frag, 0);
483         atomic_set(&rxnet->stat_tx_data_send_fail, 0);
484         atomic_set(&rxnet->stat_rx_data, 0);
485         atomic_set(&rxnet->stat_rx_data_reqack, 0);
486         atomic_set(&rxnet->stat_rx_data_jumbo, 0);
487
488         atomic_set(&rxnet->stat_tx_ack_fill, 0);
489         atomic_set(&rxnet->stat_tx_ack_send, 0);
490         atomic_set(&rxnet->stat_tx_ack_skip, 0);
491         memset(&rxnet->stat_tx_acks, 0, sizeof(rxnet->stat_tx_acks));
492         memset(&rxnet->stat_rx_acks, 0, sizeof(rxnet->stat_rx_acks));
493
494         memset(&rxnet->stat_why_req_ack, 0, sizeof(rxnet->stat_why_req_ack));
495
496         atomic_set(&rxnet->stat_io_loop, 0);
497         return size;
498 }