blob: 6d0667e62baff8cba426a6199f05c79b0c881654 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Tom Herbertcd6e1112016-03-07 14:11:07 -08002#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 Herbertcd6e1112016-03-07 14:11:07 -080018static 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
27static 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
35static 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
49static 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
61static 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
72static void kcm_seq_stop(struct seq_file *seq, void *v)
73 __releases(rcu)
74{
75 rcu_read_unlock();
76}
77
78struct kcm_proc_mux_state {
79 struct seq_net_private p;
80 int idx;
81};
82
Tom Herbertcd6e1112016-03-07 14:11:07 -080083static 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
109static 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
139static 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 Herbertbbb03022017-07-28 16:22:43 -0700145 psock->strp.stats.msgs,
146 psock->strp.stats.bytes,
Tom Herbertcd6e1112016-03-07 14:11:07 -0800147 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, Elena14afee42017-06-30 13:08:00 +0300152 refcount_read(&psock->sk->sk_wmem_alloc));
Tom Herbertcd6e1112016-03-07 14:11:07 -0800153
154 if (psock->done)
155 seq_puts(seq, "Done ");
156
157 if (psock->tx_stopped)
158 seq_puts(seq, "TxStop ");
159
Tom Herbertbbb03022017-07-28 16:22:43 -0700160 if (psock->strp.stopped)
Tom Herbertcd6e1112016-03-07 14:11:07 -0800161 seq_puts(seq, "RxStop ");
162
163 if (psock->tx_kcm)
164 seq_printf(seq, "Rsvd-%d ", psock->tx_kcm->index);
165
Tom Herbertbbb03022017-07-28 16:22:43 -0700166 if (!psock->strp.paused && !psock->ready_rx_msg) {
Tom Herbert1616b382016-08-23 11:55:31 -0700167 if (psock->sk->sk_receive_queue.qlen) {
Tom Herbertbbb03022017-07-28 16:22:43 -0700168 if (psock->strp.need_bytes)
Tom Herbert1616b382016-08-23 11:55:31 -0700169 seq_printf(seq, "RxWait=%u ",
Tom Herbertbbb03022017-07-28 16:22:43 -0700170 psock->strp.need_bytes);
Tom Herbert1616b382016-08-23 11:55:31 -0700171 else
172 seq_printf(seq, "RxWait ");
173 }
174 } else {
Tom Herbertbbb03022017-07-28 16:22:43 -0700175 if (psock->strp.paused)
Tom Herbert1616b382016-08-23 11:55:31 -0700176 seq_puts(seq, "RxPause ");
177
178 if (psock->ready_rx_msg)
179 seq_puts(seq, "RdyRx ");
180 }
Tom Herbertcd6e1112016-03-07 14:11:07 -0800181
182 seq_puts(seq, "\n");
183}
184
185static void
186kcm_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
220static 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 Hellwig2ad17b12018-04-10 19:53:58 +0200235static 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
242static 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 Herbertcd6e1112016-03-07 14:11:07 -0800248static const struct file_operations kcm_seq_fops = {
Tom Herbertcd6e1112016-03-07 14:11:07 -0800249 .open = kcm_seq_open,
250 .read = seq_read,
251 .llseek = seq_lseek,
Jiri Slabyd19af0a2016-06-20 11:36:28 +0200252 .release = seq_release_net,
Tom Herbertcd6e1112016-03-07 14:11:07 -0800253};
254
Tom Herbertcd6e1112016-03-07 14:11:07 -0800255static 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 Herbert9b738962016-08-15 14:51:02 -0700259 struct strp_aggr_stats strp_stats;
Tom Herbertcd6e1112016-03-07 14:11:07 -0800260 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 Herbert9b738962016-08-15 14:51:02 -0700267 memset(&strp_stats, 0, sizeof(strp_stats));
Tom Herbertcd6e1112016-03-07 14:11:07 -0800268
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 Herbert9b738962016-08-15 14:51:02 -0700274 aggregate_strp_stats(&knet->aggregate_strp_stats,
275 &strp_stats);
Tom Herbertcd6e1112016-03-07 14:11:07 -0800276
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 Herbert9b738962016-08-15 14:51:02 -0700282 aggregate_strp_stats(&mux->aggregate_strp_stats,
283 &strp_stats);
284 list_for_each_entry(psock, &mux->psocks, psock_list) {
Tom Herbertcd6e1112016-03-07 14:11:07 -0800285 aggregate_psock_stats(&psock->stats, &psock_stats);
Tom Herbert9b738962016-08-15 14:51:02 -0700286 save_strp_stats(&psock->strp, &strp_stats);
287 }
288
Tom Herbertcd6e1112016-03-07 14:11:07 -0800289 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 Herbert9b738962016-08-15 14:51:02 -0700321 "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n",
Tom Herbertcd6e1112016-03-07 14:11:07 -0800322 "Psock",
323 "RX-Msgs",
324 "RX-Bytes",
325 "TX-Msgs",
326 "TX-Bytes",
327 "Reserved",
328 "Unreserved",
329 "RX-Aborts",
Tom Herbert9b738962016-08-15 14:51:02 -0700330 "RX-Intr",
331 "RX-Unrecov",
Tom Herbertcd6e1112016-03-07 14:11:07 -0800332 "RX-MemFail",
333 "RX-NeedMor",
334 "RX-BadLen",
Tom Herbert7ced95e2016-03-07 14:11:10 -0800335 "RX-TooBig",
Tom Herbert29152a32016-03-07 14:11:11 -0800336 "RX-Timeout",
Tom Herbertcd6e1112016-03-07 14:11:07 -0800337 "TX-Aborts");
338
339 seq_printf(seq,
Tom Herbert9b738962016-08-15 14:51:02 -0700340 "%-8s %-10llu %-16llu %-10llu %-16llu %-10llu %-10llu %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u %-10u\n",
Tom Herbertcd6e1112016-03-07 14:11:07 -0800341 "",
Tom Herbertbbb03022017-07-28 16:22:43 -0700342 strp_stats.msgs,
343 strp_stats.bytes,
Tom Herbertcd6e1112016-03-07 14:11:07 -0800344 psock_stats.tx_msgs,
345 psock_stats.tx_bytes,
346 psock_stats.reserved,
347 psock_stats.unreserved,
Tom Herbertbbb03022017-07-28 16:22:43 -0700348 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 Herbertcd6e1112016-03-07 14:11:07 -0800356 psock_stats.tx_aborts);
357
358 return 0;
359}
360
361static 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
366static const struct file_operations kcm_stats_seq_fops = {
Tom Herbertcd6e1112016-03-07 14:11:07 -0800367 .open = kcm_stats_seq_open,
368 .read = seq_read,
369 .llseek = seq_lseek,
370 .release = single_release_net,
371};
372
373static int kcm_proc_init_net(struct net *net)
374{
Joe Perchesd6444062018-03-23 15:54:38 -0700375 if (!proc_create("kcm_stats", 0444, net->proc_net,
Christoph Hellwig2ad17b12018-04-10 19:53:58 +0200376 &kcm_stats_seq_fops))
Tom Herbertcd6e1112016-03-07 14:11:07 -0800377 goto out_kcm_stats;
Tom Herbertcd6e1112016-03-07 14:11:07 -0800378
Christoph Hellwig2ad17b12018-04-10 19:53:58 +0200379 if (!proc_create("kcm", 0444, net->proc_net, &kcm_seq_fops))
Tom Herbertcd6e1112016-03-07 14:11:07 -0800380 goto out_kcm;
381
382 return 0;
383
384out_kcm:
385 remove_proc_entry("kcm_stats", net->proc_net);
386out_kcm_stats:
Christoph Hellwig2ad17b12018-04-10 19:53:58 +0200387 return -ENOMEM;
Tom Herbertcd6e1112016-03-07 14:11:07 -0800388}
389
390static void kcm_proc_exit_net(struct net *net)
391{
Christoph Hellwig2ad17b12018-04-10 19:53:58 +0200392 remove_proc_entry("kcm", net->proc_net);
Tom Herbertcd6e1112016-03-07 14:11:07 -0800393 remove_proc_entry("kcm_stats", net->proc_net);
394}
395
396static struct pernet_operations kcm_net_ops = {
397 .init = kcm_proc_init_net,
398 .exit = kcm_proc_exit_net,
Tom Herbertcd6e1112016-03-07 14:11:07 -0800399};
400
401int __init kcm_proc_init(void)
402{
403 return register_pernet_subsys(&kcm_net_ops);
404}
405
406void __exit kcm_proc_exit(void)
407{
408 unregister_pernet_subsys(&kcm_net_ops);
409}
410
411#endif /* CONFIG_PROC_FS */