#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 */
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];
#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
#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__)
#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) \
#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
* 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) \
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,
*
* 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. */
#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;
/*
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);
(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__ */
#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 */
#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__ */
/*
* 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/
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();
"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);
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;
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)
{
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);
}
}
-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;
}
#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");
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);
}
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;
}
{
char *buf;
struct libcfs_ioctl_data *data;
- int err;
+ int err = 0;
ENTRY;
LIBCFS_ALLOC_GFP(buf, 1024, CFS_ALLOC_STD);
/* 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
}
#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, ...)
{
/* 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
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) {
#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 &&
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);
+}
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, ...)
{
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;
/* 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;
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);
}
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;
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);
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();
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);
}
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;
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;
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");
};
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,
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 */
/* __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();
}
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)
*/
#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)
/**
* 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 */
#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)
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)
/**
*/
#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)
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...) \
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)
#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)
/**
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)
/** @} */
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;
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;
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);
}
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,
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
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
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 "
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",
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;
{
struct obd_device *obd = class_exp2obd(exp);
struct lmv_obd *lmv = &obd->u.lmv;
- mdsno_t mds;
+ mdsno_t mds = 0;
int rc;
ENTRY;
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);
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;
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);
/*
* 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) {
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;
}
}
-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, ... )
{
int req_ok = req->rq_reqmsg != NULL;
int rep_ok = req->rq_repmsg != NULL;
nid = req->rq_export->exp_connection->c_peer.nid;
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",
git://git.whamcloud.com / fs / lustre-release.git / commitdiff