1 /*
2 * GPL HEADER START
3 *
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 only,
8 * as published by the Free Software Foundation.
9 *
10 * This program is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License version 2 for more details (a copy is included
14 * in the LICENSE file that accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License
17 * version 2 along with this program; If not, see
18 * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19 *
20 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21 * CA 95054 USA or visit www.sun.com if you need additional information or
22 * have any questions.
23 *
24 * GPL HEADER END
25 */
26 /*
27 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
28 * Use is subject to license terms.
29 *
30 * Copyright (c) 2011, 2012, Intel Corporation.
31 */
32 /*
33 * This file is part of Lustre, http://www.lustre.org/
34 * Lustre is a trademark of Sun Microsystems, Inc.
35 *
36 * libcfs/libcfs/debug.c
37 *
38 * Author: Phil Schwan <phil@clusterfs.com>
39 *
40 */
41
42 # define DEBUG_SUBSYSTEM S_LNET
43
44 #include "../../include/linux/libcfs/libcfs.h"
45 #include "tracefile.h"
46
47 static char debug_file_name[1024];
48
49 unsigned int libcfs_subsystem_debug = ~0;
50 module_param(libcfs_subsystem_debug, int, 0644);
51 MODULE_PARM_DESC(libcfs_subsystem_debug, "Lustre kernel debug subsystem mask");
52 EXPORT_SYMBOL(libcfs_subsystem_debug);
53
54 unsigned int libcfs_debug = (D_CANTMASK |
55 D_NETERROR | D_HA | D_CONFIG | D_IOCTL);
56 module_param(libcfs_debug, int, 0644);
57 MODULE_PARM_DESC(libcfs_debug, "Lustre kernel debug mask");
58 EXPORT_SYMBOL(libcfs_debug);
59
libcfs_param_debug_mb_set(const char * val,const struct kernel_param * kp)60 static int libcfs_param_debug_mb_set(const char *val,
61 const struct kernel_param *kp)
62 {
63 int rc;
64 unsigned num;
65
66 rc = kstrtouint(val, 0, &num);
67 if (rc < 0)
68 return rc;
69
70 if (!*((unsigned int *)kp->arg)) {
71 *((unsigned int *)kp->arg) = num;
72 return 0;
73 }
74
75 rc = cfs_trace_set_debug_mb(num);
76
77 if (!rc)
78 *((unsigned int *)kp->arg) = cfs_trace_get_debug_mb();
79
80 return rc;
81 }
82
83 /* While debug_mb setting look like unsigned int, in fact
84 * it needs quite a bunch of extra processing, so we define special
85 * debugmb parameter type with corresponding methods to handle this case */
86 static struct kernel_param_ops param_ops_debugmb = {
87 .set = libcfs_param_debug_mb_set,
88 .get = param_get_uint,
89 };
90
91 #define param_check_debugmb(name, p) \
92 __param_check(name, p, unsigned int)
93
94 static unsigned int libcfs_debug_mb;
95 module_param(libcfs_debug_mb, debugmb, 0644);
96 MODULE_PARM_DESC(libcfs_debug_mb, "Total debug buffer size.");
97 EXPORT_SYMBOL(libcfs_debug_mb);
98
99 unsigned int libcfs_printk = D_CANTMASK;
100 module_param(libcfs_printk, uint, 0644);
101 MODULE_PARM_DESC(libcfs_printk, "Lustre kernel debug console mask");
102 EXPORT_SYMBOL(libcfs_printk);
103
104 unsigned int libcfs_console_ratelimit = 1;
105 module_param(libcfs_console_ratelimit, uint, 0644);
106 MODULE_PARM_DESC(libcfs_console_ratelimit, "Lustre kernel debug console ratelimit (0 to disable)");
107 EXPORT_SYMBOL(libcfs_console_ratelimit);
108
param_set_delay_minmax(const char * val,const struct kernel_param * kp,long min,long max)109 static int param_set_delay_minmax(const char *val,
110 const struct kernel_param *kp,
111 long min, long max)
112 {
113 long d;
114 int sec;
115 int rc;
116
117 rc = kstrtoint(val, 0, &sec);
118 if (rc)
119 return -EINVAL;
120
121 d = cfs_time_seconds(sec) / 100;
122 if (d < min || d > max)
123 return -EINVAL;
124
125 *((unsigned int *)kp->arg) = d;
126
127 return 0;
128 }
129
param_get_delay(char * buffer,const struct kernel_param * kp)130 static int param_get_delay(char *buffer, const struct kernel_param *kp)
131 {
132 unsigned int d = *(unsigned int *)kp->arg;
133
134 return sprintf(buffer, "%u", (unsigned int)cfs_duration_sec(d * 100));
135 }
136
137 unsigned int libcfs_console_max_delay;
138 EXPORT_SYMBOL(libcfs_console_max_delay);
139 unsigned int libcfs_console_min_delay;
140 EXPORT_SYMBOL(libcfs_console_min_delay);
141
param_set_console_max_delay(const char * val,const struct kernel_param * kp)142 static int param_set_console_max_delay(const char *val,
143 const struct kernel_param *kp)
144 {
145 return param_set_delay_minmax(val, kp,
146 libcfs_console_min_delay, INT_MAX);
147 }
148
149 static struct kernel_param_ops param_ops_console_max_delay = {
150 .set = param_set_console_max_delay,
151 .get = param_get_delay,
152 };
153
154 #define param_check_console_max_delay(name, p) \
155 __param_check(name, p, unsigned int)
156
157 module_param(libcfs_console_max_delay, console_max_delay, 0644);
158 MODULE_PARM_DESC(libcfs_console_max_delay, "Lustre kernel debug console max delay (jiffies)");
159
param_set_console_min_delay(const char * val,const struct kernel_param * kp)160 static int param_set_console_min_delay(const char *val,
161 const struct kernel_param *kp)
162 {
163 return param_set_delay_minmax(val, kp,
164 1, libcfs_console_max_delay);
165 }
166
167 static struct kernel_param_ops param_ops_console_min_delay = {
168 .set = param_set_console_min_delay,
169 .get = param_get_delay,
170 };
171
172 #define param_check_console_min_delay(name, p) \
173 __param_check(name, p, unsigned int)
174
175 module_param(libcfs_console_min_delay, console_min_delay, 0644);
176 MODULE_PARM_DESC(libcfs_console_min_delay, "Lustre kernel debug console min delay (jiffies)");
177
param_set_uint_minmax(const char * val,const struct kernel_param * kp,unsigned int min,unsigned int max)178 static int param_set_uint_minmax(const char *val,
179 const struct kernel_param *kp,
180 unsigned int min, unsigned int max)
181 {
182 unsigned int num;
183 int ret;
184
185 if (!val)
186 return -EINVAL;
187 ret = kstrtouint(val, 0, &num);
188 if (ret < 0 || num < min || num > max)
189 return -EINVAL;
190 *((unsigned int *)kp->arg) = num;
191 return 0;
192 }
193
param_set_uintpos(const char * val,const struct kernel_param * kp)194 static int param_set_uintpos(const char *val, const struct kernel_param *kp)
195 {
196 return param_set_uint_minmax(val, kp, 1, -1);
197 }
198
199 static struct kernel_param_ops param_ops_uintpos = {
200 .set = param_set_uintpos,
201 .get = param_get_uint,
202 };
203
204 #define param_check_uintpos(name, p) \
205 __param_check(name, p, unsigned int)
206
207 unsigned int libcfs_console_backoff = CDEBUG_DEFAULT_BACKOFF;
208 module_param(libcfs_console_backoff, uintpos, 0644);
209 MODULE_PARM_DESC(libcfs_console_backoff, "Lustre kernel debug console backoff factor");
210 EXPORT_SYMBOL(libcfs_console_backoff);
211
212 unsigned int libcfs_debug_binary = 1;
213 EXPORT_SYMBOL(libcfs_debug_binary);
214
215 unsigned int libcfs_stack = 3 * THREAD_SIZE / 4;
216 EXPORT_SYMBOL(libcfs_stack);
217
218 unsigned int libcfs_catastrophe;
219 EXPORT_SYMBOL(libcfs_catastrophe);
220
221 unsigned int libcfs_panic_on_lbug = 1;
222 module_param(libcfs_panic_on_lbug, uint, 0644);
223 MODULE_PARM_DESC(libcfs_panic_on_lbug, "Lustre kernel panic on LBUG");
224 EXPORT_SYMBOL(libcfs_panic_on_lbug);
225
226 static wait_queue_head_t debug_ctlwq;
227
228 char libcfs_debug_file_path_arr[PATH_MAX] = LIBCFS_DEBUG_FILE_PATH_DEFAULT;
229
230 /* We need to pass a pointer here, but elsewhere this must be a const */
231 static char *libcfs_debug_file_path;
232 module_param(libcfs_debug_file_path, charp, 0644);
233 MODULE_PARM_DESC(libcfs_debug_file_path,
234 "Path for dumping debug logs, set 'NONE' to prevent log dumping");
235
236 int libcfs_panic_in_progress;
237
238 /* libcfs_debug_token2mask() expects the returned
239 * string in lower-case */
240 static const char *
libcfs_debug_subsys2str(int subsys)241 libcfs_debug_subsys2str(int subsys)
242 {
243 switch (1 << subsys) {
244 default:
245 return NULL;
246 case S_UNDEFINED:
247 return "undefined";
248 case S_MDC:
249 return "mdc";
250 case S_MDS:
251 return "mds";
252 case S_OSC:
253 return "osc";
254 case S_OST:
255 return "ost";
256 case S_CLASS:
257 return "class";
258 case S_LOG:
259 return "log";
260 case S_LLITE:
261 return "llite";
262 case S_RPC:
263 return "rpc";
264 case S_LNET:
265 return "lnet";
266 case S_LND:
267 return "lnd";
268 case S_PINGER:
269 return "pinger";
270 case S_FILTER:
271 return "filter";
272 case S_ECHO:
273 return "echo";
274 case S_LDLM:
275 return "ldlm";
276 case S_LOV:
277 return "lov";
278 case S_LQUOTA:
279 return "lquota";
280 case S_OSD:
281 return "osd";
282 case S_LMV:
283 return "lmv";
284 case S_SEC:
285 return "sec";
286 case S_GSS:
287 return "gss";
288 case S_MGC:
289 return "mgc";
290 case S_MGS:
291 return "mgs";
292 case S_FID:
293 return "fid";
294 case S_FLD:
295 return "fld";
296 }
297 }
298
299 /* libcfs_debug_token2mask() expects the returned
300 * string in lower-case */
301 static const char *
libcfs_debug_dbg2str(int debug)302 libcfs_debug_dbg2str(int debug)
303 {
304 switch (1 << debug) {
305 default:
306 return NULL;
307 case D_TRACE:
308 return "trace";
309 case D_INODE:
310 return "inode";
311 case D_SUPER:
312 return "super";
313 case D_EXT2:
314 return "ext2";
315 case D_MALLOC:
316 return "malloc";
317 case D_CACHE:
318 return "cache";
319 case D_INFO:
320 return "info";
321 case D_IOCTL:
322 return "ioctl";
323 case D_NETERROR:
324 return "neterror";
325 case D_NET:
326 return "net";
327 case D_WARNING:
328 return "warning";
329 case D_BUFFS:
330 return "buffs";
331 case D_OTHER:
332 return "other";
333 case D_DENTRY:
334 return "dentry";
335 case D_NETTRACE:
336 return "nettrace";
337 case D_PAGE:
338 return "page";
339 case D_DLMTRACE:
340 return "dlmtrace";
341 case D_ERROR:
342 return "error";
343 case D_EMERG:
344 return "emerg";
345 case D_HA:
346 return "ha";
347 case D_RPCTRACE:
348 return "rpctrace";
349 case D_VFSTRACE:
350 return "vfstrace";
351 case D_READA:
352 return "reada";
353 case D_MMAP:
354 return "mmap";
355 case D_CONFIG:
356 return "config";
357 case D_CONSOLE:
358 return "console";
359 case D_QUOTA:
360 return "quota";
361 case D_SEC:
362 return "sec";
363 case D_LFSCK:
364 return "lfsck";
365 }
366 }
367
368 int
libcfs_debug_mask2str(char * str,int size,int mask,int is_subsys)369 libcfs_debug_mask2str(char *str, int size, int mask, int is_subsys)
370 {
371 const char *(*fn)(int bit) = is_subsys ? libcfs_debug_subsys2str :
372 libcfs_debug_dbg2str;
373 int len = 0;
374 const char *token;
375 int i;
376
377 if (mask == 0) { /* "0" */
378 if (size > 0)
379 str[0] = '0';
380 len = 1;
381 } else { /* space-separated tokens */
382 for (i = 0; i < 32; i++) {
383 if ((mask & (1 << i)) == 0)
384 continue;
385
386 token = fn(i);
387 if (token == NULL) /* unused bit */
388 continue;
389
390 if (len > 0) { /* separator? */
391 if (len < size)
392 str[len] = ' ';
393 len++;
394 }
395
396 while (*token != 0) {
397 if (len < size)
398 str[len] = *token;
399 token++;
400 len++;
401 }
402 }
403 }
404
405 /* terminate 'str' */
406 if (len < size)
407 str[len] = 0;
408 else
409 str[size - 1] = 0;
410
411 return len;
412 }
413
414 int
libcfs_debug_str2mask(int * mask,const char * str,int is_subsys)415 libcfs_debug_str2mask(int *mask, const char *str, int is_subsys)
416 {
417 const char *(*fn)(int bit) = is_subsys ? libcfs_debug_subsys2str :
418 libcfs_debug_dbg2str;
419 int m = 0;
420 int matched;
421 int n;
422 int t;
423
424 /* Allow a number for backwards compatibility */
425
426 for (n = strlen(str); n > 0; n--)
427 if (!isspace(str[n-1]))
428 break;
429 matched = n;
430 t = sscanf(str, "%i%n", &m, &matched);
431 if (t >= 1 && matched == n) {
432 /* don't print warning for lctl set_param debug=0 or -1 */
433 if (m != 0 && m != -1)
434 CWARN("You are trying to use a numerical value for the mask - this will be deprecated in a future release.\n");
435 *mask = m;
436 return 0;
437 }
438
439 return cfs_str2mask(str, fn, mask, is_subsys ? 0 : D_CANTMASK,
440 0xffffffff);
441 }
442
443 /**
444 * Dump Lustre log to ::debug_file_path by calling tracefile_dump_all_pages()
445 */
libcfs_debug_dumplog_internal(void * arg)446 void libcfs_debug_dumplog_internal(void *arg)
447 {
448 void *journal_info;
449
450 journal_info = current->journal_info;
451 current->journal_info = NULL;
452
453 if (strncmp(libcfs_debug_file_path_arr, "NONE", 4) != 0) {
454 snprintf(debug_file_name, sizeof(debug_file_name) - 1,
455 "%s.%lld.%ld", libcfs_debug_file_path_arr,
456 (s64)ktime_get_real_seconds(), (long_ptr_t)arg);
457 pr_alert("LustreError: dumping log to %s\n",
458 debug_file_name);
459 cfs_tracefile_dump_all_pages(debug_file_name);
460 libcfs_run_debug_log_upcall(debug_file_name);
461 }
462
463 current->journal_info = journal_info;
464 }
465
libcfs_debug_dumplog_thread(void * arg)466 static int libcfs_debug_dumplog_thread(void *arg)
467 {
468 libcfs_debug_dumplog_internal(arg);
469 wake_up(&debug_ctlwq);
470 return 0;
471 }
472
libcfs_debug_dumplog(void)473 void libcfs_debug_dumplog(void)
474 {
475 wait_queue_t wait;
476 struct task_struct *dumper;
477
478 /* we're being careful to ensure that the kernel thread is
479 * able to set our state to running as it exits before we
480 * get to schedule() */
481 init_waitqueue_entry(&wait, current);
482 set_current_state(TASK_INTERRUPTIBLE);
483 add_wait_queue(&debug_ctlwq, &wait);
484
485 dumper = kthread_run(libcfs_debug_dumplog_thread,
486 (void *)(long)current_pid(),
487 "libcfs_debug_dumper");
488 if (IS_ERR(dumper))
489 pr_err("LustreError: cannot start log dump thread: %ld\n",
490 PTR_ERR(dumper));
491 else
492 schedule();
493
494 /* be sure to teardown if cfs_create_thread() failed */
495 remove_wait_queue(&debug_ctlwq, &wait);
496 set_current_state(TASK_RUNNING);
497 }
498 EXPORT_SYMBOL(libcfs_debug_dumplog);
499
libcfs_debug_init(unsigned long bufsize)500 int libcfs_debug_init(unsigned long bufsize)
501 {
502 int rc = 0;
503 unsigned int max = libcfs_debug_mb;
504
505 init_waitqueue_head(&debug_ctlwq);
506
507 if (libcfs_console_max_delay <= 0 || /* not set by user or */
508 libcfs_console_min_delay <= 0 || /* set to invalid values */
509 libcfs_console_min_delay >= libcfs_console_max_delay) {
510 libcfs_console_max_delay = CDEBUG_DEFAULT_MAX_DELAY;
511 libcfs_console_min_delay = CDEBUG_DEFAULT_MIN_DELAY;
512 }
513
514 if (libcfs_debug_file_path != NULL) {
515 strlcpy(libcfs_debug_file_path_arr,
516 libcfs_debug_file_path,
517 sizeof(libcfs_debug_file_path_arr));
518 }
519
520 /* If libcfs_debug_mb is set to an invalid value or uninitialized
521 * then just make the total buffers smp_num_cpus * TCD_MAX_PAGES */
522 if (max > cfs_trace_max_debug_mb() || max < num_possible_cpus()) {
523 max = TCD_MAX_PAGES;
524 } else {
525 max = max / num_possible_cpus();
526 max <<= (20 - PAGE_CACHE_SHIFT);
527 }
528 rc = cfs_tracefile_init(max);
529
530 if (rc == 0) {
531 libcfs_register_panic_notifier();
532 libcfs_debug_mb = cfs_trace_get_debug_mb();
533 }
534
535 return rc;
536 }
537
libcfs_debug_cleanup(void)538 int libcfs_debug_cleanup(void)
539 {
540 libcfs_unregister_panic_notifier();
541 cfs_tracefile_exit();
542 return 0;
543 }
544
libcfs_debug_clear_buffer(void)545 int libcfs_debug_clear_buffer(void)
546 {
547 cfs_trace_flush_pages();
548 return 0;
549 }
550
551 /* Debug markers, although printed by S_LNET
552 * should not be be marked as such. */
553 #undef DEBUG_SUBSYSTEM
554 #define DEBUG_SUBSYSTEM S_UNDEFINED
libcfs_debug_mark_buffer(const char * text)555 int libcfs_debug_mark_buffer(const char *text)
556 {
557 CDEBUG(D_TRACE,
558 "***************************************************\n");
559 LCONSOLE(D_WARNING, "DEBUG MARKER: %s\n", text);
560 CDEBUG(D_TRACE,
561 "***************************************************\n");
562
563 return 0;
564 }
565
566 #undef DEBUG_SUBSYSTEM
567 #define DEBUG_SUBSYSTEM S_LNET
568
libcfs_debug_set_level(unsigned int debug_level)569 void libcfs_debug_set_level(unsigned int debug_level)
570 {
571 pr_warn("Lustre: Setting portals debug level to %08x\n",
572 debug_level);
573 libcfs_debug = debug_level;
574 }
575
576 EXPORT_SYMBOL(libcfs_debug_set_level);
577