Commit | Line | Data |
---|---|---|
cd6e111b TH |
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 | |
17 | struct kcm_seq_muxinfo { | |
18 | char *name; | |
19 | const struct file_operations *seq_fops; | |
20 | const struct seq_operations seq_ops; | |
21 | }; | |
22 | ||
23 | static 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 | ||
32 | static 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 | ||
40 | static 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 | ||
54 | static 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 | ||
66 | static 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 | ||
77 | static void kcm_seq_stop(struct seq_file *seq, void *v) | |
78 | __releases(rcu) | |
79 | { | |
80 | rcu_read_unlock(); | |
81 | } | |
82 | ||
83 | struct kcm_proc_mux_state { | |
84 | struct seq_net_private p; | |
85 | int idx; | |
86 | }; | |
87 | ||
88 | static 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 | ||
100 | static 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 | ||
126 | static 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 | ||
156 | static 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 | ||
189 | static void | |
190 | kcm_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 | ||
224 | static 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 | ||
239 | static 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 | ||
246 | static 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 | ||
257 | static 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 | } | |
268 | EXPORT_SYMBOL(kcm_proc_register); | |
269 | ||
270 | static void kcm_proc_unregister(struct net *net, | |
271 | struct kcm_seq_muxinfo *muxinfo) | |
272 | { | |
273 | remove_proc_entry(muxinfo->name, net->proc_net); | |
274 | } | |
275 | EXPORT_SYMBOL(kcm_proc_unregister); | |
276 | ||
277 | static 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, | |
29152a34 | 334 | "%-8s %-10s %-16s %-10s %-16s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s %-10s\n", |
cd6e111b TH |
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", | |
7ced95ef | 346 | "RX-TooBig", |
29152a34 | 347 | "RX-Timeout", |
cd6e111b TH |
348 | "TX-Aborts"); |
349 | ||
350 | seq_printf(seq, | |
29152a34 | 351 | "%-8s %-10llu %-16llu %-10llu %-16llu %-10llu %-10llu %-10u %-10u %-10u %-10u %-10u %-10u %-10u\n", |
cd6e111b TH |
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, | |
7ced95ef | 363 | psock_stats.rx_msg_too_big, |
29152a34 | 364 | psock_stats.rx_msg_timeouts, |
cd6e111b TH |
365 | psock_stats.tx_aborts); |
366 | ||
367 | return 0; | |
368 | } | |
369 | ||
370 | static 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 | ||
375 | static 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 | ||
383 | static 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 | ||
399 | out_kcm: | |
400 | remove_proc_entry("kcm_stats", net->proc_net); | |
401 | out_kcm_stats: | |
402 | return err; | |
403 | } | |
404 | ||
405 | static 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 | ||
411 | static struct pernet_operations kcm_net_ops = { | |
412 | .init = kcm_proc_init_net, | |
413 | .exit = kcm_proc_exit_net, | |
414 | }; | |
415 | ||
416 | int __init kcm_proc_init(void) | |
417 | { | |
418 | return register_pernet_subsys(&kcm_net_ops); | |
419 | } | |
420 | ||
421 | void __exit kcm_proc_exit(void) | |
422 | { | |
423 | unregister_pernet_subsys(&kcm_net_ops); | |
424 | } | |
425 | ||
426 | #endif /* CONFIG_PROC_FS */ |