proc.c 8.1 KB

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