Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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
13static 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 */
27static 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
36static 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
43static void rxrpc_call_seq_stop(struct seq_file *seq, void *v)
44 __releases(rcu)
45{
46 rcu_read_unlock();
47}
48
49static 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
107const 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 */
117static 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
126static 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
134static 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
142static 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);
168print:
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
191const 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 */
201static 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
238static 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
274static 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
310static void rxrpc_peer_seq_stop(struct seq_file *seq, void *v)
311 __releases(rcu)
312{
313 rcu_read_unlock();
314}
315
316
317const 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 */
327static 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
353static 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
371static 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
381static void rxrpc_local_seq_stop(struct seq_file *seq, void *v)
382 __releases(rcu)
383{
384 rcu_read_unlock();
385}
386
387const 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 */
397int 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 */
469int 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}