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