X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=libcfs%2Flibcfs%2Flinux%2Flinux-tracefile.c;h=778a56fbb62d14d1c5046f5a8f4780e660a78e19;hb=refs%2Fchanges%2F93%2F13793%2F4;hp=b5b1b8e10bf55ea2655a7f73d4044a30f1ca0687;hpb=e903932500fc08b143467ce5a1c2702df35d8f0f;p=fs%2Flustre-release.git diff --git a/libcfs/libcfs/linux/linux-tracefile.c b/libcfs/libcfs/linux/linux-tracefile.c index b5b1b8e..778a56f 100644 --- a/libcfs/libcfs/linux/linux-tracefile.c +++ b/libcfs/libcfs/linux/linux-tracefile.c @@ -1,53 +1,76 @@ +/* + * GPL HEADER START + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 only, + * as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License version 2 for more details (a copy is included + * in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU General Public License + * version 2 along with this program; If not, see + * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + * GPL HEADER END + */ +/* + * 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/ + * Lustre is a trademark of Sun Microsystems, Inc. + */ + #define DEBUG_SUBSYSTEM S_LNET #define LUSTRE_TRACEFILE_PRIVATE #include #include "tracefile.h" -#ifndef get_cpu -#define get_cpu() smp_processor_id() -#define put_cpu() do { } while (0) -#endif - -/* 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; +static DECLARE_RWSEM(cfs_tracefile_sem); -int tracefile_init_arch() +int cfs_tracefile_init_arch() { int i; int j; - struct trace_cpu_data *tcd; - - init_rwsem(&tracefile_sem); + struct cfs_trace_cpu_data *tcd; /* 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) * + num_possible_cpus(), GFP_KERNEL); + if (cfs_trace_data[i] == NULL) goto out; } /* arch related info initialized */ - tcd_for_each(tcd, i, j) { + cfs_tcd_for_each(tcd, i, j) { + spin_lock_init(&tcd->tcd_lock); tcd->tcd_pages_factor = pages_factor[i]; tcd->tcd_type = i; tcd->tcd_cpu = j; @@ -55,123 +78,107 @@ 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, + 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; } } -void tracefile_read_lock() +void cfs_tracefile_read_lock() { - down_read(&tracefile_sem); + down_read(&cfs_tracefile_sem); } -void tracefile_read_unlock() +void cfs_tracefile_read_unlock() { - up_read(&tracefile_sem); + up_read(&cfs_tracefile_sem); } -void tracefile_write_lock() +void cfs_tracefile_write_lock() { - down_write(&tracefile_sem); + down_write(&cfs_tracefile_sem); } -void tracefile_write_unlock() +void cfs_tracefile_write_unlock() { - up_write(&tracefile_sem); + up_write(&cfs_tracefile_sem); } -char * -trace_get_console_buffer(void) +cfs_trace_buf_type_t cfs_trace_buf_idx_get() { - int cpu = 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) -{ - put_cpu(); -} - -struct trace_cpu_data * -trace_get_tcd(void) -{ - int cpu; - - cpu = get_cpu(); if (in_irq()) - return &(*trace_data[TCD_TYPE_IRQ])[cpu].tcd; + return CFS_TCD_TYPE_IRQ; else if (in_softirq()) - return &(*trace_data[TCD_TYPE_SOFTIRQ])[cpu].tcd; - return &(*trace_data[TCD_TYPE_PROC])[cpu].tcd; -} - -void -trace_put_tcd (struct trace_cpu_data *tcd) -{ - put_cpu(); + return CFS_TCD_TYPE_SOFTIRQ; + else + return CFS_TCD_TYPE_PROC; } -int trace_lock_tcd(struct trace_cpu_data *tcd) +/* + * The walking argument indicates the locking comes from all tcd types + * iterator and we must lock it and dissable local irqs to avoid deadlocks + * with other interrupt locks that might be happening. See LU-1311 + * for details. + */ +int cfs_trace_lock_tcd(struct cfs_trace_cpu_data *tcd, int walking) +__acquires(&tcd->tcd_lock) { - __LASSERT(tcd->tcd_type < TCD_TYPE_MAX); - if (tcd->tcd_type == TCD_TYPE_IRQ) - local_irq_disable(); - else if (tcd->tcd_type == TCD_TYPE_SOFTIRQ) - local_bh_disable(); + __LASSERT(tcd->tcd_type < CFS_TCD_TYPE_MAX); + if (tcd->tcd_type == CFS_TCD_TYPE_IRQ) + spin_lock_irqsave(&tcd->tcd_lock, tcd->tcd_lock_flags); + else if (tcd->tcd_type == CFS_TCD_TYPE_SOFTIRQ) + spin_lock_bh(&tcd->tcd_lock); + else if (unlikely(walking)) + spin_lock_irq(&tcd->tcd_lock); + else + 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, int walking) +__releases(&tcd->tcd_lock) { - __LASSERT(tcd->tcd_type < TCD_TYPE_MAX); - if (tcd->tcd_type == TCD_TYPE_IRQ) - local_irq_enable(); - else if (tcd->tcd_type == TCD_TYPE_SOFTIRQ) - local_bh_enable(); + __LASSERT(tcd->tcd_type < CFS_TCD_TYPE_MAX); + if (tcd->tcd_type == CFS_TCD_TYPE_IRQ) + spin_unlock_irqrestore(&tcd->tcd_lock, tcd->tcd_lock_flags); + else if (tcd->tcd_type == CFS_TCD_TYPE_SOFTIRQ) + spin_unlock_bh(&tcd->tcd_lock); + else if (unlikely(walking)) + spin_unlock_irq(&tcd->tcd_lock); + else + 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) @@ -181,85 +188,86 @@ 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, + 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 = 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; -#if defined(__arch_um__) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,20)) - header->ph_extern_pid = current->thread.extern_pid; -#elif defined(__arch_um__) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) - header->ph_extern_pid = current->thread.mode.tt.extern_pid; -#else + header->ph_line_num = msgdata->msg_line; header->ph_extern_pid = 0; -#endif return; } -void print_to_console(struct ptldebug_header *hdr, int mask, const char *buf, - int len, const char *file, const char *fn) +static char * +dbghdr_to_err_string(struct ptldebug_header *hdr) +{ + switch (hdr->ph_subsys) { + + case S_LND: + case S_LNET: + return "LNetError"; + default: + return "LustreError"; + } +} + +static char * +dbghdr_to_info_string(struct ptldebug_header *hdr) +{ + switch (hdr->ph_subsys) { + + case S_LND: + case S_LNET: + return "LNet"; + default: + return "Lustre"; + } +} + +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; if ((mask & D_EMERG) != 0) { - prefix = "LustreError"; + prefix = dbghdr_to_err_string(hdr); ptype = KERN_EMERG; } else if ((mask & D_ERROR) != 0) { - prefix = "LustreError"; + prefix = dbghdr_to_err_string(hdr); ptype = KERN_ERR; } else if ((mask & D_WARNING) != 0) { - prefix = "Lustre"; + prefix = dbghdr_to_info_string(hdr); ptype = KERN_WARNING; } else if ((mask & (D_CONSOLE | libcfs_printk)) != 0) { - prefix = "Lustre"; + prefix = dbghdr_to_info_string(hdr); ptype = KERN_INFO; } 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)); - - return MAX(512, (total_mb * 80)/100); -} - -void -trace_call_on_all_cpus(void (*fn)(void *arg), void *arg) -{ - cpumask_t cpus_allowed = current->cpus_allowed; - /* use cpus_allowed to quiet 2.4 UP kernel warning only */ - cpumask_t m = cpus_allowed; - int cpu; + int total_mb = (totalram_pages >> (20 - PAGE_SHIFT)); - /* Run the given routine on every CPU in thread context */ - for (cpu = 0; cpu < num_possible_cpus(); cpu++) { - if (!cpu_online(cpu)) - continue; - - cpus_clear(m); - cpu_set(cpu, m); - set_cpus_allowed(current, m); - - fn(arg); - - set_cpus_allowed(current, cpus_allowed); - } + return MAX(512, (total_mb * 80)/100); }