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