1 /*
2 * Copyright (c) 2008 Mellanox Technologies Ltd. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 */
32
33 #include <linux/proc_fs.h>
34 #include <rdma/sdp_socket.h>
35 #include "sdp.h"
36
37 #ifdef CONFIG_PROC_FS
38
39 #define PROC_SDP_STATS "sdpstats"
40 #define PROC_SDP_PERF "sdpprf"
41
42 /* just like TCP fs */
43 struct sdp_seq_afinfo {
44 struct module *owner;
45 char *name;
46 sa_family_t family;
47 int (*seq_show) (struct seq_file *m, void *v);
48 struct file_operations *seq_fops;
49 };
50
51 struct sdp_iter_state {
52 sa_family_t family;
53 int num;
54 struct seq_operations seq_ops;
55 };
56
sdp_get_idx(struct seq_file * seq,loff_t pos)57 static void *sdp_get_idx(struct seq_file *seq, loff_t pos)
58 {
59 int i = 0;
60 struct sdp_sock *ssk;
61
62 if (!list_empty(&sock_list))
63 list_for_each_entry(ssk, &sock_list, sock_list) {
64 if (i == pos)
65 return ssk;
66 i++;
67 }
68
69 return NULL;
70 }
71
sdp_seq_start(struct seq_file * seq,loff_t * pos)72 static void *sdp_seq_start(struct seq_file *seq, loff_t *pos)
73 {
74 void *start = NULL;
75 struct sdp_iter_state *st = seq->private;
76
77 st->num = 0;
78
79 if (!*pos)
80 return SEQ_START_TOKEN;
81
82 spin_lock_irq(&sock_list_lock);
83 start = sdp_get_idx(seq, *pos - 1);
84 if (start)
85 sock_hold((struct socket *)start, SOCK_REF_SEQ);
86 spin_unlock_irq(&sock_list_lock);
87
88 return start;
89 }
90
sdp_seq_next(struct seq_file * seq,void * v,loff_t * pos)91 static void *sdp_seq_next(struct seq_file *seq, void *v, loff_t *pos)
92 {
93 struct sdp_iter_state *st = seq->private;
94 void *next = NULL;
95
96 spin_lock_irq(&sock_list_lock);
97 if (v == SEQ_START_TOKEN)
98 next = sdp_get_idx(seq, 0);
99 else
100 next = sdp_get_idx(seq, *pos);
101 if (next)
102 sock_hold((struct socket *)next, SOCK_REF_SEQ);
103 spin_unlock_irq(&sock_list_lock);
104
105 *pos += 1;
106 st->num++;
107
108 return next;
109 }
110
sdp_seq_stop(struct seq_file * seq,void * v)111 static void sdp_seq_stop(struct seq_file *seq, void *v)
112 {
113 }
114
115 #define TMPSZ 150
116
sdp_seq_show(struct seq_file * seq,void * v)117 static int sdp_seq_show(struct seq_file *seq, void *v)
118 {
119 struct sdp_iter_state *st;
120 struct socket *sk = v;
121 char tmpbuf[TMPSZ + 1];
122 unsigned int dest;
123 unsigned int src;
124 int uid;
125 unsigned long inode;
126 __u16 destp;
127 __u16 srcp;
128 __u32 rx_queue, tx_queue;
129
130 if (v == SEQ_START_TOKEN) {
131 seq_printf(seq, "%-*s\n", TMPSZ - 1,
132 " sl local_address rem_address "
133 "uid inode rx_queue tx_queue state");
134 goto out;
135 }
136
137 st = seq->private;
138
139 dest = inet_sk(sk)->daddr;
140 src = inet_sk(sk)->rcv_saddr;
141 destp = ntohs(inet_sk(sk)->dport);
142 srcp = ntohs(inet_sk(sk)->sport);
143 uid = sock_i_uid(sk);
144 inode = sock_i_ino(sk);
145 rx_queue = rcv_nxt(sdp_sk(sk)) - sdp_sk(sk)->copied_seq;
146 tx_queue = sdp_sk(sk)->write_seq - sdp_sk(sk)->tx_ring.una_seq;
147
148 sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X %5d %lu %08X:%08X %X",
149 st->num, src, srcp, dest, destp, uid, inode,
150 rx_queue, tx_queue, sk->sk_state);
151
152 seq_printf(seq, "%-*s\n", TMPSZ - 1, tmpbuf);
153
154 sock_put(sk, SOCK_REF_SEQ);
155 out:
156 return 0;
157 }
158
sdp_seq_open(struct inode * inode,struct file * file)159 static int sdp_seq_open(struct inode *inode, struct file *file)
160 {
161 struct sdp_seq_afinfo *afinfo = PDE(inode)->data;
162 struct seq_file *seq;
163 struct sdp_iter_state *s;
164 int rc;
165
166 if (unlikely(afinfo == NULL))
167 return -EINVAL;
168
169 /* Workaround bogus warning by memtrack */
170 #define _kzalloc(size,flags) kzalloc(size,flags)
171 #undef kzalloc
172 s = kzalloc(sizeof(*s), GFP_KERNEL);
173 #define kzalloc(s,f) _kzalloc(s,f)
174 if (!s)
175 return -ENOMEM;
176 s->family = afinfo->family;
177 s->seq_ops.start = sdp_seq_start;
178 s->seq_ops.next = sdp_seq_next;
179 s->seq_ops.show = afinfo->seq_show;
180 s->seq_ops.stop = sdp_seq_stop;
181
182 rc = seq_open(file, &s->seq_ops);
183 if (rc)
184 goto out_kfree;
185 seq = file->private_data;
186 seq->private = s;
187 out:
188 return rc;
189 out_kfree:
190 kfree(s);
191 goto out;
192 }
193
194
195 static struct file_operations sdp_seq_fops;
196 static struct sdp_seq_afinfo sdp_seq_afinfo = {
197 .owner = THIS_MODULE,
198 .name = "sdp",
199 .family = AF_INET_SDP,
200 .seq_show = sdp_seq_show,
201 .seq_fops = &sdp_seq_fops,
202 };
203
204 #ifdef SDPSTATS_ON
205 DEFINE_PER_CPU(struct sdpstats, sdpstats);
206
sdpstats_seq_hist(struct seq_file * seq,char * str,u32 * h,int n,int is_log)207 static void sdpstats_seq_hist(struct seq_file *seq, char *str, u32 *h, int n,
208 int is_log)
209 {
210 int i;
211 u32 max = 0;
212
213 seq_printf(seq, "%s:\n", str);
214
215 for (i = 0; i < n; i++) {
216 if (h[i] > max)
217 max = h[i];
218 }
219
220 if (max == 0) {
221 seq_printf(seq, " - all values are 0\n");
222 return;
223 }
224
225 for (i = 0; i < n; i++) {
226 char s[51];
227 int j = 50 * h[i] / max;
228 int val = is_log ? (i == n-1 ? 0 : 1<<i) : i;
229 memset(s, '*', j);
230 s[j] = '\0';
231
232 seq_printf(seq, "%10d | %-50s - %d\n", val, s, h[i]);
233 }
234 }
235
236 #define SDPSTATS_COUNTER_GET(var) ({ \
237 u32 __val = 0; \
238 unsigned int __i; \
239 for_each_possible_cpu(__i) \
240 __val += per_cpu(sdpstats, __i).var; \
241 __val; \
242 })
243
244 #define SDPSTATS_HIST_GET(hist, hist_len, sum) ({ \
245 unsigned int __i; \
246 for_each_possible_cpu(__i) { \
247 unsigned int __j; \
248 u32 *h = per_cpu(sdpstats, __i).hist; \
249 for (__j = 0; __j < hist_len; __j++) { \
250 sum[__j] += h[__j]; \
251 } \
252 } \
253 })
254
255 #define __sdpstats_seq_hist(seq, msg, hist, is_log) ({ \
256 u32 tmp_hist[SDPSTATS_MAX_HIST_SIZE]; \
257 int hist_len = ARRAY_SIZE(__get_cpu_var(sdpstats).hist);\
258 memset(tmp_hist, 0, sizeof(tmp_hist)); \
259 SDPSTATS_HIST_GET(hist, hist_len, tmp_hist); \
260 sdpstats_seq_hist(seq, msg, tmp_hist, hist_len, is_log);\
261 })
262
sdpstats_seq_show(struct seq_file * seq,void * v)263 static int sdpstats_seq_show(struct seq_file *seq, void *v)
264 {
265 int i;
266
267 seq_printf(seq, "SDP statistics:\n");
268
269 __sdpstats_seq_hist(seq, "sendmsg_seglen", sendmsg_seglen, 1);
270 __sdpstats_seq_hist(seq, "send_size", send_size, 1);
271 __sdpstats_seq_hist(seq, "credits_before_update",
272 credits_before_update, 0);
273
274 seq_printf(seq, "sdp_sendmsg() calls\t\t: %d\n",
275 SDPSTATS_COUNTER_GET(sendmsg));
276 seq_printf(seq, "bcopy segments \t\t: %d\n",
277 SDPSTATS_COUNTER_GET(sendmsg_bcopy_segment));
278 seq_printf(seq, "bzcopy segments \t\t: %d\n",
279 SDPSTATS_COUNTER_GET(sendmsg_bzcopy_segment));
280 seq_printf(seq, "zcopy segments \t\t: %d\n",
281 SDPSTATS_COUNTER_GET(sendmsg_zcopy_segment));
282 seq_printf(seq, "post_send_credits \t\t: %d\n",
283 SDPSTATS_COUNTER_GET(post_send_credits));
284 seq_printf(seq, "memcpy_count \t\t: %u\n",
285 SDPSTATS_COUNTER_GET(memcpy_count));
286
287 for (i = 0; i < ARRAY_SIZE(__get_cpu_var(sdpstats).post_send); i++) {
288 if (mid2str(i)) {
289 seq_printf(seq, "post_send %-20s\t: %d\n",
290 mid2str(i),
291 SDPSTATS_COUNTER_GET(post_send[i]));
292 }
293 }
294
295 seq_printf(seq, "\n");
296 seq_printf(seq, "post_recv \t\t: %d\n",
297 SDPSTATS_COUNTER_GET(post_recv));
298 seq_printf(seq, "BZCopy poll miss \t\t: %d\n",
299 SDPSTATS_COUNTER_GET(bzcopy_poll_miss));
300 seq_printf(seq, "send_wait_for_mem \t\t: %d\n",
301 SDPSTATS_COUNTER_GET(send_wait_for_mem));
302 seq_printf(seq, "send_miss_no_credits\t\t: %d\n",
303 SDPSTATS_COUNTER_GET(send_miss_no_credits));
304
305 seq_printf(seq, "rx_poll_miss \t\t: %d\n", SDPSTATS_COUNTER_GET(rx_poll_miss));
306 seq_printf(seq, "tx_poll_miss \t\t: %d\n", SDPSTATS_COUNTER_GET(tx_poll_miss));
307 seq_printf(seq, "tx_poll_busy \t\t: %d\n", SDPSTATS_COUNTER_GET(tx_poll_busy));
308 seq_printf(seq, "tx_poll_hit \t\t: %d\n", SDPSTATS_COUNTER_GET(tx_poll_hit));
309
310 seq_printf(seq, "CQ stats:\n");
311 seq_printf(seq, "- RX interrupts\t\t: %d\n", SDPSTATS_COUNTER_GET(rx_int_count));
312 seq_printf(seq, "- TX interrupts\t\t: %d\n", SDPSTATS_COUNTER_GET(tx_int_count));
313
314 seq_printf(seq, "ZCopy stats:\n");
315 seq_printf(seq, "- TX timeout\t\t: %d\n", SDPSTATS_COUNTER_GET(zcopy_tx_timeout));
316 seq_printf(seq, "- TX cross send\t\t: %d\n", SDPSTATS_COUNTER_GET(zcopy_cross_send));
317 seq_printf(seq, "- TX aborted by peer\t: %d\n", SDPSTATS_COUNTER_GET(zcopy_tx_aborted));
318 seq_printf(seq, "- TX error\t\t: %d\n", SDPSTATS_COUNTER_GET(zcopy_tx_error));
319 return 0;
320 }
321
sdpstats_write(struct file * file,const char __user * buf,size_t count,loff_t * offs)322 static ssize_t sdpstats_write(struct file *file, const char __user *buf,
323 size_t count, loff_t *offs)
324 {
325 int i;
326
327 for_each_possible_cpu(i)
328 memset(&per_cpu(sdpstats, i), 0, sizeof(struct sdpstats));
329 printk(KERN_WARNING "Cleared sdp statistics\n");
330
331 return count;
332 }
333
sdpstats_seq_open(struct inode * inode,struct file * file)334 static int sdpstats_seq_open(struct inode *inode, struct file *file)
335 {
336 return single_open(file, sdpstats_seq_show, NULL);
337 }
338
339 static struct file_operations sdpstats_fops = {
340 .owner = THIS_MODULE,
341 .open = sdpstats_seq_open,
342 .read = seq_read,
343 .write = sdpstats_write,
344 .llseek = seq_lseek,
345 .release = single_release,
346 };
347
348 #endif
349
350 #ifdef SDP_PROFILING
351 struct sdpprf_log sdpprf_log[SDPPRF_LOG_SIZE];
352 int sdpprf_log_count;
353
354 static unsigned long long start_t;
355
sdpprf_show(struct seq_file * m,void * v)356 static int sdpprf_show(struct seq_file *m, void *v)
357 {
358 struct sdpprf_log *l = v;
359 unsigned long nsec_rem, t;
360
361 if (!sdpprf_log_count) {
362 seq_printf(m, "No performance logs\n");
363 goto out;
364 }
365
366 t = l->time - start_t;
367 nsec_rem = do_div(t, 1000000000);
368
369 seq_printf(m, "%-6d: [%5lu.%06lu] %-50s - [%d{%d} %d:%d] "
370 "mb: %p %s:%d\n",
371 l->idx, (unsigned long)t, nsec_rem/1000,
372 l->msg, l->pid, l->cpu, l->sk_num, l->sk_dport,
373 l->mb, l->func, l->line);
374 out:
375 return 0;
376 }
377
sdpprf_start(struct seq_file * p,loff_t * pos)378 static void *sdpprf_start(struct seq_file *p, loff_t *pos)
379 {
380 int idx = *pos;
381
382 if (!*pos) {
383 if (!sdpprf_log_count)
384 return SEQ_START_TOKEN;
385 }
386
387 if (*pos >= MIN(sdpprf_log_count, SDPPRF_LOG_SIZE - 1))
388 return NULL;
389
390 if (sdpprf_log_count >= SDPPRF_LOG_SIZE - 1) {
391 int off = sdpprf_log_count & (SDPPRF_LOG_SIZE - 1);
392 idx = (idx + off) & (SDPPRF_LOG_SIZE - 1);
393
394 }
395
396 if (!start_t)
397 start_t = sdpprf_log[idx].time;
398 return &sdpprf_log[idx];
399 }
400
sdpprf_next(struct seq_file * p,void * v,loff_t * pos)401 static void *sdpprf_next(struct seq_file *p, void *v, loff_t *pos)
402 {
403 struct sdpprf_log *l = v;
404
405 if (++*pos >= MIN(sdpprf_log_count, SDPPRF_LOG_SIZE - 1))
406 return NULL;
407
408 ++l;
409 if (l - &sdpprf_log[0] >= SDPPRF_LOG_SIZE - 1)
410 return &sdpprf_log[0];
411
412 return l;
413 }
414
sdpprf_stop(struct seq_file * p,void * v)415 static void sdpprf_stop(struct seq_file *p, void *v)
416 {
417 }
418
419 static struct seq_operations sdpprf_ops = {
420 .start = sdpprf_start,
421 .stop = sdpprf_stop,
422 .next = sdpprf_next,
423 .show = sdpprf_show,
424 };
425
sdpprf_open(struct inode * inode,struct file * file)426 static int sdpprf_open(struct inode *inode, struct file *file)
427 {
428 int res;
429
430 res = seq_open(file, &sdpprf_ops);
431
432 return res;
433 }
434
sdpprf_write(struct file * file,const char __user * buf,size_t count,loff_t * offs)435 static ssize_t sdpprf_write(struct file *file, const char __user *buf,
436 size_t count, loff_t *offs)
437 {
438 sdpprf_log_count = 0;
439 printk(KERN_INFO "Cleared sdpprf statistics\n");
440
441 return count;
442 }
443
444 static struct file_operations sdpprf_fops = {
445 .open = sdpprf_open,
446 .read = seq_read,
447 .llseek = seq_lseek,
448 .release = seq_release,
449 .write = sdpprf_write,
450 };
451 #endif /* SDP_PROFILING */
452
sdp_proc_init(void)453 int __init sdp_proc_init(void)
454 {
455 struct proc_dir_entry *p = NULL;
456 #ifdef SDPSTATS_ON
457 struct proc_dir_entry *stats = NULL;
458 #endif
459 #ifdef SDP_PROFILING
460 struct proc_dir_entry *prof = NULL;
461 #endif
462
463 sdp_seq_afinfo.seq_fops->owner = sdp_seq_afinfo.owner;
464 sdp_seq_afinfo.seq_fops->open = sdp_seq_open;
465 sdp_seq_afinfo.seq_fops->read = seq_read;
466 sdp_seq_afinfo.seq_fops->llseek = seq_lseek;
467 sdp_seq_afinfo.seq_fops->release = seq_release_private;
468
469 p = proc_net_fops_create(&init_net, sdp_seq_afinfo.name, S_IRUGO,
470 sdp_seq_afinfo.seq_fops);
471 if (p)
472 p->data = &sdp_seq_afinfo;
473 else
474 goto no_mem;
475
476 #ifdef SDPSTATS_ON
477
478 stats = proc_net_fops_create(&init_net, PROC_SDP_STATS,
479 S_IRUGO | S_IWUGO, &sdpstats_fops);
480 if (!stats)
481 goto no_mem_stats;
482
483 #endif
484
485 #ifdef SDP_PROFILING
486 prof = proc_net_fops_create(&init_net, PROC_SDP_PERF,
487 S_IRUGO | S_IWUGO, &sdpprf_fops);
488 if (!prof)
489 goto no_mem_prof;
490 #endif
491
492 return 0;
493
494 #ifdef SDP_PROFILING
495 no_mem_prof:
496 #endif
497
498 #ifdef SDPSTATS_ON
499 proc_net_remove(&init_net, PROC_SDP_STATS);
500
501 no_mem_stats:
502 #endif
503 proc_net_remove(&init_net, sdp_seq_afinfo.name);
504
505 no_mem:
506 return -ENOMEM;
507 }
508
sdp_proc_unregister(void)509 void sdp_proc_unregister(void)
510 {
511 proc_net_remove(&init_net, sdp_seq_afinfo.name);
512 memset(sdp_seq_afinfo.seq_fops, 0, sizeof(*sdp_seq_afinfo.seq_fops));
513
514 #ifdef SDPSTATS_ON
515 proc_net_remove(&init_net, PROC_SDP_STATS);
516 #endif
517 #ifdef SDP_PROFILING
518 proc_net_remove(&init_net, PROC_SDP_PERF);
519 #endif
520 }
521
522 #else /* CONFIG_PROC_FS */
523
sdp_proc_init(void)524 int __init sdp_proc_init(void)
525 {
526 return 0;
527 }
528
sdp_proc_unregister(void)529 void sdp_proc_unregister(void)
530 {
531
532 }
533 #endif /* CONFIG_PROC_FS */
534