Whamcloud - gitweb
a39ed41fc61ca6dc2480fa3604026c65587c255d
[fs/lustre-release.git] / libcfs / libcfs / tracefile.h
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
20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
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 (c) 2008, 2010, Oracle and/or its affiliates. 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 #ifndef __LIBCFS_TRACEFILE_H__
38 #define __LIBCFS_TRACEFILE_H__
39
40 #include <libcfs/libcfs.h>
41
42 #if defined(__linux__)
43 #include "linux/linux-tracefile.h"
44 #elif defined(__WINNT__)
45 #include "winnt/winnt-tracefile.h"
46 #else
47 #error Unsupported operating system.
48 #endif
49
50 /* trace file lock routines */
51
52 #define TRACEFILE_NAME_SIZE 1024
53 extern char      cfs_tracefile[TRACEFILE_NAME_SIZE];
54 extern long long cfs_tracefile_size;
55
56 extern void libcfs_run_debug_log_upcall(char *file);
57
58 int  cfs_tracefile_init_arch(void);
59 void cfs_tracefile_fini_arch(void);
60
61 void cfs_tracefile_read_lock(void);
62 void cfs_tracefile_read_unlock(void);
63 void cfs_tracefile_write_lock(void);
64 void cfs_tracefile_write_unlock(void);
65
66 int cfs_tracefile_dump_all_pages(char *filename);
67 void cfs_trace_debug_print(void);
68 void cfs_trace_flush_pages(void);
69 int cfs_trace_start_thread(void);
70 void cfs_trace_stop_thread(void);
71 int cfs_tracefile_init(int max_pages);
72 void cfs_tracefile_exit(void);
73
74
75
76 int cfs_trace_copyin_string(char *knl_buffer, int knl_buffer_nob,
77                             const char *usr_buffer, int usr_buffer_nob);
78 int cfs_trace_copyout_string(char *usr_buffer, int usr_buffer_nob,
79                              const char *knl_str, char *append);
80 int cfs_trace_allocate_string_buffer(char **str, int nob);
81 void cfs_trace_free_string_buffer(char *str, int nob);
82 int cfs_trace_dump_debug_buffer_usrstr(void *usr_str, int usr_str_nob);
83 int cfs_trace_daemon_command(char *str);
84 int cfs_trace_daemon_command_usrstr(void *usr_str, int usr_str_nob);
85 int cfs_trace_set_debug_mb(int mb);
86 int cfs_trace_set_debug_mb_usrstr(void *usr_str, int usr_str_nob);
87 int cfs_trace_get_debug_mb(void);
88
89 extern void libcfs_debug_dumplog_internal(void *arg);
90 extern void libcfs_register_panic_notifier(void);
91 extern void libcfs_unregister_panic_notifier(void);
92 extern int  libcfs_panic_in_progress;
93 extern int  cfs_trace_max_debug_mb(void);
94
95 #define TCD_MAX_PAGES (5 << (20 - CFS_PAGE_SHIFT))
96 #define TCD_STOCK_PAGES (TCD_MAX_PAGES)
97 #define CFS_TRACEFILE_SIZE (500 << 20)
98
99 #ifdef LUSTRE_TRACEFILE_PRIVATE
100
101 /*
102  * Private declare for tracefile
103  */
104 #define TCD_MAX_PAGES (5 << (20 - CFS_PAGE_SHIFT))
105 #define TCD_STOCK_PAGES (TCD_MAX_PAGES)
106
107 #define CFS_TRACEFILE_SIZE (500 << 20)
108
109 /* Size of a buffer for sprinting console messages if we can't get a page
110  * from system */
111 #define CFS_TRACE_CONSOLE_BUFFER_SIZE   1024
112
113 union cfs_trace_data_union {
114         struct cfs_trace_cpu_data {
115                 /*
116                  * Even though this structure is meant to be per-CPU, locking
117                  * is needed because in some places the data may be accessed
118                  * from other CPUs. This lock is directly used in trace_get_tcd
119                  * and trace_put_tcd, which are called in libcfs_debug_vmsg2 and
120                  * tcd_for_each_type_lock
121                  */
122                 cfs_spinlock_t          tcd_lock;
123                 unsigned long           tcd_lock_flags;
124
125                 /*
126                  * pages with trace records not yet processed by tracefiled.
127                  */
128                 cfs_list_t              tcd_pages;
129                 /* number of pages on ->tcd_pages */
130                 unsigned long           tcd_cur_pages;
131
132                 /*
133                  * pages with trace records already processed by
134                  * tracefiled. These pages are kept in memory, so that some
135                  * portion of log can be written in the event of LBUG. This
136                  * list is maintained in LRU order.
137                  *
138                  * Pages are moved to ->tcd_daemon_pages by tracefiled()
139                  * (put_pages_on_daemon_list()). LRU pages from this list are
140                  * discarded when list grows too large.
141                  */
142                 cfs_list_t              tcd_daemon_pages;
143                 /* number of pages on ->tcd_daemon_pages */
144                 unsigned long           tcd_cur_daemon_pages;
145
146                 /*
147                  * Maximal number of pages allowed on ->tcd_pages and
148                  * ->tcd_daemon_pages each.
149                  * Always TCD_MAX_PAGES * tcd_pages_factor / 100 in current
150                  * implementation.
151                  */
152                 unsigned long           tcd_max_pages;
153
154                 /*
155                  * preallocated pages to write trace records into. Pages from
156                  * ->tcd_stock_pages are moved to ->tcd_pages by
157                  * portals_debug_msg().
158                  *
159                  * This list is necessary, because on some platforms it's
160                  * impossible to perform efficient atomic page allocation in a
161                  * non-blockable context.
162                  *
163                  * Such platforms fill ->tcd_stock_pages "on occasion", when
164                  * tracing code is entered in blockable context.
165                  *
166                  * trace_get_tage_try() tries to get a page from
167                  * ->tcd_stock_pages first and resorts to atomic page
168                  * allocation only if this queue is empty. ->tcd_stock_pages
169                  * is replenished when tracing code is entered in blocking
170                  * context (darwin-tracefile.c:trace_get_tcd()). We try to
171                  * maintain TCD_STOCK_PAGES (40 by default) pages in this
172                  * queue. Atomic allocation is only required if more than
173                  * TCD_STOCK_PAGES pagesful are consumed by trace records all
174                  * emitted in non-blocking contexts. Which is quite unlikely.
175                  */
176                 cfs_list_t              tcd_stock_pages;
177                 /* number of pages on ->tcd_stock_pages */
178                 unsigned long           tcd_cur_stock_pages;
179
180                 unsigned short          tcd_shutting_down;
181                 unsigned short          tcd_cpu;
182                 unsigned short          tcd_type;
183                 /* The factors to share debug memory. */
184                 unsigned short          tcd_pages_factor;
185         } tcd;
186         char __pad[CFS_L1_CACHE_ALIGN(sizeof(struct cfs_trace_cpu_data))];
187 };
188
189 #define TCD_MAX_TYPES      8
190 extern union cfs_trace_data_union (*cfs_trace_data[TCD_MAX_TYPES])[CFS_NR_CPUS];
191
192 #define cfs_tcd_for_each(tcd, i, j)                                       \
193     for (i = 0; cfs_trace_data[i] != NULL; i++)                           \
194         for (j = 0, ((tcd) = &(*cfs_trace_data[i])[j].tcd);               \
195              j < cfs_num_possible_cpus();                                 \
196              j++, (tcd) = &(*cfs_trace_data[i])[j].tcd)
197
198 #define cfs_tcd_for_each_type_lock(tcd, i, cpu)                           \
199     for (i = 0; cfs_trace_data[i] &&                                      \
200          (tcd = &(*cfs_trace_data[i])[cpu].tcd) &&                        \
201          cfs_trace_lock_tcd(tcd); cfs_trace_unlock_tcd(tcd), i++)
202
203 /* XXX nikita: this declaration is internal to tracefile.c and should probably
204  * be moved there */
205 struct page_collection {
206         cfs_list_t              pc_pages;
207         /*
208          * spin-lock protecting ->pc_pages. It is taken by smp_call_function()
209          * call-back functions. XXX nikita: Which is horrible: all processors
210          * receive NMI at the same time only to be serialized by this
211          * lock. Probably ->pc_pages should be replaced with an array of
212          * NR_CPUS elements accessed locklessly.
213          */
214         cfs_spinlock_t          pc_lock;
215         /*
216          * if this flag is set, collect_pages() will spill both
217          * ->tcd_daemon_pages and ->tcd_pages to the ->pc_pages. Otherwise,
218          * only ->tcd_pages are spilled.
219          */
220         int                     pc_want_daemon_pages;
221 };
222
223 /* XXX nikita: this declaration is internal to tracefile.c and should probably
224  * be moved there */
225 struct tracefiled_ctl {
226         cfs_completion_t       tctl_start;
227         cfs_completion_t       tctl_stop;
228         cfs_waitq_t            tctl_waitq;
229         pid_t                  tctl_pid;
230         cfs_atomic_t           tctl_shutdown;
231 };
232
233 /*
234  * small data-structure for each page owned by tracefiled.
235  */
236 /* XXX nikita: this declaration is internal to tracefile.c and should probably
237  * be moved there */
238 struct cfs_trace_page {
239         /*
240          * page itself
241          */
242         cfs_page_t          *page;
243         /*
244          * linkage into one of the lists in trace_data_union or
245          * page_collection
246          */
247         cfs_list_t           linkage;
248         /*
249          * number of bytes used within this page
250          */
251         unsigned int         used;
252         /*
253          * cpu that owns this page
254          */
255         unsigned short       cpu;
256         /*
257          * type(context) of this page
258          */
259         unsigned short       type;
260 };
261
262 extern void cfs_set_ptldebug_header(struct ptldebug_header *header,
263                                     struct libcfs_debug_msg_data *m,
264                                     unsigned long stack);
265 extern void cfs_print_to_console(struct ptldebug_header *hdr, int mask,
266                                  const char *buf, int len, const char *file,
267                                  const char *fn);
268
269 extern int cfs_trace_lock_tcd(struct cfs_trace_cpu_data *tcd);
270 extern void cfs_trace_unlock_tcd(struct cfs_trace_cpu_data *tcd);
271
272 /**
273  * trace_buf_type_t, trace_buf_idx_get() and trace_console_buffers[][]
274  * are not public libcfs API; they should be defined in
275  * platform-specific tracefile include files
276  * (see, for example, linux-tracefile.h).
277  */
278
279 extern char *cfs_trace_console_buffers[CFS_NR_CPUS][CFS_TCD_TYPE_MAX];
280 extern cfs_trace_buf_type_t cfs_trace_buf_idx_get(void);
281
282 static inline char *
283 cfs_trace_get_console_buffer(void)
284 {
285         unsigned int i = cfs_get_cpu();
286         unsigned int j = cfs_trace_buf_idx_get();
287
288         return cfs_trace_console_buffers[i][j];
289 }
290
291 static inline void
292 cfs_trace_put_console_buffer(char *buffer)
293 {
294         cfs_put_cpu();
295 }
296
297 static inline struct cfs_trace_cpu_data *
298 cfs_trace_get_tcd(void)
299 {
300         struct cfs_trace_cpu_data *tcd =
301                 &(*cfs_trace_data[cfs_trace_buf_idx_get()])[cfs_get_cpu()].tcd;
302
303         cfs_trace_lock_tcd(tcd);
304
305         return tcd;
306 }
307
308 static inline void
309 cfs_trace_put_tcd (struct cfs_trace_cpu_data *tcd)
310 {
311         cfs_trace_unlock_tcd(tcd);
312
313         cfs_put_cpu();
314 }
315
316 int cfs_trace_refill_stock(struct cfs_trace_cpu_data *tcd, int gfp,
317                            cfs_list_t *stock);
318
319
320 int cfs_tcd_owns_tage(struct cfs_trace_cpu_data *tcd,
321                       struct cfs_trace_page *tage);
322
323 extern void cfs_trace_assertion_failed(const char *str,
324                                        struct libcfs_debug_msg_data *m);
325
326 /* ASSERTION that is safe to use within the debug system */
327 #define __LASSERT(cond)                                                 \
328 do {                                                                    \
329         if (unlikely(!(cond))) {                                        \
330                 LIBCFS_DEBUG_MSG_DATA_DECL(msgdata, D_EMERG, NULL);     \
331                 cfs_trace_assertion_failed("ASSERTION("#cond") failed", \
332                                            &msgdata);                   \
333         }                                                               \
334 } while (0)
335
336 #define __LASSERT_TAGE_INVARIANT(tage)                                  \
337 do {                                                                    \
338         __LASSERT(tage != NULL);                                        \
339         __LASSERT(tage->page != NULL);                                  \
340         __LASSERT(tage->used <= CFS_PAGE_SIZE);                         \
341         __LASSERT(cfs_page_count(tage->page) > 0);                      \
342 } while (0)
343
344 #endif  /* LUSTRE_TRACEFILE_PRIVATE */
345
346 #endif /* __LIBCFS_TRACEFILE_H__ */