#include <libcfs/libcfs.h>
/* XXX move things up to the top, comment */
-union trace_data_union (*trace_data[TCD_MAX_TYPES])[NR_CPUS] __cacheline_aligned;
+union cfs_trace_data_union (*cfs_trace_data[TCD_MAX_TYPES])[CFS_NR_CPUS] __cacheline_aligned;
-char tracefile[TRACEFILE_NAME_SIZE];
-long long tracefile_size = TRACEFILE_SIZE;
+char cfs_tracefile[TRACEFILE_NAME_SIZE];
+long long cfs_tracefile_size = CFS_TRACEFILE_SIZE;
static struct tracefiled_ctl trace_tctl;
-struct semaphore trace_thread_sem;
+cfs_semaphore_t cfs_trace_thread_sem;
static int thread_running = 0;
-atomic_t tage_allocated = ATOMIC_INIT(0);
+cfs_atomic_t cfs_tage_allocated = CFS_ATOMIC_INIT(0);
static void put_pages_on_tcd_daemon_list(struct page_collection *pc,
- struct trace_cpu_data *tcd);
+ struct cfs_trace_cpu_data *tcd);
-static inline struct trace_page *tage_from_list(struct list_head *list)
+static inline struct cfs_trace_page *
+cfs_tage_from_list(cfs_list_t *list)
{
- return list_entry(list, struct trace_page, linkage);
+ return cfs_list_entry(list, struct cfs_trace_page, linkage);
}
-static struct trace_page *tage_alloc(int gfp)
+static struct cfs_trace_page *cfs_tage_alloc(int gfp)
{
- cfs_page_t *page;
- struct trace_page *tage;
+ cfs_page_t *page;
+ struct cfs_trace_page *tage;
/*
* Don't spam console with allocation failures: they will be reported
}
tage->page = page;
- atomic_inc(&tage_allocated);
+ cfs_atomic_inc(&cfs_tage_allocated);
return tage;
}
-static void tage_free(struct trace_page *tage)
+static void cfs_tage_free(struct cfs_trace_page *tage)
{
__LASSERT(tage != NULL);
__LASSERT(tage->page != NULL);
cfs_free_page(tage->page);
cfs_free(tage);
- atomic_dec(&tage_allocated);
+ cfs_atomic_dec(&cfs_tage_allocated);
}
-static void tage_to_tail(struct trace_page *tage, struct list_head *queue)
+static void cfs_tage_to_tail(struct cfs_trace_page *tage,
+ cfs_list_t *queue)
{
__LASSERT(tage != NULL);
__LASSERT(queue != NULL);
- list_move_tail(&tage->linkage, queue);
+ cfs_list_move_tail(&tage->linkage, queue);
}
-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 i;
*/
for (i = 0; i + tcd->tcd_cur_stock_pages < TCD_STOCK_PAGES ; ++ i) {
- struct trace_page *tage;
+ struct cfs_trace_page *tage;
- tage = tage_alloc(gfp);
+ tage = cfs_tage_alloc(gfp);
if (tage == NULL)
break;
- list_add_tail(&tage->linkage, stock);
+ cfs_list_add_tail(&tage->linkage, stock);
}
return i;
}
/* return a page that has 'len' bytes left at the end */
-static struct trace_page *trace_get_tage_try(struct trace_cpu_data *tcd,
- unsigned long len)
+static struct cfs_trace_page *
+cfs_trace_get_tage_try(struct cfs_trace_cpu_data *tcd, unsigned long len)
{
- struct trace_page *tage;
+ struct cfs_trace_page *tage;
if (tcd->tcd_cur_pages > 0) {
- __LASSERT(!list_empty(&tcd->tcd_pages));
- tage = tage_from_list(tcd->tcd_pages.prev);
+ __LASSERT(!cfs_list_empty(&tcd->tcd_pages));
+ tage = cfs_tage_from_list(tcd->tcd_pages.prev);
if (tage->used + len <= CFS_PAGE_SIZE)
return tage;
}
if (tcd->tcd_cur_pages < tcd->tcd_max_pages) {
if (tcd->tcd_cur_stock_pages > 0) {
- tage = tage_from_list(tcd->tcd_stock_pages.prev);
+ tage = cfs_tage_from_list(tcd->tcd_stock_pages.prev);
-- tcd->tcd_cur_stock_pages;
- list_del_init(&tage->linkage);
+ cfs_list_del_init(&tage->linkage);
} else {
- tage = tage_alloc(CFS_ALLOC_ATOMIC);
+ tage = cfs_tage_alloc(CFS_ALLOC_ATOMIC);
if (tage == NULL) {
if (printk_ratelimit())
- printk(KERN_WARNING
+ printk(CFS_KERN_WARNING
"cannot allocate a tage (%ld)\n",
tcd->tcd_cur_pages);
return NULL;
}
tage->used = 0;
- tage->cpu = smp_processor_id();
+ tage->cpu = cfs_smp_processor_id();
tage->type = tcd->tcd_type;
- list_add_tail(&tage->linkage, &tcd->tcd_pages);
+ cfs_list_add_tail(&tage->linkage, &tcd->tcd_pages);
tcd->tcd_cur_pages++;
if (tcd->tcd_cur_pages > 8 && thread_running) {
return NULL;
}
-static void tcd_shrink(struct trace_cpu_data *tcd)
+static void cfs_tcd_shrink(struct cfs_trace_cpu_data *tcd)
{
int pgcount = tcd->tcd_cur_pages / 10;
struct page_collection pc;
- struct trace_page *tage;
- struct trace_page *tmp;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
- /*
- * XXX nikita: do NOT call portals_debug_msg() (CDEBUG/ENTRY/EXIT)
- * from here: this will lead to infinite recursion.
- */
+ /*
+ * XXX nikita: do NOT call portals_debug_msg() (CDEBUG/ENTRY/EXIT)
+ * from here: this will lead to infinite recursion.
+ */
if (printk_ratelimit())
- printk(KERN_WARNING "debug daemon buffer overflowed; "
+ printk(CFS_KERN_WARNING "debug daemon buffer overflowed; "
"discarding 10%% of pages (%d of %ld)\n",
pgcount + 1, tcd->tcd_cur_pages);
CFS_INIT_LIST_HEAD(&pc.pc_pages);
- spin_lock_init(&pc.pc_lock);
+ cfs_spin_lock_init(&pc.pc_lock);
cfs_list_for_each_entry_safe_typed(tage, tmp, &tcd->tcd_pages,
- struct trace_page, linkage) {
+ struct cfs_trace_page, linkage) {
if (pgcount-- == 0)
break;
- list_move_tail(&tage->linkage, &pc.pc_pages);
+ cfs_list_move_tail(&tage->linkage, &pc.pc_pages);
tcd->tcd_cur_pages--;
}
put_pages_on_tcd_daemon_list(&pc, tcd);
}
/* return a page that has 'len' bytes left at the end */
-static struct trace_page *trace_get_tage(struct trace_cpu_data *tcd,
- unsigned long len)
+static struct cfs_trace_page *cfs_trace_get_tage(struct cfs_trace_cpu_data *tcd,
+ unsigned long len)
{
- struct trace_page *tage;
+ struct cfs_trace_page *tage;
- /*
- * XXX nikita: do NOT call portals_debug_msg() (CDEBUG/ENTRY/EXIT)
- * from here: this will lead to infinite recursion.
- */
+ /*
+ * XXX nikita: do NOT call portals_debug_msg() (CDEBUG/ENTRY/EXIT)
+ * from here: this will lead to infinite recursion.
+ */
if (len > CFS_PAGE_SIZE) {
- printk(KERN_ERR
+ printk(CFS_KERN_ERR
"cowardly refusing to write %lu bytes in a page\n", len);
return NULL;
}
- tage = trace_get_tage_try(tcd, len);
+ tage = cfs_trace_get_tage_try(tcd, len);
if (tage != NULL)
return tage;
if (thread_running)
- tcd_shrink(tcd);
+ cfs_tcd_shrink(tcd);
if (tcd->tcd_cur_pages > 0) {
- tage = tage_from_list(tcd->tcd_pages.next);
+ tage = cfs_tage_from_list(tcd->tcd_pages.next);
tage->used = 0;
- tage_to_tail(tage, &tcd->tcd_pages);
+ cfs_tage_to_tail(tage, &tcd->tcd_pages);
}
return tage;
}
const char *format1, va_list args,
const char *format2, ...)
{
- struct trace_cpu_data *tcd = NULL;
- struct ptldebug_header header;
- struct trace_page *tage;
+ struct cfs_trace_cpu_data *tcd = NULL;
+ struct ptldebug_header header = {0};
+ struct cfs_trace_page *tage;
/* string_buf is used only if tcd != NULL, and is always set then */
- char *string_buf = NULL;
- char *debug_buf;
- int known_size;
- int needed = 85; /* average message length */
- int max_nob;
- va_list ap;
- int depth;
- int i;
- int remain;
+ char *string_buf = NULL;
+ char *debug_buf;
+ int known_size;
+ int needed = 85; /* average message length */
+ int max_nob;
+ va_list ap;
+ int depth;
+ int i;
+ int remain;
if (strchr(file, '/'))
file = strrchr(file, '/') + 1;
- set_ptldebug_header(&header, subsys, mask, line, CDEBUG_STACK());
+ cfs_set_ptldebug_header(&header, subsys, mask, line, CDEBUG_STACK());
- tcd = trace_get_tcd();
+ tcd = cfs_trace_get_tcd();
if (tcd == NULL) /* arch may not log in IRQ context */
goto console;
+ if (tcd->tcd_cur_pages == 0)
+ header.ph_flags |= PH_FLAG_FIRST_RECORD;
+
if (tcd->tcd_shutting_down) {
- trace_put_tcd(tcd);
+ cfs_trace_put_tcd(tcd);
tcd = NULL;
goto console;
}
* if needed is to small for this format.
*/
for (i = 0; i < 2; i++) {
- tage = trace_get_tage(tcd, needed + known_size + 1);
+ tage = cfs_trace_get_tage(tcd, needed + known_size + 1);
if (tage == NULL) {
if (needed + known_size > CFS_PAGE_SIZE)
mask |= D_ERROR;
- trace_put_tcd(tcd);
+ cfs_trace_put_tcd(tcd);
tcd = NULL;
goto console;
}
max_nob = CFS_PAGE_SIZE - tage->used - known_size;
if (max_nob <= 0) {
- printk(KERN_EMERG "negative max_nob: %i\n", max_nob);
+ printk(CFS_KERN_EMERG "negative max_nob: %i\n",
+ max_nob);
mask |= D_ERROR;
- trace_put_tcd(tcd);
+ cfs_trace_put_tcd(tcd);
tcd = NULL;
goto console;
}
}
if (format2) {
- remain = max_nob - needed;
+ remain = max_nob - needed;
if (remain < 0)
remain = 0;
}
if (*(string_buf+needed-1) != '\n')
- printk(KERN_INFO "format at %s:%d:%s doesn't end in newline\n",
+ printk(CFS_KERN_INFO "format at %s:%d:%s doesn't end in newline\n",
file, line, fn);
header.ph_len = known_size + needed;
if ((mask & libcfs_printk) == 0) {
/* no console output requested */
if (tcd != NULL)
- trace_put_tcd(tcd);
+ cfs_trace_put_tcd(tcd);
return 1;
}
/* skipping a console message */
cdls->cdls_count++;
if (tcd != NULL)
- trace_put_tcd(tcd);
+ cfs_trace_put_tcd(tcd);
return 1;
}
}
if (tcd != NULL) {
- print_to_console(&header, mask, string_buf, needed, file, fn);
- trace_put_tcd(tcd);
+ cfs_print_to_console(&header, mask, string_buf, needed, file,
+ fn);
+ cfs_trace_put_tcd(tcd);
} else {
- string_buf = trace_get_console_buffer();
+ string_buf = cfs_trace_get_console_buffer();
needed = 0;
if (format1 != NULL) {
va_copy(ap, args);
- needed = vsnprintf(string_buf, TRACE_CONSOLE_BUFFER_SIZE, format1, ap);
+ needed = vsnprintf(string_buf,
+ CFS_TRACE_CONSOLE_BUFFER_SIZE,
+ format1, ap);
va_end(ap);
}
if (format2 != NULL) {
- remain = TRACE_CONSOLE_BUFFER_SIZE - needed;
+ remain = CFS_TRACE_CONSOLE_BUFFER_SIZE - needed;
if (remain > 0) {
va_start(ap, format2);
needed += vsnprintf(string_buf+needed, remain, format2, ap);
va_end(ap);
}
}
- print_to_console(&header, mask,
- string_buf, needed, file, fn);
+ cfs_print_to_console(&header, mask,
+ string_buf, needed, file, fn);
- trace_put_console_buffer(string_buf);
+ cfs_trace_put_console_buffer(string_buf);
}
if (cdls != NULL && cdls->cdls_count != 0) {
- string_buf = trace_get_console_buffer();
+ string_buf = cfs_trace_get_console_buffer();
- needed = snprintf(string_buf, TRACE_CONSOLE_BUFFER_SIZE,
+ needed = snprintf(string_buf, CFS_TRACE_CONSOLE_BUFFER_SIZE,
"Skipped %d previous similar message%s\n",
cdls->cdls_count, (cdls->cdls_count > 1) ? "s" : "");
- print_to_console(&header, mask,
+ cfs_print_to_console(&header, mask,
string_buf, needed, file, fn);
- trace_put_console_buffer(string_buf);
+ cfs_trace_put_console_buffer(string_buf);
cdls->cdls_count = 0;
}
EXPORT_SYMBOL(libcfs_assertion_failed);
void
-trace_assertion_failed(const char *str,
- const char *fn, const char *file, int line)
+cfs_trace_assertion_failed(const char *str,
+ const char *fn, const char *file, int line)
{
struct ptldebug_header hdr;
libcfs_panic_in_progress = 1;
libcfs_catastrophe = 1;
- mb();
+ cfs_mb();
- set_ptldebug_header(&hdr, DEBUG_SUBSYSTEM, D_EMERG, line,
- CDEBUG_STACK());
+ cfs_set_ptldebug_header(&hdr, DEBUG_SUBSYSTEM, D_EMERG, line,
+ CDEBUG_STACK());
- print_to_console(&hdr, D_EMERG, str, strlen(str), file, fn);
+ cfs_print_to_console(&hdr, D_EMERG, str, strlen(str), file, fn);
LIBCFS_PANIC("Lustre debug assertion failure\n");
/* Do the collect_pages job on a single CPU: assumes that all other
* CPUs have been stopped during a panic. If this isn't true for some
* arch, this will have to be implemented separately in each arch. */
- int i;
- int j;
- struct trace_cpu_data *tcd;
+ int i;
+ int j;
+ struct cfs_trace_cpu_data *tcd;
CFS_INIT_LIST_HEAD(&pc->pc_pages);
- tcd_for_each(tcd, i, j) {
- list_splice_init(&tcd->tcd_pages, &pc->pc_pages);
+ cfs_tcd_for_each(tcd, i, j) {
+ cfs_list_splice_init(&tcd->tcd_pages, &pc->pc_pages);
tcd->tcd_cur_pages = 0;
if (pc->pc_want_daemon_pages) {
- list_splice_init(&tcd->tcd_daemon_pages, &pc->pc_pages);
+ cfs_list_splice_init(&tcd->tcd_daemon_pages,
+ &pc->pc_pages);
tcd->tcd_cur_daemon_pages = 0;
}
}
}
-static void collect_pages_on_cpu(void *info)
+static void collect_pages_on_all_cpus(struct page_collection *pc)
{
- struct trace_cpu_data *tcd;
- struct page_collection *pc = info;
- int i;
-
- spin_lock(&pc->pc_lock);
- tcd_for_each_type_lock(tcd, i) {
- list_splice_init(&tcd->tcd_pages, &pc->pc_pages);
- tcd->tcd_cur_pages = 0;
- if (pc->pc_want_daemon_pages) {
- list_splice_init(&tcd->tcd_daemon_pages, &pc->pc_pages);
- tcd->tcd_cur_daemon_pages = 0;
+ struct cfs_trace_cpu_data *tcd;
+ int i, cpu;
+
+ cfs_spin_lock(&pc->pc_lock);
+ cfs_for_each_possible_cpu(cpu) {
+ cfs_tcd_for_each_type_lock(tcd, i, cpu) {
+ cfs_list_splice_init(&tcd->tcd_pages, &pc->pc_pages);
+ tcd->tcd_cur_pages = 0;
+ if (pc->pc_want_daemon_pages) {
+ cfs_list_splice_init(&tcd->tcd_daemon_pages,
+ &pc->pc_pages);
+ tcd->tcd_cur_daemon_pages = 0;
+ }
}
}
- spin_unlock(&pc->pc_lock);
+ cfs_spin_unlock(&pc->pc_lock);
}
static void collect_pages(struct page_collection *pc)
if (libcfs_panic_in_progress)
panic_collect_pages(pc);
else
- trace_call_on_all_cpus(collect_pages_on_cpu, pc);
+ collect_pages_on_all_cpus(pc);
}
-static void put_pages_back_on_cpu(void *info)
+static void put_pages_back_on_all_cpus(struct page_collection *pc)
{
- struct page_collection *pc = info;
- struct trace_cpu_data *tcd;
- struct list_head *cur_head;
- struct trace_page *tage;
- struct trace_page *tmp;
- int i;
+ struct cfs_trace_cpu_data *tcd;
+ cfs_list_t *cur_head;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
+ int i, cpu;
- spin_lock(&pc->pc_lock);
- tcd_for_each_type_lock(tcd, i) {
- cur_head = tcd->tcd_pages.next;
+ cfs_spin_lock(&pc->pc_lock);
+ cfs_for_each_possible_cpu(cpu) {
+ cfs_tcd_for_each_type_lock(tcd, i, cpu) {
+ cur_head = tcd->tcd_pages.next;
- cfs_list_for_each_entry_safe_typed(tage, tmp, &pc->pc_pages,
- struct trace_page, linkage) {
+ cfs_list_for_each_entry_safe_typed(tage, tmp,
+ &pc->pc_pages,
+ struct cfs_trace_page,
+ linkage) {
- __LASSERT_TAGE_INVARIANT(tage);
+ __LASSERT_TAGE_INVARIANT(tage);
- if (tage->cpu != smp_processor_id() || tage->type != i)
- continue;
+ if (tage->cpu != cpu || tage->type != i)
+ continue;
- tage_to_tail(tage, cur_head);
- tcd->tcd_cur_pages++;
+ cfs_tage_to_tail(tage, cur_head);
+ tcd->tcd_cur_pages++;
+ }
}
}
- spin_unlock(&pc->pc_lock);
+ cfs_spin_unlock(&pc->pc_lock);
}
static void put_pages_back(struct page_collection *pc)
{
if (!libcfs_panic_in_progress)
- trace_call_on_all_cpus(put_pages_back_on_cpu, pc);
+ put_pages_back_on_all_cpus(pc);
}
/* Add pages to a per-cpu debug daemon ringbuffer. This buffer makes sure that
* if we have been steadily writing (and otherwise discarding) pages via the
* debug daemon. */
static void put_pages_on_tcd_daemon_list(struct page_collection *pc,
- struct trace_cpu_data *tcd)
+ struct cfs_trace_cpu_data *tcd)
{
- struct trace_page *tage;
- struct trace_page *tmp;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
- spin_lock(&pc->pc_lock);
+ cfs_spin_lock(&pc->pc_lock);
cfs_list_for_each_entry_safe_typed(tage, tmp, &pc->pc_pages,
- struct trace_page, linkage) {
+ struct cfs_trace_page, linkage) {
__LASSERT_TAGE_INVARIANT(tage);
- if (tage->cpu != smp_processor_id() ||
- tage->type != tcd->tcd_type)
+ if (tage->cpu != tcd->tcd_cpu || tage->type != tcd->tcd_type)
continue;
- tage_to_tail(tage, &tcd->tcd_daemon_pages);
+ cfs_tage_to_tail(tage, &tcd->tcd_daemon_pages);
tcd->tcd_cur_daemon_pages++;
if (tcd->tcd_cur_daemon_pages > tcd->tcd_max_pages) {
- struct trace_page *victim;
+ struct cfs_trace_page *victim;
- __LASSERT(!list_empty(&tcd->tcd_daemon_pages));
- victim = tage_from_list(tcd->tcd_daemon_pages.next);
+ __LASSERT(!cfs_list_empty(&tcd->tcd_daemon_pages));
+ victim = cfs_tage_from_list(tcd->tcd_daemon_pages.next);
__LASSERT_TAGE_INVARIANT(victim);
- list_del(&victim->linkage);
- tage_free(victim);
+ cfs_list_del(&victim->linkage);
+ cfs_tage_free(victim);
tcd->tcd_cur_daemon_pages--;
}
}
- spin_unlock(&pc->pc_lock);
-}
-
-static void put_pages_on_daemon_list_on_cpu(void *info)
-{
- struct trace_cpu_data *tcd;
- int i;
-
- tcd_for_each_type_lock(tcd, i)
- put_pages_on_tcd_daemon_list(info, tcd);
+ cfs_spin_unlock(&pc->pc_lock);
}
static void put_pages_on_daemon_list(struct page_collection *pc)
{
- trace_call_on_all_cpus(put_pages_on_daemon_list_on_cpu, pc);
+ struct cfs_trace_cpu_data *tcd;
+ int i, cpu;
+
+ cfs_for_each_possible_cpu(cpu) {
+ cfs_tcd_for_each_type_lock(tcd, i, cpu)
+ put_pages_on_tcd_daemon_list(pc, tcd);
+ }
}
-void trace_debug_print(void)
+void cfs_trace_debug_print(void)
{
struct page_collection pc;
- struct trace_page *tage;
- struct trace_page *tmp;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
- spin_lock_init(&pc.pc_lock);
+ cfs_spin_lock_init(&pc.pc_lock);
pc.pc_want_daemon_pages = 1;
collect_pages(&pc);
cfs_list_for_each_entry_safe_typed(tage, tmp, &pc.pc_pages,
- struct trace_page, linkage) {
+ struct cfs_trace_page, linkage) {
char *p, *file, *fn;
cfs_page_t *page;
p += strlen(fn) + 1;
len = hdr->ph_len - (int)(p - (char *)hdr);
- print_to_console(hdr, D_EMERG, p, len, file, fn);
+ cfs_print_to_console(hdr, D_EMERG, p, len, file, fn);
p += len;
}
- list_del(&tage->linkage);
- tage_free(tage);
+ cfs_list_del(&tage->linkage);
+ cfs_tage_free(tage);
}
}
-int tracefile_dump_all_pages(char *filename)
+int cfs_tracefile_dump_all_pages(char *filename)
{
struct page_collection pc;
cfs_file_t *filp;
- struct trace_page *tage;
- struct trace_page *tmp;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
int rc;
CFS_DECL_MMSPACE;
- tracefile_write_lock();
+ cfs_tracefile_write_lock();
filp = cfs_filp_open(filename,
O_CREAT|O_EXCL|O_WRONLY|O_LARGEFILE, 0600, &rc);
if (!filp) {
if (rc != -EEXIST)
- printk(KERN_ERR "LustreError: can't open %s for dump: rc %d\n",
+ printk(CFS_KERN_ERR
+ "LustreError: can't open %s for dump: rc %d\n",
filename, rc);
goto out;
}
- spin_lock_init(&pc.pc_lock);
+ cfs_spin_lock_init(&pc.pc_lock);
pc.pc_want_daemon_pages = 1;
collect_pages(&pc);
- if (list_empty(&pc.pc_pages)) {
+ if (cfs_list_empty(&pc.pc_pages)) {
rc = 0;
goto close;
}
* iobufs with the pages and calling generic_direct_IO */
CFS_MMSPACE_OPEN;
cfs_list_for_each_entry_safe_typed(tage, tmp, &pc.pc_pages,
- struct trace_page, linkage) {
+ struct cfs_trace_page, linkage) {
__LASSERT_TAGE_INVARIANT(tage);
rc = cfs_filp_write(filp, cfs_page_address(tage->page),
tage->used, cfs_filp_poff(filp));
if (rc != (int)tage->used) {
- printk(KERN_WARNING "wanted to write %u but wrote "
+ printk(CFS_KERN_WARNING "wanted to write %u but wrote "
"%d\n", tage->used, rc);
put_pages_back(&pc);
- __LASSERT(list_empty(&pc.pc_pages));
+ __LASSERT(cfs_list_empty(&pc.pc_pages));
break;
}
- list_del(&tage->linkage);
- tage_free(tage);
+ cfs_list_del(&tage->linkage);
+ cfs_tage_free(tage);
}
CFS_MMSPACE_CLOSE;
rc = cfs_filp_fsync(filp);
if (rc)
- printk(KERN_ERR "sync returns %d\n", rc);
+ printk(CFS_KERN_ERR "sync returns %d\n", rc);
close:
cfs_filp_close(filp);
out:
- tracefile_write_unlock();
+ cfs_tracefile_write_unlock();
return rc;
}
-void trace_flush_pages(void)
+void cfs_trace_flush_pages(void)
{
struct page_collection pc;
- struct trace_page *tage;
- struct trace_page *tmp;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
- spin_lock_init(&pc.pc_lock);
+ cfs_spin_lock_init(&pc.pc_lock);
pc.pc_want_daemon_pages = 1;
collect_pages(&pc);
cfs_list_for_each_entry_safe_typed(tage, tmp, &pc.pc_pages,
- struct trace_page, linkage) {
+ struct cfs_trace_page, linkage) {
__LASSERT_TAGE_INVARIANT(tage);
- list_del(&tage->linkage);
- tage_free(tage);
+ cfs_list_del(&tage->linkage);
+ cfs_tage_free(tage);
}
}
-int trace_copyin_string(char *knl_buffer, int knl_buffer_nob,
- const char *usr_buffer, int usr_buffer_nob)
+int cfs_trace_copyin_string(char *knl_buffer, int knl_buffer_nob,
+ const char *usr_buffer, int usr_buffer_nob)
{
int nob;
if (usr_buffer_nob > knl_buffer_nob)
return -EOVERFLOW;
- if (copy_from_user((void *)knl_buffer,
+ if (cfs_copy_from_user((void *)knl_buffer,
(void *)usr_buffer, usr_buffer_nob))
return -EFAULT;
return 0;
}
-int trace_copyout_string(char *usr_buffer, int usr_buffer_nob,
- const char *knl_buffer, char *append)
+int cfs_trace_copyout_string(char *usr_buffer, int usr_buffer_nob,
+ const char *knl_buffer, char *append)
{
/* NB if 'append' != NULL, it's a single character to append to the
* copied out string - usually "\n", for /proc entries and "" (i.e. a
if (nob > usr_buffer_nob)
nob = usr_buffer_nob;
- if (copy_to_user(usr_buffer, knl_buffer, nob))
+ if (cfs_copy_to_user(usr_buffer, knl_buffer, nob))
return -EFAULT;
if (append != NULL && nob < usr_buffer_nob) {
- if (copy_to_user(usr_buffer + nob, append, 1))
+ if (cfs_copy_to_user(usr_buffer + nob, append, 1))
return -EFAULT;
nob++;
return nob;
}
+EXPORT_SYMBOL(cfs_trace_copyout_string);
-int trace_allocate_string_buffer(char **str, int nob)
+int cfs_trace_allocate_string_buffer(char **str, int nob)
{
if (nob > 2 * CFS_PAGE_SIZE) /* string must be "sensible" */
return -EINVAL;
return 0;
}
-void trace_free_string_buffer(char *str, int nob)
+void cfs_trace_free_string_buffer(char *str, int nob)
{
cfs_free(str);
}
-int trace_dump_debug_buffer_usrstr(void *usr_str, int usr_str_nob)
+int cfs_trace_dump_debug_buffer_usrstr(void *usr_str, int usr_str_nob)
{
char *str;
int rc;
- rc = trace_allocate_string_buffer(&str, usr_str_nob + 1);
+ rc = cfs_trace_allocate_string_buffer(&str, usr_str_nob + 1);
if (rc != 0)
return rc;
- rc = trace_copyin_string(str, usr_str_nob + 1,
- usr_str, usr_str_nob);
+ rc = cfs_trace_copyin_string(str, usr_str_nob + 1,
+ usr_str, usr_str_nob);
if (rc != 0)
goto out;
goto out;
}
#endif
- rc = tracefile_dump_all_pages(str);
+ rc = cfs_tracefile_dump_all_pages(str);
out:
- trace_free_string_buffer(str, usr_str_nob + 1);
+ cfs_trace_free_string_buffer(str, usr_str_nob + 1);
return rc;
}
-int trace_daemon_command(char *str)
+int cfs_trace_daemon_command(char *str)
{
int rc = 0;
- tracefile_write_lock();
+ cfs_tracefile_write_lock();
- if (strcmp(str, "stop") == 0) {
- trace_stop_thread();
- memset(tracefile, 0, sizeof(tracefile));
+ if (strcmp(str, "stop") == 0) {
+ cfs_tracefile_write_unlock();
+ cfs_trace_stop_thread();
+ cfs_tracefile_write_lock();
+ memset(cfs_tracefile, 0, sizeof(cfs_tracefile));
- } else if (strncmp(str, "size=", 5) == 0) {
- tracefile_size = simple_strtoul(str + 5, NULL, 0);
- if (tracefile_size < 10 || tracefile_size > 20480)
- tracefile_size = TRACEFILE_SIZE;
- else
- tracefile_size <<= 20;
+ } else if (strncmp(str, "size=", 5) == 0) {
+ cfs_tracefile_size = simple_strtoul(str + 5, NULL, 0);
+ if (cfs_tracefile_size < 10 || cfs_tracefile_size > 20480)
+ cfs_tracefile_size = CFS_TRACEFILE_SIZE;
+ else
+ cfs_tracefile_size <<= 20;
- } else if (strlen(str) >= sizeof(tracefile)) {
+ } else if (strlen(str) >= sizeof(cfs_tracefile)) {
rc = -ENAMETOOLONG;
#ifndef __WINNT__
} else if (str[0] != '/') {
rc = -EINVAL;
#endif
} else {
- strcpy(tracefile, str);
+ strcpy(cfs_tracefile, str);
- printk(KERN_INFO "Lustre: debug daemon will attempt to start writing "
- "to %s (%lukB max)\n", tracefile,
- (long)(tracefile_size >> 10));
+ printk(CFS_KERN_INFO
+ "Lustre: debug daemon will attempt to start writing "
+ "to %s (%lukB max)\n", cfs_tracefile,
+ (long)(cfs_tracefile_size >> 10));
- trace_start_thread();
+ cfs_trace_start_thread();
}
- tracefile_write_unlock();
- return rc;
+ cfs_tracefile_write_unlock();
+ return rc;
}
-int trace_daemon_command_usrstr(void *usr_str, int usr_str_nob)
+int cfs_trace_daemon_command_usrstr(void *usr_str, int usr_str_nob)
{
- char *str;
- int rc;
+ char *str;
+ int rc;
- rc = trace_allocate_string_buffer(&str, usr_str_nob + 1);
+ rc = cfs_trace_allocate_string_buffer(&str, usr_str_nob + 1);
if (rc != 0)
return rc;
- rc = trace_copyin_string(str, usr_str_nob + 1,
+ rc = cfs_trace_copyin_string(str, usr_str_nob + 1,
usr_str, usr_str_nob);
if (rc == 0)
- rc = trace_daemon_command(str);
+ rc = cfs_trace_daemon_command(str);
- trace_free_string_buffer(str, usr_str_nob + 1);
- return rc;
+ cfs_trace_free_string_buffer(str, usr_str_nob + 1);
+ return rc;
}
-int trace_set_debug_mb(int mb)
+int cfs_trace_set_debug_mb(int mb)
{
- int i;
+ int i;
int j;
int pages;
- int limit = trace_max_debug_mb();
- struct trace_cpu_data *tcd;
+ int limit = cfs_trace_max_debug_mb();
+ struct cfs_trace_cpu_data *tcd;
- if (mb < num_possible_cpus())
- return -EINVAL;
+ if (mb < cfs_num_possible_cpus())
+ return -EINVAL;
- if (mb > limit) {
- printk(KERN_ERR "Lustre: Refusing to set debug buffer size to "
- "%dMB - limit is %d\n", mb, limit);
- return -EINVAL;
- }
+ if (mb > limit) {
+ printk(CFS_KERN_ERR "Lustre: Refusing to set debug buffer size "
+ "to %dMB - limit is %d\n", mb, limit);
+ return -EINVAL;
+ }
- mb /= num_possible_cpus();
+ mb /= cfs_num_possible_cpus();
pages = mb << (20 - CFS_PAGE_SHIFT);
- tracefile_write_lock();
+ cfs_tracefile_write_lock();
- tcd_for_each(tcd, i, j)
- tcd->tcd_max_pages = (pages * tcd->tcd_pages_factor) / 100;
+ cfs_tcd_for_each(tcd, i, j)
+ tcd->tcd_max_pages = (pages * tcd->tcd_pages_factor) / 100;
- tracefile_write_unlock();
+ cfs_tracefile_write_unlock();
- return 0;
+ return 0;
}
-int trace_set_debug_mb_usrstr(void *usr_str, int usr_str_nob)
+int cfs_trace_set_debug_mb_usrstr(void *usr_str, int usr_str_nob)
{
- char str[32];
+ char str[32];
int rc;
- rc = trace_copyin_string(str, sizeof(str), usr_str, usr_str_nob);
+ rc = cfs_trace_copyin_string(str, sizeof(str), usr_str, usr_str_nob);
if (rc < 0)
return rc;
- return trace_set_debug_mb(simple_strtoul(str, NULL, 0));
+ return cfs_trace_set_debug_mb(simple_strtoul(str, NULL, 0));
}
-int trace_get_debug_mb(void)
+int cfs_trace_get_debug_mb(void)
{
- int i;
+ int i;
int j;
- struct trace_cpu_data *tcd;
+ struct cfs_trace_cpu_data *tcd;
int total_pages = 0;
- tracefile_read_lock();
+ cfs_tracefile_read_lock();
- tcd_for_each(tcd, i, j)
+ cfs_tcd_for_each(tcd, i, j)
total_pages += tcd->tcd_max_pages;
- tracefile_read_unlock();
+ cfs_tracefile_read_unlock();
return (total_pages >> (20 - CFS_PAGE_SHIFT)) + 1;
}
{
struct page_collection pc;
struct tracefiled_ctl *tctl = arg;
- struct trace_page *tage;
- struct trace_page *tmp;
- struct ptldebug_header *hdr;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
cfs_file_t *filp;
+ int last_loop = 0;
int rc;
CFS_DECL_MMSPACE;
/* this is so broken in uml? what on earth is going on? */
cfs_daemonize("ktracefiled");
- spin_lock_init(&pc.pc_lock);
- complete(&tctl->tctl_start);
+ cfs_spin_lock_init(&pc.pc_lock);
+ cfs_complete(&tctl->tctl_start);
while (1) {
cfs_waitlink_t __wait;
- cfs_waitlink_init(&__wait);
- cfs_waitq_add(&tctl->tctl_waitq, &__wait);
- set_current_state(TASK_INTERRUPTIBLE);
- cfs_waitq_timedwait(&__wait, CFS_TASK_INTERRUPTIBLE,
- cfs_time_seconds(1));
- cfs_waitq_del(&tctl->tctl_waitq, &__wait);
-
- if (atomic_read(&tctl->tctl_shutdown))
- break;
-
pc.pc_want_daemon_pages = 0;
collect_pages(&pc);
- if (list_empty(&pc.pc_pages))
- continue;
+ if (cfs_list_empty(&pc.pc_pages))
+ goto end_loop;
filp = NULL;
- tracefile_read_lock();
- if (tracefile[0] != 0) {
- filp = cfs_filp_open(tracefile,
+ cfs_tracefile_read_lock();
+ if (cfs_tracefile[0] != 0) {
+ filp = cfs_filp_open(cfs_tracefile,
O_CREAT | O_RDWR | O_LARGEFILE,
0600, &rc);
if (!(filp))
- printk(KERN_WARNING "couldn't open %s: %d\n",
- tracefile, rc);
+ printk(CFS_KERN_WARNING "couldn't open %s: "
+ "%d\n", cfs_tracefile, rc);
}
- tracefile_read_unlock();
+ cfs_tracefile_read_unlock();
if (filp == NULL) {
put_pages_on_daemon_list(&pc);
- __LASSERT(list_empty(&pc.pc_pages));
- continue;
+ __LASSERT(cfs_list_empty(&pc.pc_pages));
+ goto end_loop;
}
CFS_MMSPACE_OPEN;
- /* mark the first header, so we can sort in chunks */
- tage = tage_from_list(pc.pc_pages.next);
- __LASSERT_TAGE_INVARIANT(tage);
-
- hdr = cfs_page_address(tage->page);
- hdr->ph_flags |= PH_FLAG_FIRST_RECORD;
-
cfs_list_for_each_entry_safe_typed(tage, tmp, &pc.pc_pages,
- struct trace_page, linkage) {
+ struct cfs_trace_page,
+ linkage) {
static loff_t f_pos;
__LASSERT_TAGE_INVARIANT(tage);
- if (f_pos >= (off_t)tracefile_size)
+ if (f_pos >= (off_t)cfs_tracefile_size)
f_pos = 0;
else if (f_pos > (off_t)cfs_filp_size(filp))
f_pos = cfs_filp_size(filp);
rc = cfs_filp_write(filp, cfs_page_address(tage->page),
tage->used, &f_pos);
if (rc != (int)tage->used) {
- printk(KERN_WARNING "wanted to write %u but "
- "wrote %d\n", tage->used, rc);
+ printk(CFS_KERN_WARNING "wanted to write %u "
+ "but wrote %d\n", tage->used, rc);
put_pages_back(&pc);
- __LASSERT(list_empty(&pc.pc_pages));
+ __LASSERT(cfs_list_empty(&pc.pc_pages));
}
}
CFS_MMSPACE_CLOSE;
cfs_filp_close(filp);
put_pages_on_daemon_list(&pc);
- __LASSERT(list_empty(&pc.pc_pages));
+ if (!cfs_list_empty(&pc.pc_pages)) {
+ int i;
+
+ printk(CFS_KERN_ALERT "Lustre: trace pages aren't "
+ " empty\n");
+ printk(CFS_KERN_ERR "total cpus(%d): ",
+ cfs_num_possible_cpus());
+ for (i = 0; i < cfs_num_possible_cpus(); i++)
+ if (cfs_cpu_online(i))
+ printk(CFS_KERN_ERR "%d(on) ", i);
+ else
+ printk(CFS_KERN_ERR "%d(off) ", i);
+ printk(CFS_KERN_ERR "\n");
+
+ i = 0;
+ cfs_list_for_each_entry_safe(tage, tmp, &pc.pc_pages,
+ linkage)
+ printk(CFS_KERN_ERR "page %d belongs to cpu "
+ "%d\n", ++i, tage->cpu);
+ printk(CFS_KERN_ERR "There are %d pages unwritten\n",
+ i);
+ }
+ __LASSERT(cfs_list_empty(&pc.pc_pages));
+end_loop:
+ if (cfs_atomic_read(&tctl->tctl_shutdown)) {
+ if (last_loop == 0) {
+ last_loop = 1;
+ continue;
+ } else {
+ break;
+ }
+ }
+ cfs_waitlink_init(&__wait);
+ cfs_waitq_add(&tctl->tctl_waitq, &__wait);
+ cfs_set_current_state(CFS_TASK_INTERRUPTIBLE);
+ cfs_waitq_timedwait(&__wait, CFS_TASK_INTERRUPTIBLE,
+ cfs_time_seconds(1));
+ cfs_waitq_del(&tctl->tctl_waitq, &__wait);
}
- complete(&tctl->tctl_stop);
+ cfs_complete(&tctl->tctl_stop);
return 0;
}
-int trace_start_thread(void)
+int cfs_trace_start_thread(void)
{
struct tracefiled_ctl *tctl = &trace_tctl;
int rc = 0;
- mutex_down(&trace_thread_sem);
+ cfs_mutex_down(&cfs_trace_thread_sem);
if (thread_running)
goto out;
- init_completion(&tctl->tctl_start);
- init_completion(&tctl->tctl_stop);
+ cfs_init_completion(&tctl->tctl_start);
+ cfs_init_completion(&tctl->tctl_stop);
cfs_waitq_init(&tctl->tctl_waitq);
- atomic_set(&tctl->tctl_shutdown, 0);
+ cfs_atomic_set(&tctl->tctl_shutdown, 0);
if (cfs_kernel_thread(tracefiled, tctl, 0) < 0) {
rc = -ECHILD;
goto out;
}
- wait_for_completion(&tctl->tctl_start);
+ cfs_wait_for_completion(&tctl->tctl_start);
thread_running = 1;
out:
- mutex_up(&trace_thread_sem);
+ cfs_mutex_up(&cfs_trace_thread_sem);
return rc;
}
-void trace_stop_thread(void)
+void cfs_trace_stop_thread(void)
{
struct tracefiled_ctl *tctl = &trace_tctl;
- mutex_down(&trace_thread_sem);
+ cfs_mutex_down(&cfs_trace_thread_sem);
if (thread_running) {
- printk(KERN_INFO "Lustre: shutting down debug daemon thread...\n");
- atomic_set(&tctl->tctl_shutdown, 1);
- wait_for_completion(&tctl->tctl_stop);
+ printk(CFS_KERN_INFO
+ "Lustre: shutting down debug daemon thread...\n");
+ cfs_atomic_set(&tctl->tctl_shutdown, 1);
+ cfs_wait_for_completion(&tctl->tctl_stop);
thread_running = 0;
}
- mutex_up(&trace_thread_sem);
+ cfs_mutex_up(&cfs_trace_thread_sem);
}
-int tracefile_init(int max_pages)
+int cfs_tracefile_init(int max_pages)
{
- struct trace_cpu_data *tcd;
+ struct cfs_trace_cpu_data *tcd;
int i;
int j;
int rc;
int factor;
- rc = tracefile_init_arch();
+ rc = cfs_tracefile_init_arch();
if (rc != 0)
return rc;
- tcd_for_each(tcd, i, j) {
+ cfs_tcd_for_each(tcd, i, j) {
/* tcd_pages_factor is initialized int tracefile_init_arch. */
factor = tcd->tcd_pages_factor;
CFS_INIT_LIST_HEAD(&tcd->tcd_pages);
return 0;
}
-static void trace_cleanup_on_cpu(void *info)
+static void trace_cleanup_on_all_cpus(void)
{
- struct trace_cpu_data *tcd;
- struct trace_page *tage;
- struct trace_page *tmp;
- int i;
-
- tcd_for_each_type_lock(tcd, i) {
- tcd->tcd_shutting_down = 1;
-
- cfs_list_for_each_entry_safe_typed(tage, tmp, &tcd->tcd_pages,
- struct trace_page, linkage) {
- __LASSERT_TAGE_INVARIANT(tage);
+ struct cfs_trace_cpu_data *tcd;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
+ int i, cpu;
+
+ cfs_for_each_possible_cpu(cpu) {
+ cfs_tcd_for_each_type_lock(tcd, i, cpu) {
+ tcd->tcd_shutting_down = 1;
+
+ cfs_list_for_each_entry_safe_typed(tage, tmp,
+ &tcd->tcd_pages,
+ struct cfs_trace_page,
+ linkage) {
+ __LASSERT_TAGE_INVARIANT(tage);
+
+ cfs_list_del(&tage->linkage);
+ cfs_tage_free(tage);
+ }
- list_del(&tage->linkage);
- tage_free(tage);
+ tcd->tcd_cur_pages = 0;
}
- tcd->tcd_cur_pages = 0;
}
}
-static void trace_cleanup(void)
+static void cfs_trace_cleanup(void)
{
struct page_collection pc;
CFS_INIT_LIST_HEAD(&pc.pc_pages);
- spin_lock_init(&pc.pc_lock);
+ cfs_spin_lock_init(&pc.pc_lock);
- trace_call_on_all_cpus(trace_cleanup_on_cpu, &pc);
+ trace_cleanup_on_all_cpus();
- tracefile_fini_arch();
+ cfs_tracefile_fini_arch();
}
-void tracefile_exit(void)
+void cfs_tracefile_exit(void)
{
- trace_stop_thread();
- trace_cleanup();
+ cfs_trace_stop_thread();
+ cfs_trace_cleanup();
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff