X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Ftracefile.h;h=968c128aeb94a4f9ed21d30139ecb19f22e07ab6;hb=357de3461d95f693d416e380dd4963533f44ea25;hp=a857fb541bc40b8c6358200dec1b3d394f5f7f67;hpb=e428ed025908ff5f51f8a94558321927834aeef9;p=fs%2Flustre-release.git diff --git a/libcfs/libcfs/tracefile.h b/libcfs/libcfs/tracefile.h index a857fb5..968c128 100644 --- a/libcfs/libcfs/tracefile.h +++ b/libcfs/libcfs/tracefile.h @@ -1,6 +1,4 @@ -/* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*- - * vim:expandtab:shiftwidth=8:tabstop=8: - * +/* * GPL HEADER START * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. @@ -26,8 +24,10 @@ * GPL HEADER END */ /* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved + * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * Use is subject to license terms. + * + * Copyright (c) 2012, Intel Corporation. */ /* * This file is part of Lustre, http://www.lustre.org/ @@ -39,54 +39,62 @@ #include +#if defined(__linux__) +#include "linux/linux-tracefile.h" +#elif defined(__WINNT__) +#include "winnt/winnt-tracefile.h" +#else +#error Unsupported operating system. +#endif + /* trace file lock routines */ #define TRACEFILE_NAME_SIZE 1024 -extern char tracefile[TRACEFILE_NAME_SIZE]; -extern long long tracefile_size; +extern char cfs_tracefile[TRACEFILE_NAME_SIZE]; +extern long long cfs_tracefile_size; extern void libcfs_run_debug_log_upcall(char *file); -int tracefile_init_arch(void); -void tracefile_fini_arch(void); - -void tracefile_read_lock(void); -void tracefile_read_unlock(void); -void tracefile_write_lock(void); -void tracefile_write_unlock(void); - -int tracefile_dump_all_pages(char *filename); -void trace_debug_print(void); -void trace_flush_pages(void); -int trace_start_thread(void); -void trace_stop_thread(void); -int tracefile_init(int max_pages); -void tracefile_exit(void); - - - -int trace_copyin_string(char *knl_buffer, int knl_buffer_nob, - const char *usr_buffer, int usr_buffer_nob); -int trace_copyout_string(char *usr_buffer, int usr_buffer_nob, - const char *knl_str, char *append); -int trace_allocate_string_buffer(char **str, int nob); -void trace_free_string_buffer(char *str, int nob); -int trace_dump_debug_buffer_usrstr(void *usr_str, int usr_str_nob); -int trace_daemon_command(char *str); -int trace_daemon_command_usrstr(void *usr_str, int usr_str_nob); -int trace_set_debug_mb(int mb); -int trace_set_debug_mb_usrstr(void *usr_str, int usr_str_nob); -int trace_get_debug_mb(void); +int cfs_tracefile_init_arch(void); +void cfs_tracefile_fini_arch(void); + +void cfs_tracefile_read_lock(void); +void cfs_tracefile_read_unlock(void); +void cfs_tracefile_write_lock(void); +void cfs_tracefile_write_unlock(void); + +int cfs_tracefile_dump_all_pages(char *filename); +void cfs_trace_debug_print(void); +void cfs_trace_flush_pages(void); +int cfs_trace_start_thread(void); +void cfs_trace_stop_thread(void); +int cfs_tracefile_init(int max_pages); +void cfs_tracefile_exit(void); + + + +int cfs_trace_copyin_string(char *knl_buffer, int knl_buffer_nob, + const char *usr_buffer, int usr_buffer_nob); +int cfs_trace_copyout_string(char *usr_buffer, int usr_buffer_nob, + const char *knl_str, char *append); +int cfs_trace_allocate_string_buffer(char **str, int nob); +void cfs_trace_free_string_buffer(char *str, int nob); +int cfs_trace_dump_debug_buffer_usrstr(void *usr_str, int usr_str_nob); +int cfs_trace_daemon_command(char *str); +int cfs_trace_daemon_command_usrstr(void *usr_str, int usr_str_nob); +int cfs_trace_set_debug_mb(int mb); +int cfs_trace_set_debug_mb_usrstr(void *usr_str, int usr_str_nob); +int cfs_trace_get_debug_mb(void); extern void libcfs_debug_dumplog_internal(void *arg); extern void libcfs_register_panic_notifier(void); extern void libcfs_unregister_panic_notifier(void); extern int libcfs_panic_in_progress; -extern int trace_max_debug_mb(void); +extern int cfs_trace_max_debug_mb(void); #define TCD_MAX_PAGES (5 << (20 - CFS_PAGE_SHIFT)) #define TCD_STOCK_PAGES (TCD_MAX_PAGES) -#define TRACEFILE_SIZE (500 << 20) +#define CFS_TRACEFILE_SIZE (500 << 20) #ifdef LUSTRE_TRACEFILE_PRIVATE @@ -96,14 +104,14 @@ extern int trace_max_debug_mb(void); #define TCD_MAX_PAGES (5 << (20 - CFS_PAGE_SHIFT)) #define TCD_STOCK_PAGES (TCD_MAX_PAGES) -#define TRACEFILE_SIZE (500 << 20) +#define CFS_TRACEFILE_SIZE (500 << 20) /* Size of a buffer for sprinting console messages if we can't get a page * from system */ -#define TRACE_CONSOLE_BUFFER_SIZE 1024 +#define CFS_TRACE_CONSOLE_BUFFER_SIZE 1024 -union trace_data_union { - struct trace_cpu_data { +union cfs_trace_data_union { + struct cfs_trace_cpu_data { /* * Even though this structure is meant to be per-CPU, locking * is needed because in some places the data may be accessed @@ -111,13 +119,13 @@ union trace_data_union { * and trace_put_tcd, which are called in libcfs_debug_vmsg2 and * tcd_for_each_type_lock */ - spinlock_t tcd_lock; + spinlock_t tcd_lock; unsigned long tcd_lock_flags; /* * pages with trace records not yet processed by tracefiled. */ - struct list_head tcd_pages; + cfs_list_t tcd_pages; /* number of pages on ->tcd_pages */ unsigned long tcd_cur_pages; @@ -131,7 +139,7 @@ union trace_data_union { * (put_pages_on_daemon_list()). LRU pages from this list are * discarded when list grows too large. */ - struct list_head tcd_daemon_pages; + cfs_list_t tcd_daemon_pages; /* number of pages on ->tcd_daemon_pages */ unsigned long tcd_cur_daemon_pages; @@ -165,7 +173,7 @@ union trace_data_union { * TCD_STOCK_PAGES pagesful are consumed by trace records all * emitted in non-blocking contexts. Which is quite unlikely. */ - struct list_head tcd_stock_pages; + cfs_list_t tcd_stock_pages; /* number of pages on ->tcd_stock_pages */ unsigned long tcd_cur_stock_pages; @@ -175,26 +183,27 @@ union trace_data_union { /* The factors to share debug memory. */ unsigned short tcd_pages_factor; } tcd; - char __pad[L1_CACHE_ALIGN(sizeof(struct trace_cpu_data))]; + char __pad[CFS_L1_CACHE_ALIGN(sizeof(struct cfs_trace_cpu_data))]; }; #define TCD_MAX_TYPES 8 -extern union trace_data_union (*trace_data[TCD_MAX_TYPES])[NR_CPUS]; +extern union cfs_trace_data_union (*cfs_trace_data[TCD_MAX_TYPES])[CFS_NR_CPUS]; -#define tcd_for_each(tcd, i, j) \ - for (i = 0; trace_data[i] != NULL; i++) \ - for (j = 0, ((tcd) = &(*trace_data[i])[j].tcd); \ - j < num_possible_cpus(); j++, (tcd) = &(*trace_data[i])[j].tcd) +#define cfs_tcd_for_each(tcd, i, j) \ + for (i = 0; cfs_trace_data[i] != NULL; i++) \ + for (j = 0, ((tcd) = &(*cfs_trace_data[i])[j].tcd); \ + j < cfs_num_possible_cpus(); \ + j++, (tcd) = &(*cfs_trace_data[i])[j].tcd) -#define tcd_for_each_type_lock(tcd, i, cpu) \ - for (i = 0; trace_data[i] && \ - (tcd = &(*trace_data[i])[cpu].tcd) && \ - trace_lock_tcd(tcd); trace_unlock_tcd(tcd), i++) +#define cfs_tcd_for_each_type_lock(tcd, i, cpu) \ + for (i = 0; cfs_trace_data[i] && \ + (tcd = &(*cfs_trace_data[i])[cpu].tcd) && \ + cfs_trace_lock_tcd(tcd, 1); cfs_trace_unlock_tcd(tcd, 1), i++) /* XXX nikita: this declaration is internal to tracefile.c and should probably * be moved there */ struct page_collection { - struct list_head pc_pages; + cfs_list_t pc_pages; /* * spin-lock protecting ->pc_pages. It is taken by smp_call_function() * call-back functions. XXX nikita: Which is horrible: all processors @@ -202,23 +211,23 @@ struct page_collection { * lock. Probably ->pc_pages should be replaced with an array of * NR_CPUS elements accessed locklessly. */ - spinlock_t pc_lock; + spinlock_t pc_lock; /* * if this flag is set, collect_pages() will spill both * ->tcd_daemon_pages and ->tcd_pages to the ->pc_pages. Otherwise, * only ->tcd_pages are spilled. */ - int pc_want_daemon_pages; + int pc_want_daemon_pages; }; /* XXX nikita: this declaration is internal to tracefile.c and should probably * be moved there */ struct tracefiled_ctl { - struct completion tctl_start; - struct completion tctl_stop; - cfs_waitq_t tctl_waitq; - pid_t tctl_pid; - atomic_t tctl_shutdown; + struct completion tctl_start; + struct completion tctl_stop; + cfs_waitq_t tctl_waitq; + pid_t tctl_pid; + cfs_atomic_t tctl_shutdown; }; /* @@ -226,68 +235,111 @@ struct tracefiled_ctl { */ /* XXX nikita: this declaration is internal to tracefile.c and should probably * be moved there */ -struct trace_page { +struct cfs_trace_page { /* * page itself */ - cfs_page_t *page; + cfs_page_t *page; /* * linkage into one of the lists in trace_data_union or * page_collection */ - struct list_head linkage; + cfs_list_t linkage; /* * number of bytes used within this page */ - unsigned int used; + unsigned int used; /* * cpu that owns this page */ - unsigned short cpu; + unsigned short cpu; /* * type(context) of this page */ - unsigned short type; + unsigned short type; }; -extern void set_ptldebug_header(struct ptldebug_header *header, - int subsys, int mask, const int line, - unsigned long stack); -extern void print_to_console(struct ptldebug_header *hdr, int mask, const char *buf, - int len, const char *file, const char *fn); +extern void cfs_set_ptldebug_header(struct ptldebug_header *header, + 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, + const char *fn); + +extern int cfs_trace_lock_tcd(struct cfs_trace_cpu_data *tcd, int walking); +extern void cfs_trace_unlock_tcd(struct cfs_trace_cpu_data *tcd, int walking); + +/** + * trace_buf_type_t, trace_buf_idx_get() and trace_console_buffers[][] + * are not public libcfs API; they should be defined in + * platform-specific tracefile include files + * (see, for example, linux-tracefile.h). + */ + +extern char *cfs_trace_console_buffers[CFS_NR_CPUS][CFS_TCD_TYPE_MAX]; +extern cfs_trace_buf_type_t cfs_trace_buf_idx_get(void); + +static inline char * +cfs_trace_get_console_buffer(void) +{ + unsigned int i = cfs_get_cpu(); + unsigned int j = cfs_trace_buf_idx_get(); + + return cfs_trace_console_buffers[i][j]; +} + +static inline void +cfs_trace_put_console_buffer(char *buffer) +{ + cfs_put_cpu(); +} + +static inline struct cfs_trace_cpu_data * +cfs_trace_get_tcd(void) +{ + struct cfs_trace_cpu_data *tcd = + &(*cfs_trace_data[cfs_trace_buf_idx_get()])[cfs_get_cpu()].tcd; + + cfs_trace_lock_tcd(tcd, 0); + + return tcd; +} + +static inline void +cfs_trace_put_tcd (struct cfs_trace_cpu_data *tcd) +{ + cfs_trace_unlock_tcd(tcd, 0); -extern struct trace_cpu_data *trace_get_tcd(void); -extern void trace_put_tcd(struct trace_cpu_data *tcd); -extern int trace_lock_tcd(struct trace_cpu_data *tcd); -extern void trace_unlock_tcd(struct trace_cpu_data *tcd); -extern char *trace_get_console_buffer(void); -extern void trace_put_console_buffer(char *buffer); + cfs_put_cpu(); +} -int trace_refill_stock(struct trace_cpu_data *tcd, int gfp, - struct list_head *stock); +int cfs_trace_refill_stock(struct cfs_trace_cpu_data *tcd, int gfp, + cfs_list_t *stock); -int tcd_owns_tage(struct trace_cpu_data *tcd, struct trace_page *tage); +int cfs_tcd_owns_tage(struct cfs_trace_cpu_data *tcd, + struct cfs_trace_page *tage); -extern void 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))) { \ - trace_assertion_failed("ASSERTION("#cond") failed", \ - __FUNCTION__, __FILE__, __LINE__); \ + LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL); \ + cfs_trace_assertion_failed("ASSERTION("#cond") failed", \ + &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 */