Whamcloud - gitweb
b=16098
[fs/lustre-release.git] / libcfs / libcfs / linux / linux-tracefile.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * GPL HEADER START
5  *
6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 only,
10  * as published by the Free Software Foundation.
11  *
12  * This program is distributed in the hope that it will be useful, but
13  * WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * General Public License version 2 for more details (a copy is included
16  * in the LICENSE file that accompanied this code).
17  *
18  * You should have received a copy of the GNU General Public License
19  * version 2 along with this program; If not, see [sun.com URL with a
20  * copy of GPLv2].
21  *
22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
23  * CA 95054 USA or visit www.sun.com if you need additional information or
24  * have any questions.
25  *
26  * GPL HEADER END
27  */
28 /*
29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
30  * Use is subject to license terms.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #define DEBUG_SUBSYSTEM S_LNET
38 #define LUSTRE_TRACEFILE_PRIVATE
39
40 #include <libcfs/libcfs.h>
41 #include "tracefile.h"
42
43 #ifndef get_cpu
44 #define get_cpu() smp_processor_id()
45 #define put_cpu() do { } while (0)
46 #endif
47
48 /* three types of trace_data in linux */
49 enum {
50         TCD_TYPE_PROC = 0,
51         TCD_TYPE_SOFTIRQ,
52         TCD_TYPE_IRQ,
53         TCD_TYPE_MAX
54 };
55
56 /* percents to share the total debug memory for each type */
57 static unsigned int pages_factor[TCD_TYPE_MAX] = {
58         80,  /* 80% pages for TCD_TYPE_PROC */
59         10,  /* 10% pages for TCD_TYPE_SOFTIRQ */
60         10   /* 10% pages for TCD_TYPE_IRQ */
61 };
62
63 char *trace_console_buffers[NR_CPUS][3];
64
65 struct rw_semaphore tracefile_sem;
66
67 int tracefile_init_arch()
68 {
69         int    i;
70         int    j;
71         struct trace_cpu_data *tcd;
72
73         init_rwsem(&tracefile_sem);
74
75         /* initialize trace_data */
76         memset(trace_data, 0, sizeof(trace_data));
77         for (i = 0; i < TCD_TYPE_MAX; i++) {
78                 trace_data[i]=kmalloc(sizeof(union trace_data_union)*NR_CPUS,
79                                                           GFP_KERNEL);
80                 if (trace_data[i] == NULL)
81                         goto out;
82
83         }
84
85         /* arch related info initialized */
86         tcd_for_each(tcd, i, j) {
87                 tcd->tcd_pages_factor = pages_factor[i];
88                 tcd->tcd_type = i;
89                 tcd->tcd_cpu = j;
90         }
91
92         for (i = 0; i < num_possible_cpus(); i++)
93                 for (j = 0; j < 3; j++) {
94                         trace_console_buffers[i][j] =
95                                 kmalloc(TRACE_CONSOLE_BUFFER_SIZE,
96                                         GFP_KERNEL);
97
98                         if (trace_console_buffers[i][j] == NULL)
99                                 goto out;
100                 }
101
102         return 0;
103
104 out:
105         tracefile_fini_arch();
106         printk(KERN_ERR "lnet: No enough memory\n");
107         return -ENOMEM;
108
109 }
110
111 void tracefile_fini_arch()
112 {
113         int    i;
114         int    j;
115
116         for (i = 0; i < num_possible_cpus(); i++)
117                 for (j = 0; j < 3; j++)
118                         if (trace_console_buffers[i][j] != NULL) {
119                                 kfree(trace_console_buffers[i][j]);
120                                 trace_console_buffers[i][j] = NULL;
121                         }
122
123         for (i = 0; trace_data[i] != NULL; i++) {
124                 kfree(trace_data[i]);
125                 trace_data[i] = NULL;
126         }
127 }
128
129 void tracefile_read_lock()
130 {
131         down_read(&tracefile_sem);
132 }
133
134 void tracefile_read_unlock()
135 {
136         up_read(&tracefile_sem);
137 }
138
139 void tracefile_write_lock()
140 {
141         down_write(&tracefile_sem);
142 }
143
144 void tracefile_write_unlock()
145 {
146         up_write(&tracefile_sem);
147 }
148
149 char *
150 trace_get_console_buffer(void)
151 {
152         int  cpu = get_cpu();
153         int  idx;
154
155         if (in_irq()) {
156                 idx = 0;
157         } else if (in_softirq()) {
158                 idx = 1;
159         } else {
160                 idx = 2;
161         }
162
163         return trace_console_buffers[cpu][idx];
164 }
165
166 void
167 trace_put_console_buffer(char *buffer)
168 {
169         put_cpu();
170 }
171
172 struct trace_cpu_data *
173 trace_get_tcd(void)
174 {
175         int cpu;
176
177         cpu = get_cpu();
178         if (in_irq())
179                 return &(*trace_data[TCD_TYPE_IRQ])[cpu].tcd;
180         else if (in_softirq())
181                 return &(*trace_data[TCD_TYPE_SOFTIRQ])[cpu].tcd;
182         return &(*trace_data[TCD_TYPE_PROC])[cpu].tcd;
183 }
184
185 void
186 trace_put_tcd (struct trace_cpu_data *tcd)
187 {
188         put_cpu();
189 }
190
191 int trace_lock_tcd(struct trace_cpu_data *tcd)
192 {
193         __LASSERT(tcd->tcd_type < TCD_TYPE_MAX);
194         if (tcd->tcd_type == TCD_TYPE_IRQ)
195                 local_irq_disable();
196         else if (tcd->tcd_type == TCD_TYPE_SOFTIRQ)
197                 local_bh_disable();
198         return 1;
199 }
200
201 void trace_unlock_tcd(struct trace_cpu_data *tcd)
202 {
203         __LASSERT(tcd->tcd_type < TCD_TYPE_MAX);
204         if (tcd->tcd_type == TCD_TYPE_IRQ)
205                 local_irq_enable();
206         else if (tcd->tcd_type == TCD_TYPE_SOFTIRQ)
207                 local_bh_enable();
208 }
209
210 int tcd_owns_tage(struct trace_cpu_data *tcd, struct trace_page *tage)
211 {
212         /*
213          * XXX nikita: do NOT call portals_debug_msg() (CDEBUG/ENTRY/EXIT)
214          * from here: this will lead to infinite recursion.
215          */
216         return tcd->tcd_cpu == tage->cpu;
217 }
218
219 void
220 set_ptldebug_header(struct ptldebug_header *header, int subsys, int mask,
221                     const int line, unsigned long stack)
222 {
223         struct timeval tv;
224
225         do_gettimeofday(&tv);
226
227         header->ph_subsys = subsys;
228         header->ph_mask = mask;
229         header->ph_cpu_id = smp_processor_id();
230         header->ph_sec = (__u32)tv.tv_sec;
231         header->ph_usec = tv.tv_usec;
232         header->ph_stack = stack;
233         header->ph_pid = current->pid;
234         header->ph_line_num = line;
235 #if defined(__arch_um__) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,20))
236         header->ph_extern_pid = current->thread.extern_pid;
237 #elif defined(__arch_um__) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
238         header->ph_extern_pid = current->thread.mode.tt.extern_pid;
239 #else
240         header->ph_extern_pid = 0;
241 #endif
242         return;
243 }
244
245 void print_to_console(struct ptldebug_header *hdr, int mask, const char *buf,
246                              int len, const char *file, const char *fn)
247 {
248         char *prefix = "Lustre", *ptype = NULL;
249
250         if ((mask & D_EMERG) != 0) {
251                 prefix = "LustreError";
252                 ptype = KERN_EMERG;
253         } else if ((mask & D_ERROR) != 0) {
254                 prefix = "LustreError";
255                 ptype = KERN_ERR;
256         } else if ((mask & D_WARNING) != 0) {
257                 prefix = "Lustre";
258                 ptype = KERN_WARNING;
259         } else if ((mask & (D_CONSOLE | libcfs_printk)) != 0) {
260                 prefix = "Lustre";
261                 ptype = KERN_INFO;
262         }
263
264         if ((mask & D_CONSOLE) != 0) {
265                 printk("%s%s: %.*s", ptype, prefix, len, buf);
266         } else {
267                 printk("%s%s: %d:%d:(%s:%d:%s()) %.*s", ptype, prefix, hdr->ph_pid,
268                        hdr->ph_extern_pid, file, hdr->ph_line_num, fn, len, buf);
269         }
270         return;
271 }
272
273 int trace_max_debug_mb(void)
274 {
275         int  total_mb = (num_physpages >> (20 - CFS_PAGE_SHIFT));
276         
277         return MAX(512, (total_mb * 80)/100);
278 }
279
280 void
281 trace_call_on_all_cpus(void (*fn)(void *arg), void *arg)
282 {
283         cpumask_t cpus_allowed = current->cpus_allowed;
284         /* use cpus_allowed to quiet 2.4 UP kernel warning only */
285         cpumask_t m = cpus_allowed;
286         int       cpu;
287
288         /* Run the given routine on every CPU in thread context */
289         for (cpu = 0; cpu < num_possible_cpus(); cpu++) {
290                 if (!cpu_online(cpu))
291                         continue;
292
293                 cpus_clear(m);
294                 cpu_set(cpu, m);
295                 set_cpus_allowed(current, m);
296
297                 fn(arg);
298
299                 set_cpus_allowed(current, cpus_allowed);
300         }
301 }