From: Michael Jeanson Date: Wed, 12 Aug 2020 20:58:26 +0000 (-0400) Subject: Namespace all logging statements X-Git-Tag: v2.13.0-rc1~180 X-Git-Url: https://git.lttng.org./?a=commitdiff_plain;h=5a15f70c5211ff4a398171a6971586e2948eb419;p=lttng-modules.git Namespace all logging statements Add the 'LTTng:' prefix to all our logging statements to easily distinguish them from other kernel messages. Change-Id: I90fb4f4c75ce195734ec82946827bcf78e03429a Signed-off-by: Michael Jeanson Signed-off-by: Mathieu Desnoyers --- diff --git a/include/lttng/filter.h b/include/lttng/filter.h index eb70fe36..e999a057 100644 --- a/include/lttng/filter.h +++ b/include/lttng/filter.h @@ -23,14 +23,14 @@ #ifdef DEBUG #define dbg_printk(fmt, args...) \ - printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt, \ + printk(KERN_DEBUG "LTTng: [debug bytecode in %s:%s@%u] " fmt, \ __FILE__, __func__, __LINE__, ## args) #else #define dbg_printk(fmt, args...) \ do { \ /* do nothing but check printf format */ \ if (0) \ - printk(KERN_DEBUG "[debug bytecode in %s:%s@%u] " fmt, \ + printk(KERN_DEBUG "LTTng: [debug bytecode in %s:%s@%u] " fmt, \ __FILE__, __func__, __LINE__, ## args); \ } while (0) #endif @@ -138,7 +138,7 @@ static inline int vstack_push(struct vstack *stack) { if (stack->top >= FILTER_STACK_LEN - 1) { - printk(KERN_WARNING "Stack full\n"); + printk(KERN_WARNING "LTTng: filter: Stack full\n"); return -EINVAL; } ++stack->top; @@ -149,7 +149,7 @@ static inline int vstack_pop(struct vstack *stack) { if (unlikely(stack->top < 0)) { - printk(KERN_WARNING "Stack empty\n"); + printk(KERN_WARNING "LTTng: filter: Stack empty\n"); return -EINVAL; } stack->top--; diff --git a/include/wrapper/vmalloc.h b/include/wrapper/vmalloc.h index 8c59f4e1..bbc900d1 100644 --- a/include/wrapper/vmalloc.h +++ b/include/wrapper/vmalloc.h @@ -59,7 +59,7 @@ void wrapper_vmalloc_sync_mappings(void) * trigger recursive page faults. */ printk_once(KERN_WARNING "LTTng: vmalloc_sync_mappings symbol lookup failed.\n"); - printk_once(KERN_WARNING "Page fault handler and NMI tracing might trigger faults.\n"); + printk_once(KERN_WARNING "LTTng: Page fault handler and NMI tracing might trigger faults.\n"); #endif } } @@ -97,7 +97,7 @@ void wrapper_vmalloc_sync_mappings(void) * trigger recursive page faults. */ printk_once(KERN_WARNING "LTTng: vmalloc_sync_all symbol lookup failed.\n"); - printk_once(KERN_WARNING "Page fault handler and NMI tracing might trigger faults.\n"); + printk_once(KERN_WARNING "LTTng: Page fault handler and NMI tracing might trigger faults.\n"); #endif } } @@ -208,8 +208,8 @@ static inline void print_vmalloc_node_range_warning(void) { printk_once(KERN_WARNING "LTTng: __vmalloc_node_range symbol lookup failed.\n"); - printk_once(KERN_WARNING "Tracer performance will be degraded on NUMA systems.\n"); - printk_once(KERN_WARNING "Please rebuild your kernel with CONFIG_KALLSYMS enabled.\n"); + printk_once(KERN_WARNING "LTTng: Tracer performance will be degraded on NUMA systems.\n"); + printk_once(KERN_WARNING "LTTng: Please rebuild your kernel with CONFIG_KALLSYMS enabled.\n"); } #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4,0,0)) diff --git a/src/lib/ringbuffer/ring_buffer_backend.c b/src/lib/ringbuffer/ring_buffer_backend.c index d6547d7d..1625804f 100644 --- a/src/lib/ringbuffer/ring_buffer_backend.c +++ b/src/lib/ringbuffer/ring_buffer_backend.c @@ -283,7 +283,7 @@ int lttng_cpuhp_rb_backend_prepare(unsigned int cpu, ret = lib_ring_buffer_create(buf, chanb, cpu); if (ret) { printk(KERN_ERR - "ring_buffer_cpu_hp_callback: cpu %d " + "LTTng: ring_buffer_cpu_hp_callback: cpu %d " "buffer creation failed\n", cpu); return ret; } @@ -324,7 +324,7 @@ int lib_ring_buffer_cpu_hp_callback(struct notifier_block *nb, ret = lib_ring_buffer_create(buf, chanb, cpu); if (ret) { printk(KERN_ERR - "ring_buffer_cpu_hp_callback: cpu %d " + "LTTng: ring_buffer_cpu_hp_callback: cpu %d " "buffer creation failed\n", cpu); return NOTIFY_BAD; } diff --git a/src/lib/ringbuffer/ring_buffer_frontend.c b/src/lib/ringbuffer/ring_buffer_frontend.c index fca37fbc..d3dfcb1b 100644 --- a/src/lib/ringbuffer/ring_buffer_frontend.c +++ b/src/lib/ringbuffer/ring_buffer_frontend.c @@ -1455,7 +1455,7 @@ void lib_ring_buffer_print_subbuffer_errors(struct lib_ring_buffer *buf, if (subbuf_offset(commit_count, chan) != 0) printk(KERN_WARNING - "ring buffer %s, cpu %d: " + "LTTng: ring buffer %s, cpu %d: " "commit count in subbuffer %lu,\n" "expecting multiples of %lu bytes\n" " [ %lu bytes committed, %lu bytes reader-visible ]\n", @@ -1463,7 +1463,7 @@ void lib_ring_buffer_print_subbuffer_errors(struct lib_ring_buffer *buf, chan->backend.subbuf_size, commit_count, commit_count_sb); - printk(KERN_DEBUG "ring buffer: %s, cpu %d: %lu bytes committed\n", + printk(KERN_DEBUG "LTTng: ring buffer: %s, cpu %d: %lu bytes committed\n", chan->backend.name, cpu, commit_count); } @@ -1484,7 +1484,7 @@ void lib_ring_buffer_print_buffer_errors(struct lib_ring_buffer *buf, cons_offset = atomic_long_read(&buf->consumed); if (write_offset != cons_offset) printk(KERN_DEBUG - "ring buffer %s, cpu %d: " + "LTTng: ring buffer %s, cpu %d: " "non-consumed data\n" " [ %lu bytes written, %lu bytes read ]\n", chan->backend.name, cpu, write_offset, cons_offset); @@ -1507,13 +1507,13 @@ void lib_ring_buffer_print_records_count(struct channel *chan, const struct lib_ring_buffer_config *config = &chan->backend.config; if (!strcmp(chan->backend.name, "relay-metadata")) { - printk(KERN_DEBUG "ring buffer %s: %lu records written, " + printk(KERN_DEBUG "LTTng: ring buffer %s: %lu records written, " "%lu records overrun\n", chan->backend.name, v_read(config, &buf->records_count), v_read(config, &buf->records_overrun)); } else { - printk(KERN_DEBUG "ring buffer %s, cpu %d: %lu records written, " + printk(KERN_DEBUG "LTTng: ring buffer %s, cpu %d: %lu records written, " "%lu records overrun\n", chan->backend.name, cpu, v_read(config, &buf->records_count), @@ -1542,7 +1542,7 @@ void lib_ring_buffer_print_errors(struct channel *chan, || v_read(config, &buf->records_lost_wrap) || v_read(config, &buf->records_lost_big)) printk(KERN_WARNING - "ring buffer %s, cpu %d: records were lost. Caused by:\n" + "LTTng: ring buffer %s, cpu %d: records were lost. Caused by:\n" " [ %lu buffer full, %lu nest buffer wrap-around, " "%lu event too big ]\n", chan->backend.name, cpu, diff --git a/src/lib/ringbuffer/ring_buffer_iterator.c b/src/lib/ringbuffer/ring_buffer_iterator.c index 15d7c75c..64fc5086 100644 --- a/src/lib/ringbuffer/ring_buffer_iterator.c +++ b/src/lib/ringbuffer/ring_buffer_iterator.c @@ -296,7 +296,7 @@ ssize_t channel_get_next_record(struct channel *chan, */ if (chan->iter.last_timestamp > (buf->iter.timestamp + MAX_CLOCK_DELTA)) { - printk(KERN_WARNING "ring_buffer: timestamps going " + printk(KERN_WARNING "LTTng: ring_buffer: timestamps going " "backward. Last time %llu ns, cpu %d, " "current time %llu ns, cpu %d, " "delta %llu ns.\n", diff --git a/src/lib/ringbuffer/ring_buffer_splice.c b/src/lib/ringbuffer/ring_buffer_splice.c index 6061cce1..7b7e3d65 100644 --- a/src/lib/ringbuffer/ring_buffer_splice.c +++ b/src/lib/ringbuffer/ring_buffer_splice.c @@ -19,10 +19,15 @@ #include #include -#if 0 +#ifdef DEBUG #define printk_dbg(fmt, args...) printk(fmt, args) #else -#define printk_dbg(fmt, args...) +#define printk_dbg(fmt, args...) \ +do { \ + /* do nothing but check printf format */ \ + if (0) \ + printk(fmt, ## args); \ +} while (0) #endif loff_t vfs_lib_ring_buffer_no_llseek(struct file *file, loff_t offset, @@ -131,7 +136,7 @@ static int subbuf_splice_actor(struct file *in, nr_pages = min_t(unsigned int, subbuf_pages, PIPE_DEF_BUFFERS); roffset = consumed_old & PAGE_MASK; poff = consumed_old & ~PAGE_MASK; - printk_dbg(KERN_DEBUG "SPLICE actor len %zu pos %zd write_pos %ld\n", + printk_dbg(KERN_DEBUG "LTTng: SPLICE actor len %zu pos %zd write_pos %ld\n", len, (ssize_t)*ppos, lib_ring_buffer_get_offset(config, buf)); for (; spd.nr_pages < nr_pages; spd.nr_pages++) { @@ -142,7 +147,7 @@ static int subbuf_splice_actor(struct file *in, if (!len) break; - printk_dbg(KERN_DEBUG "SPLICE actor loop len %zu roffset %ld\n", + printk_dbg(KERN_DEBUG "LTTng: SPLICE actor loop len %zu roffset %ld\n", len, roffset); /* @@ -202,11 +207,11 @@ ssize_t lib_ring_buffer_splice_read(struct file *in, loff_t *ppos, ret = 0; spliced = 0; - printk_dbg(KERN_DEBUG "SPLICE read len %zu pos %zd\n", len, + printk_dbg(KERN_DEBUG "LTTng: SPLICE read len %zu pos %zd\n", len, (ssize_t)*ppos); while (len && !spliced) { ret = subbuf_splice_actor(in, ppos, pipe, len, flags, buf); - printk_dbg(KERN_DEBUG "SPLICE read loop ret %d\n", ret); + printk_dbg(KERN_DEBUG "LTTng: SPLICE read loop ret %d\n", ret); if (ret < 0) break; else if (!ret) { diff --git a/src/lttng-abi.c b/src/lttng-abi.c index 4dd6e7e5..198987bd 100644 --- a/src/lttng-abi.c +++ b/src/lttng-abi.c @@ -1080,7 +1080,7 @@ int lttng_metadata_ring_buffer_open(struct inode *inode, struct file *file) * session, we need to keep our own reference on the transport. */ if (!try_module_get(stream->transport->owner)) { - printk(KERN_WARNING "LTT : Can't lock transport module.\n"); + printk(KERN_WARNING "LTTng: Can't lock transport module.\n"); return -EBUSY; } return lib_ring_buffer_open(inode, file, buf); @@ -1234,7 +1234,7 @@ int lttng_abi_open_metadata_stream(struct file *channel_file) * session, we need to keep our own reference on the transport. */ if (!try_module_get(metadata_stream->transport->owner)) { - printk(KERN_WARNING "LTT : Can't lock transport module.\n"); + printk(KERN_WARNING "LTTng: Can't lock transport module.\n"); ret = -EINVAL; goto notransport; } @@ -2018,7 +2018,7 @@ int __init lttng_abi_init(void) <tng_proc_ops, NULL); if (!lttng_proc_dentry) { - printk(KERN_ERR "Error creating LTTng control file\n"); + printk(KERN_ERR "LTTng: Error creating control file\n"); ret = -ENOMEM; goto error; } diff --git a/src/lttng-clock.c b/src/lttng-clock.c index 7512a3f4..2e623be3 100644 --- a/src/lttng-clock.c +++ b/src/lttng-clock.c @@ -69,7 +69,7 @@ void lttng_clock_ref(void) ret = try_module_get(lttng_trace_clock_mod); if (!ret) { - printk(KERN_ERR "LTTng-clock cannot get clock plugin module\n"); + printk(KERN_ERR "LTTng: LTTng-clock cannot get clock plugin module\n"); WRITE_ONCE(lttng_trace_clock, NULL); lttng_trace_clock_mod = NULL; } diff --git a/src/lttng-context.c b/src/lttng-context.c index 4b948ef8..311dd6e1 100644 --- a/src/lttng-context.c +++ b/src/lttng-context.c @@ -256,95 +256,95 @@ int lttng_context_init(void) ret = lttng_add_hostname_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_hostname_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_hostname_to_ctx"); } ret = lttng_add_nice_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_nice_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_nice_to_ctx"); } ret = lttng_add_pid_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_pid_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_pid_to_ctx"); } ret = lttng_add_ppid_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_ppid_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_ppid_to_ctx"); } ret = lttng_add_prio_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_prio_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_prio_to_ctx"); } ret = lttng_add_procname_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_procname_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_procname_to_ctx"); } ret = lttng_add_tid_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_tid_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_tid_to_ctx"); } ret = lttng_add_vppid_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_vppid_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_vppid_to_ctx"); } ret = lttng_add_vtid_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_vtid_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_vtid_to_ctx"); } ret = lttng_add_vpid_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_vpid_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_vpid_to_ctx"); } ret = lttng_add_cpu_id_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_cpu_id_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_cpu_id_to_ctx"); } ret = lttng_add_interruptible_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_interruptible_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_interruptible_to_ctx"); } ret = lttng_add_need_reschedule_to_ctx(<tng_static_ctx); if (ret) { - printk(KERN_WARNING "Cannot add context lttng_add_need_reschedule_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_need_reschedule_to_ctx"); } ret = lttng_add_preemptible_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_preemptible_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_preemptible_to_ctx"); } ret = lttng_add_migratable_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_migratable_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_migratable_to_ctx"); } ret = lttng_add_cgroup_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_cgroup_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_cgroup_ns_to_ctx"); } ret = lttng_add_ipc_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_ipc_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_ipc_ns_to_ctx"); } ret = lttng_add_mnt_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_mnt_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_mnt_ns_to_ctx"); } ret = lttng_add_net_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_net_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_net_ns_to_ctx"); } ret = lttng_add_pid_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_pid_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_pid_ns_to_ctx"); } ret = lttng_add_user_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_user_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_user_ns_to_ctx"); } ret = lttng_add_uts_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_uts_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_uts_ns_to_ctx"); } ret = lttng_add_time_ns_to_ctx(<tng_static_ctx); if (ret && ret != -ENOSYS) { - printk(KERN_WARNING "Cannot add context lttng_add_time_ns_to_ctx"); + printk(KERN_WARNING "LTTng: Cannot add context lttng_add_time_ns_to_ctx"); } /* TODO: perf counters for filtering */ return 0; diff --git a/src/lttng-events.c b/src/lttng-events.c index 62f8e054..631dfcb6 100644 --- a/src/lttng-events.c +++ b/src/lttng-events.c @@ -502,12 +502,12 @@ struct lttng_channel *lttng_channel_create(struct lttng_session *session, goto active; /* Refuse to add channel to active session */ transport = lttng_transport_find(transport_name); if (!transport) { - printk(KERN_WARNING "LTTng transport %s not found\n", + printk(KERN_WARNING "LTTng: transport %s not found\n", transport_name); goto notransport; } if (!try_module_get(transport->owner)) { - printk(KERN_WARNING "LTT : Can't lock transport module.\n"); + printk(KERN_WARNING "LTTng: Can't lock transport module.\n"); goto notransport; } chan = kzalloc(sizeof(struct lttng_channel), GFP_KERNEL); @@ -1320,7 +1320,7 @@ void lttng_create_tracepoint_if_missing(struct lttng_enabler *enabler) NULL, NULL, desc, LTTNG_KERNEL_TRACEPOINT); if (!event) { - printk(KERN_INFO "Unable to create event %s\n", + printk(KERN_INFO "LTTng: Unable to create event %s\n", probe_desc->event_desc[i]->name); } } diff --git a/src/lttng-filter-interpreter.c b/src/lttng-filter-interpreter.c index 6c1c2f27..b38bc126 100644 --- a/src/lttng-filter-interpreter.c +++ b/src/lttng-filter-interpreter.c @@ -234,7 +234,7 @@ uint64_t lttng_filter_false(void *filter_data, start_pc = &bytecode->data[0]; \ for (pc = next_pc = start_pc; pc - start_pc < bytecode->len; \ pc = next_pc) { \ - dbg_printk("Executing op %s (%u)\n", \ + dbg_printk("LTTng: Executing op %s (%u)\n", \ lttng_filter_print_op((unsigned int) *(filter_opcode_t *) pc), \ (unsigned int) *(filter_opcode_t *) pc); \ switch (*(filter_opcode_t *) pc) { @@ -317,11 +317,11 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, } case atype_array_nestable: if (!lttng_is_bytewise_integer(field->type.u.array_nestable.elem_type)) { - printk(KERN_WARNING "Array nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: filter: Array nesting only supports integer types.\n"); return -EINVAL; } if (field->type.u.array_nestable.elem_type->u.integer.encoding == lttng_encode_none) { - printk(KERN_WARNING "Only string arrays are supported for contexts.\n"); + printk(KERN_WARNING "LTTng: filter: Only string arrays are supported for contexts.\n"); return -EINVAL; } ptr->object_type = OBJECT_TYPE_STRING; @@ -330,11 +330,11 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, break; case atype_sequence_nestable: if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.elem_type)) { - printk(KERN_WARNING "Sequence nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: filter: Sequence nesting only supports integer types.\n"); return -EINVAL; } if (field->type.u.sequence_nestable.elem_type->u.integer.encoding == lttng_encode_none) { - printk(KERN_WARNING "Only string sequences are supported for contexts.\n"); + printk(KERN_WARNING "LTTng: filter: Only string sequences are supported for contexts.\n"); return -EINVAL; } ptr->object_type = OBJECT_TYPE_STRING; @@ -347,13 +347,13 @@ static int context_get_index(struct lttng_probe_ctx *lttng_probe_ctx, ptr->ptr = v.str; break; case atype_struct_nestable: - printk(KERN_WARNING "Structure type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: filter: Structure type cannot be loaded.\n"); return -EINVAL; case atype_variant_nestable: - printk(KERN_WARNING "Variant type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: filter: Variant type cannot be loaded.\n"); return -EINVAL; default: - printk(KERN_WARNING "Unknown type: %d", (int) field->type.atype); + printk(KERN_WARNING "LTTng: filter: Unknown type: %d", (int) field->type.atype); return -EINVAL; } return 0; @@ -412,12 +412,12 @@ static int dynamic_get_index(struct lttng_probe_ctx *lttng_probe_ctx, break; } case OBJECT_TYPE_STRUCT: - printk(KERN_WARNING "Nested structures are not supported yet.\n"); + printk(KERN_WARNING "LTTng: filter: Nested structures are not supported yet.\n"); ret = -EINVAL; goto end; case OBJECT_TYPE_VARIANT: default: - printk(KERN_WARNING "Unexpected get index type %d", + printk(KERN_WARNING "LTTng: filter: Unexpected get index type %d", (int) stack_top->u.ptr.object_type); ret = -EINVAL; goto end; @@ -588,7 +588,7 @@ static int dynamic_load_field(struct estack_entry *stack_top) case OBJECT_TYPE_ARRAY: case OBJECT_TYPE_STRUCT: case OBJECT_TYPE_VARIANT: - printk(KERN_WARNING "Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); + printk(KERN_WARNING "LTTng: filter: Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); ret = -EINVAL; goto end; } @@ -764,7 +764,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data, #ifdef INTERPRETER_USE_SWITCH default: #endif /* INTERPRETER_USE_SWITCH */ - printk(KERN_WARNING "unknown bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -782,7 +782,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data, OP(FILTER_OP_MOD): OP(FILTER_OP_PLUS): OP(FILTER_OP_MINUS): - printk(KERN_WARNING "unsupported bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -793,7 +793,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data, OP(FILTER_OP_LT): OP(FILTER_OP_GE): OP(FILTER_OP_LE): - printk(KERN_WARNING "unsupported non-specialized bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -1034,7 +1034,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data, OP(FILTER_OP_UNARY_PLUS): OP(FILTER_OP_UNARY_MINUS): OP(FILTER_OP_UNARY_NOT): - printk(KERN_WARNING "unsupported non-specialized bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -1237,7 +1237,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data, /* cast */ OP(FILTER_OP_CAST_TO_S64): - printk(KERN_WARNING "unsupported non-specialized bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported non-specialized bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -1391,7 +1391,7 @@ uint64_t lttng_filter_interpret_bytecode(void *filter_data, dbg_printk("op get symbol\n"); switch (estack_ax(stack, top)->u.ptr.type) { case LOAD_OBJECT: - printk(KERN_WARNING "Nested fields not implemented yet.\n"); + printk(KERN_WARNING "LTTng: filter: Nested fields not implemented yet.\n"); ret = -EINVAL; goto end; case LOAD_ROOT_CONTEXT: diff --git a/src/lttng-filter-specialize.c b/src/lttng-filter-specialize.c index ccc45835..1d7f29a4 100644 --- a/src/lttng-filter-specialize.c +++ b/src/lttng-filter-specialize.c @@ -119,7 +119,7 @@ static int specialize_load_field(struct vstack_entry *stack_top, insn->op = FILTER_OP_LOAD_FIELD_U64; break; case OBJECT_TYPE_DOUBLE: - printk(KERN_WARNING "Double type unsupported\n\n"); + printk(KERN_WARNING "LTTng: filter: Double type unsupported\n\n"); ret = -EINVAL; goto end; case OBJECT_TYPE_STRING: @@ -139,7 +139,7 @@ static int specialize_load_field(struct vstack_entry *stack_top, case OBJECT_TYPE_ARRAY: case OBJECT_TYPE_STRUCT: case OBJECT_TYPE_VARIANT: - printk(KERN_WARNING "Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); + printk(KERN_WARNING "LTTng: filter: Sequences, arrays, struct and variant cannot be loaded (nested types).\n"); ret = -EINVAL; goto end; } @@ -260,7 +260,7 @@ static int specialize_get_index(struct bytecode_runtime *runtime, /* Only generated by the specialize phase. */ case OBJECT_TYPE_VARIANT: /* Fall-through */ default: - printk(KERN_WARNING "Unexpected get index type %d", + printk(KERN_WARNING "LTTng: filter: Unexpected get index type %d", (int) stack_top->load.object_type); ret = -EINVAL; goto end; @@ -269,7 +269,7 @@ static int specialize_get_index(struct bytecode_runtime *runtime, case LOAD_ROOT_CONTEXT: case LOAD_ROOT_APP_CONTEXT: case LOAD_ROOT_PAYLOAD: - printk(KERN_WARNING "Index lookup for root field not implemented yet.\n"); + printk(KERN_WARNING "LTTng: filter: Index lookup for root field not implemented yet.\n"); ret = -EINVAL; goto end; } @@ -337,7 +337,7 @@ static int specialize_load_object(const struct lttng_event_field *field, } case atype_array_nestable: if (!lttng_is_bytewise_integer(field->type.u.array_nestable.elem_type)) { - printk(KERN_WARNING "Array nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: filter Array nesting only supports integer types.\n"); return -EINVAL; } if (is_context) { @@ -353,7 +353,7 @@ static int specialize_load_object(const struct lttng_event_field *field, break; case atype_sequence_nestable: if (!lttng_is_bytewise_integer(field->type.u.sequence_nestable.elem_type)) { - printk(KERN_WARNING "Sequence nesting only supports integer types.\n"); + printk(KERN_WARNING "LTTng: filter Sequence nesting only supports integer types.\n"); return -EINVAL; } if (is_context) { @@ -371,13 +371,13 @@ static int specialize_load_object(const struct lttng_event_field *field, load->object_type = OBJECT_TYPE_STRING; break; case atype_struct_nestable: - printk(KERN_WARNING "Structure type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: filter: Structure type cannot be loaded.\n"); return -EINVAL; case atype_variant_nestable: - printk(KERN_WARNING "Variant type cannot be loaded.\n"); + printk(KERN_WARNING "LTTng: filter: Variant type cannot be loaded.\n"); return -EINVAL; default: - printk(KERN_WARNING "Unknown type: %d", (int) field->type.atype); + printk(KERN_WARNING "LTTng: filter: Unknown type: %d", (int) field->type.atype); return -EINVAL; } return 0; @@ -505,7 +505,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch (*(filter_opcode_t *) pc) { case FILTER_OP_UNKNOWN: default: - printk(KERN_WARNING "unknown bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -521,7 +521,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, case FILTER_OP_MOD: case FILTER_OP_PLUS: case FILTER_OP_MINUS: - printk(KERN_WARNING "unsupported bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -532,7 +532,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; @@ -574,7 +574,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; @@ -616,12 +616,12 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "invalid register type for > binary operator\n"); + printk(KERN_WARNING "LTTng: filter: invalid register type for '>' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: @@ -656,12 +656,12 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "invalid register type for < binary operator\n"); + printk(KERN_WARNING "LTTng: filter: invalid register type for '<' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: @@ -696,12 +696,12 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "invalid register type for >= binary operator\n"); + printk(KERN_WARNING "LTTng: filter: invalid register type for '>=' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: @@ -735,12 +735,12 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "invalid register type for <= binary operator\n"); + printk(KERN_WARNING "LTTng: filter: invalid register type for '<=' binary operator\n"); ret = -EINVAL; goto end; case REG_STRING: @@ -819,7 +819,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; @@ -841,7 +841,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; @@ -863,7 +863,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch(vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; @@ -915,14 +915,14 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, /* load field ref */ case FILTER_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); ret = -EINVAL; goto end; } /* get context ref */ case FILTER_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "Unknown get context ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n"); ret = -EINVAL; goto end; } @@ -1021,13 +1021,13 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, switch (vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "Cast op can only be applied to numeric or floating point registers\n"); + printk(KERN_WARNING "LTTng: filter: Cast op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; case REG_S64: @@ -1145,7 +1145,7 @@ int lttng_filter_specialize_bytecode(struct lttng_event *event, dbg_printk("op get symbol\n"); switch (vstack_ax(stack)->load.type) { case LOAD_OBJECT: - printk(KERN_WARNING "Nested fields not implemented yet.\n"); + printk(KERN_WARNING "LTTng: filter: Nested fields not implemented yet.\n"); ret = -EINVAL; goto end; case LOAD_ROOT_CONTEXT: diff --git a/src/lttng-filter-validator.c b/src/lttng-filter-validator.c index 38d6ed07..f117eadf 100644 --- a/src/lttng-filter-validator.c +++ b/src/lttng-filter-validator.c @@ -87,7 +87,7 @@ int merge_point_add_check(struct mp_table *mp_table, unsigned long target_pc, target_pc, hash); kfree(mp_node); if (merge_points_compare(stack, &lookup_node->stack)) { - printk(KERN_WARNING "Merge points differ for offset %lu\n", + printk(KERN_WARNING "LTTng: filter: Merge points differ for offset %lu\n", target_pc); return -EINVAL; } @@ -180,15 +180,15 @@ unknown: return 1; error_empty: - printk(KERN_WARNING "empty stack for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: filter: empty stack for '%s' binary operator\n", str); return -EINVAL; error_mismatch: - printk(KERN_WARNING "type mismatch for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: filter: type mismatch for '%s' binary operator\n", str); return -EINVAL; error_type: - printk(KERN_WARNING "unknown type for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: filter: unknown type for '%s' binary operator\n", str); return -EINVAL; } @@ -239,11 +239,11 @@ unknown: return 1; error_empty: - printk(KERN_WARNING "empty stack for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: filter: empty stack for '%s' binary operator\n", str); return -EINVAL; error_type: - printk(KERN_WARNING "unknown type for '%s' binary operator\n", str); + printk(KERN_WARNING "LTTng: filter: unknown type for '%s' binary operator\n", str); return -EINVAL; } @@ -279,7 +279,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, case FILTER_OP_UNKNOWN: default: { - printk(KERN_WARNING "unknown bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; break; @@ -328,7 +328,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, case FILTER_OP_UNARY_MINUS_DOUBLE: case FILTER_OP_UNARY_NOT_DOUBLE: { - printk(KERN_WARNING "unsupported bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; break; @@ -397,7 +397,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, /* load field ref */ case FILTER_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); ret = -EINVAL; break; } @@ -405,7 +405,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, /* get context ref */ case FILTER_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); ret = -EINVAL; break; } @@ -504,7 +504,7 @@ int bytecode_validate_overflow(struct bytecode_runtime *bytecode, } case FILTER_OP_GET_SYMBOL_FIELD: - printk(KERN_WARNING "Unexpected get symbol field\n"); + printk(KERN_WARNING "LTTng: filter: Unexpected get symbol field\n"); ret = -EINVAL; break; @@ -564,7 +564,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_UNKNOWN: default: { - printk(KERN_WARNING "unknown bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -609,7 +609,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_CAST_DOUBLE_TO_S64: case FILTER_OP_GET_CONTEXT_REF_DOUBLE: { - printk(KERN_WARNING "unsupported bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -666,13 +666,13 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_LE_STRING: { if (!vstack_ax(stack) || !vstack_bx(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_STRING || vstack_bx(stack)->type != REG_STRING) { - printk(KERN_WARNING "Unexpected register type for string comparator\n"); + printk(KERN_WARNING "LTTng: filter: Unexpected register type for string comparator\n"); ret = -EINVAL; goto end; } @@ -684,13 +684,13 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_NE_STAR_GLOB_STRING: { if (!vstack_ax(stack) || !vstack_bx(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_STAR_GLOB_STRING && vstack_bx(stack)->type != REG_STAR_GLOB_STRING) { - printk(KERN_WARNING "Unexpected register type for globbing pattern comparator\n"); + printk(KERN_WARNING "LTTng: filter: Unexpected register type for globbing pattern comparator\n"); ret = -EINVAL; goto end; } @@ -705,13 +705,13 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_LE_S64: { if (!vstack_ax(stack) || !vstack_bx(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_S64 || vstack_bx(stack)->type != REG_S64) { - printk(KERN_WARNING "Unexpected register type for s64 comparator\n"); + printk(KERN_WARNING "LTTng: filter: Unexpected register type for s64 comparator\n"); ret = -EINVAL; goto end; } @@ -750,20 +750,20 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_UNARY_NOT: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } switch (vstack_ax(stack)->type) { default: case REG_DOUBLE: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "Unary op can only be applied to numeric or floating point registers\n"); + printk(KERN_WARNING "LTTng: filter: Unary op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; case REG_S64: @@ -775,20 +775,20 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_UNARY_BIT_NOT: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } switch (vstack_ax(stack)->type) { default: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: case REG_DOUBLE: - printk(KERN_WARNING "Unary bitwise op can only be applied to numeric registers\n"); + printk(KERN_WARNING "LTTng: filter: Unary bitwise op can only be applied to numeric registers\n"); ret = -EINVAL; goto end; case REG_S64: @@ -804,12 +804,12 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, case FILTER_OP_UNARY_NOT_S64: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_S64) { - printk(KERN_WARNING "Invalid register type\n"); + printk(KERN_WARNING "LTTng: filter: Invalid register type\n"); ret = -EINVAL; goto end; } @@ -823,12 +823,12 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, struct logical_op *insn = (struct logical_op *) pc; if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_S64) { - printk(KERN_WARNING "Logical comparator expects S64 register\n"); + printk(KERN_WARNING "LTTng: filter: Logical comparator expects S64 register\n"); ret = -EINVAL; goto end; } @@ -836,7 +836,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, dbg_printk("Validate jumping to bytecode offset %u\n", (unsigned int) insn->skip_offset); if (unlikely(start_pc + insn->skip_offset <= pc)) { - printk(KERN_WARNING "Loops are not allowed in bytecode\n"); + printk(KERN_WARNING "LTTng: filter: Loops are not allowed in bytecode\n"); ret = -EINVAL; goto end; } @@ -846,7 +846,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, /* load field ref */ case FILTER_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); ret = -EINVAL; goto end; } @@ -889,20 +889,20 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, struct cast_op *insn = (struct cast_op *) pc; if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } switch (vstack_ax(stack)->type) { default: case REG_DOUBLE: - printk(KERN_WARNING "unknown register type\n"); + printk(KERN_WARNING "LTTng: filter: unknown register type\n"); ret = -EINVAL; goto end; case REG_STRING: case REG_STAR_GLOB_STRING: - printk(KERN_WARNING "Cast op can only be applied to numeric or floating point registers\n"); + printk(KERN_WARNING "LTTng: filter: Cast op can only be applied to numeric or floating point registers\n"); ret = -EINVAL; goto end; case REG_S64: @@ -910,7 +910,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, } if (insn->op == FILTER_OP_CAST_DOUBLE_TO_S64) { if (vstack_ax(stack)->type != REG_DOUBLE) { - printk(KERN_WARNING "Cast expects double\n"); + printk(KERN_WARNING "LTTng: filter: Cast expects double\n"); ret = -EINVAL; goto end; } @@ -925,7 +925,7 @@ int validate_instruction_context(struct bytecode_runtime *bytecode, /* get context ref */ case FILTER_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "Unknown get context ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n"); ret = -EINVAL; goto end; } @@ -1109,7 +1109,7 @@ int validate_instruction_all_contexts(struct bytecode_runtime *bytecode, dbg_printk("Filter: validate merge point at offset %lu\n", target_pc); if (merge_points_compare(stack, &mp_node->stack)) { - printk(KERN_WARNING "Merge points differ for offset %lu\n", + printk(KERN_WARNING "LTTng: filter: Merge points differ for offset %lu\n", target_pc); return -EINVAL; } @@ -1141,7 +1141,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case FILTER_OP_UNKNOWN: default: { - printk(KERN_WARNING "unknown bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unknown bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -1150,7 +1150,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case FILTER_OP_RETURN: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1159,7 +1159,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "Unexpected register type %d at end of bytecode\n", + printk(KERN_WARNING "LTTng: filter: Unexpected register type %d at end of bytecode\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1172,7 +1172,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case FILTER_OP_RETURN_S64: { if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1181,7 +1181,7 @@ int exec_insn(struct bytecode_runtime *bytecode, break; default: case REG_TYPE_UNKNOWN: - printk(KERN_WARNING "Unexpected register type %d at end of bytecode\n", + printk(KERN_WARNING "LTTng: filter: Unexpected register type %d at end of bytecode\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1224,7 +1224,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case FILTER_OP_LOAD_DOUBLE: case FILTER_OP_CAST_DOUBLE_TO_S64: { - printk(KERN_WARNING "unsupported bytecode op %u\n", + printk(KERN_WARNING "LTTng: filter: unsupported bytecode op %u\n", (unsigned int) *(filter_opcode_t *) pc); ret = -EINVAL; goto end; @@ -1262,7 +1262,7 @@ int exec_insn(struct bytecode_runtime *bytecode, goto end; } if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1274,7 +1274,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1291,7 +1291,7 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1300,7 +1300,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1317,7 +1317,7 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1325,7 +1325,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_S64: break; default: - printk(KERN_WARNING "Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1340,7 +1340,7 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1349,7 +1349,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1364,7 +1364,7 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1374,7 +1374,7 @@ int exec_insn(struct bytecode_runtime *bytecode, break; case REG_DOUBLE: default: - printk(KERN_WARNING "Unexpected register type %d for operation\n", + printk(KERN_WARNING "LTTng: filter: Unexpected register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1401,7 +1401,7 @@ int exec_insn(struct bytecode_runtime *bytecode, } if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } @@ -1410,7 +1410,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_S64: break; default: - printk(KERN_WARNING "Incorrect register type %d for operation\n", + printk(KERN_WARNING "LTTng: filter: Incorrect register type %d for operation\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1429,14 +1429,14 @@ int exec_insn(struct bytecode_runtime *bytecode, /* load field ref */ case FILTER_OP_LOAD_FIELD_REF: { - printk(KERN_WARNING "Unknown field ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown field ref type\n"); ret = -EINVAL; goto end; } /* get context ref */ case FILTER_OP_GET_CONTEXT_REF: { - printk(KERN_WARNING "Unknown get context ref type\n"); + printk(KERN_WARNING "LTTng: filter: Unknown get context ref type\n"); ret = -EINVAL; goto end; } @@ -1509,7 +1509,7 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n"); ret = -EINVAL; goto end; } @@ -1519,7 +1519,7 @@ int exec_insn(struct bytecode_runtime *bytecode, case REG_TYPE_UNKNOWN: break; default: - printk(KERN_WARNING "Incorrect register type %d for cast\n", + printk(KERN_WARNING "LTTng: filter: Incorrect register type %d for cast\n", (int) vstack_ax(stack)->type); ret = -EINVAL; goto end; @@ -1554,12 +1554,12 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1579,12 +1579,12 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1598,12 +1598,12 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1616,12 +1616,12 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1635,12 +1635,12 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1652,12 +1652,12 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1669,12 +1669,12 @@ int exec_insn(struct bytecode_runtime *bytecode, { /* Pop 1, push 1 */ if (!vstack_ax(stack)) { - printk(KERN_WARNING "Empty stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Empty stack\n\n"); ret = -EINVAL; goto end; } if (vstack_ax(stack)->type != REG_PTR) { - printk(KERN_WARNING "Expecting pointer on top of stack\n\n"); + printk(KERN_WARNING "LTTng: filter: Expecting pointer on top of stack\n\n"); ret = -EINVAL; goto end; } @@ -1702,7 +1702,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) mp_table = kzalloc(sizeof(*mp_table), GFP_KERNEL); if (!mp_table) { - printk(KERN_WARNING "Error allocating hash table for bytecode validation\n"); + printk(KERN_WARNING "LTTng: filter: Error allocating hash table for bytecode validation\n"); return -ENOMEM; } start_pc = &bytecode->code[0]; @@ -1711,7 +1711,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) ret = bytecode_validate_overflow(bytecode, start_pc, pc); if (ret != 0) { if (ret == -ERANGE) - printk(KERN_WARNING "filter bytecode overflow\n"); + printk(KERN_WARNING "LTTng: filter: filter bytecode overflow\n"); goto end; } dbg_printk("Validating op %s (%u)\n", @@ -1734,7 +1734,7 @@ int lttng_filter_validate_bytecode(struct bytecode_runtime *bytecode) end: if (delete_all_nodes(mp_table)) { if (!ret) { - printk(KERN_WARNING "Unexpected merge points\n"); + printk(KERN_WARNING "LTTng: filter: Unexpected merge points\n"); ret = -EINVAL; } } diff --git a/src/lttng-filter.c b/src/lttng-filter.c index 12c22644..85576821 100644 --- a/src/lttng-filter.c +++ b/src/lttng-filter.c @@ -374,7 +374,7 @@ int apply_reloc(struct lttng_event *event, */ return 0; default: - printk(KERN_WARNING "Unknown reloc op type %u\n", op->op); + printk(KERN_WARNING "LTTng: filter: Unknown reloc op type %u\n", op->op); return -EINVAL; } return 0; diff --git a/src/lttng-ring-buffer-client.h b/src/lttng-ring-buffer-client.h index aad7955f..fa0b8d47 100644 --- a/src/lttng-ring-buffer-client.h +++ b/src/lttng-ring-buffer-client.h @@ -566,7 +566,7 @@ struct channel *_channel_create(const char *name, * using lttng_relay_transport.ops. */ if (!try_module_get(THIS_MODULE)) { - printk(KERN_WARNING "LTT : Can't lock transport module.\n"); + printk(KERN_WARNING "LTTng: Can't lock transport module.\n"); goto error; } chan->backend.priv_ops = <tng_relay_transport.ops; diff --git a/src/lttng-ring-buffer-metadata-client.h b/src/lttng-ring-buffer-metadata-client.h index 0f68b385..12fcd914 100644 --- a/src/lttng-ring-buffer-metadata-client.h +++ b/src/lttng-ring-buffer-metadata-client.h @@ -254,7 +254,7 @@ struct channel *_channel_create(const char *name, * using lttng_relay_transport.ops. */ if (!try_module_get(THIS_MODULE)) { - printk(KERN_WARNING "LTT : Can't lock transport module.\n"); + printk(KERN_WARNING "LTTng: Can't lock transport module.\n"); goto error; } chan->backend.priv_ops = <tng_relay_transport.ops; diff --git a/src/lttng-tp-mempool.c b/src/lttng-tp-mempool.c index 70ee5cc6..ea406ced 100644 --- a/src/lttng-tp-mempool.c +++ b/src/lttng-tp-mempool.c @@ -96,7 +96,7 @@ void lttng_tp_mempool_destroy(void) i++; } if (i < LTTNG_TP_MEMPOOL_NR_BUF_PER_CPU) { - printk(KERN_WARNING "Leak detected in tp-mempool\n"); + printk(KERN_WARNING "LTTng: Leak detected in tp-mempool\n"); } } free_percpu(pool); diff --git a/src/lttng-tracepoint.c b/src/lttng-tracepoint.c index ed78a177..53828104 100644 --- a/src/lttng-tracepoint.c +++ b/src/lttng-tracepoint.c @@ -130,7 +130,7 @@ struct tracepoint_entry *add_tracepoint(const char *name) lttng_hlist_for_each_entry(e, head, hlist) { if (!strcmp(name, e->name)) { printk(KERN_NOTICE - "tracepoint %s busy\n", name); + "LTTng: tracepoint %s busy\n", name); return ERR_PTR(-EEXIST); /* Already there */ } } diff --git a/src/probes/lttng-uprobes.c b/src/probes/lttng-uprobes.c index c0f6e7c3..be6a50fc 100644 --- a/src/probes/lttng-uprobes.c +++ b/src/probes/lttng-uprobes.c @@ -128,7 +128,7 @@ static struct inode *get_inode_from_fd(int fd) */ file = fcheck(fd); if (file == NULL) { - printk(KERN_WARNING "Cannot access file backing the fd(%d)\n", fd); + printk(KERN_WARNING "LTTng: Cannot access file backing the fd(%d)\n", fd); inode = NULL; goto error; } @@ -136,7 +136,7 @@ static struct inode *get_inode_from_fd(int fd) /* Grab a reference on the inode. */ inode = igrab(file->f_path.dentry->d_inode); if (inode == NULL) - printk(KERN_WARNING "Cannot grab a reference on the inode.\n"); + printk(KERN_WARNING "LTTng: Cannot grab a reference on the inode.\n"); error: rcu_read_unlock(); return inode; @@ -155,7 +155,7 @@ int lttng_uprobes_add_callsite(struct lttng_event *event, uprobe_handler = kzalloc(sizeof(struct lttng_uprobe_handler), GFP_KERNEL); if (!uprobe_handler) { - printk(KERN_WARNING "Error allocating uprobe_uprobe_handlers"); + printk(KERN_WARNING "LTTng: Error allocating uprobe_handler"); ret = -ENOMEM; goto end; } @@ -174,7 +174,7 @@ int lttng_uprobes_add_callsite(struct lttng_event *event, ret = wrapper_uprobe_register(event->u.uprobe.inode, uprobe_handler->offset, &uprobe_handler->up_consumer); if (ret) { - printk(KERN_WARNING "Error registering probe on inode %lu " + printk(KERN_WARNING "LTTng: Error registering probe on inode %lu " "and offset 0x%llx\n", event->u.uprobe.inode->i_ino, uprobe_handler->offset); ret = -1; @@ -203,7 +203,7 @@ int lttng_uprobes_register(const char *name, int fd, struct lttng_event *event) inode = get_inode_from_fd(fd); if (!inode) { - printk(KERN_WARNING "Cannot get inode from fd\n"); + printk(KERN_WARNING "LTTng: Cannot get inode from fd\n"); ret = -EBADF; goto inode_error; } diff --git a/src/probes/lttng.c b/src/probes/lttng.c index 8a0dd4b8..ab233c1a 100644 --- a/src/probes/lttng.c +++ b/src/probes/lttng.c @@ -121,7 +121,7 @@ int __init lttng_logger_init(void) /* /dev/lttng-logger */ ret = misc_register(&logger_dev); if (ret) { - printk(KERN_ERR "Error creating LTTng logger device\n"); + printk(KERN_ERR "LTTng: Error creating logger device\n"); goto error; } @@ -130,7 +130,7 @@ int __init lttng_logger_init(void) S_IRUGO | S_IWUGO, NULL, <tng_logger_proc_ops, NULL); if (!lttng_logger_dentry) { - printk(KERN_ERR "Error creating LTTng logger proc file\n"); + printk(KERN_ERR "LTTng: Error creating logger proc file\n"); ret = -ENOMEM; goto error_proc; } diff --git a/src/wrapper/kallsyms.c b/src/wrapper/kallsyms.c index 6af77f53..e7c66394 100644 --- a/src/wrapper/kallsyms.c +++ b/src/wrapper/kallsyms.c @@ -61,7 +61,7 @@ unsigned long wrapper_kallsyms_lookup_name(const char *name) if (kallsyms_lookup_name_sym) return kallsyms_lookup_name_sym(name); else { - printk_once(KERN_WARNING "LTTng requires kallsyms_lookup_name\n"); + printk_once(KERN_WARNING "LTTng: requires kallsyms_lookup_name\n"); return 0; } }