X-Git-Url: http://git.liburcu.org/?p=lttng-modules.git;a=blobdiff_plain;f=lttng-context.c;h=869496d8ce0f222925afd2b4535ba15b2168ec87;hp=a28a9d2370ae39e3bbd569d2de416f6924e0678c;hb=6bb4326c067161532e0e6f3a0deec2d28b4595e8;hpb=a90917c3f8c4ed79117f1caa333b29a2108084ec diff --git a/lttng-context.c b/lttng-context.c index a28a9d23..869496d8 100644 --- a/lttng-context.c +++ b/lttng-context.c @@ -1,20 +1,29 @@ -/* - * lttng-context.c +/* SPDX-License-Identifier: (GPL-2.0 or LGPL-2.1) * - * Copyright 2011 (c) - Mathieu Desnoyers + * lttng-context.c * * LTTng trace/channel/event context management. * - * Dual LGPL v2.1/GPL v2 license. + * Copyright (C) 2011-2012 Mathieu Desnoyers */ #include #include #include #include -#include "wrapper/vmalloc.h" /* for wrapper_vmalloc_sync_all() */ -#include "lttng-events.h" -#include "lttng-tracer.h" +#include /* for wrapper_vmalloc_sync_all() */ +#include +#include + +/* + * The filter implementation requires that two consecutive "get" for the + * same context performed by the same thread return the same result. + */ + +/* + * Static array of contexts, for $ctx filters. + */ +struct lttng_ctx *lttng_static_ctx; int lttng_find_context(struct lttng_ctx *ctx, const char *name) { @@ -31,6 +40,29 @@ int lttng_find_context(struct lttng_ctx *ctx, const char *name) } EXPORT_SYMBOL_GPL(lttng_find_context); +int lttng_get_context_index(struct lttng_ctx *ctx, const char *name) +{ + unsigned int i; + const char *subname; + + if (!ctx) + return -1; + if (strncmp(name, "$ctx.", strlen("$ctx.")) == 0) { + subname = name + strlen("$ctx."); + } else { + subname = name; + } + for (i = 0; i < ctx->nr_fields; i++) { + /* Skip allocated (but non-initialized) contexts */ + if (!ctx->fields[i].event_field.name) + continue; + if (!strcmp(ctx->fields[i].event_field.name, subname)) + return i; + } + return -1; +} +EXPORT_SYMBOL_GPL(lttng_get_context_index); + /* * Note: as we append context information, the pointer location may change. */ @@ -43,18 +75,19 @@ struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx_p) *ctx_p = kzalloc(sizeof(struct lttng_ctx), GFP_KERNEL); if (!*ctx_p) return NULL; + (*ctx_p)->largest_align = 1; } ctx = *ctx_p; if (ctx->nr_fields + 1 > ctx->allocated_fields) { struct lttng_ctx_field *new_fields; ctx->allocated_fields = max_t(size_t, 1, 2 * ctx->allocated_fields); - new_fields = kzalloc(ctx->allocated_fields * sizeof(struct lttng_ctx_field), GFP_KERNEL); + new_fields = lttng_kvzalloc(ctx->allocated_fields * sizeof(struct lttng_ctx_field), GFP_KERNEL); if (!new_fields) return NULL; if (ctx->fields) memcpy(new_fields, ctx->fields, sizeof(*ctx->fields) * ctx->nr_fields); - kfree(ctx->fields); + lttng_kvfree(ctx->fields); ctx->fields = new_fields; } field = &ctx->fields[ctx->nr_fields]; @@ -63,6 +96,120 @@ struct lttng_ctx_field *lttng_append_context(struct lttng_ctx **ctx_p) } EXPORT_SYMBOL_GPL(lttng_append_context); +/* + * lttng_context_update() should be called at least once between context + * modification and trace start. + */ +void lttng_context_update(struct lttng_ctx *ctx) +{ + int i; + size_t largest_align = 8; /* in bits */ + + for (i = 0; i < ctx->nr_fields; i++) { + struct lttng_type *type; + size_t field_align = 8; + + type = &ctx->fields[i].event_field.type; + switch (type->atype) { + case atype_integer: + field_align = type->u.basic.integer.alignment; + break; + case atype_array: + case atype_array_bitfield: + { + struct lttng_basic_type *btype; + + btype = &type->u.array.elem_type; + switch (btype->atype) { + case atype_integer: + field_align = btype->u.basic.integer.alignment; + break; + case atype_string: + break; + + case atype_array: + case atype_sequence: + case atype_array_bitfield: + case atype_sequence_bitfield: + case atype_struct: + case atype_array_compound: + case atype_sequence_compound: + case atype_variant: + default: + WARN_ON_ONCE(1); + break; + } + break; + } + case atype_sequence: + case atype_sequence_bitfield: + { + struct lttng_basic_type *btype; + + btype = &type->u.sequence.length_type; + switch (btype->atype) { + case atype_integer: + field_align = btype->u.basic.integer.alignment; + break; + + case atype_string: + case atype_array: + case atype_sequence: + case atype_array_bitfield: + case atype_sequence_bitfield: + case atype_struct: + case atype_array_compound: + case atype_sequence_compound: + case atype_variant: + default: + WARN_ON_ONCE(1); + break; + } + + btype = &type->u.sequence.elem_type; + switch (btype->atype) { + case atype_integer: + field_align = max_t(size_t, + field_align, + btype->u.basic.integer.alignment); + break; + + case atype_string: + break; + + case atype_array: + case atype_sequence: + case atype_array_bitfield: + case atype_sequence_bitfield: + case atype_struct: + case atype_array_compound: + case atype_sequence_compound: + case atype_variant: + default: + WARN_ON_ONCE(1); + break; + } + break; + } + case atype_string: + break; + + case atype_struct: + case atype_array_compound: + case atype_sequence_compound: + case atype_variant: + break; + + case atype_enum: + default: + WARN_ON_ONCE(1); + break; + } + largest_align = max_t(size_t, largest_align, field_align); + } + ctx->largest_align = largest_align >> 3; /* bits to bytes */ +} + /* * Remove last context field. */ @@ -88,6 +235,80 @@ void lttng_destroy_context(struct lttng_ctx *ctx) if (ctx->fields[i].destroy) ctx->fields[i].destroy(&ctx->fields[i]); } - kfree(ctx->fields); + lttng_kvfree(ctx->fields); kfree(ctx); } + +int lttng_context_init(void) +{ + int ret; + + ret = lttng_add_hostname_to_ctx(<tng_static_ctx); + if (ret) { + printk(KERN_WARNING "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"); + } + ret = lttng_add_pid_to_ctx(<tng_static_ctx); + if (ret) { + printk(KERN_WARNING "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"); + } + ret = lttng_add_prio_to_ctx(<tng_static_ctx); + if (ret) { + printk(KERN_WARNING "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"); + } + ret = lttng_add_tid_to_ctx(<tng_static_ctx); + if (ret) { + printk(KERN_WARNING "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"); + } + ret = lttng_add_vtid_to_ctx(<tng_static_ctx); + if (ret) { + printk(KERN_WARNING "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"); + } + ret = lttng_add_cpu_id_to_ctx(<tng_static_ctx); + if (ret) { + printk(KERN_WARNING "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"); + } + ret = lttng_add_need_reschedule_to_ctx(<tng_static_ctx); + if (ret) { + printk(KERN_WARNING "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"); + } + ret = lttng_add_migratable_to_ctx(<tng_static_ctx); + if (ret && ret != -ENOSYS) { + printk(KERN_WARNING "Cannot add context lttng_add_migratable_to_ctx"); + } + /* TODO: perf counters for filtering */ + return 0; +} + +void lttng_context_exit(void) +{ + lttng_destroy_context(lttng_static_ctx); + lttng_static_ctx = NULL; +}