1 /* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
6 * debug functionality for o2net
8 * Copyright (C) 2005, 2008 Oracle. All rights reserved.
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the
22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 * Boston, MA 021110-1307, USA.
27 #ifdef CONFIG_DEBUG_FS
29 #include <linux/module.h>
30 #include <linux/types.h>
31 #include <linux/slab.h>
32 #include <linux/idr.h>
33 #include <linux/kref.h>
34 #include <linux/seq_file.h>
35 #include <linux/debugfs.h>
37 #include <linux/uaccess.h>
40 #include "nodemanager.h"
41 #define MLOG_MASK_PREFIX ML_TCP
44 #include "tcp_internal.h"
46 #define O2NET_DEBUG_DIR "o2net"
47 #define SC_DEBUG_NAME "sock_containers"
48 #define NST_DEBUG_NAME "send_tracking"
50 static struct dentry *o2net_dentry;
51 static struct dentry *sc_dentry;
52 static struct dentry *nst_dentry;
54 static DEFINE_SPINLOCK(o2net_debug_lock);
56 static LIST_HEAD(sock_containers);
57 static LIST_HEAD(send_tracking);
59 void o2net_debug_add_nst(struct o2net_send_tracking *nst)
61 spin_lock(&o2net_debug_lock);
62 list_add(&nst->st_net_debug_item, &send_tracking);
63 spin_unlock(&o2net_debug_lock);
66 void o2net_debug_del_nst(struct o2net_send_tracking *nst)
68 spin_lock(&o2net_debug_lock);
69 if (!list_empty(&nst->st_net_debug_item))
70 list_del_init(&nst->st_net_debug_item);
71 spin_unlock(&o2net_debug_lock);
74 static struct o2net_send_tracking
75 *next_nst(struct o2net_send_tracking *nst_start)
77 struct o2net_send_tracking *nst, *ret = NULL;
79 assert_spin_locked(&o2net_debug_lock);
81 list_for_each_entry(nst, &nst_start->st_net_debug_item,
83 /* discover the head of the list */
84 if (&nst->st_net_debug_item == &send_tracking)
87 /* use st_task to detect real nsts in the list */
88 if (nst->st_task != NULL) {
97 static void *nst_seq_start(struct seq_file *seq, loff_t *pos)
99 struct o2net_send_tracking *nst, *dummy_nst = seq->private;
101 spin_lock(&o2net_debug_lock);
102 nst = next_nst(dummy_nst);
103 spin_unlock(&o2net_debug_lock);
108 static void *nst_seq_next(struct seq_file *seq, void *v, loff_t *pos)
110 struct o2net_send_tracking *nst, *dummy_nst = seq->private;
112 spin_lock(&o2net_debug_lock);
113 nst = next_nst(dummy_nst);
114 list_del_init(&dummy_nst->st_net_debug_item);
116 list_add(&dummy_nst->st_net_debug_item,
117 &nst->st_net_debug_item);
118 spin_unlock(&o2net_debug_lock);
120 return nst; /* unused, just needs to be null when done */
123 static int nst_seq_show(struct seq_file *seq, void *v)
125 struct o2net_send_tracking *nst, *dummy_nst = seq->private;
127 s64 sock, send, status;
129 spin_lock(&o2net_debug_lock);
130 nst = next_nst(dummy_nst);
133 sock = ktime_to_us(ktime_sub(now, nst->st_sock_time));
134 send = ktime_to_us(ktime_sub(now, nst->st_send_time));
135 status = ktime_to_us(ktime_sub(now, nst->st_status_time));
138 /* get_task_comm isn't exported. oh well. */
139 seq_printf(seq, "%p:\n"
142 " process name: %s\n"
146 " message type: %u\n"
147 " message key: 0x%08x\n"
148 " sock acquiry: %lld usecs ago\n"
149 " send start: %lld usecs ago\n"
150 " wait start: %lld usecs ago\n",
151 nst, (unsigned long)task_pid_nr(nst->st_task),
152 (unsigned long)nst->st_task->tgid,
153 nst->st_task->comm, nst->st_node,
154 nst->st_sc, nst->st_id, nst->st_msg_type,
161 spin_unlock(&o2net_debug_lock);
166 static void nst_seq_stop(struct seq_file *seq, void *v)
170 static const struct seq_operations nst_seq_ops = {
171 .start = nst_seq_start,
172 .next = nst_seq_next,
173 .stop = nst_seq_stop,
174 .show = nst_seq_show,
177 static int nst_fop_open(struct inode *inode, struct file *file)
179 struct o2net_send_tracking *dummy_nst;
180 struct seq_file *seq;
183 dummy_nst = kmalloc(sizeof(struct o2net_send_tracking), GFP_KERNEL);
184 if (dummy_nst == NULL) {
188 dummy_nst->st_task = NULL;
190 ret = seq_open(file, &nst_seq_ops);
194 seq = file->private_data;
195 seq->private = dummy_nst;
196 o2net_debug_add_nst(dummy_nst);
205 static int nst_fop_release(struct inode *inode, struct file *file)
207 struct seq_file *seq = file->private_data;
208 struct o2net_send_tracking *dummy_nst = seq->private;
210 o2net_debug_del_nst(dummy_nst);
211 return seq_release_private(inode, file);
214 static const struct file_operations nst_seq_fops = {
215 .open = nst_fop_open,
218 .release = nst_fop_release,
221 void o2net_debug_add_sc(struct o2net_sock_container *sc)
223 spin_lock(&o2net_debug_lock);
224 list_add(&sc->sc_net_debug_item, &sock_containers);
225 spin_unlock(&o2net_debug_lock);
228 void o2net_debug_del_sc(struct o2net_sock_container *sc)
230 spin_lock(&o2net_debug_lock);
231 list_del_init(&sc->sc_net_debug_item);
232 spin_unlock(&o2net_debug_lock);
235 static struct o2net_sock_container
236 *next_sc(struct o2net_sock_container *sc_start)
238 struct o2net_sock_container *sc, *ret = NULL;
240 assert_spin_locked(&o2net_debug_lock);
242 list_for_each_entry(sc, &sc_start->sc_net_debug_item,
244 /* discover the head of the list miscast as a sc */
245 if (&sc->sc_net_debug_item == &sock_containers)
248 /* use sc_page to detect real scs in the list */
249 if (sc->sc_page != NULL) {
258 static void *sc_seq_start(struct seq_file *seq, loff_t *pos)
260 struct o2net_sock_container *sc, *dummy_sc = seq->private;
262 spin_lock(&o2net_debug_lock);
263 sc = next_sc(dummy_sc);
264 spin_unlock(&o2net_debug_lock);
269 static void *sc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
271 struct o2net_sock_container *sc, *dummy_sc = seq->private;
273 spin_lock(&o2net_debug_lock);
274 sc = next_sc(dummy_sc);
275 list_del_init(&dummy_sc->sc_net_debug_item);
277 list_add(&dummy_sc->sc_net_debug_item, &sc->sc_net_debug_item);
278 spin_unlock(&o2net_debug_lock);
280 return sc; /* unused, just needs to be null when done */
283 #define TV_SEC_USEC(TV) TV.tv_sec, (long)TV.tv_usec
285 static int sc_seq_show(struct seq_file *seq, void *v)
287 struct o2net_sock_container *sc, *dummy_sc = seq->private;
289 spin_lock(&o2net_debug_lock);
290 sc = next_sc(dummy_sc);
293 struct inet_sock *inet = NULL;
295 __be32 saddr = 0, daddr = 0;
296 __be16 sport = 0, dport = 0;
299 inet = inet_sk(sc->sc_sock->sk);
300 /* the stack's structs aren't sparse endian clean */
301 saddr = (__force __be32)inet->inet_saddr;
302 daddr = (__force __be32)inet->inet_daddr;
303 sport = (__force __be16)inet->inet_sport;
304 dport = (__force __be16)inet->inet_dport;
307 /* XXX sigh, inet-> doesn't have sparse annotation so any
308 * use of it here generates a warning with -Wbitwise */
309 seq_printf(seq, "%p:\n"
315 " handshake ok: %u\n"
317 " data ready: %lu.%ld\n"
318 " advance start: %lu.%ld\n"
319 " advance stop: %lu.%ld\n"
320 " func start: %lu.%ld\n"
321 " func stop: %lu.%ld\n"
325 atomic_read(&sc->sc_kref.refcount),
326 &saddr, inet ? ntohs(sport) : 0,
327 &daddr, inet ? ntohs(dport) : 0,
328 sc->sc_node->nd_name,
331 TV_SEC_USEC(sc->sc_tv_timer),
332 TV_SEC_USEC(sc->sc_tv_data_ready),
333 TV_SEC_USEC(sc->sc_tv_advance_start),
334 TV_SEC_USEC(sc->sc_tv_advance_stop),
335 TV_SEC_USEC(sc->sc_tv_func_start),
336 TV_SEC_USEC(sc->sc_tv_func_stop),
342 spin_unlock(&o2net_debug_lock);
347 static void sc_seq_stop(struct seq_file *seq, void *v)
351 static const struct seq_operations sc_seq_ops = {
352 .start = sc_seq_start,
358 static int sc_fop_open(struct inode *inode, struct file *file)
360 struct o2net_sock_container *dummy_sc;
361 struct seq_file *seq;
364 dummy_sc = kmalloc(sizeof(struct o2net_sock_container), GFP_KERNEL);
365 if (dummy_sc == NULL) {
369 dummy_sc->sc_page = NULL;
371 ret = seq_open(file, &sc_seq_ops);
375 seq = file->private_data;
376 seq->private = dummy_sc;
377 o2net_debug_add_sc(dummy_sc);
386 static int sc_fop_release(struct inode *inode, struct file *file)
388 struct seq_file *seq = file->private_data;
389 struct o2net_sock_container *dummy_sc = seq->private;
391 o2net_debug_del_sc(dummy_sc);
392 return seq_release_private(inode, file);
395 static const struct file_operations sc_seq_fops = {
399 .release = sc_fop_release,
402 int o2net_debugfs_init(void)
404 o2net_dentry = debugfs_create_dir(O2NET_DEBUG_DIR, NULL);
410 nst_dentry = debugfs_create_file(NST_DEBUG_NAME, S_IFREG|S_IRUSR,
418 sc_dentry = debugfs_create_file(SC_DEBUG_NAME, S_IFREG|S_IRUSR,
428 debugfs_remove(sc_dentry);
429 debugfs_remove(nst_dentry);
430 debugfs_remove(o2net_dentry);
434 void o2net_debugfs_exit(void)
436 debugfs_remove(sc_dentry);
437 debugfs_remove(nst_dentry);
438 debugfs_remove(o2net_dentry);
441 #endif /* CONFIG_DEBUG_FS */