]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
17926a79 DH |
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) | |
17926a79 DH |
6 | */ |
7 | ||
8 | #include <linux/module.h> | |
9 | #include <net/sock.h> | |
10 | #include <net/af_rxrpc.h> | |
11 | #include "ar-internal.h" | |
12 | ||
bba304db DH |
13 | static const char *const rxrpc_conn_states[RXRPC_CONN__NR_STATES] = { |
14 | [RXRPC_CONN_UNUSED] = "Unused ", | |
15 | [RXRPC_CONN_CLIENT] = "Client ", | |
00e90712 | 16 | [RXRPC_CONN_SERVICE_PREALLOC] = "SvPrealc", |
bba304db DH |
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", | |
17926a79 DH |
22 | }; |
23 | ||
17926a79 DH |
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) | |
88f2a825 DH |
28 | __acquires(rcu) |
29 | __acquires(rxnet->call_lock) | |
17926a79 | 30 | { |
2baec2c3 DH |
31 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
32 | ||
8d94aa38 | 33 | rcu_read_lock(); |
2baec2c3 DH |
34 | read_lock(&rxnet->call_lock); |
35 | return seq_list_start_head(&rxnet->calls, *_pos); | |
17926a79 DH |
36 | } |
37 | ||
38 | static void *rxrpc_call_seq_next(struct seq_file *seq, void *v, loff_t *pos) | |
39 | { | |
2baec2c3 DH |
40 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
41 | ||
42 | return seq_list_next(v, &rxnet->calls, pos); | |
17926a79 DH |
43 | } |
44 | ||
45 | static void rxrpc_call_seq_stop(struct seq_file *seq, void *v) | |
88f2a825 DH |
46 | __releases(rxnet->call_lock) |
47 | __releases(rcu) | |
17926a79 | 48 | { |
2baec2c3 DH |
49 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
50 | ||
51 | read_unlock(&rxnet->call_lock); | |
8d94aa38 | 52 | rcu_read_unlock(); |
17926a79 DH |
53 | } |
54 | ||
55 | static int rxrpc_call_seq_show(struct seq_file *seq, void *v) | |
56 | { | |
df5d8bf7 DH |
57 | struct rxrpc_local *local; |
58 | struct rxrpc_sock *rx; | |
59 | struct rxrpc_peer *peer; | |
17926a79 | 60 | struct rxrpc_call *call; |
2baec2c3 | 61 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
770b26de | 62 | unsigned long timeout = 0; |
3e018daf | 63 | rxrpc_seq_t tx_hard_ack, rx_hard_ack; |
75b54cb5 | 64 | char lbuff[50], rbuff[50]; |
17926a79 | 65 | |
2baec2c3 | 66 | if (v == &rxnet->calls) { |
17926a79 | 67 | seq_puts(seq, |
75b54cb5 DH |
68 | "Proto Local " |
69 | " Remote " | |
17926a79 | 70 | " SvID ConnID CallID End Use State Abort " |
32f71aa4 | 71 | " DebugId TxSeq TW RxSeq RW RxSerial RxTimo\n"); |
17926a79 DH |
72 | return 0; |
73 | } | |
74 | ||
75 | call = list_entry(v, struct rxrpc_call, link); | |
17926a79 | 76 | |
8d94aa38 | 77 | rx = rcu_dereference(call->socket); |
df5d8bf7 DH |
78 | if (rx) { |
79 | local = READ_ONCE(rx->local); | |
80 | if (local) | |
75b54cb5 | 81 | sprintf(lbuff, "%pISpc", &local->srx.transport); |
df5d8bf7 DH |
82 | else |
83 | strcpy(lbuff, "no_local"); | |
84 | } else { | |
85 | strcpy(lbuff, "no_socket"); | |
86 | } | |
17926a79 | 87 | |
df5d8bf7 DH |
88 | peer = call->peer; |
89 | if (peer) | |
75b54cb5 | 90 | sprintf(rbuff, "%pISpc", &peer->srx.transport); |
f4e7da8c DH |
91 | else |
92 | strcpy(rbuff, "no_connection"); | |
17926a79 | 93 | |
887763bb DH |
94 | if (call->state != RXRPC_CALL_SERVER_PREALLOC) { |
95 | timeout = READ_ONCE(call->expect_rx_by); | |
887763bb DH |
96 | timeout -= jiffies; |
97 | } | |
98 | ||
3e018daf DH |
99 | tx_hard_ack = READ_ONCE(call->tx_hard_ack); |
100 | rx_hard_ack = READ_ONCE(call->rx_hard_ack); | |
17926a79 | 101 | seq_printf(seq, |
75b54cb5 | 102 | "UDP %-47.47s %-47.47s %4x %08x %08x %s %3u" |
32f71aa4 | 103 | " %-8.8s %08x %08x %08x %02x %08x %02x %08x %06lx\n", |
17926a79 DH |
104 | lbuff, |
105 | rbuff, | |
f4e7da8c | 106 | call->service_id, |
0d12f8a4 DH |
107 | call->cid, |
108 | call->call_id, | |
dabe5a79 | 109 | rxrpc_is_service_call(call) ? "Svc" : "Clt", |
17926a79 DH |
110 | atomic_read(&call->usage), |
111 | rxrpc_call_states[call->state], | |
f5c17aae | 112 | call->abort_code, |
32f71aa4 | 113 | call->debug_id, |
3e018daf | 114 | tx_hard_ack, READ_ONCE(call->tx_top) - tx_hard_ack, |
887763bb | 115 | rx_hard_ack, READ_ONCE(call->rx_top) - rx_hard_ack, |
6b97bd7a | 116 | call->rx_serial, |
887763bb | 117 | timeout); |
17926a79 DH |
118 | |
119 | return 0; | |
120 | } | |
121 | ||
c3506372 | 122 | const struct seq_operations rxrpc_call_seq_ops = { |
17926a79 DH |
123 | .start = rxrpc_call_seq_start, |
124 | .next = rxrpc_call_seq_next, | |
125 | .stop = rxrpc_call_seq_stop, | |
126 | .show = rxrpc_call_seq_show, | |
127 | }; | |
128 | ||
17926a79 DH |
129 | /* |
130 | * generate a list of extant virtual connections in /proc/net/rxrpc_conns | |
131 | */ | |
132 | static void *rxrpc_connection_seq_start(struct seq_file *seq, loff_t *_pos) | |
88f2a825 | 133 | __acquires(rxnet->conn_lock) |
17926a79 | 134 | { |
2baec2c3 DH |
135 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
136 | ||
137 | read_lock(&rxnet->conn_lock); | |
138 | return seq_list_start_head(&rxnet->conn_proc_list, *_pos); | |
17926a79 DH |
139 | } |
140 | ||
141 | static void *rxrpc_connection_seq_next(struct seq_file *seq, void *v, | |
142 | loff_t *pos) | |
143 | { | |
2baec2c3 DH |
144 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
145 | ||
146 | return seq_list_next(v, &rxnet->conn_proc_list, pos); | |
17926a79 DH |
147 | } |
148 | ||
149 | static void rxrpc_connection_seq_stop(struct seq_file *seq, void *v) | |
88f2a825 | 150 | __releases(rxnet->conn_lock) |
17926a79 | 151 | { |
2baec2c3 DH |
152 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
153 | ||
154 | read_unlock(&rxnet->conn_lock); | |
17926a79 DH |
155 | } |
156 | ||
157 | static int rxrpc_connection_seq_show(struct seq_file *seq, void *v) | |
158 | { | |
159 | struct rxrpc_connection *conn; | |
2baec2c3 | 160 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); |
75b54cb5 | 161 | char lbuff[50], rbuff[50]; |
17926a79 | 162 | |
2baec2c3 | 163 | if (v == &rxnet->conn_proc_list) { |
17926a79 | 164 | seq_puts(seq, |
75b54cb5 DH |
165 | "Proto Local " |
166 | " Remote " | |
a1399f8b | 167 | " SvID ConnID End Use State Key " |
245500d8 | 168 | " Serial ISerial CallId0 CallId1 CallId2 CallId3\n" |
17926a79 DH |
169 | ); |
170 | return 0; | |
171 | } | |
172 | ||
4d028b2c | 173 | conn = list_entry(v, struct rxrpc_connection, proc_link); |
00e90712 DH |
174 | if (conn->state == RXRPC_CONN_SERVICE_PREALLOC) { |
175 | strcpy(lbuff, "no_local"); | |
176 | strcpy(rbuff, "no_connection"); | |
177 | goto print; | |
178 | } | |
17926a79 | 179 | |
75b54cb5 | 180 | sprintf(lbuff, "%pISpc", &conn->params.local->srx.transport); |
17926a79 | 181 | |
75b54cb5 | 182 | sprintf(rbuff, "%pISpc", &conn->params.peer->srx.transport); |
00e90712 | 183 | print: |
17926a79 | 184 | seq_printf(seq, |
75b54cb5 | 185 | "UDP %-47.47s %-47.47s %4x %08x %s %3u" |
6b97bd7a | 186 | " %s %08x %08x %08x %08x %08x %08x %08x\n", |
17926a79 DH |
187 | lbuff, |
188 | rbuff, | |
68d6d1ae | 189 | conn->service_id, |
19ffa01c | 190 | conn->proto.cid, |
19ffa01c | 191 | rxrpc_conn_is_service(conn) ? "Svc" : "Clt", |
17926a79 DH |
192 | atomic_read(&conn->usage), |
193 | rxrpc_conn_states[conn->state], | |
19ffa01c | 194 | key_serial(conn->params.key), |
17926a79 | 195 | atomic_read(&conn->serial), |
6b97bd7a DH |
196 | conn->hi_serial, |
197 | conn->channels[0].call_id, | |
198 | conn->channels[1].call_id, | |
199 | conn->channels[2].call_id, | |
200 | conn->channels[3].call_id); | |
17926a79 DH |
201 | |
202 | return 0; | |
203 | } | |
204 | ||
c3506372 | 205 | const struct seq_operations rxrpc_connection_seq_ops = { |
17926a79 DH |
206 | .start = rxrpc_connection_seq_start, |
207 | .next = rxrpc_connection_seq_next, | |
208 | .stop = rxrpc_connection_seq_stop, | |
209 | .show = rxrpc_connection_seq_show, | |
210 | }; | |
bc0e7cf4 DH |
211 | |
212 | /* | |
213 | * generate a list of extant virtual peers in /proc/net/rxrpc/peers | |
214 | */ | |
215 | static int rxrpc_peer_seq_show(struct seq_file *seq, void *v) | |
216 | { | |
217 | struct rxrpc_peer *peer; | |
218 | time64_t now; | |
219 | char lbuff[50], rbuff[50]; | |
220 | ||
221 | if (v == SEQ_START_TOKEN) { | |
222 | seq_puts(seq, | |
223 | "Proto Local " | |
224 | " Remote " | |
c410bf01 | 225 | " Use CW MTU LastUse RTT RTO\n" |
bc0e7cf4 DH |
226 | ); |
227 | return 0; | |
228 | } | |
229 | ||
230 | peer = list_entry(v, struct rxrpc_peer, hash_link); | |
231 | ||
232 | sprintf(lbuff, "%pISpc", &peer->local->srx.transport); | |
233 | ||
234 | sprintf(rbuff, "%pISpc", &peer->srx.transport); | |
235 | ||
236 | now = ktime_get_seconds(); | |
237 | seq_printf(seq, | |
238 | "UDP %-47.47s %-47.47s %3u" | |
c410bf01 | 239 | " %3u %5u %6llus %8u %8u\n", |
bc0e7cf4 DH |
240 | lbuff, |
241 | rbuff, | |
242 | atomic_read(&peer->usage), | |
243 | peer->cong_cwnd, | |
244 | peer->mtu, | |
245 | now - peer->last_tx_at, | |
c410bf01 DH |
246 | peer->srtt_us >> 3, |
247 | jiffies_to_usecs(peer->rto_j)); | |
bc0e7cf4 DH |
248 | |
249 | return 0; | |
250 | } | |
251 | ||
252 | static void *rxrpc_peer_seq_start(struct seq_file *seq, loff_t *_pos) | |
253 | __acquires(rcu) | |
254 | { | |
255 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); | |
256 | unsigned int bucket, n; | |
257 | unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash); | |
258 | void *p; | |
259 | ||
260 | rcu_read_lock(); | |
261 | ||
262 | if (*_pos >= UINT_MAX) | |
263 | return NULL; | |
264 | ||
265 | n = *_pos & ((1U << shift) - 1); | |
266 | bucket = *_pos >> shift; | |
267 | for (;;) { | |
268 | if (bucket >= HASH_SIZE(rxnet->peer_hash)) { | |
269 | *_pos = UINT_MAX; | |
270 | return NULL; | |
271 | } | |
272 | if (n == 0) { | |
273 | if (bucket == 0) | |
274 | return SEQ_START_TOKEN; | |
275 | *_pos += 1; | |
276 | n++; | |
277 | } | |
278 | ||
279 | p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1); | |
280 | if (p) | |
281 | return p; | |
282 | bucket++; | |
283 | n = 1; | |
284 | *_pos = (bucket << shift) | n; | |
285 | } | |
286 | } | |
287 | ||
288 | static void *rxrpc_peer_seq_next(struct seq_file *seq, void *v, loff_t *_pos) | |
289 | { | |
290 | struct rxrpc_net *rxnet = rxrpc_net(seq_file_net(seq)); | |
291 | unsigned int bucket, n; | |
292 | unsigned int shift = 32 - HASH_BITS(rxnet->peer_hash); | |
293 | void *p; | |
294 | ||
295 | if (*_pos >= UINT_MAX) | |
296 | return NULL; | |
297 | ||
298 | bucket = *_pos >> shift; | |
299 | ||
300 | p = seq_hlist_next_rcu(v, &rxnet->peer_hash[bucket], _pos); | |
301 | if (p) | |
302 | return p; | |
303 | ||
304 | for (;;) { | |
305 | bucket++; | |
306 | n = 1; | |
307 | *_pos = (bucket << shift) | n; | |
308 | ||
309 | if (bucket >= HASH_SIZE(rxnet->peer_hash)) { | |
310 | *_pos = UINT_MAX; | |
311 | return NULL; | |
312 | } | |
313 | if (n == 0) { | |
314 | *_pos += 1; | |
315 | n++; | |
316 | } | |
317 | ||
318 | p = seq_hlist_start_rcu(&rxnet->peer_hash[bucket], n - 1); | |
319 | if (p) | |
320 | return p; | |
321 | } | |
322 | } | |
323 | ||
324 | static void rxrpc_peer_seq_stop(struct seq_file *seq, void *v) | |
325 | __releases(rcu) | |
326 | { | |
327 | rcu_read_unlock(); | |
328 | } | |
329 | ||
330 | ||
331 | const struct seq_operations rxrpc_peer_seq_ops = { | |
332 | .start = rxrpc_peer_seq_start, | |
333 | .next = rxrpc_peer_seq_next, | |
334 | .stop = rxrpc_peer_seq_stop, | |
335 | .show = rxrpc_peer_seq_show, | |
336 | }; |