From 4e465c73696510d6c411644babab76d44da9c517 Mon Sep 17 00:00:00 2001 From: Oleg Drokin Date: Fri, 25 May 2012 00:06:59 -0400 Subject: [PATCH] LU-969 Revert stack usage reduction patch This patch introduced quite a few problems in the end. Broke return values on 32bit systems (LU-1436) Local io performance regression (LU-1408) Revert "LU-969 debug: reduce stack usage" This reverts commit b9cbe3616b6e0b44c7835b1aec65befb85f848f9. Change-Id: I9966d9490e5016ef95d3ca088796ae187af318d5 Signed-off-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, 310 insertions(+), 366 deletions(-) diff --git a/libcfs/include/libcfs/darwin/libcfs.h b/libcfs/include/libcfs/darwin/libcfs.h index e672a70..b77b23d 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(msgdata, mask, cdls) do {} while(0) +#define CHECK_STACK() 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 8a366f9..44b2e07 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 unsigned int libcfs_console_max_delay; -extern unsigned int libcfs_console_min_delay; +extern cfs_duration_t libcfs_console_max_delay; +extern cfs_duration_t 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,28 +166,10 @@ 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 @@ -203,12 +185,12 @@ static inline int cfs_cdebug_show(unsigned int mask, unsigned int subsystem) #define __CDEBUG(cdls, mask, format, ...) \ do { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, cdls); \ - \ - CFS_CHECK_STACK(&msgdata, mask, cdls); \ + CFS_CHECK_STACK(); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) \ - libcfs_debug_msg(&msgdata, format, ## __VA_ARGS__); \ + libcfs_debug_msg(cdls, DEBUG_SUBSYSTEM, mask, \ + __FILE__, __FUNCTION__, __LINE__, \ + format, ## __VA_ARGS__); \ } while (0) #define CDEBUG(mask, format, ...) __CDEBUG(NULL, mask, format, ## __VA_ARGS__) @@ -231,10 +213,7 @@ 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) \ @@ -263,15 +242,12 @@ do { \ #ifdef CDEBUG_ENABLED -void libcfs_log_goto(struct libcfs_debug_msg_data *, const char *, long_ptr_t); #define GOTO(label, rc) \ do { \ - 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); \ - } \ + 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); \ goto label; \ } while (0) #else @@ -285,18 +261,13 @@ 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; \ - 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); \ + return RETURN__ret; \ } while (0) #elif defined(_MSC_VER) #define RETURN(rc) \ @@ -334,14 +305,54 @@ do { \ return; \ } while (0) -extern int libcfs_debug_msg(struct libcfs_debug_msg_data *msgdata, - const char *format1, ...) - __attribute__ ((format (printf, 2, 3))); +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_vmsg2(struct libcfs_debug_msg_data *msgdata, - const char *format1, - va_list args, const char *format2, ...) - __attribute__ ((format (printf, 4, 5))); +extern void libcfs_assertion_failed(const char *expr, const char *file, + const char *fn, const int line); /* 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 f344bd5..82810ad 100644 --- a/libcfs/include/libcfs/libcfs_private.h +++ b/libcfs/include/libcfs/libcfs_private.h @@ -71,35 +71,48 @@ * * requires -Wall. Unfortunately this rules out use of likely/unlikely. */ -#define LASSERTF(cond, fmt, ...) \ +#define LASSERT(cond) \ do { \ if (cond) \ ; \ - else { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ - libcfs_debug_msg(&msgdata, \ - "ASSERTION( %s ) failed: " fmt, #cond, \ - ## __VA_ARGS__); \ - LBUG(); \ - } \ + else \ + libcfs_assertion_failed( #cond , __FILE__, \ + __FUNCTION__, __LINE__); \ } while(0) -#define LASSERT(cond) LASSERTF(cond, "\n") +#define LASSERTF(cond, fmt, ...) \ +do { \ + if (cond) \ + ; \ + else { \ + libcfs_debug_msg(NULL, DEBUG_SUBSYSTEM, D_EMERG, \ + __FILE__, __FUNCTION__,__LINE__, \ + "ASSERTION(" #cond ") failed: " fmt, \ + ## __VA_ARGS__); \ + LBUG(); \ + } \ +} while(0) #else /* !LASSERT_CHECKED */ +#define LASSERT(cond) \ +do { \ + if (unlikely(!(cond))) \ + libcfs_assertion_failed(#cond , __FILE__, \ + __FUNCTION__, __LINE__); \ +} while(0) + #define LASSERTF(cond, fmt, ...) \ do { \ if (unlikely(!(cond))) { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ - libcfs_debug_msg(&msgdata, \ - "ASSERTION( %s ) failed: " fmt, #cond, \ + libcfs_debug_msg(NULL, DEBUG_SUBSYSTEM, D_EMERG, \ + __FILE__, __FUNCTION__,__LINE__, \ + "ASSERTION(" #cond ") failed: " fmt, \ ## __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. */ @@ -120,13 +133,10 @@ do { \ #define KLASSERT(e) LASSERT(e) -void lbug_with_loc(struct libcfs_debug_msg_data *) __attribute__((noreturn)); +void lbug_with_loc(const char *file, const char *func, const int line) + __attribute__((noreturn)); -#define LBUG() \ -do { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ - lbug_with_loc(&msgdata); \ -} while(0) +#define LBUG() lbug_with_loc(__FILE__, __FUNCTION__, __LINE__) extern cfs_atomic_t libcfs_kmemory; /* @@ -212,7 +222,7 @@ do { \ void libcfs_debug_dumpstack(cfs_task_t *tsk); void libcfs_run_upcall(char **argv); -void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *); +void libcfs_run_lbug_upcall(const char * file, const char *fn, const int line); 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 dee91d9..d8fcbca 100644 --- a/libcfs/include/libcfs/linux/libcfs.h +++ b/libcfs/include/libcfs/linux/libcfs.h @@ -78,24 +78,22 @@ (THREAD_SIZE - 1))) # endif /* __ia64__ */ -#define __CHECK_STACK(msgdata, mask, cdls) \ +#define __CHECK_STACK(file, func, line) \ do { \ - 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; \ + 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); \ dump_stack(); \ /*panic("LBUG");*/ \ } \ } while (0) -#define CFS_CHECK_STACK(msgdata, mask, cdls) __CHECK_STACK(msgdata, mask, cdls) +#define CFS_CHECK_STACK() __CHECK_STACK(__FILE__, __func__, __LINE__) #else /* __x86_64__ */ -#define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0) +#define CFS_CHECK_STACK() 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 28826f9..f96723b 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(msgdata, mask, cdls) do {} while(0) +#define CFS_CHECK_STACK() 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 1011f6e..12c073b 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(msgdata, mask, cdls) do {} while(0) +#define CFS_CHECK_STACK() do {} while(0) #else /* !__KERNEL__ */ -#define CFS_CHECK_STACK(msgdata, mask, cdls) do {} while(0) +#define CFS_CHECK_STACK() 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 475faae..6b07670 100644 --- a/libcfs/libcfs/darwin/darwin-debug.c +++ b/libcfs/libcfs/darwin/darwin-debug.c @@ -28,8 +28,6 @@ /* * 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/ @@ -46,17 +44,17 @@ void libcfs_debug_dumpstack(cfs_task_t *tsk) return; } -void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *msgdata) +void libcfs_run_lbug_upcall(const char *file, const char *fn, const int line) { } -void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) +void lbug_with_loc(const char *file, const char *func, const int line) { libcfs_catastrophe = 1; CEMERG("LBUG: pid: %u thread: %#x\n", (unsigned)cfs_curproc_pid(), (unsigned)current_thread()); libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(msgdata); + libcfs_run_lbug_upcall(file, func, line); while (1) cfs_schedule(); diff --git a/libcfs/libcfs/debug.c b/libcfs/libcfs/debug.c index 604a0fb..00fbb56 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); -unsigned int libcfs_console_max_delay; -CFS_MODULE_PARM(libcfs_console_max_delay, "l", uint, 0644, +cfs_duration_t libcfs_console_max_delay; +CFS_MODULE_PARM(libcfs_console_max_delay, "l", ulong, 0644, "Lustre kernel debug console max delay (jiffies)"); EXPORT_SYMBOL(libcfs_console_max_delay); -unsigned int libcfs_console_min_delay; -CFS_MODULE_PARM(libcfs_console_min_delay, "l", uint, 0644, +cfs_duration_t libcfs_console_min_delay; +CFS_MODULE_PARM(libcfs_console_min_delay, "l", ulong, 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 = 3 * THREAD_SIZE / 4; +unsigned int libcfs_stack; EXPORT_SYMBOL(libcfs_stack); unsigned int portal_enter_debugger; @@ -386,7 +386,6 @@ 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) { @@ -459,20 +458,5 @@ 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 c805b8b..7b2d3a9 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(struct libcfs_debug_msg_data *msgdata) +void libcfs_run_lbug_upcall(const char *file, const char *fn, const int line) { char *argv[6]; char buf[32]; ENTRY; - snprintf (buf, sizeof buf, "%d", msgdata->msg_line); + snprintf (buf, sizeof buf, "%d", line); argv[1] = "LBUG"; - argv[2] = (char *)msgdata->msg_file; - argv[3] = (char *)msgdata->msg_fn; + argv[2] = (char *)file; + argv[3] = (char *)fn; argv[4] = buf; argv[5] = NULL; @@ -167,22 +167,23 @@ void libcfs_run_lbug_upcall(struct libcfs_debug_msg_data *msgdata) } #ifdef __arch_um__ -void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) +void lbug_with_loc(const char *file, const char *func, const int line) { libcfs_catastrophe = 1; - libcfs_debug_msg(msgdata, "LBUG - trying to dump log to %s\n", + libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, + "LBUG - trying to dump log to %s\n", libcfs_debug_file_path); libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(msgdata); + libcfs_run_lbug_upcall(file, func, line); asm("int $3"); panic("LBUG"); } #else /* coverity[+kill] */ -void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) +void lbug_with_loc(const char *file, const char *func, const int line) { libcfs_catastrophe = 1; - libcfs_debug_msg(msgdata, "LBUG\n"); + libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, "LBUG\n"); if (in_interrupt()) { panic("LBUG in interrupt.\n"); @@ -192,7 +193,7 @@ void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) libcfs_debug_dumpstack(NULL); if (!libcfs_panic_on_lbug) libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(msgdata); + libcfs_run_lbug_upcall(file, func, line); 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 51d7d7f..0bbcac9 100644 --- a/libcfs/libcfs/linux/linux-tracefile.c +++ b/libcfs/libcfs/linux/linux-tracefile.c @@ -181,23 +181,22 @@ int cfs_tcd_owns_tage(struct cfs_trace_cpu_data *tcd, } void -cfs_set_ptldebug_header(struct ptldebug_header *header, - struct libcfs_debug_msg_data *msgdata, - unsigned long stack) +cfs_set_ptldebug_header(struct ptldebug_header *header, int subsys, int mask, + const int line, unsigned long stack) { struct timeval tv; do_gettimeofday(&tv); - header->ph_subsys = msgdata->msg_subsys; - header->ph_mask = msgdata->msg_mask; + header->ph_subsys = subsys; + header->ph_mask = 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 = msgdata->msg_line; + header->ph_line_num = line; header->ph_extern_pid = 0; return; } diff --git a/libcfs/libcfs/module.c b/libcfs/libcfs/module.c index b602016..8278b4c 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 = 0; + int err; 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 36967d5..9e083a1 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; -unsigned int libcfs_console_max_delay; -unsigned int libcfs_console_min_delay; +cfs_duration_t libcfs_console_max_delay; +cfs_duration_t libcfs_console_min_delay; unsigned int libcfs_console_backoff = CDEBUG_DEFAULT_BACKOFF; #else /* !HAVE_CATAMOUNT_DATA_H */ #ifdef HAVE_NETDB_H @@ -243,21 +243,10 @@ 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(struct libcfs_debug_msg_data *msgdata, +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, ...) { @@ -275,7 +264,7 @@ libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, /* 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 (((msgdata->msg_mask & libcfs_printk) && toconsole == 1) || toconsole > 1) + if (((mask & libcfs_printk) && toconsole == 1) || toconsole > 1) console = 1; #endif @@ -283,12 +272,11 @@ libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, return 0; } - if (msgdata->msg_mask & (D_EMERG | D_ERROR)) + if (mask & (D_EMERG | D_ERROR)) prefix = "LustreError"; nob = snprintf(buf, sizeof(buf), "%s: %u-%s:(%s:%d:%s()): ", prefix, - source_pid, source_nid, msgdata->msg_file, - msgdata->msg_line, msgdata->msg_fn); + source_pid, source_nid, file, line, fn); remain = sizeof(buf) - nob; if (format1) { @@ -304,8 +292,6 @@ libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, #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 && @@ -365,38 +351,16 @@ 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, - msgdata->msg_file, msgdata->msg_line, msgdata->msg_fn, buf); + file, line, fn, buf); return 0; } void -libcfs_assertion_failed(const char *expr, struct libcfs_debug_msg_data *msgdata) +libcfs_assertion_failed(const char *expr, const char *file, const char *func, + const int line) { - libcfs_debug_msg(msgdata, "ASSERTION(%s) failed\n", expr); + libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, + "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 8e42428..d681fc3 100644 --- a/libcfs/libcfs/tracefile.c +++ b/libcfs/libcfs/tracefile.c @@ -243,21 +243,8 @@ static struct cfs_trace_page *cfs_trace_get_tage(struct cfs_trace_cpu_data *tcd, return tage; } -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, +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, ...) { @@ -274,9 +261,6 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, 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; @@ -286,7 +270,7 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, /* 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, msgdata, CDEBUG_STACK()); + cfs_set_ptldebug_header(&header, subsys, mask, line, CDEBUG_STACK()); if (tcd == NULL) /* arch may not log in IRQ context */ goto console; @@ -302,8 +286,8 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, depth = __current_nesting_level(); known_size = strlen(file) + 1 + depth; - if (msgdata->msg_fn) - known_size += strlen(msgdata->msg_fn) + 1; + if (fn) + known_size += strlen(fn) + 1; if (libcfs_debug_binary) known_size += sizeof(header); @@ -360,8 +344,8 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, } if (*(string_buf+needed-1) != '\n') - printk(CFS_KERN_INFO "format at %s:%d:%s doesn't end in " - "newline\n", file, msgdata->msg_line, msgdata->msg_fn); + printk(CFS_KERN_INFO "format at %s:%d:%s doesn't end in newline\n", + file, line, fn); header.ph_len = known_size + needed; debug_buf = (char *)cfs_page_address(tage->page) + tage->used; @@ -382,10 +366,10 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata, tage->used += strlen(file) + 1; debug_buf += strlen(file) + 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; + if (fn) { + strcpy(debug_buf, fn); + tage->used += strlen(fn) + 1; + debug_buf += strlen(fn) + 1; } __LASSERT(debug_buf == string_buf); @@ -432,7 +416,7 @@ console: if (tcd != NULL) { cfs_print_to_console(&header, mask, string_buf, needed, file, - msgdata->msg_fn); + fn); cfs_trace_put_tcd(tcd); } else { string_buf = cfs_trace_get_console_buffer(); @@ -449,13 +433,12 @@ 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, msgdata->msg_fn); + string_buf, needed, file, fn); cfs_trace_put_console_buffer(string_buf); } @@ -464,12 +447,11 @@ 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, msgdata->msg_fn); + string_buf, needed, file, fn); cfs_trace_put_console_buffer(string_buf); cdls->cdls_count = 0; @@ -480,17 +462,19 @@ console: EXPORT_SYMBOL(libcfs_debug_vmsg2); void -libcfs_assertion_failed(const char *expr, struct libcfs_debug_msg_data *msgdata) +libcfs_assertion_failed(const char *expr, const char *file, + const char *func, const int line) { - libcfs_debug_msg(msgdata, "ASSERTION(%s) failed\n", expr); + libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, + "ASSERTION(%s) failed\n", expr); /* cfs_enter_debugger(); */ - lbug_with_loc(msgdata); + lbug_with_loc(file, func, line); } EXPORT_SYMBOL(libcfs_assertion_failed); void cfs_trace_assertion_failed(const char *str, - struct libcfs_debug_msg_data *msgdata) + const char *fn, const char *file, int line) { struct ptldebug_header hdr; @@ -498,10 +482,10 @@ cfs_trace_assertion_failed(const char *str, libcfs_catastrophe = 1; cfs_mb(); - cfs_set_ptldebug_header(&hdr, msgdata, CDEBUG_STACK()); + cfs_set_ptldebug_header(&hdr, DEBUG_SUBSYSTEM, D_EMERG, line, + CDEBUG_STACK()); - cfs_print_to_console(&hdr, D_EMERG, str, strlen(str), - msgdata->msg_file, msgdata->msg_fn); + cfs_print_to_console(&hdr, D_EMERG, str, strlen(str), file, fn); LIBCFS_PANIC("Lustre debug assertion failure\n"); diff --git a/libcfs/libcfs/tracefile.h b/libcfs/libcfs/tracefile.h index a39ed41..1f87b32 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, - struct libcfs_debug_msg_data *m, + int subsys, int mask, const int line, unsigned long stack); extern void cfs_print_to_console(struct ptldebug_header *hdr, int mask, const char *buf, int len, const char *file, @@ -320,26 +320,25 @@ 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, - struct libcfs_debug_msg_data *m); +extern void cfs_trace_assertion_failed(const char *str, const char *fn, + const char *file, int line); /* 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", \ - &msgdata); \ + __FUNCTION__, __FILE__, __LINE__); \ } \ -} 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 ec2447e..0529581 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(struct libcfs_debug_msg_data *msgdata) +void lbug_with_loc(const char *file, const char *func, const int line) { /* No libcfs_catastrophe in userspace! */ - libcfs_debug_msg(msgdata, "LBUG\n"); + libcfs_debug_msg(NULL, 0, D_EMERG, file, func, line, "LBUG\n"); abort(); } diff --git a/libcfs/libcfs/winnt/winnt-debug.c b/libcfs/libcfs/winnt/winnt-debug.c index 4ddb786..2e50fac 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(struct libcfs_debug_msg_data *msgdata) +void libcfs_run_lbug_upcall(const char *file, const char *fn, const int line) { } -void lbug_with_loc(struct libcfs_debug_msg_data *msgdata) +void lbug_with_loc(const char *file, const char *func, const int line) { libcfs_catastrophe = 1; CEMERG("LBUG: pid: %u thread: %#x\n", cfs_curproc_pid(), PsGetCurrentThread()); cfs_enter_debugger(); libcfs_debug_dumplog(); - libcfs_run_lbug_upcall(msgdata); + libcfs_run_lbug_upcall(file, func, line); } void cfs_enter_debugger(void) diff --git a/lustre/fid/fid_request.c b/lustre/fid/fid_request.c index bc04b3dd..214f542 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 = 0; + seqno_t seqnr; 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 47782be..86966dc 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 { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ + static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - cl_page_print(env, &msgdata, lu_cdebug_printer, page); \ + cl_page_print(env, &__info, 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 { \ - 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__); \ - } \ +#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__); \ + } \ } while (0) /** @} cl_page */ @@ -1789,10 +1789,10 @@ struct cl_lock_operations { #define CL_LOCK_DEBUG(mask, env, lock, format, ...) \ do { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ + static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - cl_lock_print(env, &msgdata, lu_cdebug_printer, lock); \ + cl_lock_print(env, &__info, 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 0fd61fb..2b9424f 100644 --- a/lustre/include/lu_object.h +++ b/lustre/include/lu_object.h @@ -752,23 +752,40 @@ 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 { \ - 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__); \ - } \ +#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__); \ + } \ } while (0) /** @@ -776,12 +793,12 @@ do { \ */ #define LU_OBJECT_HEADER(mask, env, object, format, ...) \ do { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, mask, NULL); \ + static DECLARE_LU_CDEBUG_PRINT_INFO(__info, mask); \ \ if (cfs_cdebug_show(mask, DEBUG_SUBSYSTEM)) { \ - lu_object_header_print(env, &msgdata, lu_cdebug_printer,\ + lu_object_header_print(env, &__info, lu_cdebug_printer, \ (object)->lo_header); \ - lu_cdebug_printer(env, &msgdata, "\n"); \ + lu_cdebug_printer(env, &__info, "\n"); \ CDEBUG(mask, format , ## __VA_ARGS__); \ } \ } while (0) diff --git a/lustre/include/lustre_capa.h b/lustre/include/lustre_capa.h index d9110ae..33f1199 100644 --- a/lustre/include/lustre_capa.h +++ b/lustre/include/lustre_capa.h @@ -155,16 +155,13 @@ static inline __u32 capa_expiry(struct lustre_capa *capa) return capa->lc_expiry; } -void _debug_capa(struct lustre_capa *, struct libcfs_debug_msg_data *, - const char *fmt, ... ); -#define DEBUG_CAPA(level, capa, fmt, args...) \ +#define DEBUG_CAPA(level, c, fmt, args...) \ do { \ - 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); \ - } \ +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)); \ } 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 9dd9cc7..4bc9160 100644 --- a/lustre/include/lustre_dlm.h +++ b/lustre/include/lustre_dlm.h @@ -884,32 +884,39 @@ extern char *ldlm_lockname[]; extern char *ldlm_typename[]; extern char *ldlm_it2str(int it); #ifdef LIBCFS_DEBUG -#define ldlm_lock_debug(msgdata, mask, cdls, lock, fmt, a...) do { \ - CFS_CHECK_STACK(msgdata, mask, cdls); \ +#define ldlm_lock_debug(cdls, level, lock, file, func, line, fmt, a...) do { \ + CFS_CHECK_STACK(); \ \ - if (((mask) & D_CANTMASK) != 0 || \ - ((libcfs_debug & (mask)) != 0 && \ - (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) \ - _ldlm_lock_debug(lock, msgdata, fmt, ##a); \ + 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 ); \ + } \ } while(0) -void _ldlm_lock_debug(struct ldlm_lock *lock, - struct libcfs_debug_msg_data *data, - const char *fmt, ...) - __attribute__ ((format (printf, 3, 4))); +void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 mask, + struct libcfs_debug_msg_data *data, const char *fmt, + ...) + __attribute__ ((format (printf, 4, 5))); -#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);\ +#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); \ } 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 { \ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_DLMTRACE, NULL); \ - ldlm_lock_debug(&msgdata, D_DLMTRACE, NULL, lock, "### " fmt , ##a);\ +#define LDLM_DEBUG(lock, fmt, a...) do { \ + ldlm_lock_debug(NULL, D_DLMTRACE, lock, \ + __FILE__, __FUNCTION__, __LINE__, \ + "### " 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 6ca398b..c71a3b2 100644 --- a/lustre/include/lustre_net.h +++ b/lustre/include/lustre_net.h @@ -827,22 +827,25 @@ 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, +void _debug_req(struct ptlrpc_request *req, __u32 mask, struct libcfs_debug_msg_data *data, const char *fmt, ...) - __attribute__ ((format (printf, 3, 4))); + __attribute__ ((format (printf, 4, 5))); /** * Helper that decides if we need to print request accordig to current debug * level settings */ -#define debug_req(msgdata, mask, cdls, req, fmt, a...) \ +#define debug_req(cdls, level, req, file, func, line, fmt, a...) \ do { \ - CFS_CHECK_STACK(msgdata, mask, cdls); \ + CFS_CHECK_STACK(); \ \ - if (((mask) & D_CANTMASK) != 0 || \ - ((libcfs_debug & (mask)) != 0 && \ - (libcfs_subsystem_debug & DEBUG_SUBSYSTEM) != 0)) \ - _debug_req((req), msgdata, fmt, ##a); \ + 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); \ + } \ } while(0) /** @@ -853,12 +856,11 @@ do { \ do { \ if ((level) & (D_ERROR | D_WARNING)) { \ static cfs_debug_limit_state_t cdls; \ - 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); \ - } \ + debug_req(&cdls, level, req, __FILE__, __func__, __LINE__, \ + "@@@ "fmt" ", ## args); \ + } else \ + debug_req(NULL, level, req, __FILE__, __func__, __LINE__, \ + "@@@ "fmt" ", ## args); \ } while (0) /** @} */ diff --git a/lustre/ldlm/ldlm_lib.c b/lustre/ldlm/ldlm_lib.c index c4aab4a..a8433fce 100644 --- a/lustre/ldlm/ldlm_lib.c +++ b/lustre/ldlm/ldlm_lib.c @@ -1784,8 +1784,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 *thread = NULL; + struct lu_env env; + struct ptlrpc_thread fake_svc_thread, *thread = &fake_svc_thread; int rc = 0; ENTRY; @@ -1796,26 +1796,13 @@ static int target_recovery_thread(void *arg) RECALC_SIGPENDING; SIGNAL_MASK_UNLOCK(current, flags); - 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); + rc = lu_context_init(&env.le_ctx, LCT_MD_THREAD); + if (rc) 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; @@ -1908,12 +1895,9 @@ 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 c6a56f5..d840b7f 100644 --- a/lustre/ldlm/ldlm_lock.c +++ b/lustre/ldlm/ldlm_lock.c @@ -1964,16 +1964,18 @@ void ldlm_lock_dump_handle(int level, struct lustre_handle *lockh) LDLM_LOCK_PUT(lock); } -void _ldlm_lock_debug(struct ldlm_lock *lock, - struct libcfs_debug_msg_data *msgdata, - const char *fmt, ...) +void _ldlm_lock_debug(struct ldlm_lock *lock, __u32 level, + struct libcfs_debug_msg_data *data, 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(msgdata, fmt, args, + libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, + data->msg_fn, data->msg_line, 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, @@ -1991,7 +1993,8 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, switch (lock->l_resource->lr_type) { case LDLM_EXTENT: - libcfs_debug_vmsg2(msgdata, fmt, args, + libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, + data->msg_fn, data->msg_line, 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 @@ -2015,7 +2018,8 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, break; case LDLM_FLOCK: - libcfs_debug_vmsg2(msgdata, fmt, args, + libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, + data->msg_fn, data->msg_line, 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 @@ -2039,7 +2043,8 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, break; case LDLM_IBITS: - libcfs_debug_vmsg2(msgdata, fmt, args, + libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, + data->msg_fn, data->msg_line, 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 " @@ -2062,7 +2067,8 @@ void _ldlm_lock_debug(struct ldlm_lock *lock, break; default: - libcfs_debug_vmsg2(msgdata, fmt, args, + libcfs_debug_vmsg2(cdls, data->msg_subsys, level,data->msg_file, + data->msg_fn, data->msg_line, 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 96244e3..68772ce 100644 --- a/lustre/ldlm/ldlm_lockd.c +++ b/lustre/ldlm/ldlm_lockd.c @@ -180,15 +180,13 @@ 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(&msgdata); + libcfs_run_lbug_upcall(__FILE__, + "waiting_locks_callback", + expired_lock_thread.elt_dump); 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 09167d6..214da81 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 = 0; + mdsno_t mds; int rc; ENTRY; diff --git a/lustre/obdclass/capa.c b/lustre/obdclass/capa.c index 6675db9..7038891 100644 --- a/lustre/obdclass/capa.c +++ b/lustre/obdclass/capa.c @@ -388,23 +388,6 @@ 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 d3781a70..7ffd6c8 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 libcfs_debug_msg_data *msgdata = cookie; - struct lu_cdebug_data *key; + struct lu_cdebug_print_info *info = cookie; + struct lu_cdebug_data *key; int used; int complete; va_list args; @@ -400,8 +400,10 @@ 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(msgdata->msg_mask, msgdata->msg_subsys)) - libcfs_debug_msg(msgdata, "%s", key->lck_area); + 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); key->lck_area[0] = 0; } va_end(args); @@ -1152,9 +1154,9 @@ void lu_stack_fini(const struct lu_env *env, struct lu_device *top) /* * Uh-oh, objects still exist. */ - LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_ERROR, NULL); + static DECLARE_LU_CDEBUG_PRINT_INFO(cookie, D_ERROR); - lu_site_print(env, site, &msgdata, lu_cdebug_printer); + lu_site_print(env, site, &cookie, 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 c81d860..3929127 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 = NULL; + struct llog_handle *handle; 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 ff64fe0..c540321 100644 --- a/lustre/ptlrpc/pack_generic.c +++ b/lustre/ptlrpc/pack_generic.c @@ -2270,9 +2270,8 @@ static inline int rep_ptlrpc_body_swabbed(struct ptlrpc_request *req) } } -void _debug_req(struct ptlrpc_request *req, - struct libcfs_debug_msg_data *msgdata, - const char *fmt, ... ) +void _debug_req(struct ptlrpc_request *req, __u32 mask, + struct libcfs_debug_msg_data *data, const char *fmt, ... ) { int req_ok = req->rq_reqmsg != NULL; int rep_ok = req->rq_repmsg != NULL; @@ -2284,7 +2283,8 @@ void _debug_req(struct ptlrpc_request *req, } va_start(args, fmt); - libcfs_debug_vmsg2(msgdata, fmt, args, + libcfs_debug_vmsg2(data->msg_cdls, data->msg_subsys, mask, data->msg_file, + data->msg_fn, data->msg_line, 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