Whamcloud - gitweb
b=15977 analyse only consistent part of the log
[fs/lustre-release.git] / libcfs / libcfs / linux / linux-tracefile.c
index 78d0d8a..3028269 100644 (file)
 #include <libcfs/libcfs.h>
 #include "tracefile.h"
 
-/* three types of trace_data in linux */
-enum {
-       TCD_TYPE_PROC = 0,
-       TCD_TYPE_SOFTIRQ,
-       TCD_TYPE_IRQ,
-       TCD_TYPE_MAX
-};
-
 /* percents to share the total debug memory for each type */
-static unsigned int pages_factor[TCD_TYPE_MAX] = {
-       80,  /* 80% pages for TCD_TYPE_PROC */
-       10,  /* 10% pages for TCD_TYPE_SOFTIRQ */
-       10   /* 10% pages for TCD_TYPE_IRQ */
+static unsigned int pages_factor[CFS_TCD_TYPE_MAX] = {
+       80,  /* 80% pages for CFS_TCD_TYPE_PROC */
+       10,  /* 10% pages for CFS_TCD_TYPE_SOFTIRQ */
+       10   /* 10% pages for CFS_TCD_TYPE_IRQ */
 };
 
-char *trace_console_buffers[NR_CPUS][3];
+char *cfs_trace_console_buffers[NR_CPUS][CFS_TCD_TYPE_MAX];
 
-struct rw_semaphore tracefile_sem;
+cfs_rw_semaphore_t cfs_tracefile_sem;
 
-int tracefile_init_arch()
+int cfs_tracefile_init_arch()
 {
        int    i;
        int    j;
-       struct trace_cpu_data *tcd;
+       struct cfs_trace_cpu_data *tcd;
 
-       init_rwsem(&tracefile_sem);
+       cfs_init_rwsem(&cfs_tracefile_sem);
 
        /* initialize trace_data */
-       memset(trace_data, 0, sizeof(trace_data));
-       for (i = 0; i < TCD_TYPE_MAX; i++) {
-               trace_data[i]=kmalloc(sizeof(union trace_data_union)*NR_CPUS,
-                                                         GFP_KERNEL);
-               if (trace_data[i] == NULL)
+       memset(cfs_trace_data, 0, sizeof(cfs_trace_data));
+       for (i = 0; i < CFS_TCD_TYPE_MAX; i++) {
+               cfs_trace_data[i] =
+                        kmalloc(sizeof(union cfs_trace_data_union) * NR_CPUS,
+                                GFP_KERNEL);
+               if (cfs_trace_data[i] == NULL)
                        goto out;
 
        }
 
        /* arch related info initialized */
-       tcd_for_each(tcd, i, j) {
-               spin_lock_init(&tcd->tcd_lock);
+       cfs_tcd_for_each(tcd, i, j) {
+               cfs_spin_lock_init(&tcd->tcd_lock);
                tcd->tcd_pages_factor = pages_factor[i];
                tcd->tcd_type = i;
                tcd->tcd_cpu = j;
@@ -87,130 +80,98 @@ int tracefile_init_arch()
 
        for (i = 0; i < num_possible_cpus(); i++)
                for (j = 0; j < 3; j++) {
-                       trace_console_buffers[i][j] =
-                               kmalloc(TRACE_CONSOLE_BUFFER_SIZE,
-                                       GFP_KERNEL);
+                        cfs_trace_console_buffers[i][j] =
+                                kmalloc(CFS_TRACE_CONSOLE_BUFFER_SIZE,
+                                        GFP_KERNEL);
 
-                       if (trace_console_buffers[i][j] == NULL)
+                       if (cfs_trace_console_buffers[i][j] == NULL)
                                goto out;
                }
 
        return 0;
 
 out:
-       tracefile_fini_arch();
-       printk(KERN_ERR "lnet: No enough memory\n");
+       cfs_tracefile_fini_arch();
+       printk(KERN_ERR "lnet: Not enough memory\n");
        return -ENOMEM;
 
 }
 
-void tracefile_fini_arch()
+void cfs_tracefile_fini_arch()
 {
        int    i;
        int    j;
 
        for (i = 0; i < num_possible_cpus(); i++)
                for (j = 0; j < 3; j++)
-                       if (trace_console_buffers[i][j] != NULL) {
-                               kfree(trace_console_buffers[i][j]);
-                               trace_console_buffers[i][j] = NULL;
+                       if (cfs_trace_console_buffers[i][j] != NULL) {
+                               kfree(cfs_trace_console_buffers[i][j]);
+                               cfs_trace_console_buffers[i][j] = NULL;
                        }
 
-       for (i = 0; trace_data[i] != NULL; i++) {
-               kfree(trace_data[i]);
-               trace_data[i] = NULL;
+       for (i = 0; cfs_trace_data[i] != NULL; i++) {
+               kfree(cfs_trace_data[i]);
+               cfs_trace_data[i] = NULL;
        }
 
-       fini_rwsem(&tracefile_sem);
+       cfs_fini_rwsem(&cfs_tracefile_sem);
 }
 
-void tracefile_read_lock()
+void cfs_tracefile_read_lock()
 {
-       down_read(&tracefile_sem);
+       cfs_down_read(&cfs_tracefile_sem);
 }
 
-void tracefile_read_unlock()
+void cfs_tracefile_read_unlock()
 {
-       up_read(&tracefile_sem);
+       cfs_up_read(&cfs_tracefile_sem);
 }
 
-void tracefile_write_lock()
+void cfs_tracefile_write_lock()
 {
-       down_write(&tracefile_sem);
+       cfs_down_write(&cfs_tracefile_sem);
 }
 
-void tracefile_write_unlock()
-{
-       up_write(&tracefile_sem);
-}
-
-char *
-trace_get_console_buffer(void)
-{
-       int  cpu = cfs_get_cpu();
-       int  idx;
-
-       if (in_irq()) {
-               idx = 0;
-       } else if (in_softirq()) {
-               idx = 1;
-       } else {
-               idx = 2;
-       }
-
-       return trace_console_buffers[cpu][idx];
-}
-
-void
-trace_put_console_buffer(char *buffer)
+void cfs_tracefile_write_unlock()
 {
-       cfs_put_cpu();
+       cfs_up_write(&cfs_tracefile_sem);
 }
 
-struct trace_cpu_data *
-trace_get_tcd(void)
+cfs_trace_buf_type_t cfs_trace_buf_idx_get()
 {
-       struct trace_cpu_data *tcd;
-       int cpu;
-
-       cpu = cfs_get_cpu();
        if (in_irq())
-               tcd = &(*trace_data[TCD_TYPE_IRQ])[cpu].tcd;
+               return CFS_TCD_TYPE_IRQ;
        else if (in_softirq())
-               tcd = &(*trace_data[TCD_TYPE_SOFTIRQ])[cpu].tcd;
+               return CFS_TCD_TYPE_SOFTIRQ;
        else
-               tcd = &(*trace_data[TCD_TYPE_PROC])[cpu].tcd;
-
-       trace_lock_tcd(tcd);
-
-       return tcd;
-}
-
-void
-trace_put_tcd (struct trace_cpu_data *tcd)
-{
-       trace_unlock_tcd(tcd);
-
-       cfs_put_cpu();
+               return CFS_TCD_TYPE_PROC;
 }
 
-int trace_lock_tcd(struct trace_cpu_data *tcd)
+int cfs_trace_lock_tcd(struct cfs_trace_cpu_data *tcd)
 {
-       __LASSERT(tcd->tcd_type < TCD_TYPE_MAX);
-
-       spin_lock_irqsave(&tcd->tcd_lock, tcd->tcd_lock_flags);
-
+       __LASSERT(tcd->tcd_type < CFS_TCD_TYPE_MAX);
+        if (tcd->tcd_type == CFS_TCD_TYPE_IRQ)
+                cfs_spin_lock_irqsave(&tcd->tcd_lock, tcd->tcd_lock_flags);
+        else if (tcd->tcd_type == CFS_TCD_TYPE_SOFTIRQ)
+                cfs_spin_lock_bh(&tcd->tcd_lock);
+        else
+                cfs_spin_lock(&tcd->tcd_lock);
        return 1;
 }
 
-void trace_unlock_tcd(struct trace_cpu_data *tcd)
+void cfs_trace_unlock_tcd(struct cfs_trace_cpu_data *tcd)
 {
-       __LASSERT(tcd->tcd_type < TCD_TYPE_MAX);
-
-       spin_unlock_irqrestore(&tcd->tcd_lock, tcd->tcd_lock_flags);
+       __LASSERT(tcd->tcd_type < CFS_TCD_TYPE_MAX);
+        if (tcd->tcd_type == CFS_TCD_TYPE_IRQ)
+                cfs_spin_unlock_irqrestore(&tcd->tcd_lock, tcd->tcd_lock_flags);
+        else if (tcd->tcd_type == CFS_TCD_TYPE_SOFTIRQ)
+                cfs_spin_unlock_bh(&tcd->tcd_lock);
+        else
+                cfs_spin_unlock(&tcd->tcd_lock);
 }
 
-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)
 {
        /*
         * XXX nikita: do NOT call portals_debug_msg() (CDEBUG/ENTRY/EXIT)
@@ -220,8 +181,8 @@ int tcd_owns_tage(struct trace_cpu_data *tcd, struct trace_page *tage)
 }
 
 void
-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, int subsys, int mask,
+                        const int line, unsigned long stack)
 {
        struct timeval tv;
 
@@ -229,7 +190,8 @@ set_ptldebug_header(struct ptldebug_header *header, int subsys, int mask,
 
        header->ph_subsys = subsys;
        header->ph_mask = mask;
-       header->ph_cpu_id = smp_processor_id();
+       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;
@@ -245,8 +207,9 @@ set_ptldebug_header(struct ptldebug_header *header, int subsys, int mask,
        return;
 }
 
-void print_to_console(struct ptldebug_header *hdr, int mask, const char *buf,
-                            int len, const char *file, const char *fn)
+void cfs_print_to_console(struct ptldebug_header *hdr, int mask,
+                          const char *buf, int len, const char *file,
+                          const char *fn)
 {
        char *prefix = "Lustre", *ptype = NULL;
 
@@ -267,15 +230,16 @@ void print_to_console(struct ptldebug_header *hdr, int mask, const char *buf,
        if ((mask & D_CONSOLE) != 0) {
                printk("%s%s: %.*s", ptype, prefix, len, buf);
        } else {
-               printk("%s%s: %d:%d:(%s:%d:%s()) %.*s", ptype, prefix, hdr->ph_pid,
-                      hdr->ph_extern_pid, file, hdr->ph_line_num, fn, len, buf);
+               printk("%s%s: %d:%d:(%s:%d:%s()) %.*s", ptype, prefix,
+                       hdr->ph_pid, hdr->ph_extern_pid, file, hdr->ph_line_num,
+                       fn, len, buf);
        }
        return;
 }
 
-int trace_max_debug_mb(void)
+int cfs_trace_max_debug_mb(void)
 {
-       int  total_mb = (num_physpages >> (20 - CFS_PAGE_SHIFT));
-       
+       int  total_mb = (cfs_num_physpages >> (20 - PAGE_SHIFT));
+
        return MAX(512, (total_mb * 80)/100);
 }