From b9cbe3616b6e0b44c7835b1aec65befb85f848f9 Mon Sep 17 00:00:00 2001 From: Hongchao Zhang Date: Mon, 12 Mar 2012 16:11:47 +0800 Subject: [PATCH] LU-969 debug: reduce stack usage 1, libcfs_debug_vmsg2 to accept libcfs_debug_msg_data struture to replace SUBSYSTEM, __FILE__, __FUNCTION__, __LINE__ and cdls on the stack 2, CDEBUG, DEBUG_CAPA use static libcfs_debug_msg_data 3, remove the local variable in RETURN/GOTO/__CHECK_STACK 4, reduce stack in recovery thread by moving lu_env, ptlrpc_thread to heap. Signed-off-by: Alex Zhuravlev Signed-off-by: Hongchao Zhang Signed-off-by: Bob Glossman Change-Id: I75fe53027f56e27255b5f558e8fd57c7db833648 Reviewed-on: http://review.whamcloud.com/2668 Reviewed-by: Andreas Dilger Tested-by: Hudson Reviewed-by: Oleg Drokin --- libcfs/include/libcfs/darwin/libcfs.h | 2 +- libcfs/include/libcfs/libcfs_debug.h | 115 +++++++++++++++------------------ libcfs/include/libcfs/libcfs_private.h | 50 ++++++-------- libcfs/include/libcfs/linux/libcfs.h | 22 ++++--- libcfs/include/libcfs/posix/libcfs.h | 2 +- libcfs/include/libcfs/winnt/libcfs.h | 4 +- libcfs/libcfs/darwin/darwin-debug.c | 8 ++- libcfs/libcfs/debug.c | 28 ++++++-- libcfs/libcfs/linux/linux-debug.c | 21 +++--- libcfs/libcfs/linux/linux-tracefile.c | 11 ++-- libcfs/libcfs/module.c | 2 +- libcfs/libcfs/posix/posix-debug.c | 62 ++++++++++++++---- libcfs/libcfs/tracefile.c | 68 +++++++++++-------- libcfs/libcfs/tracefile.h | 17 ++--- libcfs/libcfs/user-prim.c | 4 +- libcfs/libcfs/winnt/winnt-debug.c | 6 +- lustre/fid/fid_request.c | 2 +- lustre/include/cl_object.h | 24 +++---- lustre/include/lu_object.h | 39 ++++------- lustre/include/lustre_capa.h | 15 +++-- lustre/include/lustre_dlm.h | 41 +++++------- lustre/include/lustre_net.h | 30 ++++----- lustre/ldlm/ldlm_lib.c | 30 +++++++-- lustre/ldlm/ldlm_lock.c | 22 +++---- lustre/ldlm/ldlm_lockd.c | 8 ++- lustre/lmv/lmv_obd.c | 2 +- lustre/obdclass/capa.c | 17 +++++ lustre/obdclass/lu_object.c | 14 ++-- lustre/ptlrpc/llog_server.c | 2 +- lustre/ptlrpc/pack_generic.c | 8 +-- 30 files changed, 366 insertions(+), 310 deletions(-) diff --git a/libcfs/include/libcfs/darwin/libcfs.h b/libcfs/include/libcfs/darwin/libcfs.h index b77b23d..e672a70 100644 --- a/libcfs/include/libcfs/darwin/libcfs.h +++ b/libcfs/include/libcfs/darwin/libcfs.h @@ -97,7 +97,7 @@ typedef unsigned long long cycles_t; #endif #define LUSTRE_TRACE_SIZE (THREAD_SIZE >> 5) -#define CHECK_STACK() do { } while(0) +#define CHECK_STACK(msgdata, mask, cdls) do {} while(0) #define CDEBUG_STACK() (0L) /* Darwin has defined RETURN, so we have to undef it in lustre */ diff --git a/libcfs/include/libcfs/libcfs_debug.h b/libcfs/include/libcfs/libcfs_debug.h index 44b2e07..8a366f9 100644 --- a/libcfs/include/libcfs/libcfs_debug.h +++ b/libcfs/include/libcfs/libcfs_debug.h @@ -51,8 +51,8 @@ extern unsigned int libcfs_debug; extern unsigned int libcfs_printk; extern unsigned int libcfs_console_ratelimit; extern unsigned int libcfs_watchdog_ratelimit; -extern cfs_duration_t libcfs_console_max_delay; -extern cfs_duration_t libcfs_console_min_delay; +extern unsigned int libcfs_console_max_delay; +extern unsigned int libcfs_console_min_delay; extern unsigned int libcfs_console_backoff; extern unsigned int libcfs_debug_binary; extern char libcfs_debug_file_path_arr[PATH_MAX]; @@ -166,10 +166,28 @@ struct ptldebug_header { #define CDEBUG_DEFAULT_BACKOFF 2 typedef struct { cfs_time_t cdls_next; + unsigned int cdls_delay; int cdls_count; - cfs_duration_t cdls_delay; } cfs_debug_limit_state_t; +struct libcfs_debug_msg_data { + const char *msg_file; + const char *msg_fn; + int msg_subsys; + int msg_line; + int msg_mask; + cfs_debug_limit_state_t *msg_cdls; +}; + +#define LIBCFS_DEBUG_MSG_DATA_DECL(dataname, mask, cdls) \ + static struct libcfs_debug_msg_data dataname = { \ + .msg_subsys = DEBUG_SUBSYSTEM, \ + .msg_file = __FILE__, \ + .msg_fn = __FUNCTION__, \ + .msg_line = __LINE__, \ + .msg_cdls = (cdls) }; \ + dataname.msg_mask = (mask); + #if defined(__KERNEL__) || (defined(__arch_lib__) && !defined(LUSTRE_UTILS)) #ifdef CDEBUG_ENABLED @@ -185,12 +203,12 @@ static inline int cfs_cdebug_show(unsigned int mask, unsigned int subsystem) #define __CDEBUG(cdls, mask, format, ...) \ do { \ - CFS_CHECK_STACK(); \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, cdls); \ + \ + CFS_CHECK_STACK(&msgdata, mask, cdls); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) \ - libcfs_debug_msg(cdls, DEBUG_SUBSYSTEM, mask, \ - __FILE__, __FUNCTION__, __LINE__, \ - format, ## __VA_ARGS__); \ + libcfs_debug_msg(&msgdata, format, ## __VA_ARGS__); \ } while (0) #define CDEBUG(mask, format, ...) __CDEBUG(NULL, mask, format, ## __VA_ARGS__) @@ -213,7 +231,10 @@ static inline int cfs_cdebug_show(unsigned int mask, unsigned int subsystem) #endif #else /* !__KERNEL__ && (!__arch_lib__ || LUSTRE_UTILS) */ - +static inline int cfs_cdebug_show(unsigned int mask, unsigned int subsystem) +{ + return 0; +} #define CDEBUG(mask, format, ...) \ do { \ if (((mask) & D_CANTMASK) != 0) \ @@ -242,12 +263,15 @@ do { \ #ifdef CDEBUG_ENABLED +void libcfs_log_goto(struct libcfs_debug_msg_data *, const char *, long_ptr_t); #define GOTO(label, rc) \ do { \ - long_ptr_t GOTO__ret = (long_ptr_t)(rc); \ - CDEBUG(D_TRACE,"Process leaving via %s (rc=" LPLU " : " LPLD \ - " : " LPLX ")\n", #label, (ulong_ptr_t)GOTO__ret, \ - GOTO__ret, GOTO__ret); \ + if (cfs_cdebug_show(D_TRACE, DEBUG_SUBSYSTEM)) { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_TRACE, NULL); \ + libcfs_log_goto(&msgdata, #label, (long_ptr_t)(rc)); \ + } else { \ + (void)(rc); \ + } \ goto label; \ } while (0) #else @@ -261,13 +285,18 @@ do { \ * there will be a warning in osx. */ #if defined(__GNUC__) + +long libcfs_log_return(struct libcfs_debug_msg_data *, long rc); #define RETURN(rc) \ do { \ - typeof(rc) RETURN__ret = (rc); \ - CDEBUG(D_TRACE, "Process leaving (rc=%lu : %ld : %lx)\n", \ - (long)RETURN__ret, (long)RETURN__ret, (long)RETURN__ret);\ EXIT_NESTING; \ - return RETURN__ret; \ + if (cfs_cdebug_show(D_TRACE, DEBUG_SUBSYSTEM)) { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_TRACE, NULL); \ + return (typeof(rc))libcfs_log_return(&msgdata, \ + (long)(rc)); \ + } \ + \ + return (rc); \ } while (0) #elif defined(_MSC_VER) #define RETURN(rc) \ @@ -305,54 +334,14 @@ do { \ return; \ } while (0) -struct libcfs_debug_msg_data { - cfs_debug_limit_state_t *msg_cdls; - int msg_subsys; - const char *msg_file; - const char *msg_fn; - int msg_line; -}; - -#define DEBUG_MSG_DATA_INIT(cdls, subsystem, file, func, ln ) { \ - /* msg_cdls */ (cdls), \ - /* msg_subsys */ (subsystem), \ - /* msg_file */ (file), \ - /* msg_fn */ (func), \ - /* msg_line */ (ln) \ - } - - -extern int libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, - int subsys, int mask, - const char *file, const char *fn, const int line, - const char *format1, va_list args, - const char *format2, ...) - __attribute__ ((format (printf, 9, 10))); - -#define libcfs_debug_vmsg(cdls, subsys, mask, file, fn, line, format, args) \ - libcfs_debug_vmsg2(cdls, subsys, mask, file, fn,line,format,args,NULL,NULL) - -#define libcfs_debug_msg(cdls, subsys, mask, file, fn, line, format, ...) \ - libcfs_debug_vmsg2(cdls, subsys, mask, file, fn,line,NULL,NULL,format, ## __VA_ARGS__) - -#define cdebug_va(cdls, mask, file, func, line, fmt, args) do { \ - CFS_CHECK_STACK(); \ - \ - if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) \ - libcfs_debug_vmsg(cdls, DEBUG_SUBSYSTEM, (mask), \ - (file), (func), (line), fmt, args); \ -} while(0) - -#define cdebug(cdls, mask, file, func, line, fmt, ...) do { \ - CFS_CHECK_STACK(); \ - \ - if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) \ - libcfs_debug_msg(cdls, DEBUG_SUBSYSTEM, (mask), \ - (file), (func), (line), fmt, ## __VA_ARGS__);\ -} while(0) +extern int libcfs_debug_msg(struct libcfs_debug_msg_data *msgdata, + const char *format1, ...) + __attribute__ ((format (printf, 2, 3))); -extern void libcfs_assertion_failed(const char *expr, const char *file, - const char *fn, const int line); +extern int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, + const char *format1, + va_list args, const char *format2, ...) + __attribute__ ((format (printf, 4, 5))); /* one more external symbol that tracefile provides: */ extern int cfs_trace_copyout_string(char *usr_buffer, int usr_buffer_nob, diff --git a/libcfs/include/libcfs/libcfs_private.h b/libcfs/include/libcfs/libcfs_private.h index 9e33e26..9ccf3bd 100644 --- a/libcfs/include/libcfs/libcfs_private.h +++ b/libcfs/include/libcfs/libcfs_private.h @@ -71,48 +71,35 @@ * * requires -Wall. Unfortunately this rules out use of likely/unlikely. */ -#define LASSERT(cond) \ +#define LASSERTF(cond, fmt, ...) \ do { \ if (cond) \ ; \ - else \ - libcfs_assertion_failed( #cond , __FILE__, \ - __FUNCTION__, __LINE__); \ -} while(0) - -#define LASSERTF(cond, fmt, ...) \ -do { \ - if (cond) \ - ; \ - else { \ - libcfs_debug_msg(NULL, DEBUG_SUBSYSTEM, D_EMERG, \ - __FILE__, __FUNCTION__,__LINE__, \ - "ASSERTION(" #cond ") failed: " fmt, \ + else { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ + libcfs_debug_msg(&msgdata, \ + "ASSERTION( %s ) failed: " fmt, #cond, \ ## __VA_ARGS__); \ - LBUG(); \ - } \ + LBUG(); \ + } \ } while(0) -#else /* !LASSERT_CHECKED */ +#define LASSERT(cond) LASSERTF(cond, "\n") -#define LASSERT(cond) \ -do { \ - if (unlikely(!(cond))) \ - libcfs_assertion_failed(#cond , __FILE__, \ - __FUNCTION__, __LINE__); \ -} while(0) +#else /* !LASSERT_CHECKED */ #define LASSERTF(cond, fmt, ...) \ do { \ if (unlikely(!(cond))) { \ - libcfs_debug_msg(NULL, DEBUG_SUBSYSTEM, D_EMERG, \ - __FILE__, __FUNCTION__,__LINE__, \ - "ASSERTION(" #cond ") failed: " fmt, \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ + libcfs_debug_msg(&msgdata, \ + "ASSERTION( %s ) failed: " fmt, #cond, \ ## __VA_ARGS__ ); \ LBUG(); \ } \ } while(0) +#define LASSERT(cond) LASSERTF(cond, "\n") #endif /* !LASSERT_CHECKED */ #else /* !LIBCFS_DEBUG */ /* sizeof is to use expression without evaluating it. */ @@ -133,10 +120,13 @@ do { \ #define KLASSERT(e) LASSERT(e) -void lbug_with_loc(const char *file, const char *func, const int line) - __attribute__((noreturn)); +void lbug_with_loc(struct libcfs_debug_msg_data *) __attribute__((noreturn)); -#define LBUG() lbug_with_loc(__FILE__, __FUNCTION__, __LINE__) +#define LBUG() \ +do { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ + lbug_with_loc(&msgdata); \ +} while(0) extern cfs_atomic_t libcfs_kmemory; /* @@ -222,7 +212,7 @@ do { \ void libcfs_debug_dumpstack(cfs_task_t *tsk); void libcfs_run_upcall(char **argv); -void libcfs_run_lbug_upcall(const char * file, const char *fn, const int line); +void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *); void libcfs_debug_dumplog(void); int libcfs_debug_init(unsigned long bufsize); int libcfs_debug_cleanup(void); diff --git a/libcfs/include/libcfs/linux/libcfs.h b/libcfs/include/libcfs/linux/libcfs.h index d8fcbca..dee91d9 100644 --- a/libcfs/include/libcfs/linux/libcfs.h +++ b/libcfs/include/libcfs/linux/libcfs.h @@ -78,22 +78,24 @@ (THREAD_SIZE - 1))) # endif /* __ia64__ */ -#define __CHECK_STACK(file, func, line) \ +#define __CHECK_STACK(msgdata, mask, cdls) \ do { \ - unsigned long _stack = CDEBUG_STACK(); \ - \ - if (_stack > 3*THREAD_SIZE/4 && _stack > libcfs_stack) { \ - libcfs_stack = _stack; \ - libcfs_debug_msg(NULL, DEBUG_SUBSYSTEM, D_WARNING, \ - file, func, line, \ - "maximum lustre stack %lu\n", _stack); \ + if (unlikely(CDEBUG_STACK() > libcfs_stack)) { \ + libcfs_stack = CDEBUG_STACK(); \ + (msgdata)->msg_mask = D_WARNING; \ + (msgdata)->msg_cdls = NULL; \ + libcfs_debug_msg(msgdata, \ + "maximum lustre stack %lu\n", \ + CDEBUG_STACK()); \ + (msgdata)->msg_mask = mask; \ + (msgdata)->msg_cdls = cdls; \ dump_stack(); \ /*panic("LBUG");*/ \ } \ } while (0) -#define CFS_CHECK_STACK() __CHECK_STACK(__FILE__, __func__, __LINE__) +#define CFS_CHECK_STACK(msgdata, mask, cdls) __CHECK_STACK(msgdata, mask, cdls) #else /* __x86_64__ */ -#define CFS_CHECK_STACK() do { } while(0) +#define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0) #define CDEBUG_STACK() (0L) #endif /* __x86_64__ */ diff --git a/libcfs/include/libcfs/posix/libcfs.h b/libcfs/include/libcfs/posix/libcfs.h index f96723b..28826f9 100644 --- a/libcfs/include/libcfs/posix/libcfs.h +++ b/libcfs/include/libcfs/posix/libcfs.h @@ -206,7 +206,7 @@ typedef struct dirent64 cfs_dirent_t; #define LUSTRE_TRACE_SIZE (CFS_THREAD_SIZE >> 5) -#define CFS_CHECK_STACK() do { } while(0) +#define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0) #define CDEBUG_STACK() (0L) /* initial pid */ diff --git a/libcfs/include/libcfs/winnt/libcfs.h b/libcfs/include/libcfs/winnt/libcfs.h index 12c073b..1011f6e 100644 --- a/libcfs/include/libcfs/winnt/libcfs.h +++ b/libcfs/include/libcfs/winnt/libcfs.h @@ -100,9 +100,9 @@ static inline __u32 query_stack_size() #ifdef __KERNEL__ #define CDEBUG_STACK() (CFS_THREAD_SIZE - (__u32)IoGetRemainingStackSize()) -#define CFS_CHECK_STACK() do {} while(0) +#define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0) #else /* !__KERNEL__ */ -#define CFS_CHECK_STACK() do { } while(0) +#define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0) #define CDEBUG_STACK() (0L) #endif /* __KERNEL__ */ diff --git a/libcfs/libcfs/darwin/darwin-debug.c b/libcfs/libcfs/darwin/darwin-debug.c index 6b07670..475faae 100644 --- a/libcfs/libcfs/darwin/darwin-debug.c +++ b/libcfs/libcfs/darwin/darwin-debug.c @@ -28,6 +28,8 @@ /* * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2012, Whamcloud, Inc. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -44,17 +46,17 @@ void libcfs_debug_dumpstack(cfs_task_t *tsk) return; } -void libcfs_run_lbug_upcall(const char *file, const char *fn, const int line) +void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *msgdata) { } -void lbug_with_loc(const char *file, const char *func, const int line) +void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) { libcfs_catastrophe = 1; CEMERG("LBUG: pid: %u thread: %#x\n", (unsigned)cfs_curproc_pid(), (unsigned)current_thread()); libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(file, func, line); + libcfs_run_lbug_upcall(msgdata); while (1) cfs_schedule(); diff --git a/libcfs/libcfs/debug.c b/libcfs/libcfs/debug.c index 00fbb56..604a0fb 100644 --- a/libcfs/libcfs/debug.c +++ b/libcfs/libcfs/debug.c @@ -78,13 +78,13 @@ CFS_MODULE_PARM(libcfs_console_ratelimit, "i", uint, 0644, "Lustre kernel debug console ratelimit (0 to disable)"); EXPORT_SYMBOL(libcfs_console_ratelimit); -cfs_duration_t libcfs_console_max_delay; -CFS_MODULE_PARM(libcfs_console_max_delay, "l", ulong, 0644, +unsigned int libcfs_console_max_delay; +CFS_MODULE_PARM(libcfs_console_max_delay, "l", uint, 0644, "Lustre kernel debug console max delay (jiffies)"); EXPORT_SYMBOL(libcfs_console_max_delay); -cfs_duration_t libcfs_console_min_delay; -CFS_MODULE_PARM(libcfs_console_min_delay, "l", ulong, 0644, +unsigned int libcfs_console_min_delay; +CFS_MODULE_PARM(libcfs_console_min_delay, "l", uint, 0644, "Lustre kernel debug console min delay (jiffies)"); EXPORT_SYMBOL(libcfs_console_min_delay); @@ -96,7 +96,7 @@ EXPORT_SYMBOL(libcfs_console_backoff); unsigned int libcfs_debug_binary = 1; EXPORT_SYMBOL(libcfs_debug_binary); -unsigned int libcfs_stack; +unsigned int libcfs_stack = 3 * THREAD_SIZE / 4; EXPORT_SYMBOL(libcfs_stack); unsigned int portal_enter_debugger; @@ -386,6 +386,7 @@ void libcfs_debug_dumplog(void) cfs_waitq_del(&debug_ctlwq, &wait); cfs_set_current_state(CFS_TASK_RUNNING); } +EXPORT_SYMBOL(libcfs_debug_dumplog); int libcfs_debug_init(unsigned long bufsize) { @@ -458,5 +459,20 @@ void libcfs_debug_set_level(unsigned int debug_level) libcfs_debug = debug_level; } -EXPORT_SYMBOL(libcfs_debug_dumplog); EXPORT_SYMBOL(libcfs_debug_set_level); + +long libcfs_log_return(struct libcfs_debug_msg_data *msgdata, long rc) +{ + libcfs_debug_msg(msgdata, "Process leaving (rc=%lu : %ld : %lx)\n", + rc, rc, rc); + return rc; +} +EXPORT_SYMBOL(libcfs_log_return); + +void libcfs_log_goto(struct libcfs_debug_msg_data *msgdata, const char *label, + long_ptr_t rc) +{ + libcfs_debug_msg(msgdata, "Process leaving via %s (rc=" LPLU " : " LPLD + " : " LPLX ")\n", label, (ulong_ptr_t)rc, rc, rc); +} +EXPORT_SYMBOL(libcfs_log_goto); diff --git a/libcfs/libcfs/linux/linux-debug.c b/libcfs/libcfs/linux/linux-debug.c index 7b2d3a9..c805b8b 100644 --- a/libcfs/libcfs/linux/linux-debug.c +++ b/libcfs/libcfs/linux/linux-debug.c @@ -149,17 +149,17 @@ void libcfs_run_upcall(char **argv) } } -void libcfs_run_lbug_upcall(const char *file, const char *fn, const int line) +void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *msgdata) { char *argv[6]; char buf[32]; ENTRY; - snprintf (buf, sizeof buf, "%d", line); + snprintf (buf, sizeof buf, "%d", msgdata->msg_line); argv[1] = "LBUG"; - argv[2] = (char *)file; - argv[3] = (char *)fn; + argv[2] = (char *)msgdata->msg_file; + argv[3] = (char *)msgdata->msg_fn; argv[4] = buf; argv[5] = NULL; @@ -167,23 +167,22 @@ void libcfs_run_lbug_upcall(const char *file, const char *fn, const int line) } #ifdef __arch_um__ -void lbug_with_loc(const char *file, const char *func, const int line) +void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) { libcfs_catastrophe = 1; - libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, - "LBUG - trying to dump log to %s\n", + libcfs_debug_msg(msgdata, "LBUG - trying to dump log to %s\n", libcfs_debug_file_path); libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(file, func, line); + libcfs_run_lbug_upcall(msgdata); asm("int $3"); panic("LBUG"); } #else /* coverity[+kill] */ -void lbug_with_loc(const char *file, const char *func, const int line) +void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) { libcfs_catastrophe = 1; - libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, "LBUG\n"); + libcfs_debug_msg(msgdata, "LBUG\n"); if (in_interrupt()) { panic("LBUG in interrupt.\n"); @@ -193,7 +192,7 @@ void lbug_with_loc(const char *file, const char *func, const int line) libcfs_debug_dumpstack(NULL); if (!libcfs_panic_on_lbug) libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(file, func, line); + libcfs_run_lbug_upcall(msgdata); if (libcfs_panic_on_lbug) panic("LBUG"); set_task_state(current, TASK_UNINTERRUPTIBLE); diff --git a/libcfs/libcfs/linux/linux-tracefile.c b/libcfs/libcfs/linux/linux-tracefile.c index 0bbcac9..51d7d7f 100644 --- a/libcfs/libcfs/linux/linux-tracefile.c +++ b/libcfs/libcfs/linux/linux-tracefile.c @@ -181,22 +181,23 @@ int cfs_tcd_owns_tage(struct cfs_trace_cpu_data *tcd, } void -cfs_set_ptldebug_header(struct ptldebug_header *header, int subsys, int mask, - const int line, unsigned long stack) +cfs_set_ptldebug_header(struct ptldebug_header *header, + struct libcfs_debug_msg_data *msgdata, + unsigned long stack) { struct timeval tv; do_gettimeofday(&tv); - header->ph_subsys = subsys; - header->ph_mask = mask; + header->ph_subsys = msgdata->msg_subsys; + header->ph_mask = msgdata->msg_mask; header->ph_cpu_id = cfs_smp_processor_id(); header->ph_type = cfs_trace_buf_idx_get(); header->ph_sec = (__u32)tv.tv_sec; header->ph_usec = tv.tv_usec; header->ph_stack = stack; header->ph_pid = current->pid; - header->ph_line_num = line; + header->ph_line_num = msgdata->msg_line; header->ph_extern_pid = 0; return; } diff --git a/libcfs/libcfs/module.c b/libcfs/libcfs/module.c index 8278b4c..b602016 100644 --- a/libcfs/libcfs/module.c +++ b/libcfs/libcfs/module.c @@ -332,7 +332,7 @@ static int libcfs_ioctl(struct cfs_psdev_file *pfile, unsigned long cmd, void *a { char *buf; struct libcfs_ioctl_data *data; - int err; + int err = 0; ENTRY; LIBCFS_ALLOC_GFP(buf, 1024, CFS_ALLOC_STD); diff --git a/libcfs/libcfs/posix/posix-debug.c b/libcfs/libcfs/posix/posix-debug.c index 9e083a1..36967d5 100644 --- a/libcfs/libcfs/posix/posix-debug.c +++ b/libcfs/libcfs/posix/posix-debug.c @@ -53,8 +53,8 @@ static char source_nid[16]; /* 0 indicates no messages to console, 1 is errors, > 1 is all debug messages */ static int toconsole = 1; unsigned int libcfs_console_ratelimit = 1; -cfs_duration_t libcfs_console_max_delay; -cfs_duration_t libcfs_console_min_delay; +unsigned int libcfs_console_max_delay; +unsigned int libcfs_console_min_delay; unsigned int libcfs_console_backoff = CDEBUG_DEFAULT_BACKOFF; #else /* !HAVE_CATAMOUNT_DATA_H */ #ifdef HAVE_NETDB_H @@ -243,10 +243,21 @@ void catamount_printline(char *buf, size_t size) } #endif +int libcfs_debug_msg(struct libcfs_debug_msg_data *msgdata, + const char *format, ...) +{ + va_list args; + int rc; + + va_start(args, format); + rc = libcfs_debug_vmsg2(msgdata, format, args, NULL); + va_end(args); + + return rc; +} + int -libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, - int subsys, int mask, - const char *file, const char *fn, const int line, +libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, const char *format1, va_list args, const char *format2, ...) { @@ -264,7 +275,7 @@ libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, /* toconsole == 0 - all messages to debug_file_fd * toconsole == 1 - warnings to console, all to debug_file_fd * toconsole > 1 - all debug to console */ - if (((mask & libcfs_printk) && toconsole == 1) || toconsole > 1) + if (((msgdata->msg_mask & libcfs_printk) && toconsole == 1) || toconsole > 1) console = 1; #endif @@ -272,11 +283,12 @@ libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, return 0; } - if (mask & (D_EMERG | D_ERROR)) + if (msgdata->msg_mask & (D_EMERG | D_ERROR)) prefix = "LustreError"; nob = snprintf(buf, sizeof(buf), "%s: %u-%s:(%s:%d:%s()): ", prefix, - source_pid, source_nid, file, line, fn); + source_pid, source_nid, msgdata->msg_file, + msgdata->msg_line, msgdata->msg_fn); remain = sizeof(buf) - nob; if (format1) { @@ -292,6 +304,8 @@ libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, #ifdef HAVE_CATAMOUNT_DATA_H if (console) { + cfs_debug_limit_state_t *cdls = msgdata->msg_cdls; + /* check rate limit for console */ if (cdls != NULL) { if (libcfs_console_ratelimit && @@ -351,16 +365,38 @@ out_file: fprintf(debug_file_fd, CFS_TIME_T".%06lu:%u:%s:(%s:%d:%s()): %s", tv.tv_sec, tv.tv_usec, source_pid, source_nid, - file, line, fn, buf); + msgdata->msg_file, msgdata->msg_line, msgdata->msg_fn, buf); return 0; } void -libcfs_assertion_failed(const char *expr, const char *file, const char *func, - const int line) +libcfs_assertion_failed(const char *expr, struct libcfs_debug_msg_data *msgdata) { - libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, - "ASSERTION(%s) failed\n", expr); + libcfs_debug_msg(msgdata, "ASSERTION(%s) failed\n", expr); abort(); } + +/* + * a helper function for RETURN(): the sole purpose is to save 8-16 bytes + * on the stack - function calling RETURN() doesn't need to allocate two + * additional 'rc' on the stack + */ +long libcfs_log_return(struct libcfs_debug_msg_data *msgdata, long rc) +{ + libcfs_debug_msg(msgdata, "Process leaving (rc=%lu : %ld : %lx)\n", + rc, rc, rc); + return rc; +} + +/* + * a helper function for GOTO(): the sole purpose is to save 8-16 bytes + * on the stack - function calling GOTO() doesn't need to allocate two + * additional 'rc' on the stack + */ +void libcfs_log_goto(struct libcfs_debug_msg_data *msgdata, const char *l, + long_ptr_t rc) +{ + libcfs_debug_msg(msgdata, "Process leaving via %s (rc=" LPLU " : " + LPLD " : " LPLX ")\n", l, (ulong_ptr_t) rc, rc, rc); +} diff --git a/libcfs/libcfs/tracefile.c b/libcfs/libcfs/tracefile.c index d681fc3..8e42428 100644 --- a/libcfs/libcfs/tracefile.c +++ b/libcfs/libcfs/tracefile.c @@ -243,8 +243,21 @@ static struct cfs_trace_page *cfs_trace_get_tage(struct cfs_trace_cpu_data *tcd, return tage; } -int libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, int subsys, int mask, - const char *file, const char *fn, const int line, +int libcfs_debug_msg(struct libcfs_debug_msg_data *msgdata, + const char *format, ...) +{ + va_list args; + int rc; + + va_start(args, format); + rc = libcfs_debug_vmsg2(msgdata, format, args, NULL); + va_end(args); + + return rc; +} +EXPORT_SYMBOL(libcfs_debug_msg); + +int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, const char *format1, va_list args, const char *format2, ...) { @@ -261,6 +274,9 @@ int libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, int subsys, int mask, int depth; int i; int remain; + int mask = msgdata->msg_mask; + char *file = (char *)msgdata->msg_file; + cfs_debug_limit_state_t *cdls = msgdata->msg_cdls; if (strchr(file, '/')) file = strrchr(file, '/') + 1; @@ -270,7 +286,7 @@ int libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, int subsys, int mask, /* cfs_trace_get_tcd() grabs a lock, which disables preemption and * pins us to a particular CPU. This avoids an smp_processor_id() * warning on Linux when debugging is enabled. */ - cfs_set_ptldebug_header(&header, subsys, mask, line, CDEBUG_STACK()); + cfs_set_ptldebug_header(&header, msgdata, CDEBUG_STACK()); if (tcd == NULL) /* arch may not log in IRQ context */ goto console; @@ -286,8 +302,8 @@ int libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, int subsys, int mask, depth = __current_nesting_level(); known_size = strlen(file) + 1 + depth; - if (fn) - known_size += strlen(fn) + 1; + if (msgdata->msg_fn) + known_size += strlen(msgdata->msg_fn) + 1; if (libcfs_debug_binary) known_size += sizeof(header); @@ -344,8 +360,8 @@ int libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, int subsys, int mask, } if (*(string_buf+needed-1) != '\n') - printk(CFS_KERN_INFO "format at %s:%d:%s doesn't end in newline\n", - file, line, fn); + printk(CFS_KERN_INFO "format at %s:%d:%s doesn't end in " + "newline\n", file, msgdata->msg_line, msgdata->msg_fn); header.ph_len = known_size + needed; debug_buf = (char *)cfs_page_address(tage->page) + tage->used; @@ -366,10 +382,10 @@ int libcfs_debug_vmsg2(cfs_debug_limit_state_t *cdls, int subsys, int mask, tage->used += strlen(file) + 1; debug_buf += strlen(file) + 1; - if (fn) { - strcpy(debug_buf, fn); - tage->used += strlen(fn) + 1; - debug_buf += strlen(fn) + 1; + if (msgdata->msg_fn) { + strcpy(debug_buf, msgdata->msg_fn); + tage->used += strlen(msgdata->msg_fn) + 1; + debug_buf += strlen(msgdata->msg_fn) + 1; } __LASSERT(debug_buf == string_buf); @@ -416,7 +432,7 @@ console: if (tcd != NULL) { cfs_print_to_console(&header, mask, string_buf, needed, file, - fn); + msgdata->msg_fn); cfs_trace_put_tcd(tcd); } else { string_buf = cfs_trace_get_console_buffer(); @@ -433,12 +449,13 @@ console: remain = CFS_TRACE_CONSOLE_BUFFER_SIZE - needed; if (remain > 0) { va_start(ap, format2); - needed += vsnprintf(string_buf+needed, remain, format2, ap); + needed += vsnprintf(string_buf+needed, remain, + format2, ap); va_end(ap); } } cfs_print_to_console(&header, mask, - string_buf, needed, file, fn); + string_buf, needed, file, msgdata->msg_fn); cfs_trace_put_console_buffer(string_buf); } @@ -447,11 +464,12 @@ console: string_buf = cfs_trace_get_console_buffer(); needed = snprintf(string_buf, CFS_TRACE_CONSOLE_BUFFER_SIZE, - "Skipped %d previous similar message%s\n", - cdls->cdls_count, (cdls->cdls_count > 1) ? "s" : ""); + "Skipped %d previous similar message%s\n", + cdls->cdls_count, + (cdls->cdls_count > 1) ? "s" : ""); cfs_print_to_console(&header, mask, - string_buf, needed, file, fn); + string_buf, needed, file, msgdata->msg_fn); cfs_trace_put_console_buffer(string_buf); cdls->cdls_count = 0; @@ -462,19 +480,17 @@ console: EXPORT_SYMBOL(libcfs_debug_vmsg2); void -libcfs_assertion_failed(const char *expr, const char *file, - const char *func, const int line) +libcfs_assertion_failed(const char *expr, struct libcfs_debug_msg_data *msgdata) { - libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, - "ASSERTION(%s) failed\n", expr); + libcfs_debug_msg(msgdata, "ASSERTION(%s) failed\n", expr); /* cfs_enter_debugger(); */ - lbug_with_loc(file, func, line); + lbug_with_loc(msgdata); } EXPORT_SYMBOL(libcfs_assertion_failed); void cfs_trace_assertion_failed(const char *str, - const char *fn, const char *file, int line) + struct libcfs_debug_msg_data *msgdata) { struct ptldebug_header hdr; @@ -482,10 +498,10 @@ cfs_trace_assertion_failed(const char *str, libcfs_catastrophe = 1; cfs_mb(); - cfs_set_ptldebug_header(&hdr, DEBUG_SUBSYSTEM, D_EMERG, line, - CDEBUG_STACK()); + cfs_set_ptldebug_header(&hdr, msgdata, CDEBUG_STACK()); - cfs_print_to_console(&hdr, D_EMERG, str, strlen(str), file, fn); + cfs_print_to_console(&hdr, D_EMERG, str, strlen(str), + msgdata->msg_file, msgdata->msg_fn); LIBCFS_PANIC("Lustre debug assertion failure\n"); diff --git a/libcfs/libcfs/tracefile.h b/libcfs/libcfs/tracefile.h index 1f87b32..a39ed41 100644 --- a/libcfs/libcfs/tracefile.h +++ b/libcfs/libcfs/tracefile.h @@ -260,7 +260,7 @@ struct cfs_trace_page { }; extern void cfs_set_ptldebug_header(struct ptldebug_header *header, - int subsys, int mask, const int line, + struct libcfs_debug_msg_data *m, unsigned long stack); extern void cfs_print_to_console(struct ptldebug_header *hdr, int mask, const char *buf, int len, const char *file, @@ -320,25 +320,26 @@ int cfs_trace_refill_stock(struct cfs_trace_cpu_data *tcd, int gfp, int cfs_tcd_owns_tage(struct cfs_trace_cpu_data *tcd, struct cfs_trace_page *tage); -extern void cfs_trace_assertion_failed(const char *str, const char *fn, - const char *file, int line); +extern void cfs_trace_assertion_failed(const char *str, + struct libcfs_debug_msg_data *m); /* ASSERTION that is safe to use within the debug system */ #define __LASSERT(cond) \ - do { \ +do { \ if (unlikely(!(cond))) { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ cfs_trace_assertion_failed("ASSERTION("#cond") failed", \ - __FUNCTION__, __FILE__, __LINE__); \ + &msgdata); \ } \ - } while (0) +} while (0) #define __LASSERT_TAGE_INVARIANT(tage) \ - do { \ +do { \ __LASSERT(tage != NULL); \ __LASSERT(tage->page != NULL); \ __LASSERT(tage->used <= CFS_PAGE_SIZE); \ __LASSERT(cfs_page_count(tage->page) > 0); \ - } while (0) +} while (0) #endif /* LUSTRE_TRACEFILE_PRIVATE */ diff --git a/libcfs/libcfs/user-prim.c b/libcfs/libcfs/user-prim.c index 0529581..ec2447e 100644 --- a/libcfs/libcfs/user-prim.c +++ b/libcfs/libcfs/user-prim.c @@ -377,10 +377,10 @@ void *cfs_stack_trace_frame(struct cfs_stack_trace *trace, int frame_no) /* __linux__ */ #endif -void lbug_with_loc(const char *file, const char *func, const int line) +void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) { /* No libcfs_catastrophe in userspace! */ - libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, "LBUG\n"); + libcfs_debug_msg(msgdata, "LBUG\n"); abort(); } diff --git a/libcfs/libcfs/winnt/winnt-debug.c b/libcfs/libcfs/winnt/winnt-debug.c index 2e50fac..4ddb786 100644 --- a/libcfs/libcfs/winnt/winnt-debug.c +++ b/libcfs/libcfs/winnt/winnt-debug.c @@ -53,18 +53,18 @@ cfs_task_t *libcfs_current(void) return cfs_current(); } -void libcfs_run_lbug_upcall(const char *file, const char *fn, const int line) +void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *msgdata) { } -void lbug_with_loc(const char *file, const char *func, const int line) +void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) { libcfs_catastrophe = 1; CEMERG("LBUG: pid: %u thread: %#x\n", cfs_curproc_pid(), PsGetCurrentThread()); cfs_enter_debugger(); libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(file, func, line); + libcfs_run_lbug_upcall(msgdata); } void cfs_enter_debugger(void) diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c index 214f542..bc04b3dd 100644 --- a/lustre/fid/fid_request.c +++ b/lustre/fid/fid_request.c @@ -262,7 +262,7 @@ int seq_client_alloc_fid(struct lu_client_seq *seq, struct lu_fid *fid) cfs_down(&seq->lcs_sem); while (1) { - seqno_t seqnr; + seqno_t seqnr = 0; if (!fid_is_zero(&seq->lcs_fid) && fid_oid(&seq->lcs_fid) < seq->lcs_width) { diff --git a/lustre/include/cl_object.h b/lustre/include/cl_object.h index 86966dc..47782be 100644 --- a/lustre/include/cl_object.h +++ b/lustre/include/cl_object.h @@ -1065,10 +1065,10 @@ struct cl_page_operations { */ #define CL_PAGE_DEBUG(mask, env, page, format, ...) \ do { \ - static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - cl_page_print(env, &__info, lu_cdebug_printer, page); \ + cl_page_print(env, &msgdata, lu_cdebug_printer, page); \ CDEBUG(mask, format , ## __VA_ARGS__); \ } \ } while (0) @@ -1076,14 +1076,14 @@ do { \ /** * Helper macro, dumping shorter information about \a page into a log. */ -#define CL_PAGE_HEADER(mask, env, page, format, ...) \ -do { \ - static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ - \ - if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - cl_page_header_print(env, &__info, lu_cdebug_printer, page); \ - CDEBUG(mask, format , ## __VA_ARGS__); \ - } \ +#define CL_PAGE_HEADER(mask, env, page, format, ...) \ +do { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ + \ + if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ + cl_page_header_print(env, &msgdata, lu_cdebug_printer, page); \ + CDEBUG(mask, format , ## __VA_ARGS__); \ + } \ } while (0) /** @} cl_page */ @@ -1789,10 +1789,10 @@ struct cl_lock_operations { #define CL_LOCK_DEBUG(mask, env, lock, format, ...) \ do { \ - static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - cl_lock_print(env, &__info, lu_cdebug_printer, lock); \ + cl_lock_print(env, &msgdata, lu_cdebug_printer, lock); \ CDEBUG(mask, format , ## __VA_ARGS__); \ } \ } while (0) diff --git a/lustre/include/lu_object.h b/lustre/include/lu_object.h index 2b9424f..0fd61fb 100644 --- a/lustre/include/lu_object.h +++ b/lustre/include/lu_object.h @@ -752,40 +752,23 @@ lu_object_ops(const struct lu_object *o) struct lu_object *lu_object_locate(struct lu_object_header *h, const struct lu_device_type *dtype); -struct lu_cdebug_print_info { - int lpi_subsys; - int lpi_mask; - const char *lpi_file; - const char *lpi_fn; - int lpi_line; -}; - /** * Printer function emitting messages through libcfs_debug_msg(). */ int lu_cdebug_printer(const struct lu_env *env, void *cookie, const char *format, ...); -#define DECLARE_LU_CDEBUG_PRINT_INFO(var, mask) \ - struct lu_cdebug_print_info var = { \ - .lpi_subsys = DEBUG_SUBSYSTEM, \ - .lpi_mask = (mask), \ - .lpi_file = __FILE__, \ - .lpi_fn = __FUNCTION__, \ - .lpi_line = __LINE__ \ - } - /** * Print object description followed by a user-supplied message. */ -#define LU_OBJECT_DEBUG(mask, env, object, format, ...) \ -do { \ - static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ - \ - if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - lu_object_print(env, &__info, lu_cdebug_printer, object); \ - CDEBUG(mask, format , ## __VA_ARGS__); \ - } \ +#define LU_OBJECT_DEBUG(mask, env, object, format, ...) \ +do { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ + \ + if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ + lu_object_print(env, &msgdata, lu_cdebug_printer, object);\ + CDEBUG(mask, format , ## __VA_ARGS__); \ + } \ } while (0) /** @@ -793,12 +776,12 @@ do { \ */ #define LU_OBJECT_HEADER(mask, env, object, format, ...) \ do { \ - static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - lu_object_header_print(env, &__info, lu_cdebug_printer, \ + lu_object_header_print(env, &msgdata, lu_cdebug_printer,\ (object)->lo_header); \ - lu_cdebug_printer(env, &__info, "\n"); \ + lu_cdebug_printer(env, &msgdata, "\n"); \ CDEBUG(mask, format , ## __VA_ARGS__); \ } \ } while (0) diff --git a/lustre/include/lustre_capa.h b/lustre/include/lustre_capa.h index 33f1199..d9110ae 100644 --- a/lustre/include/lustre_capa.h +++ b/lustre/include/lustre_capa.h @@ -155,13 +155,16 @@ static inline __u32 capa_expiry(struct lustre_capa *capa) return capa->lc_expiry; } -#define DEBUG_CAPA(level, c, fmt, args...) \ +void _debug_capa(struct lustre_capa *, struct libcfs_debug_msg_data *, + const char *fmt, ... ); +#define DEBUG_CAPA(level, capa, fmt, args...) \ do { \ -CDEBUG(level, fmt " capability@%p fid "DFID" opc "LPX64" uid "LPU64" gid " \ - LPU64" flags %u alg %d keyid %u timeout %u expiry %u\n", \ - ##args, c, PFID(capa_fid(c)), capa_opc(c), capa_uid(c), capa_gid(c), \ - capa_flags(c), capa_alg(c), capa_keyid(c), capa_timeout(c), \ - capa_expiry(c)); \ + if (((level) & D_CANTMASK) != 0 || \ + ((libcfs_debug & (level)) != 0 && \ + (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, level, NULL); \ + _debug_capa((capa), &msgdata, fmt, ##args); \ + } \ } while (0) #define DEBUG_CAPA_KEY(level, k, fmt, args...) \ diff --git a/lustre/include/lustre_dlm.h b/lustre/include/lustre_dlm.h index 4bc9160..9dd9cc7 100644 --- a/lustre/include/lustre_dlm.h +++ b/lustre/include/lustre_dlm.h @@ -884,39 +884,32 @@ extern char *ldlm_lockname[]; extern char *ldlm_typename[]; extern char *ldlm_it2str(int it); #ifdef LIBCFS_DEBUG -#define ldlm_lock_debug(cdls, level, lock, file, func, line, fmt, a...) do { \ - CFS_CHECK_STACK(); \ +#define ldlm_lock_debug(msgdata, mask, cdls, lock, fmt, a...) do { \ + CFS_CHECK_STACK(msgdata, mask, cdls); \ \ - if (((level) & D_CANTMASK) != 0 || \ - ((libcfs_debug & (level)) != 0 && \ - (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) { \ - static struct libcfs_debug_msg_data _ldlm_dbg_data = \ - DEBUG_MSG_DATA_INIT(cdls, DEBUG_SUBSYSTEM, \ - file, func, line); \ - _ldlm_lock_debug(lock, level, &_ldlm_dbg_data, fmt, \ - ##a ); \ - } \ + if (((mask) & D_CANTMASK) != 0 || \ + ((libcfs_debug & (mask)) != 0 && \ + (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) \ + _ldlm_lock_debug(lock, msgdata, fmt, ##a); \ } while(0) -void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 mask, - struct libcfs_debug_msg_data *data, const char *fmt, - ...) - __attribute__ ((format (printf, 4, 5))); +void _ldlm_lock_debug(struct ldlm_lock *lock, + struct libcfs_debug_msg_data *data, + const char *fmt, ...) + __attribute__ ((format (printf, 3, 4))); -#define LDLM_DEBUG_LIMIT(mask, lock, fmt, a...) do { \ - static cfs_debug_limit_state_t _ldlm_cdls; \ - ldlm_lock_debug(&_ldlm_cdls, mask, lock, \ - __FILE__, __FUNCTION__, __LINE__, \ - "### " fmt , ##a); \ +#define LDLM_DEBUG_LIMIT(mask, lock, fmt, a...) do { \ + static cfs_debug_limit_state_t _ldlm_cdls; \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, &_ldlm_cdls); \ + ldlm_lock_debug(&msgdata, mask, &_ldlm_cdls, lock, "### " fmt , ##a);\ } while (0) #define LDLM_ERROR(lock, fmt, a...) LDLM_DEBUG_LIMIT(D_ERROR, lock, fmt, ## a) #define LDLM_WARN(lock, fmt, a...) LDLM_DEBUG_LIMIT(D_WARNING, lock, fmt, ## a) -#define LDLM_DEBUG(lock, fmt, a...) do { \ - ldlm_lock_debug(NULL, D_DLMTRACE, lock, \ - __FILE__, __FUNCTION__, __LINE__, \ - "### " fmt , ##a); \ +#define LDLM_DEBUG(lock, fmt, a...) do { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_DLMTRACE, NULL); \ + ldlm_lock_debug(&msgdata, D_DLMTRACE, NULL, lock, "### " fmt , ##a);\ } while (0) #else /* !LIBCFS_DEBUG */ # define LDLM_DEBUG(lock, fmt, a...) ((void)0) diff --git a/lustre/include/lustre_net.h b/lustre/include/lustre_net.h index 35748c8..9740da1 100644 --- a/lustre/include/lustre_net.h +++ b/lustre/include/lustre_net.h @@ -827,25 +827,22 @@ ptlrpc_rqphase2str(struct ptlrpc_request *req) #define REQ_FLAGS_FMT "%s:%s%s%s%s%s%s%s%s%s%s%s%s" -void _debug_req(struct ptlrpc_request *req, __u32 mask, +void _debug_req(struct ptlrpc_request *req, struct libcfs_debug_msg_data *data, const char *fmt, ...) - __attribute__ ((format (printf, 4, 5))); + __attribute__ ((format (printf, 3, 4))); /** * Helper that decides if we need to print request accordig to current debug * level settings */ -#define debug_req(cdls, level, req, file, func, line, fmt, a...) \ +#define debug_req(msgdata, mask, cdls, req, fmt, a...) \ do { \ - CFS_CHECK_STACK(); \ + CFS_CHECK_STACK(msgdata, mask, cdls); \ \ - if (((level) & D_CANTMASK) != 0 || \ - ((libcfs_debug & (level)) != 0 && \ - (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) { \ - static struct libcfs_debug_msg_data _req_dbg_data = \ - DEBUG_MSG_DATA_INIT(cdls, DEBUG_SUBSYSTEM, file, func, line); \ - _debug_req((req), (level), &_req_dbg_data, fmt, ##a); \ - } \ + if (((mask) & D_CANTMASK) != 0 || \ + ((libcfs_debug & (mask)) != 0 && \ + (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) \ + _debug_req((req), msgdata, fmt, ##a); \ } while(0) /** @@ -856,11 +853,12 @@ do { \ do { \ if ((level) & (D_ERROR | D_WARNING)) { \ static cfs_debug_limit_state_t cdls; \ - debug_req(&cdls, level, req, __FILE__, __func__, __LINE__, \ - "@@@ "fmt" ", ## args); \ - } else \ - debug_req(NULL, level, req, __FILE__, __func__, __LINE__, \ - "@@@ "fmt" ", ## args); \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, level, &cdls); \ + debug_req(&msgdata, level, &cdls, req, "@@@ "fmt" ", ## args);\ + } else { \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, level, NULL); \ + debug_req(&msgdata, level, NULL, req, "@@@ "fmt" ", ## args); \ + } \ } while (0) /** @} */ diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c index d71a755..d7073a7 100644 --- a/lustre/ldlm/ldlm_lib.c +++ b/lustre/ldlm/ldlm_lib.c @@ -1744,8 +1744,8 @@ static int target_recovery_thread(void *arg) struct target_recovery_data *trd = &obd->obd_recovery_data; unsigned long delta; unsigned long flags; - struct lu_env env; - struct ptlrpc_thread fake_svc_thread, *thread = &fake_svc_thread; + struct lu_env *env; + struct ptlrpc_thread *thread = NULL; int rc = 0; ENTRY; @@ -1756,13 +1756,26 @@ static int target_recovery_thread(void *arg) RECALC_SIGPENDING; SIGNAL_MASK_UNLOCK(current, flags); - rc = lu_context_init(&env.le_ctx, LCT_MD_THREAD); - if (rc) + OBD_ALLOC_PTR(thread); + if (thread == NULL) + RETURN(-ENOMEM); + + OBD_ALLOC_PTR(env); + if (env == NULL) { + OBD_FREE_PTR(thread); + RETURN(-ENOMEM); + } + + rc = lu_context_init(&env->le_ctx, LCT_MD_THREAD); + if (rc) { + OBD_FREE_PTR(thread); + OBD_FREE_PTR(env); RETURN(rc); + } - thread->t_env = &env; + thread->t_env = env; thread->t_id = -1; /* force filter_iobuf_get/put to use local buffers */ - env.le_ctx.lc_thread = thread; + env->le_ctx.lc_thread = thread; thread->t_data = NULL; thread->t_watchdog = NULL; @@ -1855,9 +1868,12 @@ static int target_recovery_thread(void *arg) target_finish_recovery(obd); - lu_context_fini(&env.le_ctx); + lu_context_fini(&env->le_ctx); trd->trd_processing_task = 0; cfs_complete(&trd->trd_finishing); + + OBD_FREE_PTR(thread); + OBD_FREE_PTR(env); RETURN(rc); } diff --git a/lustre/ldlm/ldlm_lock.c b/lustre/ldlm/ldlm_lock.c index d840b7f..c6a56f5 100644 --- a/lustre/ldlm/ldlm_lock.c +++ b/lustre/ldlm/ldlm_lock.c @@ -1964,18 +1964,16 @@ void ldlm_lock_dump_handle(int level, struct lustre_handle *lockh) LDLM_LOCK_PUT(lock); } -void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level, - struct libcfs_debug_msg_data *data, const char *fmt, - ...) +void _ldlm_lock_debug(struct ldlm_lock *lock, + struct libcfs_debug_msg_data *msgdata, + const char *fmt, ...) { va_list args; - cfs_debug_limit_state_t *cdls = data->msg_cdls; va_start(args, fmt); if (lock->l_resource == NULL) { - libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, - data->msg_fn, data->msg_line, fmt, args, + libcfs_debug_vmsg2(msgdata, fmt, args, " ns: \?\? lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s " "res: \?\? rrc=\?\? type: \?\?\? flags: "LPX64" remote: " LPX64" expref: %d pid: %u timeout: %lu\n", lock, @@ -1993,8 +1991,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level, switch (lock->l_resource->lr_type) { case LDLM_EXTENT: - libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, - data->msg_fn, data->msg_line, fmt, args, + libcfs_debug_vmsg2(msgdata, fmt, args, " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s " "res: "LPU64"/"LPU64" rrc: %d type: %s ["LPU64"->"LPU64 "] (req "LPU64"->"LPU64") flags: "LPX64" remote: "LPX64 @@ -2018,8 +2015,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level, break; case LDLM_FLOCK: - libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, - data->msg_fn, data->msg_line, fmt, args, + libcfs_debug_vmsg2(msgdata, fmt, args, " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s " "res: "LPU64"/"LPU64" rrc: %d type: %s pid: %d " "["LPU64"->"LPU64"] flags: "LPX64" remote: "LPX64 @@ -2043,8 +2039,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level, break; case LDLM_IBITS: - libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, - data->msg_fn, data->msg_line, fmt, args, + libcfs_debug_vmsg2(msgdata, fmt, args, " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s " "res: "LPU64"/"LPU64" bits "LPX64" rrc: %d type: %s " "flags: "LPX64" remote: "LPX64" expref: %d " @@ -2067,8 +2062,7 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level, break; default: - libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, - data->msg_fn, data->msg_line, fmt, args, + libcfs_debug_vmsg2(msgdata, fmt, args, " ns: %s lock: %p/"LPX64" lrc: %d/%d,%d mode: %s/%s " "res: "LPU64"/"LPU64" rrc: %d type: %s flags: "LPX64" " "remote: "LPX64" expref: %d pid: %u timeout %lu\n", diff --git a/lustre/ldlm/ldlm_lockd.c b/lustre/ldlm/ldlm_lockd.c index 68772ce..96244e3 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -180,13 +180,15 @@ static int expired_lock_main(void *arg) cfs_spin_lock_bh(&waiting_locks_spinlock); if (expired_lock_thread.elt_dump) { + struct libcfs_debug_msg_data msgdata = { + .msg_file = __FILE__, + .msg_fn = "waiting_locks_callback", + .msg_line = expired_lock_thread.elt_dump }; cfs_spin_unlock_bh(&waiting_locks_spinlock); /* from waiting_locks_callback, but not in timer */ libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(__FILE__, - "waiting_locks_callback", - expired_lock_thread.elt_dump); + libcfs_run_lbug_upcall(&msgdata); cfs_spin_lock_bh(&waiting_locks_spinlock); expired_lock_thread.elt_dump = 0; diff --git a/lustre/lmv/lmv_obd.c b/lustre/lmv/lmv_obd.c index 214da81..09167d6 100644 --- a/lustre/lmv/lmv_obd.c +++ b/lustre/lmv/lmv_obd.c @@ -1017,7 +1017,7 @@ int lmv_fid_alloc(struct obd_export *exp, struct lu_fid *fid, { struct obd_device *obd = class_exp2obd(exp); struct lmv_obd *lmv = &obd->u.lmv; - mdsno_t mds; + mdsno_t mds = 0; int rc; ENTRY; diff --git a/lustre/obdclass/capa.c b/lustre/obdclass/capa.c index 81a9ec5..e042e0d 100644 --- a/lustre/obdclass/capa.c +++ b/lustre/obdclass/capa.c @@ -388,6 +388,23 @@ void capa_cpy(void *capa, struct obd_capa *ocapa) cfs_spin_unlock(&ocapa->c_lock); } +void _debug_capa(struct lustre_capa *c, + struct libcfs_debug_msg_data *msgdata, + const char *fmt, ... ) +{ + va_list args; + va_start(args, fmt); + libcfs_debug_vmsg2(msgdata, fmt, args, + " capability@%p fid "DFID" opc "LPX64" uid "LPU64 + " gid "LPU64" flags %u alg %d keyid %u timeout %u " + "expiry %u\n", c, PFID(capa_fid(c)), capa_opc(c), + capa_uid(c), capa_gid(c), capa_flags(c), + capa_alg(c), capa_keyid(c), capa_timeout(c), + capa_expiry(c)); + va_end(args); +} +EXPORT_SYMBOL(_debug_capa); + EXPORT_SYMBOL(init_capa_hash); EXPORT_SYMBOL(cleanup_capa_hash); EXPORT_SYMBOL(capa_add); diff --git a/lustre/obdclass/lu_object.c b/lustre/obdclass/lu_object.c index 7ffd6c8..d3781a70 100644 --- a/lustre/obdclass/lu_object.c +++ b/lustre/obdclass/lu_object.c @@ -381,8 +381,8 @@ struct lu_context_key lu_global_key = { int lu_cdebug_printer(const struct lu_env *env, void *cookie, const char *format, ...) { - struct lu_cdebug_print_info *info = cookie; - struct lu_cdebug_data *key; + struct libcfs_debug_msg_data *msgdata = cookie; + struct lu_cdebug_data *key; int used; int complete; va_list args; @@ -400,10 +400,8 @@ int lu_cdebug_printer(const struct lu_env *env, vsnprintf(key->lck_area + used, ARRAY_SIZE(key->lck_area) - used, format, args); if (complete) { - if (cfs_cdebug_show(info->lpi_mask, info->lpi_subsys)) - libcfs_debug_msg(NULL, info->lpi_subsys, info->lpi_mask, - (char *)info->lpi_file, info->lpi_fn, - info->lpi_line, "%s", key->lck_area); + if (cfs_cdebug_show(msgdata->msg_mask, msgdata->msg_subsys)) + libcfs_debug_msg(msgdata, "%s", key->lck_area); key->lck_area[0] = 0; } va_end(args); @@ -1154,9 +1152,9 @@ void lu_stack_fini(const struct lu_env *env, struct lu_device *top) /* * Uh-oh, objects still exist. */ - static DECLARE_LU_CDEBUG_PRINT_INFO(cookie, D_ERROR); + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_ERROR, NULL); - lu_site_print(env, site, &cookie, lu_cdebug_printer); + lu_site_print(env, site, &msgdata, lu_cdebug_printer); } for (scan = top; scan != NULL; scan = next) { diff --git a/lustre/ptlrpc/llog_server.c b/lustre/ptlrpc/llog_server.c index 3929127..c81d860 100644 --- a/lustre/ptlrpc/llog_server.c +++ b/lustre/ptlrpc/llog_server.c @@ -528,7 +528,7 @@ static int llog_catinfo_cb(struct llog_handle *cat, static char *out = NULL; static int remains = 0; struct llog_ctxt *ctxt = NULL; - struct llog_handle *handle; + struct llog_handle *handle = NULL; struct llog_logid *logid; struct llog_logid_rec *lir; int l, rc, index, count = 0; diff --git a/lustre/ptlrpc/pack_generic.c b/lustre/ptlrpc/pack_generic.c index 8c2cc00..1ae8130 100644 --- a/lustre/ptlrpc/pack_generic.c +++ b/lustre/ptlrpc/pack_generic.c @@ -2270,13 +2270,13 @@ static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request *req) } } -void _debug_req(struct ptlrpc_request *req, __u32 mask, - struct libcfs_debug_msg_data *data, const char *fmt, ... ) +void _debug_req(struct ptlrpc_request *req, + struct libcfs_debug_msg_data *msgdata, + const char *fmt, ... ) { va_list args; va_start(args, fmt); - libcfs_debug_vmsg2(data->msg_cdls, data->msg_subsys, mask, data->msg_file, - data->msg_fn, data->msg_line, fmt, args, + libcfs_debug_vmsg2(msgdata, fmt, args, " req@%p x"LPU64"/t"LPD64"("LPD64") o%d->%s@%s:%d/%d" " lens %d/%d e %d to %d dl "CFS_TIME_T" ref %d " "fl "REQ_FLAGS_FMT"/%x/%x rc %d/%d\n", -- 1.8.3.1