* Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
* Use is subject to license terms.
*
- * Copyright (c) 2012, Intel Corporation.
+ * Copyright (c) 2012, 2013, Intel Corporation.
*/
/*
* This file is part of Lustre, http://www.lustre.org/
#include <libcfs/libcfs.h>
/* XXX move things up to the top, comment */
-union cfs_trace_data_union (*cfs_trace_data[TCD_MAX_TYPES])[CFS_NR_CPUS] __cacheline_aligned;
+union cfs_trace_data_union (*cfs_trace_data[TCD_MAX_TYPES])[NR_CPUS] __cacheline_aligned;
char cfs_tracefile[TRACEFILE_NAME_SIZE];
long long cfs_tracefile_size = CFS_TRACEFILE_SIZE;
struct mutex cfs_trace_thread_mutex;
static int thread_running = 0;
-cfs_atomic_t cfs_tage_allocated = CFS_ATOMIC_INIT(0);
+static atomic_t cfs_tage_allocated = ATOMIC_INIT(0);
static void put_pages_on_tcd_daemon_list(struct page_collection *pc,
- struct cfs_trace_cpu_data *tcd);
+ struct cfs_trace_cpu_data *tcd);
static inline struct cfs_trace_page *
-cfs_tage_from_list(cfs_list_t *list)
+cfs_tage_from_list(struct list_head *list)
{
- return cfs_list_entry(list, struct cfs_trace_page, linkage);
+ return list_entry(list, struct cfs_trace_page, linkage);
}
-static struct cfs_trace_page *cfs_tage_alloc(int gfp)
+static struct cfs_trace_page *cfs_tage_alloc(gfp_t gfp)
{
- cfs_page_t *page;
- struct cfs_trace_page *tage;
-
- /* My caller is trying to free memory */
- if (!cfs_in_interrupt() && cfs_memory_pressure_get())
- return NULL;
+ struct page *page;
+ struct cfs_trace_page *tage;
- /*
- * Don't spam console with allocation failures: they will be reported
- * by upper layer anyway.
- */
- gfp |= CFS_ALLOC_NOWARN;
- page = cfs_alloc_page(gfp);
- if (page == NULL)
- return NULL;
-
- tage = cfs_alloc(sizeof(*tage), gfp);
- if (tage == NULL) {
- cfs_free_page(page);
- return NULL;
- }
+ /* My caller is trying to free memory */
+ if (!in_interrupt() && memory_pressure_get())
+ return NULL;
+
+ /*
+ * Don't spam console with allocation failures: they will be reported
+ * by upper layer anyway.
+ */
+ gfp |= __GFP_NOWARN;
+ page = alloc_page(gfp);
+ if (page == NULL)
+ return NULL;
+
+ tage = kmalloc(sizeof(*tage), gfp);
+ if (tage == NULL) {
+ __free_page(page);
+ return NULL;
+ }
- tage->page = page;
- cfs_atomic_inc(&cfs_tage_allocated);
- return tage;
+ tage->page = page;
+ atomic_inc(&cfs_tage_allocated);
+ return tage;
}
static void cfs_tage_free(struct cfs_trace_page *tage)
{
- __LASSERT(tage != NULL);
- __LASSERT(tage->page != NULL);
+ __LASSERT(tage != NULL);
+ __LASSERT(tage->page != NULL);
- cfs_free_page(tage->page);
- cfs_free(tage);
- cfs_atomic_dec(&cfs_tage_allocated);
+ __free_page(tage->page);
+ kfree(tage);
+ atomic_dec(&cfs_tage_allocated);
}
static void cfs_tage_to_tail(struct cfs_trace_page *tage,
- cfs_list_t *queue)
+ struct list_head *queue)
{
- __LASSERT(tage != NULL);
- __LASSERT(queue != NULL);
+ __LASSERT(tage != NULL);
+ __LASSERT(queue != NULL);
- cfs_list_move_tail(&tage->linkage, queue);
+ list_move_tail(&tage->linkage, queue);
}
-int cfs_trace_refill_stock(struct cfs_trace_cpu_data *tcd, int gfp,
- cfs_list_t *stock)
+int cfs_trace_refill_stock(struct cfs_trace_cpu_data *tcd, gfp_t gfp,
+ struct list_head *stock)
{
- int i;
+ int i;
- /*
- * 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.
+ */
- for (i = 0; i + tcd->tcd_cur_stock_pages < TCD_STOCK_PAGES ; ++ i) {
- struct cfs_trace_page *tage;
+ for (i = 0; i + tcd->tcd_cur_stock_pages < TCD_STOCK_PAGES ; ++ i) {
+ struct cfs_trace_page *tage;
- tage = cfs_tage_alloc(gfp);
- if (tage == NULL)
- break;
- cfs_list_add_tail(&tage->linkage, stock);
- }
- return i;
+ tage = cfs_tage_alloc(gfp);
+ if (tage == NULL)
+ break;
+ list_add_tail(&tage->linkage, stock);
+ }
+ return i;
}
/* return a page that has 'len' bytes left at the end */
struct cfs_trace_page *tage;
if (tcd->tcd_cur_pages > 0) {
- __LASSERT(!cfs_list_empty(&tcd->tcd_pages));
+ __LASSERT(!list_empty(&tcd->tcd_pages));
tage = cfs_tage_from_list(tcd->tcd_pages.prev);
- if (tage->used + len <= CFS_PAGE_SIZE)
+ if (tage->used + len <= PAGE_CACHE_SIZE)
return tage;
}
- if (tcd->tcd_cur_pages < tcd->tcd_max_pages) {
+ if (tcd->tcd_cur_pages < tcd->tcd_max_pages) {
if (tcd->tcd_cur_stock_pages > 0) {
tage = cfs_tage_from_list(tcd->tcd_stock_pages.prev);
--tcd->tcd_cur_stock_pages;
- cfs_list_del_init(&tage->linkage);
+ list_del_init(&tage->linkage);
} else {
- tage = cfs_tage_alloc(CFS_ALLOC_ATOMIC);
+ tage = cfs_tage_alloc(GFP_ATOMIC);
if (unlikely(tage == NULL)) {
- if ((!cfs_memory_pressure_get() ||
- cfs_in_interrupt()) && printk_ratelimit())
- printk(CFS_KERN_WARNING
+ if ((!memory_pressure_get() ||
+ in_interrupt()) && printk_ratelimit())
+ printk(KERN_WARNING
"cannot allocate a tage (%ld)\n",
tcd->tcd_cur_pages);
return NULL;
}
}
- tage->used = 0;
- tage->cpu = cfs_smp_processor_id();
- tage->type = tcd->tcd_type;
- cfs_list_add_tail(&tage->linkage, &tcd->tcd_pages);
- tcd->tcd_cur_pages++;
-
- if (tcd->tcd_cur_pages > 8 && thread_running) {
- struct tracefiled_ctl *tctl = &trace_tctl;
- /*
- * wake up tracefiled to process some pages.
- */
- cfs_waitq_signal(&tctl->tctl_waitq);
- }
- return tage;
+ tage->used = 0;
+ tage->cpu = smp_processor_id();
+ tage->type = tcd->tcd_type;
+ list_add_tail(&tage->linkage, &tcd->tcd_pages);
+ tcd->tcd_cur_pages++;
+
+ if (tcd->tcd_cur_pages > 8 && thread_running) {
+ struct tracefiled_ctl *tctl = &trace_tctl;
+ /*
+ * wake up tracefiled to process some pages.
+ */
+ wake_up(&tctl->tctl_waitq);
+ }
+ return tage;
}
return NULL;
}
static void cfs_tcd_shrink(struct cfs_trace_cpu_data *tcd)
{
- int pgcount = tcd->tcd_cur_pages / 10;
- struct page_collection pc;
- struct cfs_trace_page *tage;
- struct cfs_trace_page *tmp;
+ int pgcount = tcd->tcd_cur_pages / 10;
+ struct page_collection pc;
+ 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(CFS_KERN_WARNING "debug daemon buffer overflowed; "
- "discarding 10%% of pages (%d of %ld)\n",
- pgcount + 1, tcd->tcd_cur_pages);
+ if (printk_ratelimit())
+ printk(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);
+ INIT_LIST_HEAD(&pc.pc_pages);
- cfs_list_for_each_entry_safe_typed(tage, tmp, &tcd->tcd_pages,
- struct cfs_trace_page, linkage) {
- if (pgcount-- == 0)
- break;
+ list_for_each_entry_safe(tage, tmp, &tcd->tcd_pages, linkage) {
+ if (pgcount-- == 0)
+ break;
- cfs_list_move_tail(&tage->linkage, &pc.pc_pages);
- tcd->tcd_cur_pages--;
- }
- put_pages_on_tcd_daemon_list(&pc, tcd);
+ 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 */
* from here: this will lead to infinite recursion.
*/
- if (len > CFS_PAGE_SIZE) {
- printk(CFS_KERN_ERR
- "cowardly refusing to write %lu bytes in a page\n", len);
- return NULL;
- }
+ if (len > PAGE_CACHE_SIZE) {
+ printk(KERN_ERR
+ "cowardly refusing to write %lu bytes in a page\n", len);
+ return NULL;
+ }
tage = cfs_trace_get_tage_try(tcd, len);
if (tage != NULL)
int needed = 85; /* average message length */
int max_nob;
va_list ap;
- int depth;
int i;
int remain;
int mask = msgdata->msg_mask;
goto console;
}
- depth = __current_nesting_level();
- known_size = strlen(file) + 1 + depth;
+ known_size = strlen(file) + 1;
if (msgdata->msg_fn)
known_size += strlen(msgdata->msg_fn) + 1;
for (i = 0; i < 2; i++) {
tage = cfs_trace_get_tage(tcd, needed + known_size + 1);
if (tage == NULL) {
- if (needed + known_size > CFS_PAGE_SIZE)
+ if (needed + known_size > PAGE_CACHE_SIZE)
mask |= D_ERROR;
cfs_trace_put_tcd(tcd);
goto console;
}
- string_buf = (char *)cfs_page_address(tage->page) +
+ string_buf = (char *)page_address(tage->page) +
tage->used + known_size;
- max_nob = CFS_PAGE_SIZE - tage->used - known_size;
- if (max_nob <= 0) {
- printk(CFS_KERN_EMERG "negative max_nob: %d\n",
- max_nob);
- mask |= D_ERROR;
- cfs_trace_put_tcd(tcd);
- tcd = NULL;
- goto console;
- }
+ max_nob = PAGE_CACHE_SIZE - tage->used - known_size;
+ if (max_nob <= 0) {
+ printk(KERN_EMERG "negative max_nob: %d\n",
+ max_nob);
+ mask |= D_ERROR;
+ cfs_trace_put_tcd(tcd);
+ tcd = NULL;
+ goto console;
+ }
needed = 0;
if (format1) {
break;
}
- if (*(string_buf+needed-1) != '\n')
- printk(CFS_KERN_INFO "format at %s:%d:%s doesn't end in "
- "newline\n", file, msgdata->msg_line, msgdata->msg_fn);
+ if (*(string_buf+needed-1) != '\n')
+ printk(KERN_INFO "format at %s:%d:%s doesn't end in "
+ "newline\n", file, msgdata->msg_line, msgdata->msg_fn);
header.ph_len = known_size + needed;
- debug_buf = (char *)cfs_page_address(tage->page) + tage->used;
+ debug_buf = (char *)page_address(tage->page) + tage->used;
if (libcfs_debug_binary) {
memcpy(debug_buf, &header, sizeof(header));
debug_buf += sizeof(header);
}
- /* indent message according to the nesting level */
- while (depth-- > 0) {
- *(debug_buf++) = '.';
- ++ tage->used;
- }
-
strcpy(debug_buf, file);
tage->used += strlen(file) + 1;
debug_buf += strlen(file) + 1;
__LASSERT(debug_buf == string_buf);
tage->used += needed;
- __LASSERT (tage->used <= CFS_PAGE_SIZE);
+ __LASSERT(tage->used <= PAGE_CACHE_SIZE);
console:
if ((mask & libcfs_printk) == 0) {
cdls->cdls_delay /= libcfs_console_backoff * 4;
} else {
cdls->cdls_delay *= libcfs_console_backoff;
-
- if (cdls->cdls_delay < libcfs_console_min_delay)
- cdls->cdls_delay = libcfs_console_min_delay;
- else if (cdls->cdls_delay > libcfs_console_max_delay)
- cdls->cdls_delay = libcfs_console_max_delay;
}
+ if (cdls->cdls_delay < libcfs_console_min_delay)
+ cdls->cdls_delay = libcfs_console_min_delay;
+ else if (cdls->cdls_delay > libcfs_console_max_delay)
+ cdls->cdls_delay = libcfs_console_max_delay;
+
/* ensure cdls_next is never zero after it's been seen */
cdls->cdls_next = (cfs_time_current() + cdls->cdls_delay) | 1;
}
void
cfs_trace_assertion_failed(const char *str,
- struct libcfs_debug_msg_data *msgdata)
+ struct libcfs_debug_msg_data *msgdata)
{
- struct ptldebug_header hdr;
+ struct ptldebug_header hdr;
- libcfs_panic_in_progress = 1;
- libcfs_catastrophe = 1;
- cfs_mb();
+ libcfs_panic_in_progress = 1;
+ libcfs_catastrophe = 1;
+ smp_mb();
- cfs_set_ptldebug_header(&hdr, msgdata, CDEBUG_STACK());
+ cfs_set_ptldebug_header(&hdr, msgdata, CDEBUG_STACK());
- cfs_print_to_console(&hdr, D_EMERG, str, strlen(str),
- msgdata->msg_file, msgdata->msg_fn);
+ cfs_print_to_console(&hdr, D_EMERG, str, strlen(str),
+ msgdata->msg_file, msgdata->msg_fn);
- LIBCFS_PANIC("Lustre debug assertion failure\n");
+ panic("Lustre debug assertion failure\n");
- /* not reached */
+ /* not reached */
}
static void
panic_collect_pages(struct page_collection *pc)
{
- /* 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 cfs_trace_cpu_data *tcd;
+ /* 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 cfs_trace_cpu_data *tcd;
- CFS_INIT_LIST_HEAD(&pc->pc_pages);
+ INIT_LIST_HEAD(&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;
+ cfs_tcd_for_each(tcd, i, j) {
+ 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;
- }
- }
+ if (pc->pc_want_daemon_pages) {
+ list_splice_init(&tcd->tcd_daemon_pages,
+ &pc->pc_pages);
+ tcd->tcd_cur_daemon_pages = 0;
+ }
+ }
}
static void collect_pages_on_all_cpus(struct page_collection *pc)
struct cfs_trace_cpu_data *tcd;
int i, cpu;
- 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);
+ for_each_possible_cpu(cpu) {
+ cfs_tcd_for_each_type_lock(tcd, i, cpu) {
+ 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;
+ }
+ }
+ }
}
static void collect_pages(struct page_collection *pc)
{
- CFS_INIT_LIST_HEAD(&pc->pc_pages);
+ INIT_LIST_HEAD(&pc->pc_pages);
- if (libcfs_panic_in_progress)
- panic_collect_pages(pc);
- else
- collect_pages_on_all_cpus(pc);
+ if (libcfs_panic_in_progress)
+ panic_collect_pages(pc);
+ else
+ collect_pages_on_all_cpus(pc);
}
static void put_pages_back_on_all_cpus(struct page_collection *pc)
{
struct cfs_trace_cpu_data *tcd;
- cfs_list_t *cur_head;
+ struct list_head *cur_head;
struct cfs_trace_page *tage;
struct cfs_trace_page *tmp;
int i, cpu;
- spin_lock(&pc->pc_lock);
- cfs_for_each_possible_cpu(cpu) {
+ 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 cfs_trace_page,
- linkage) {
+ list_for_each_entry_safe(tage, tmp, &pc->pc_pages,
+ linkage) {
- __LASSERT_TAGE_INVARIANT(tage);
+ __LASSERT_TAGE_INVARIANT(tage);
- if (tage->cpu != cpu || tage->type != i)
- continue;
+ if (tage->cpu != cpu || tage->type != i)
+ continue;
- cfs_tage_to_tail(tage, cur_head);
- tcd->tcd_cur_pages++;
- }
- }
- }
- spin_unlock(&pc->pc_lock);
+ cfs_tage_to_tail(tage, cur_head);
+ tcd->tcd_cur_pages++;
+ }
+ }
+ }
}
static void put_pages_back(struct page_collection *pc)
struct cfs_trace_page *tage;
struct cfs_trace_page *tmp;
- spin_lock(&pc->pc_lock);
- cfs_list_for_each_entry_safe_typed(tage, tmp, &pc->pc_pages,
- struct cfs_trace_page, linkage) {
+ list_for_each_entry_safe(tage, tmp, &pc->pc_pages, linkage) {
+ __LASSERT_TAGE_INVARIANT(tage);
- __LASSERT_TAGE_INVARIANT(tage);
-
- if (tage->cpu != tcd->tcd_cpu || tage->type != tcd->tcd_type)
- continue;
+ if (tage->cpu != tcd->tcd_cpu || tage->type != tcd->tcd_type)
+ continue;
- cfs_tage_to_tail(tage, &tcd->tcd_daemon_pages);
- tcd->tcd_cur_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 cfs_trace_page *victim;
+ if (tcd->tcd_cur_daemon_pages > tcd->tcd_max_pages) {
+ struct cfs_trace_page *victim;
- __LASSERT(!cfs_list_empty(&tcd->tcd_daemon_pages));
- victim = cfs_tage_from_list(tcd->tcd_daemon_pages.next);
+ __LASSERT(!list_empty(&tcd->tcd_daemon_pages));
+ victim = cfs_tage_from_list(tcd->tcd_daemon_pages.next);
__LASSERT_TAGE_INVARIANT(victim);
- cfs_list_del(&victim->linkage);
- cfs_tage_free(victim);
- tcd->tcd_cur_daemon_pages--;
- }
- }
- spin_unlock(&pc->pc_lock);
+ list_del(&victim->linkage);
+ cfs_tage_free(victim);
+ tcd->tcd_cur_daemon_pages--;
+ }
+ }
}
static void put_pages_on_daemon_list(struct page_collection *pc)
struct cfs_trace_cpu_data *tcd;
int i, cpu;
- cfs_for_each_possible_cpu(cpu) {
+ for_each_possible_cpu(cpu) {
cfs_tcd_for_each_type_lock(tcd, i, cpu)
put_pages_on_tcd_daemon_list(pc, tcd);
}
struct cfs_trace_page *tage;
struct cfs_trace_page *tmp;
- spin_lock_init(&pc.pc_lock);
+ pc.pc_want_daemon_pages = 1;
+ collect_pages(&pc);
+ list_for_each_entry_safe(tage, tmp, &pc.pc_pages, linkage) {
+ char *p, *file, *fn;
+ struct page *page;
- pc.pc_want_daemon_pages = 1;
- collect_pages(&pc);
- cfs_list_for_each_entry_safe_typed(tage, tmp, &pc.pc_pages,
- struct cfs_trace_page, linkage) {
- char *p, *file, *fn;
- cfs_page_t *page;
+ __LASSERT_TAGE_INVARIANT(tage);
- __LASSERT_TAGE_INVARIANT(tage);
-
- page = tage->page;
- p = cfs_page_address(page);
- while (p < ((char *)cfs_page_address(page) + tage->used)) {
+ page = tage->page;
+ p = page_address(page);
+ while (p < ((char *)page_address(page) + tage->used)) {
struct ptldebug_header *hdr;
int len;
hdr = (void *)p;
p += len;
}
- cfs_list_del(&tage->linkage);
- cfs_tage_free(tage);
- }
+ list_del(&tage->linkage);
+ cfs_tage_free(tage);
+ }
}
int cfs_tracefile_dump_all_pages(char *filename)
struct cfs_trace_page *tmp;
int rc;
- CFS_DECL_MMSPACE;
+ DECL_MMSPACE;
cfs_tracefile_write_lock();
goto out;
}
- spin_lock_init(&pc.pc_lock);
pc.pc_want_daemon_pages = 1;
collect_pages(&pc);
- if (cfs_list_empty(&pc.pc_pages)) {
+ if (list_empty(&pc.pc_pages)) {
rc = 0;
goto close;
}
/* ok, for now, just write the pages. in the future we'll be building
* 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 cfs_trace_page, linkage) {
+ MMSPACE_OPEN;
+ list_for_each_entry_safe(tage, tmp, &pc.pc_pages, linkage) {
__LASSERT_TAGE_INVARIANT(tage);
- rc = filp_write(filp, cfs_page_address(tage->page),
+ rc = filp_write(filp, page_address(tage->page),
tage->used, filp_poff(filp));
- if (rc != (int)tage->used) {
- printk(CFS_KERN_WARNING "wanted to write %u but wrote "
- "%d\n", tage->used, rc);
- put_pages_back(&pc);
- __LASSERT(cfs_list_empty(&pc.pc_pages));
- break;
- }
- cfs_list_del(&tage->linkage);
+ if (rc != (int)tage->used) {
+ printk(KERN_WARNING "wanted to write %u but wrote "
+ "%d\n", tage->used, rc);
+ put_pages_back(&pc);
+ __LASSERT(list_empty(&pc.pc_pages));
+ break;
+ }
+ list_del(&tage->linkage);
cfs_tage_free(tage);
}
- CFS_MMSPACE_CLOSE;
- rc = filp_fsync(filp);
+ MMSPACE_CLOSE;
+ rc = ll_vfs_fsync_range(filp, 0, LLONG_MAX, 1);
if (rc)
- printk(CFS_KERN_ERR "sync returns %d\n", rc);
+ printk(KERN_ERR "sync returns %d\n", rc);
close:
filp_close(filp, NULL);
out:
struct cfs_trace_page *tage;
struct cfs_trace_page *tmp;
- 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 cfs_trace_page, linkage) {
+ pc.pc_want_daemon_pages = 1;
+ collect_pages(&pc);
+ list_for_each_entry_safe(tage, tmp, &pc.pc_pages, linkage) {
- __LASSERT_TAGE_INVARIANT(tage);
+ __LASSERT_TAGE_INVARIANT(tage);
- cfs_list_del(&tage->linkage);
- cfs_tage_free(tage);
- }
+ list_del(&tage->linkage);
+ cfs_tage_free(tage);
+ }
}
int cfs_trace_copyin_string(char *knl_buffer, int knl_buffer_nob,
- const char *usr_buffer, int usr_buffer_nob)
+ const char __user *usr_buffer, int usr_buffer_nob)
{
int nob;
if (usr_buffer_nob > knl_buffer_nob)
return -EOVERFLOW;
- if (cfs_copy_from_user((void *)knl_buffer,
- (void *)usr_buffer, usr_buffer_nob))
+ if (copy_from_user(knl_buffer, usr_buffer, usr_buffer_nob))
return -EFAULT;
nob = strnlen(knl_buffer, usr_buffer_nob);
}
EXPORT_SYMBOL(cfs_trace_copyin_string);
-int cfs_trace_copyout_string(char *usr_buffer, int usr_buffer_nob,
+int cfs_trace_copyout_string(char __user *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
if (nob > usr_buffer_nob)
nob = usr_buffer_nob;
- if (cfs_copy_to_user(usr_buffer, knl_buffer, nob))
+ if (copy_to_user(usr_buffer, knl_buffer, nob))
return -EFAULT;
if (append != NULL && nob < usr_buffer_nob) {
- if (cfs_copy_to_user(usr_buffer + nob, append, 1))
+ if (copy_to_user(usr_buffer + nob, append, 1))
return -EFAULT;
nob++;
int cfs_trace_allocate_string_buffer(char **str, int nob)
{
- if (nob > 2 * CFS_PAGE_SIZE) /* string must be "sensible" */
+ if (nob > 2 * PAGE_CACHE_SIZE) /* string must be "sensible" */
return -EINVAL;
- *str = cfs_alloc(nob, CFS_ALLOC_STD | CFS_ALLOC_ZERO);
+ *str = kmalloc(nob, GFP_IOFS | __GFP_ZERO);
if (*str == NULL)
return -ENOMEM;
void cfs_trace_free_string_buffer(char *str, int nob)
{
- cfs_free(str);
+ kfree(str);
}
-int cfs_trace_dump_debug_buffer_usrstr(void *usr_str, int usr_str_nob)
+int cfs_trace_dump_debug_buffer_usrstr(void __user *usr_str, int usr_str_nob)
{
char *str;
int rc;
if (rc != 0)
goto out;
-#if !defined(__WINNT__)
if (str[0] != '/') {
rc = -EINVAL;
goto out;
}
-#endif
rc = cfs_tracefile_dump_all_pages(str);
out:
cfs_trace_free_string_buffer(str, usr_str_nob + 1);
} else if (strlen(str) >= sizeof(cfs_tracefile)) {
rc = -ENAMETOOLONG;
-#ifndef __WINNT__
} else if (str[0] != '/') {
rc = -EINVAL;
-#endif
} else {
- strcpy(cfs_tracefile, str);
+ strcpy(cfs_tracefile, str);
- printk(CFS_KERN_INFO
- "Lustre: debug daemon will attempt to start writing "
- "to %s (%lukB max)\n", cfs_tracefile,
- (long)(cfs_tracefile_size >> 10));
+ printk(KERN_INFO
+ "Lustre: debug daemon will attempt to start writing "
+ "to %s (%lukB max)\n", cfs_tracefile,
+ (long)(cfs_tracefile_size >> 10));
- cfs_trace_start_thread();
+ cfs_trace_start_thread();
}
cfs_tracefile_write_unlock();
return rc;
}
-int cfs_trace_daemon_command_usrstr(void *usr_str, int usr_str_nob)
+int cfs_trace_daemon_command_usrstr(void __user *usr_str, int usr_str_nob)
{
char *str;
int rc;
int cfs_trace_set_debug_mb(int mb)
{
- int i;
- int j;
- int pages;
- int limit = cfs_trace_max_debug_mb();
- struct cfs_trace_cpu_data *tcd;
+ int i;
+ int j;
+ int pages;
+ int limit = cfs_trace_max_debug_mb();
+ struct cfs_trace_cpu_data *tcd;
- if (mb < cfs_num_possible_cpus()) {
- printk(CFS_KERN_WARNING
- "Lustre: %d MB is too small for debug buffer size, "
- "setting it to %d MB.\n", mb, cfs_num_possible_cpus());
- mb = cfs_num_possible_cpus();
- }
+ if (mb < num_possible_cpus()) {
+ printk(KERN_WARNING
+ "Lustre: %d MB is too small for debug buffer size, "
+ "setting it to %d MB.\n", mb, num_possible_cpus());
+ mb = num_possible_cpus();
+ }
- if (mb > limit) {
- printk(CFS_KERN_WARNING
- "Lustre: %d MB is too large for debug buffer size, "
- "setting it to %d MB.\n", mb, limit);
- mb = limit;
- }
+ if (mb > limit) {
+ printk(KERN_WARNING
+ "Lustre: %d MB is too large for debug buffer size, "
+ "setting it to %d MB.\n", mb, limit);
+ mb = limit;
+ }
- mb /= cfs_num_possible_cpus();
- pages = mb << (20 - CFS_PAGE_SHIFT);
+ mb /= num_possible_cpus();
+ pages = mb << (20 - PAGE_CACHE_SHIFT);
- cfs_tracefile_write_lock();
+ cfs_tracefile_write_lock();
- cfs_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;
- cfs_tracefile_write_unlock();
+ cfs_tracefile_write_unlock();
- return 0;
+ return 0;
}
-int cfs_trace_set_debug_mb_usrstr(void *usr_str, int usr_str_nob)
+int cfs_trace_set_debug_mb_usrstr(void __user *usr_str, int usr_str_nob)
{
char str[32];
int rc;
cfs_tracefile_read_unlock();
- return (total_pages >> (20 - CFS_PAGE_SHIFT)) + 1;
+ return (total_pages >> (20 - PAGE_CACHE_SHIFT)) + 1;
}
static int tracefiled(void *arg)
int last_loop = 0;
int rc;
- CFS_DECL_MMSPACE;
+ DECL_MMSPACE;
/* we're started late enough that we pick up init's fs context */
/* 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);
- while (1) {
- cfs_waitlink_t __wait;
+ while (1) {
+ wait_queue_t __wait;
pc.pc_want_daemon_pages = 0;
collect_pages(&pc);
- if (cfs_list_empty(&pc.pc_pages))
+ if (list_empty(&pc.pc_pages))
goto end_loop;
filp = NULL;
if (IS_ERR(filp)) {
rc = PTR_ERR(filp);
filp = NULL;
- printk(CFS_KERN_WARNING "couldn't open %s: "
+ printk(KERN_WARNING "couldn't open %s: "
"%d\n", cfs_tracefile, rc);
}
}
cfs_tracefile_read_unlock();
if (filp == NULL) {
put_pages_on_daemon_list(&pc);
- __LASSERT(cfs_list_empty(&pc.pc_pages));
+ __LASSERT(list_empty(&pc.pc_pages));
goto end_loop;
}
- CFS_MMSPACE_OPEN;
+ MMSPACE_OPEN;
- cfs_list_for_each_entry_safe_typed(tage, tmp, &pc.pc_pages,
- struct cfs_trace_page,
- linkage) {
+ list_for_each_entry_safe(tage, tmp, &pc.pc_pages, linkage) {
static loff_t f_pos;
__LASSERT_TAGE_INVARIANT(tage);
else if (f_pos > (off_t)filp_size(filp))
f_pos = filp_size(filp);
- rc = filp_write(filp, cfs_page_address(tage->page),
+ rc = filp_write(filp, page_address(tage->page),
tage->used, &f_pos);
- if (rc != (int)tage->used) {
- printk(CFS_KERN_WARNING "wanted to write %u "
- "but wrote %d\n", tage->used, rc);
- put_pages_back(&pc);
- __LASSERT(cfs_list_empty(&pc.pc_pages));
- }
+ if (rc != (int)tage->used) {
+ printk(KERN_WARNING "wanted to write %u "
+ "but wrote %d\n", tage->used, rc);
+ put_pages_back(&pc);
+ __LASSERT(list_empty(&pc.pc_pages));
+ break;
+ }
}
- CFS_MMSPACE_CLOSE;
+ MMSPACE_CLOSE;
filp_close(filp, NULL);
put_pages_on_daemon_list(&pc);
- if (!cfs_list_empty(&pc.pc_pages)) {
+ if (!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 (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));
+ printk(KERN_ALERT "Lustre: trace pages aren't "
+ " empty\n");
+ printk(KERN_ERR "total cpus(%d): ",
+ num_possible_cpus());
+ for (i = 0; i < num_possible_cpus(); i++)
+ if (cpu_online(i))
+ printk(KERN_ERR "%d(on) ", i);
+ else
+ printk(KERN_ERR "%d(off) ", i);
+ printk(KERN_ERR "\n");
+
+ i = 0;
+ list_for_each_entry_safe(tage, tmp, &pc.pc_pages,
+ linkage)
+ printk(KERN_ERR "page %d belongs to cpu "
+ "%d\n", ++i, tage->cpu);
+ printk(KERN_ERR "There are %d pages unwritten\n",
+ i);
+ }
+ __LASSERT(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);
+ if (atomic_read(&tctl->tctl_shutdown)) {
+ if (last_loop == 0) {
+ last_loop = 1;
+ continue;
+ } else {
+ break;
+ }
+ }
+ init_waitqueue_entry_current(&__wait);
+ add_wait_queue(&tctl->tctl_waitq, &__wait);
+ set_current_state(TASK_INTERRUPTIBLE);
+ waitq_timedwait(&__wait, TASK_INTERRUPTIBLE,
+ cfs_time_seconds(1));
+ remove_wait_queue(&tctl->tctl_waitq, &__wait);
}
complete(&tctl->tctl_stop);
return 0;
init_completion(&tctl->tctl_start);
init_completion(&tctl->tctl_stop);
- cfs_waitq_init(&tctl->tctl_waitq);
- cfs_atomic_set(&tctl->tctl_shutdown, 0);
+ init_waitqueue_head(&tctl->tctl_waitq);
+ atomic_set(&tctl->tctl_shutdown, 0);
- if (cfs_create_thread(tracefiled, tctl, 0) < 0) {
- rc = -ECHILD;
- goto out;
- }
+ if (IS_ERR(kthread_run(tracefiled, tctl, "ktracefiled"))) {
+ rc = -ECHILD;
+ goto out;
+ }
wait_for_completion(&tctl->tctl_start);
- thread_running = 1;
+ thread_running = 1;
out:
mutex_unlock(&cfs_trace_thread_mutex);
return rc;
void cfs_trace_stop_thread(void)
{
- struct tracefiled_ctl *tctl = &trace_tctl;
+ struct tracefiled_ctl *tctl = &trace_tctl;
mutex_lock(&cfs_trace_thread_mutex);
- if (thread_running) {
- printk(CFS_KERN_INFO
- "Lustre: shutting down debug daemon thread...\n");
- cfs_atomic_set(&tctl->tctl_shutdown, 1);
+ 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);
- thread_running = 0;
- }
+ thread_running = 0;
+ }
mutex_unlock(&cfs_trace_thread_mutex);
}
int cfs_tracefile_init(int max_pages)
{
- struct cfs_trace_cpu_data *tcd;
- int i;
- int j;
- int rc;
- int factor;
-
- rc = cfs_tracefile_init_arch();
- if (rc != 0)
- return rc;
-
- 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);
- CFS_INIT_LIST_HEAD(&tcd->tcd_stock_pages);
- CFS_INIT_LIST_HEAD(&tcd->tcd_daemon_pages);
- tcd->tcd_cur_pages = 0;
- tcd->tcd_cur_stock_pages = 0;
- tcd->tcd_cur_daemon_pages = 0;
- tcd->tcd_max_pages = (max_pages * factor) / 100;
- LASSERT(tcd->tcd_max_pages > 0);
- tcd->tcd_shutting_down = 0;
- }
-
- return 0;
+ struct cfs_trace_cpu_data *tcd;
+ int i;
+ int j;
+ int rc;
+ int factor;
+
+ rc = cfs_tracefile_init_arch();
+ if (rc != 0)
+ return rc;
+
+ cfs_tcd_for_each(tcd, i, j) {
+ /* tcd_pages_factor is initialized int tracefile_init_arch. */
+ factor = tcd->tcd_pages_factor;
+ INIT_LIST_HEAD(&tcd->tcd_pages);
+ INIT_LIST_HEAD(&tcd->tcd_stock_pages);
+ INIT_LIST_HEAD(&tcd->tcd_daemon_pages);
+ tcd->tcd_cur_pages = 0;
+ tcd->tcd_cur_stock_pages = 0;
+ tcd->tcd_cur_daemon_pages = 0;
+ tcd->tcd_max_pages = (max_pages * factor) / 100;
+ LASSERT(tcd->tcd_max_pages > 0);
+ tcd->tcd_shutting_down = 0;
+ }
+ return 0;
}
static void trace_cleanup_on_all_cpus(void)
{
- 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;
+ struct cfs_trace_cpu_data *tcd;
+ struct cfs_trace_page *tage;
+ struct cfs_trace_page *tmp;
+ int i, cpu;
- cfs_list_for_each_entry_safe_typed(tage, tmp,
- &tcd->tcd_pages,
- struct cfs_trace_page,
- linkage) {
- __LASSERT_TAGE_INVARIANT(tage);
+ for_each_possible_cpu(cpu) {
+ cfs_tcd_for_each_type_lock(tcd, i, cpu) {
+ tcd->tcd_shutting_down = 1;
- cfs_list_del(&tage->linkage);
- cfs_tage_free(tage);
- }
+ list_for_each_entry_safe(tage, tmp, &tcd->tcd_pages, linkage) {
+ __LASSERT_TAGE_INVARIANT(tage);
- tcd->tcd_cur_pages = 0;
- }
- }
+ list_del(&tage->linkage);
+ cfs_tage_free(tage);
+ }
+ tcd->tcd_cur_pages = 0;
+ }
+ }
}
static void cfs_trace_cleanup(void)
{
struct page_collection pc;
- CFS_INIT_LIST_HEAD(&pc.pc_pages);
- spin_lock_init(&pc.pc_lock);
+ INIT_LIST_HEAD(&pc.pc_pages);
trace_cleanup_on_all_cpus();