#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);
+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_page *tage;
/* My caller is trying to free memory */
- if (!cfs_in_interrupt() && memory_pressure_get())
+ if (!in_interrupt() && memory_pressure_get())
return NULL;
/*
}
tage->page = page;
- cfs_atomic_inc(&cfs_tage_allocated);
+ atomic_inc(&cfs_tage_allocated);
return tage;
}
__free_page(tage->page);
kfree(tage);
- cfs_atomic_dec(&cfs_tage_allocated);
+ atomic_dec(&cfs_tage_allocated);
}
static void cfs_tage_to_tail(struct cfs_trace_page *tage,
tage = cfs_tage_alloc(GFP_ATOMIC);
if (unlikely(tage == NULL)) {
if ((!memory_pressure_get() ||
- cfs_in_interrupt()) && printk_ratelimit())
- printk(CFS_KERN_WARNING
+ 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;
+ 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.
+ */
+ wake_up(&tctl->tctl_waitq);
+ }
+ return tage;
}
return NULL;
}
* 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);
*/
if (len > PAGE_CACHE_SIZE) {
- printk(CFS_KERN_ERR
- "cowardly refusing to write %lu bytes in a page\n", len);
- return NULL;
- }
+ 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)
tage->used + known_size;
max_nob = PAGE_CACHE_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;
- }
+ 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 *)page_address(tage->page) + tage->used;
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
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;
- }
+ if (rc != (int)tage->used) {
+ printk(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);
cfs_tage_free(tage);
}
MMSPACE_CLOSE;
rc = filp_fsync(filp);
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:
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();
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();
+ 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)
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 (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);
}
}
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(cfs_list_empty(&pc.pc_pages));
+ }
}
MMSPACE_CLOSE;
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 (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;
+ cfs_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(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);
+ 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 (IS_ERR(kthread_run(tracefiled, tctl, "ktracefiled"))) {
rc = -ECHILD;
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);
}