xref: /openbmc/linux/fs/ocfs2/cluster/masklog.h (revision b6dcefde)
1 /* -*- mode: c; c-basic-offset: 8; -*-
2  * vim: noexpandtab sw=8 ts=8 sts=0:
3  *
4  * Copyright (C) 2005 Oracle.  All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public
17  * License along with this program; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 021110-1307, USA.
20  */
21 
22 #ifndef O2CLUSTER_MASKLOG_H
23 #define O2CLUSTER_MASKLOG_H
24 
25 /*
26  * For now this is a trivial wrapper around printk() that gives the critical
27  * ability to enable sets of debugging output at run-time.  In the future this
28  * will almost certainly be redirected to relayfs so that it can pay a
29  * substantially lower heisenberg tax.
30  *
31  * Callers associate the message with a bitmask and a global bitmask is
32  * maintained with help from /proc.  If any of the bits match the message is
33  * output.
34  *
35  * We must have efficient bit tests on i386 and it seems gcc still emits crazy
36  * code for the 64bit compare.  It emits very good code for the dual unsigned
37  * long tests, though, completely avoiding tests that can never pass if the
38  * caller gives a constant bitmask that fills one of the longs with all 0s.  So
39  * the desire is to have almost all of the calls decided on by comparing just
40  * one of the longs.  This leads to having infrequently given bits that are
41  * frequently matched in the high bits.
42  *
43  * _ERROR and _NOTICE are used for messages that always go to the console and
44  * have appropriate KERN_ prefixes.  We wrap these in our function instead of
45  * just calling printk() so that this can eventually make its way through
46  * relayfs along with the debugging messages.  Everything else gets KERN_DEBUG.
47  * The inline tests and macro dance give GCC the opportunity to quite cleverly
48  * only emit the appropriage printk() when the caller passes in a constant
49  * mask, as is almost always the case.
50  *
51  * All this bitmask nonsense is managed from the files under
52  * /sys/fs/o2cb/logmask/.  Reading the files gives a straightforward
53  * indication of which bits are allowed (allow) or denied (off/deny).
54  * 	ENTRY deny
55  * 	EXIT deny
56  * 	TCP off
57  * 	MSG off
58  * 	SOCKET off
59  * 	ERROR allow
60  * 	NOTICE allow
61  *
62  * Writing changes the state of a given bit and requires a strictly formatted
63  * single write() call:
64  *
65  * 	write(fd, "allow", 5);
66  *
67  * Echoing allow/deny/off string into the logmask files can flip the bits
68  * on or off as expected; here is the bash script for example:
69  *
70  * log_mask="/sys/fs/o2cb/log_mask"
71  * for node in ENTRY EXIT TCP MSG SOCKET ERROR NOTICE; do
72  *	echo allow >"$log_mask"/"$node"
73  * done
74  *
75  * The debugfs.ocfs2 tool can also flip the bits with the -l option:
76  *
77  * debugfs.ocfs2 -l TCP allow
78  */
79 
80 /* for task_struct */
81 #include <linux/sched.h>
82 
83 /* bits that are frequently given and infrequently matched in the low word */
84 /* NOTE: If you add a flag, you need to also update mlog.c! */
85 #define ML_ENTRY	0x0000000000000001ULL /* func call entry */
86 #define ML_EXIT		0x0000000000000002ULL /* func call exit */
87 #define ML_TCP		0x0000000000000004ULL /* net cluster/tcp.c */
88 #define ML_MSG		0x0000000000000008ULL /* net network messages */
89 #define ML_SOCKET	0x0000000000000010ULL /* net socket lifetime */
90 #define ML_HEARTBEAT	0x0000000000000020ULL /* hb all heartbeat tracking */
91 #define ML_HB_BIO	0x0000000000000040ULL /* hb io tracing */
92 #define ML_DLMFS	0x0000000000000080ULL /* dlm user dlmfs */
93 #define ML_DLM		0x0000000000000100ULL /* dlm general debugging */
94 #define ML_DLM_DOMAIN	0x0000000000000200ULL /* dlm domain debugging */
95 #define ML_DLM_THREAD	0x0000000000000400ULL /* dlm domain thread */
96 #define ML_DLM_MASTER	0x0000000000000800ULL /* dlm master functions */
97 #define ML_DLM_RECOVERY	0x0000000000001000ULL /* dlm master functions */
98 #define ML_AIO		0x0000000000002000ULL /* ocfs2 aio read and write */
99 #define ML_JOURNAL	0x0000000000004000ULL /* ocfs2 journalling functions */
100 #define ML_DISK_ALLOC	0x0000000000008000ULL /* ocfs2 disk allocation */
101 #define ML_SUPER	0x0000000000010000ULL /* ocfs2 mount / umount */
102 #define ML_FILE_IO	0x0000000000020000ULL /* ocfs2 file I/O */
103 #define ML_EXTENT_MAP	0x0000000000040000ULL /* ocfs2 extent map caching */
104 #define ML_DLM_GLUE	0x0000000000080000ULL /* ocfs2 dlm glue layer */
105 #define ML_BH_IO	0x0000000000100000ULL /* ocfs2 buffer I/O */
106 #define ML_UPTODATE	0x0000000000200000ULL /* ocfs2 caching sequence #'s */
107 #define ML_NAMEI	0x0000000000400000ULL /* ocfs2 directory / namespace */
108 #define ML_INODE	0x0000000000800000ULL /* ocfs2 inode manipulation */
109 #define ML_VOTE		0x0000000001000000ULL /* ocfs2 node messaging  */
110 #define ML_DCACHE	0x0000000002000000ULL /* ocfs2 dcache operations */
111 #define ML_CONN		0x0000000004000000ULL /* net connection management */
112 #define ML_QUORUM	0x0000000008000000ULL /* net connection quorum */
113 #define ML_EXPORT	0x0000000010000000ULL /* ocfs2 export operations */
114 #define ML_XATTR	0x0000000020000000ULL /* ocfs2 extended attributes */
115 #define ML_QUOTA	0x0000000040000000ULL /* ocfs2 quota operations */
116 #define ML_REFCOUNT	0x0000000080000000ULL /* refcount tree operations */
117 /* bits that are infrequently given and frequently matched in the high word */
118 #define ML_ERROR	0x0000000100000000ULL /* sent to KERN_ERR */
119 #define ML_NOTICE	0x0000000200000000ULL /* setn to KERN_NOTICE */
120 #define ML_KTHREAD	0x0000000400000000ULL /* kernel thread activity */
121 
122 #define MLOG_INITIAL_AND_MASK (ML_ERROR|ML_NOTICE)
123 #define MLOG_INITIAL_NOT_MASK (ML_ENTRY|ML_EXIT)
124 #ifndef MLOG_MASK_PREFIX
125 #define MLOG_MASK_PREFIX 0
126 #endif
127 
128 /*
129  * When logging is disabled, force the bit test to 0 for anything other
130  * than errors and notices, allowing gcc to remove the code completely.
131  * When enabled, allow all masks.
132  */
133 #if defined(CONFIG_OCFS2_DEBUG_MASKLOG)
134 #define ML_ALLOWED_BITS ~0
135 #else
136 #define ML_ALLOWED_BITS (ML_ERROR|ML_NOTICE)
137 #endif
138 
139 #define MLOG_MAX_BITS 64
140 
141 struct mlog_bits {
142 	unsigned long words[MLOG_MAX_BITS / BITS_PER_LONG];
143 };
144 
145 extern struct mlog_bits mlog_and_bits, mlog_not_bits;
146 
147 #if BITS_PER_LONG == 32
148 
149 #define __mlog_test_u64(mask, bits)			\
150 	( (u32)(mask & 0xffffffff) & bits.words[0] || 	\
151 	  ((u64)(mask) >> 32) & bits.words[1] )
152 #define __mlog_set_u64(mask, bits) do {			\
153 	bits.words[0] |= (u32)(mask & 0xffffffff);	\
154        	bits.words[1] |= (u64)(mask) >> 32;		\
155 } while (0)
156 #define __mlog_clear_u64(mask, bits) do {		\
157 	bits.words[0] &= ~((u32)(mask & 0xffffffff));	\
158        	bits.words[1] &= ~((u64)(mask) >> 32);		\
159 } while (0)
160 #define MLOG_BITS_RHS(mask) {				\
161 	{						\
162 		[0] = (u32)(mask & 0xffffffff),		\
163 		[1] = (u64)(mask) >> 32,		\
164 	}						\
165 }
166 
167 #else /* 32bit long above, 64bit long below */
168 
169 #define __mlog_test_u64(mask, bits)	((mask) & bits.words[0])
170 #define __mlog_set_u64(mask, bits) do {		\
171 	bits.words[0] |= (mask);		\
172 } while (0)
173 #define __mlog_clear_u64(mask, bits) do {	\
174 	bits.words[0] &= ~(mask);		\
175 } while (0)
176 #define MLOG_BITS_RHS(mask) { { (mask) } }
177 
178 #endif
179 
180 /*
181  * smp_processor_id() "helpfully" screams when called outside preemptible
182  * regions in current kernels.  sles doesn't have the variants that don't
183  * scream.  just do this instead of trying to guess which we're building
184  * against.. *sigh*.
185  */
186 #define __mlog_cpu_guess ({		\
187 	unsigned long _cpu = get_cpu();	\
188 	put_cpu();			\
189 	_cpu;				\
190 })
191 
192 /* In the following two macros, the whitespace after the ',' just
193  * before ##args is intentional. Otherwise, gcc 2.95 will eat the
194  * previous token if args expands to nothing.
195  */
196 #define __mlog_printk(level, fmt, args...)				\
197 	printk(level "(%u,%lu):%s:%d " fmt, task_pid_nr(current),	\
198 	       __mlog_cpu_guess, __PRETTY_FUNCTION__, __LINE__ ,	\
199 	       ##args)
200 
201 #define mlog(mask, fmt, args...) do {					\
202 	u64 __m = MLOG_MASK_PREFIX | (mask);				\
203 	if ((__m & ML_ALLOWED_BITS) &&					\
204 	    __mlog_test_u64(__m, mlog_and_bits) &&			\
205 	    !__mlog_test_u64(__m, mlog_not_bits)) {			\
206 		if (__m & ML_ERROR)					\
207 			__mlog_printk(KERN_ERR, "ERROR: "fmt , ##args);	\
208 		else if (__m & ML_NOTICE)				\
209 			__mlog_printk(KERN_NOTICE, fmt , ##args);	\
210 		else __mlog_printk(KERN_INFO, fmt , ##args);		\
211 	}								\
212 } while (0)
213 
214 #define mlog_errno(st) do {						\
215 	int _st = (st);							\
216 	if (_st != -ERESTARTSYS && _st != -EINTR &&			\
217 	    _st != AOP_TRUNCATED_PAGE && _st != -ENOSPC)		\
218 		mlog(ML_ERROR, "status = %lld\n", (long long)_st);	\
219 } while (0)
220 
221 #if defined(CONFIG_OCFS2_DEBUG_MASKLOG)
222 #define mlog_entry(fmt, args...) do {					\
223 	mlog(ML_ENTRY, "ENTRY:" fmt , ##args);				\
224 } while (0)
225 
226 #define mlog_entry_void() do {						\
227 	mlog(ML_ENTRY, "ENTRY:\n");					\
228 } while (0)
229 
230 /*
231  * We disable this for sparse.
232  */
233 #if !defined(__CHECKER__)
234 #define mlog_exit(st) do {						     \
235 	if (__builtin_types_compatible_p(typeof(st), unsigned long))	     \
236 		mlog(ML_EXIT, "EXIT: %lu\n", (unsigned long) (st));	     \
237 	else if (__builtin_types_compatible_p(typeof(st), signed long))      \
238 		mlog(ML_EXIT, "EXIT: %ld\n", (signed long) (st));	     \
239 	else if (__builtin_types_compatible_p(typeof(st), unsigned int)	     \
240 		 || __builtin_types_compatible_p(typeof(st), unsigned short) \
241 		 || __builtin_types_compatible_p(typeof(st), unsigned char)) \
242 		mlog(ML_EXIT, "EXIT: %u\n", (unsigned int) (st));	     \
243 	else if (__builtin_types_compatible_p(typeof(st), signed int)	     \
244 		 || __builtin_types_compatible_p(typeof(st), signed short)   \
245 		 || __builtin_types_compatible_p(typeof(st), signed char))   \
246 		mlog(ML_EXIT, "EXIT: %d\n", (signed int) (st));		     \
247 	else if (__builtin_types_compatible_p(typeof(st), long long))	     \
248 		mlog(ML_EXIT, "EXIT: %lld\n", (long long) (st));	     \
249 	else								     \
250 		mlog(ML_EXIT, "EXIT: %llu\n", (unsigned long long) (st));    \
251 } while (0)
252 #else
253 #define mlog_exit(st) do {						     \
254 	mlog(ML_EXIT, "EXIT: %lld\n", (long long) (st));		     \
255 } while (0)
256 #endif
257 
258 #define mlog_exit_ptr(ptr) do {						\
259 	mlog(ML_EXIT, "EXIT: %p\n", ptr);				\
260 } while (0)
261 
262 #define mlog_exit_void() do {						\
263 	mlog(ML_EXIT, "EXIT\n");					\
264 } while (0)
265 #else
266 #define mlog_entry(...)  do { } while (0)
267 #define mlog_entry_void(...)  do { } while (0)
268 #define mlog_exit(...)  do { } while (0)
269 #define mlog_exit_ptr(...)  do { } while (0)
270 #define mlog_exit_void(...)  do { } while (0)
271 #endif  /* defined(CONFIG_OCFS2_DEBUG_MASKLOG) */
272 
273 #define mlog_bug_on_msg(cond, fmt, args...) do {			\
274 	if (cond) {							\
275 		mlog(ML_ERROR, "bug expression: " #cond "\n");		\
276 		mlog(ML_ERROR, fmt, ##args);				\
277 		BUG();							\
278 	}								\
279 } while (0)
280 
281 #include <linux/kobject.h>
282 #include <linux/sysfs.h>
283 int mlog_sys_init(struct kset *o2cb_subsys);
284 void mlog_sys_shutdown(void);
285 
286 #endif /* O2CLUSTER_MASKLOG_H */
287