Greg Kroah-Hartman | b244131 | 2017-11-01 15:07:57 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 2 | #include <linux/in.h> |
| 3 | #include <linux/inet.h> |
| 4 | #include <linux/list.h> |
| 5 | #include <linux/module.h> |
| 6 | #include <linux/net.h> |
| 7 | #include <linux/proc_fs.h> |
| 8 | #include <linux/rculist.h> |
| 9 | #include <linux/seq_file.h> |
| 10 | #include <linux/socket.h> |
| 11 | #include <net/inet_sock.h> |
| 12 | #include <net/kcm.h> |
| 13 | #include <net/net_namespace.h> |
| 14 | #include <net/netns/generic.h> |
| 15 | #include <net/tcp.h> |
| 16 | |
| 17 | #ifdef CONFIG_PROC_FS |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 18 | static struct kcm_mux *kcm_get_first(struct seq_file *seq) |
| 19 | { |
| 20 | struct net *net = seq_file_net(seq); |
| 21 | struct kcm_net *knet = net_generic(net, kcm_net_id); |
| 22 | |
| 23 | return list_first_or_null_rcu(&knet->mux_list, |
| 24 | struct kcm_mux, kcm_mux_list); |
| 25 | } |
| 26 | |
| 27 | static struct kcm_mux *kcm_get_next(struct kcm_mux *mux) |
| 28 | { |
| 29 | struct kcm_net *knet = mux->knet; |
| 30 | |
| 31 | return list_next_or_null_rcu(&knet->mux_list, &mux->kcm_mux_list, |
| 32 | struct kcm_mux, kcm_mux_list); |
| 33 | } |
| 34 | |
| 35 | static struct kcm_mux *kcm_get_idx(struct seq_file *seq, loff_t pos) |
| 36 | { |
| 37 | struct net *net = seq_file_net(seq); |
| 38 | struct kcm_net *knet = net_generic(net, kcm_net_id); |
| 39 | struct kcm_mux *m; |
| 40 | |
| 41 | list_for_each_entry_rcu(m, &knet->mux_list, kcm_mux_list) { |
| 42 | if (!pos) |
| 43 | return m; |
| 44 | --pos; |
| 45 | } |
| 46 | return NULL; |
| 47 | } |
| 48 | |
| 49 | static void *kcm_seq_next(struct seq_file *seq, void *v, loff_t *pos) |
| 50 | { |
| 51 | void *p; |
| 52 | |
| 53 | if (v == SEQ_START_TOKEN) |
| 54 | p = kcm_get_first(seq); |
| 55 | else |
| 56 | p = kcm_get_next(v); |
| 57 | ++*pos; |
| 58 | return p; |
| 59 | } |
| 60 | |
| 61 | static void *kcm_seq_start(struct seq_file *seq, loff_t *pos) |
| 62 | __acquires(rcu) |
| 63 | { |
| 64 | rcu_read_lock(); |
| 65 | |
| 66 | if (!*pos) |
| 67 | return SEQ_START_TOKEN; |
| 68 | else |
| 69 | return kcm_get_idx(seq, *pos - 1); |
| 70 | } |
| 71 | |
| 72 | static void kcm_seq_stop(struct seq_file *seq, void *v) |
| 73 | __releases(rcu) |
| 74 | { |
| 75 | rcu_read_unlock(); |
| 76 | } |
| 77 | |
| 78 | struct kcm_proc_mux_state { |
| 79 | struct seq_net_private p; |
| 80 | int idx; |
| 81 | }; |
| 82 | |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 83 | static void kcm_format_mux_header(struct seq_file *seq) |
| 84 | { |
| 85 | struct net *net = seq_file_net(seq); |
| 86 | struct kcm_net *knet = net_generic(net, kcm_net_id); |
| 87 | |
| 88 | seq_printf(seq, |
| 89 | "*** KCM statistics (%d MUX) ****\n", |
| 90 | knet->count); |
| 91 | |
| 92 | seq_printf(seq, |
| 93 | "%-14s %-10s %-16s %-10s %-16s %-8s %-8s %-8s %-8s %s", |
| 94 | "Object", |
| 95 | "RX-Msgs", |
| 96 | "RX-Bytes", |
| 97 | "TX-Msgs", |
| 98 | "TX-Bytes", |
| 99 | "Recv-Q", |
| 100 | "Rmem", |
| 101 | "Send-Q", |
| 102 | "Smem", |
| 103 | "Status"); |
| 104 | |
| 105 | /* XXX: pdsts header stuff here */ |
| 106 | seq_puts(seq, "\n"); |
| 107 | } |
| 108 | |
| 109 | static void kcm_format_sock(struct kcm_sock *kcm, struct seq_file *seq, |
| 110 | int i, int *len) |
| 111 | { |
| 112 | seq_printf(seq, |
| 113 | " kcm-%-7u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8s ", |
| 114 | kcm->index, |
| 115 | kcm->stats.rx_msgs, |
| 116 | kcm->stats.rx_bytes, |
| 117 | kcm->stats.tx_msgs, |
| 118 | kcm->stats.tx_bytes, |
| 119 | kcm->sk.sk_receive_queue.qlen, |
| 120 | sk_rmem_alloc_get(&kcm->sk), |
| 121 | kcm->sk.sk_write_queue.qlen, |
| 122 | "-"); |
| 123 | |
| 124 | if (kcm->tx_psock) |
| 125 | seq_printf(seq, "Psck-%u ", kcm->tx_psock->index); |
| 126 | |
| 127 | if (kcm->tx_wait) |
| 128 | seq_puts(seq, "TxWait "); |
| 129 | |
| 130 | if (kcm->tx_wait_more) |
| 131 | seq_puts(seq, "WMore "); |
| 132 | |
| 133 | if (kcm->rx_wait) |
| 134 | seq_puts(seq, "RxWait "); |
| 135 | |
| 136 | seq_puts(seq, "\n"); |
| 137 | } |
| 138 | |
| 139 | static void kcm_format_psock(struct kcm_psock *psock, struct seq_file *seq, |
| 140 | int i, int *len) |
| 141 | { |
| 142 | seq_printf(seq, |
| 143 | " psock-%-5u %-10llu %-16llu %-10llu %-16llu %-8d %-8d %-8d %-8d ", |
| 144 | psock->index, |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 145 | psock->strp.stats.msgs, |
| 146 | psock->strp.stats.bytes, |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 147 | psock->stats.tx_msgs, |
| 148 | psock->stats.tx_bytes, |
| 149 | psock->sk->sk_receive_queue.qlen, |
| 150 | atomic_read(&psock->sk->sk_rmem_alloc), |
| 151 | psock->sk->sk_write_queue.qlen, |
Reshetova, Elena | 14afee4 | 2017-06-30 13:08:00 +0300 | [diff] [blame] | 152 | refcount_read(&psock->sk->sk_wmem_alloc)); |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 153 | |
| 154 | if (psock->done) |
| 155 | seq_puts(seq, "Done "); |
| 156 | |
| 157 | if (psock->tx_stopped) |
| 158 | seq_puts(seq, "TxStop "); |
| 159 | |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 160 | if (psock->strp.stopped) |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 161 | seq_puts(seq, "RxStop "); |
| 162 | |
| 163 | if (psock->tx_kcm) |
| 164 | seq_printf(seq, "Rsvd-%d ", psock->tx_kcm->index); |
| 165 | |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 166 | if (!psock->strp.paused && !psock->ready_rx_msg) { |
Tom Herbert | 1616b38 | 2016-08-23 11:55:31 -0700 | [diff] [blame] | 167 | if (psock->sk->sk_receive_queue.qlen) { |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 168 | if (psock->strp.need_bytes) |
Tom Herbert | 1616b38 | 2016-08-23 11:55:31 -0700 | [diff] [blame] | 169 | seq_printf(seq, "RxWait=%u ", |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 170 | psock->strp.need_bytes); |
Tom Herbert | 1616b38 | 2016-08-23 11:55:31 -0700 | [diff] [blame] | 171 | else |
| 172 | seq_printf(seq, "RxWait "); |
| 173 | } |
| 174 | } else { |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 175 | if (psock->strp.paused) |
Tom Herbert | 1616b38 | 2016-08-23 11:55:31 -0700 | [diff] [blame] | 176 | seq_puts(seq, "RxPause "); |
| 177 | |
| 178 | if (psock->ready_rx_msg) |
| 179 | seq_puts(seq, "RdyRx "); |
| 180 | } |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 181 | |
| 182 | seq_puts(seq, "\n"); |
| 183 | } |
| 184 | |
| 185 | static void |
| 186 | kcm_format_mux(struct kcm_mux *mux, loff_t idx, struct seq_file *seq) |
| 187 | { |
| 188 | int i, len; |
| 189 | struct kcm_sock *kcm; |
| 190 | struct kcm_psock *psock; |
| 191 | |
| 192 | /* mux information */ |
| 193 | seq_printf(seq, |
| 194 | "%-6s%-8s %-10llu %-16llu %-10llu %-16llu %-8s %-8s %-8s %-8s ", |
| 195 | "mux", "", |
| 196 | mux->stats.rx_msgs, |
| 197 | mux->stats.rx_bytes, |
| 198 | mux->stats.tx_msgs, |
| 199 | mux->stats.tx_bytes, |
| 200 | "-", "-", "-", "-"); |
| 201 | |
| 202 | seq_printf(seq, "KCMs: %d, Psocks %d\n", |
| 203 | mux->kcm_socks_cnt, mux->psocks_cnt); |
| 204 | |
| 205 | /* kcm sock information */ |
| 206 | i = 0; |
| 207 | spin_lock_bh(&mux->lock); |
| 208 | list_for_each_entry(kcm, &mux->kcm_socks, kcm_sock_list) { |
| 209 | kcm_format_sock(kcm, seq, i, &len); |
| 210 | i++; |
| 211 | } |
| 212 | i = 0; |
| 213 | list_for_each_entry(psock, &mux->psocks, psock_list) { |
| 214 | kcm_format_psock(psock, seq, i, &len); |
| 215 | i++; |
| 216 | } |
| 217 | spin_unlock_bh(&mux->lock); |
| 218 | } |
| 219 | |
| 220 | static int kcm_seq_show(struct seq_file *seq, void *v) |
| 221 | { |
| 222 | struct kcm_proc_mux_state *mux_state; |
| 223 | |
| 224 | mux_state = seq->private; |
| 225 | if (v == SEQ_START_TOKEN) { |
| 226 | mux_state->idx = 0; |
| 227 | kcm_format_mux_header(seq); |
| 228 | } else { |
| 229 | kcm_format_mux(v, mux_state->idx, seq); |
| 230 | mux_state->idx++; |
| 231 | } |
| 232 | return 0; |
| 233 | } |
| 234 | |
Christoph Hellwig | 2ad17b1 | 2018-04-10 19:53:58 +0200 | [diff] [blame^] | 235 | static const struct seq_operations kcm_seq_ops = { |
| 236 | .show = kcm_seq_show, |
| 237 | .start = kcm_seq_start, |
| 238 | .next = kcm_seq_next, |
| 239 | .stop = kcm_seq_stop, |
| 240 | }; |
| 241 | |
| 242 | static int kcm_seq_open(struct inode *inode, struct file *file) |
| 243 | { |
| 244 | return seq_open_net(inode, file, &kcm_seq_ops, |
| 245 | sizeof(struct kcm_proc_mux_state)); |
| 246 | } |
| 247 | |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 248 | static const struct file_operations kcm_seq_fops = { |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 249 | .open = kcm_seq_open, |
| 250 | .read = seq_read, |
| 251 | .llseek = seq_lseek, |
Jiri Slaby | d19af0a | 2016-06-20 11:36:28 +0200 | [diff] [blame] | 252 | .release = seq_release_net, |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 253 | }; |
| 254 | |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 255 | static int kcm_stats_seq_show(struct seq_file *seq, void *v) |
| 256 | { |
| 257 | struct kcm_psock_stats psock_stats; |
| 258 | struct kcm_mux_stats mux_stats; |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 259 | struct strp_aggr_stats strp_stats; |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 260 | struct kcm_mux *mux; |
| 261 | struct kcm_psock *psock; |
| 262 | struct net *net = seq->private; |
| 263 | struct kcm_net *knet = net_generic(net, kcm_net_id); |
| 264 | |
| 265 | memset(&mux_stats, 0, sizeof(mux_stats)); |
| 266 | memset(&psock_stats, 0, sizeof(psock_stats)); |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 267 | memset(&strp_stats, 0, sizeof(strp_stats)); |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 268 | |
| 269 | mutex_lock(&knet->mutex); |
| 270 | |
| 271 | aggregate_mux_stats(&knet->aggregate_mux_stats, &mux_stats); |
| 272 | aggregate_psock_stats(&knet->aggregate_psock_stats, |
| 273 | &psock_stats); |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 274 | aggregate_strp_stats(&knet->aggregate_strp_stats, |
| 275 | &strp_stats); |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 276 | |
| 277 | list_for_each_entry_rcu(mux, &knet->mux_list, kcm_mux_list) { |
| 278 | spin_lock_bh(&mux->lock); |
| 279 | aggregate_mux_stats(&mux->stats, &mux_stats); |
| 280 | aggregate_psock_stats(&mux->aggregate_psock_stats, |
| 281 | &psock_stats); |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 282 | aggregate_strp_stats(&mux->aggregate_strp_stats, |
| 283 | &strp_stats); |
| 284 | list_for_each_entry(psock, &mux->psocks, psock_list) { |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 285 | aggregate_psock_stats(&psock->stats, &psock_stats); |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 286 | save_strp_stats(&psock->strp, &strp_stats); |
| 287 | } |
| 288 | |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 289 | spin_unlock_bh(&mux->lock); |
| 290 | } |
| 291 | |
| 292 | mutex_unlock(&knet->mutex); |
| 293 | |
| 294 | seq_printf(seq, |
| 295 | "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s\n", |
| 296 | "MUX", |
| 297 | "RX-Msgs", |
| 298 | "RX-Bytes", |
| 299 | "TX-Msgs", |
| 300 | "TX-Bytes", |
| 301 | "TX-Retries", |
| 302 | "Attach", |
| 303 | "Unattach", |
| 304 | "UnattchRsvd", |
| 305 | "RX-RdyDrops"); |
| 306 | |
| 307 | seq_printf(seq, |
| 308 | "%-8s %-10llu %-16llu %-10llu %-16llu %-10u %-10u %-10u %-10u %-10u\n", |
| 309 | "", |
| 310 | mux_stats.rx_msgs, |
| 311 | mux_stats.rx_bytes, |
| 312 | mux_stats.tx_msgs, |
| 313 | mux_stats.tx_bytes, |
| 314 | mux_stats.tx_retries, |
| 315 | mux_stats.psock_attach, |
| 316 | mux_stats.psock_unattach_rsvd, |
| 317 | mux_stats.psock_unattach, |
| 318 | mux_stats.rx_ready_drops); |
| 319 | |
| 320 | seq_printf(seq, |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 321 | "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n", |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 322 | "Psock", |
| 323 | "RX-Msgs", |
| 324 | "RX-Bytes", |
| 325 | "TX-Msgs", |
| 326 | "TX-Bytes", |
| 327 | "Reserved", |
| 328 | "Unreserved", |
| 329 | "RX-Aborts", |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 330 | "RX-Intr", |
| 331 | "RX-Unrecov", |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 332 | "RX-MemFail", |
| 333 | "RX-NeedMor", |
| 334 | "RX-BadLen", |
Tom Herbert | 7ced95e | 2016-03-07 14:11:10 -0800 | [diff] [blame] | 335 | "RX-TooBig", |
Tom Herbert | 29152a3 | 2016-03-07 14:11:11 -0800 | [diff] [blame] | 336 | "RX-Timeout", |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 337 | "TX-Aborts"); |
| 338 | |
| 339 | seq_printf(seq, |
Tom Herbert | 9b73896 | 2016-08-15 14:51:02 -0700 | [diff] [blame] | 340 | "%-8s %-10llu %-16llu %-10llu %-16llu %-10llu %-10llu %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u\n", |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 341 | "", |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 342 | strp_stats.msgs, |
| 343 | strp_stats.bytes, |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 344 | psock_stats.tx_msgs, |
| 345 | psock_stats.tx_bytes, |
| 346 | psock_stats.reserved, |
| 347 | psock_stats.unreserved, |
Tom Herbert | bbb0302 | 2017-07-28 16:22:43 -0700 | [diff] [blame] | 348 | strp_stats.aborts, |
| 349 | strp_stats.interrupted, |
| 350 | strp_stats.unrecov_intr, |
| 351 | strp_stats.mem_fail, |
| 352 | strp_stats.need_more_hdr, |
| 353 | strp_stats.bad_hdr_len, |
| 354 | strp_stats.msg_too_big, |
| 355 | strp_stats.msg_timeouts, |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 356 | psock_stats.tx_aborts); |
| 357 | |
| 358 | return 0; |
| 359 | } |
| 360 | |
| 361 | static int kcm_stats_seq_open(struct inode *inode, struct file *file) |
| 362 | { |
| 363 | return single_open_net(inode, file, kcm_stats_seq_show); |
| 364 | } |
| 365 | |
| 366 | static const struct file_operations kcm_stats_seq_fops = { |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 367 | .open = kcm_stats_seq_open, |
| 368 | .read = seq_read, |
| 369 | .llseek = seq_lseek, |
| 370 | .release = single_release_net, |
| 371 | }; |
| 372 | |
| 373 | static int kcm_proc_init_net(struct net *net) |
| 374 | { |
Joe Perches | d644406 | 2018-03-23 15:54:38 -0700 | [diff] [blame] | 375 | if (!proc_create("kcm_stats", 0444, net->proc_net, |
Christoph Hellwig | 2ad17b1 | 2018-04-10 19:53:58 +0200 | [diff] [blame^] | 376 | &kcm_stats_seq_fops)) |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 377 | goto out_kcm_stats; |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 378 | |
Christoph Hellwig | 2ad17b1 | 2018-04-10 19:53:58 +0200 | [diff] [blame^] | 379 | if (!proc_create("kcm", 0444, net->proc_net, &kcm_seq_fops)) |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 380 | goto out_kcm; |
| 381 | |
| 382 | return 0; |
| 383 | |
| 384 | out_kcm: |
| 385 | remove_proc_entry("kcm_stats", net->proc_net); |
| 386 | out_kcm_stats: |
Christoph Hellwig | 2ad17b1 | 2018-04-10 19:53:58 +0200 | [diff] [blame^] | 387 | return -ENOMEM; |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | static void kcm_proc_exit_net(struct net *net) |
| 391 | { |
Christoph Hellwig | 2ad17b1 | 2018-04-10 19:53:58 +0200 | [diff] [blame^] | 392 | remove_proc_entry("kcm", net->proc_net); |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 393 | remove_proc_entry("kcm_stats", net->proc_net); |
| 394 | } |
| 395 | |
| 396 | static struct pernet_operations kcm_net_ops = { |
| 397 | .init = kcm_proc_init_net, |
| 398 | .exit = kcm_proc_exit_net, |
Tom Herbert | cd6e111 | 2016-03-07 14:11:07 -0800 | [diff] [blame] | 399 | }; |
| 400 | |
| 401 | int __init kcm_proc_init(void) |
| 402 | { |
| 403 | return register_pernet_subsys(&kcm_net_ops); |
| 404 | } |
| 405 | |
| 406 | void __exit kcm_proc_exit(void) |
| 407 | { |
| 408 | unregister_pernet_subsys(&kcm_net_ops); |
| 409 | } |
| 410 | |
| 411 | #endif /* CONFIG_PROC_FS */ |