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 <mjeanson@efficios.com>
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>

diff --git a/include/lttng/filter.h b/include/lttng/filter.h
index eb70fe365fcd0758e0e26ec4fad37106f48d22a1..e999a0572f2797bcda2eb59a2ef18f6e0cadf085 100644 (file)
--- 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 8c59f4e1537b606f3cbbee50064d24d68d809a2c..bbc900d1ad677fce4ecf360c577703f1f822a3c5 100644 (file)
--- 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 d6547d7de9c9cef6f45a6fb426c864a1b8ee3347..1625804f8b5ef845060c82221e293c9ed3a714d0 100644 (file)
--- 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 fca37fbc3a5b143a08cb55b94f762bf664fb7187..d3dfcb1b1e4d9cfbf283bd47548118462014f71c 100644 (file)
--- 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 15d7c75c15862b8ec4f47771dd98dc1eb8291c30..64fc50861b062ba8ba988a7a51f013a407154ccb 100644 (file)
--- 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 6061cce1e380f2cf682e1a5656778b8d3e35a7d5..7b7e3d65156bb16813cf7012f5eb2e50c9679795 100644 (file)
--- a/src/lib/ringbuffer/ring_buffer_splice.c
+++ b/src/lib/ringbuffer/ring_buffer_splice.c
@@ -19,10 +19,15 @@
 #include <ringbuffer/frontend.h>
 #include <ringbuffer/vfs.h>
 
-#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 4dd6e7e5e2fff77290f493664b543e66471b0a96..198987bd5a74f25775ef0e269699a11182b6bdc0 100644 (file)
--- 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)
                                        &lttng_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 7512a3f4be074000b78bad96d973a76a4069f0b2..2e623be3b7f817f3233dc47912cb027e2aacfe6f 100644 (file)
--- 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 4b948ef8001277b53346d651ee08efc0497f8ef8..311dd6e1cd2d40898d85d277e494123e92b358d1 100644 (file)
--- 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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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(&lttng_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 62f8e054043ef7c668ab3ed5e253c739d7871d0f..631dfcb6689e0ef2bb346da8dd4a42a5681605dd 100644 (file)
--- 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 6c1c2f279e021391589cf28e1ae41976bc21cb80..b38bc126ef1eb4e368b11c0a067b961eed8edddf 100644 (file)
--- 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 ccc458351e65e145d810797a2da4c0f3e18b29a3..1d7f29a4c7ca15bcce9142185db53b52deb6b019 100644 (file)
--- 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 38d6ed07bb531da45e1ca83ca9c1373acb71837f..f117eadf25a30977358ce1eb181ee195dd9ba222 100644 (file)
--- 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 12c22644f26989f942c6f20f9527ade9c3a3a0a9..855768217057185b1dca778ec424f3a870f5ec3e 100644 (file)
--- 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 aad7955f8accfcdea845b14858b431adab3cf69c..fa0b8d4709d2e4122edd654c77770d4ed3d64bdb 100644 (file)
--- 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 = &lttng_relay_transport.ops;

diff --git a/src/lttng-ring-buffer-metadata-client.h b/src/lttng-ring-buffer-metadata-client.h
index 0f68b38538779c2abe404cb59eca9394fead5358..12fcd914969d12d781a8396334d2ff6352d499fc 100644 (file)
--- 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 = &lttng_relay_transport.ops;

diff --git a/src/lttng-tp-mempool.c b/src/lttng-tp-mempool.c
index 70ee5cc6b9d7cfef42e3a8b91b480f8097e28c01..ea406ced9d4c34b27e15946bfb73b6ef899da93a 100644 (file)
--- 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 ed78a1770e16c13de50f51b620ca589deece0bc5..53828104113efbaae5cbfb4754531df5c405368f 100644 (file)
--- 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 c0f6e7c31c2a81c749735de4094637a75294b757..be6a50fc0125d5ef51613f0a7c647d72d6932c71 100644 (file)
--- 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 8a0dd4b8acdcefe06015d37d2599bb01ef7b907b..ab233c1a4452184f410f86acd285f90f7692da0b 100644 (file)
--- 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,
                                &lttng_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 6af77f538950d7b3718bd33fffb749053ae03333..e7c6639432ee9ebf84b51644cc22f01f0dcbb960 100644 (file)
--- 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;
        }
 }