X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fbin%2Flttng-sessiond%2Fust-app.c;h=50d2f1932657e56f7863e5b23fd3ef8b48cad87d;hp=6e2659c1e08f385b99ee4b55fdba5e26953e11b2;hb=a84d10248d99b14e8758011fbe82344b19b258b7;hpb=fc4b93fa8aa36b19caad0f8dc4a6a3237fcc36bf diff --git a/src/bin/lttng-sessiond/ust-app.c b/src/bin/lttng-sessiond/ust-app.c index 6e2659c1e..50d2f1932 100644 --- a/src/bin/lttng-sessiond/ust-app.c +++ b/src/bin/lttng-sessiond/ust-app.c @@ -26,8 +26,8 @@ #include #include #include -#include -#include +#include +#include #include #include @@ -1253,9 +1253,9 @@ static struct ust_app_event_notifier_rule *alloc_ust_app_event_notifier_rule( condition = lttng_trigger_get_condition(trigger); assert(condition); - assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_EVENT_RULE_HIT); + assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT); - assert(LTTNG_CONDITION_STATUS_OK == lttng_condition_event_rule_get_rule(condition, &event_rule)); + assert(LTTNG_CONDITION_STATUS_OK == lttng_condition_on_event_get_rule(condition, &event_rule)); assert(event_rule); /* Acquire the event notifier's reference to the trigger. */ @@ -1585,7 +1585,7 @@ error: static int set_ust_capture(struct ust_app *app, const struct lttng_bytecode *bytecode, unsigned int capture_seqnum, - struct lttng_ust_object_data *ust_object) + struct lttng_ust_abi_object_data *ust_object) { int ret; struct lttng_ust_abi_capture_bytecode *ust_bytecode = NULL; @@ -2000,7 +2000,6 @@ static int init_ust_event_notifier_from_event_rule( struct lttng_ust_abi_event_notifier *event_notifier) { enum lttng_event_rule_status status; - enum lttng_loglevel_type loglevel_type; enum lttng_ust_abi_loglevel_type ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL; int loglevel = -1, ret = 0; const char *pattern; @@ -2023,39 +2022,40 @@ static int init_ust_event_notifier_from_event_rule( loglevel = 0; ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL; } else { - status = lttng_event_rule_tracepoint_get_pattern( - rule, &pattern); - if (status != LTTNG_EVENT_RULE_STATUS_OK) { - /* At this point, this is a fatal error. */ - abort(); - } + const struct lttng_log_level_rule *log_level_rule; - status = lttng_event_rule_tracepoint_get_log_level_type( - rule, &loglevel_type); + status = lttng_event_rule_tracepoint_get_pattern(rule, &pattern); if (status != LTTNG_EVENT_RULE_STATUS_OK) { /* At this point, this is a fatal error. */ abort(); } - switch (loglevel_type) { - case LTTNG_EVENT_LOGLEVEL_ALL: + status = lttng_event_rule_tracepoint_get_log_level_rule( + rule, &log_level_rule); + if (status == LTTNG_EVENT_RULE_STATUS_UNSET) { ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_ALL; - break; - case LTTNG_EVENT_LOGLEVEL_RANGE: - ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_RANGE; - break; - case LTTNG_EVENT_LOGLEVEL_SINGLE: - ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_SINGLE; - break; - default: - /* Unknown log level specification type. */ - abort(); - } + } else if (status == LTTNG_EVENT_RULE_STATUS_OK) { + enum lttng_log_level_rule_status llr_status; + + switch (lttng_log_level_rule_get_type(log_level_rule)) { + case LTTNG_LOG_LEVEL_RULE_TYPE_EXACTLY: + ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_SINGLE; + llr_status = lttng_log_level_rule_exactly_get_level( + log_level_rule, &loglevel); + break; + case LTTNG_LOG_LEVEL_RULE_TYPE_AT_LEAST_AS_SEVERE_AS: + ust_loglevel_type = LTTNG_UST_ABI_LOGLEVEL_RANGE; + llr_status = lttng_log_level_rule_at_least_as_severe_as_get_level( + log_level_rule, &loglevel); + break; + default: + abort(); + } - if (loglevel_type != LTTNG_EVENT_LOGLEVEL_ALL) { - status = lttng_event_rule_tracepoint_get_log_level( - rule, &loglevel); - assert(status == LTTNG_EVENT_RULE_STATUS_OK); + assert(llr_status == LTTNG_LOG_LEVEL_RULE_STATUS_OK); + } else { + /* At this point this is a fatal error. */ + abort(); } } @@ -2095,10 +2095,12 @@ static int create_ust_event_notifier(struct ust_app *app, condition = lttng_trigger_get_const_condition( ua_event_notifier_rule->trigger); assert(condition); - assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_EVENT_RULE_HIT); + assert(lttng_condition_get_type(condition) == LTTNG_CONDITION_TYPE_ON_EVENT); - condition_status = lttng_condition_event_rule_get_rule(condition, &event_rule); + condition_status = lttng_condition_on_event_get_rule( + condition, &event_rule); assert(condition_status == LTTNG_CONDITION_STATUS_OK); + assert(event_rule); assert(lttng_event_rule_get_type(event_rule) == LTTNG_EVENT_RULE_TYPE_TRACEPOINT); @@ -2158,13 +2160,13 @@ static int create_ust_event_notifier(struct ust_app *app, } /* Set the capture bytecodes. */ - cond_status = lttng_condition_event_rule_get_capture_descriptor_count( + cond_status = lttng_condition_on_event_get_capture_descriptor_count( condition, &capture_bytecode_count); assert(cond_status == LTTNG_CONDITION_STATUS_OK); for (i = 0; i < capture_bytecode_count; i++) { const struct lttng_bytecode *capture_bytecode = - lttng_condition_event_rule_get_capture_bytecode_at_index( + lttng_condition_on_event_get_capture_bytecode_at_index( condition, i); ret = set_ust_capture(app, capture_bytecode, i, @@ -3011,12 +3013,12 @@ error: * * Return 0 on success or else a negative value. */ -static int duplicate_channel_object(struct buffer_reg_channel *reg_chan, +static int duplicate_channel_object(struct buffer_reg_channel *buf_reg_chan, struct ust_app_channel *ua_chan) { int ret; - assert(reg_chan); + assert(buf_reg_chan); assert(ua_chan); /* Need two fds for the channel. */ @@ -3027,10 +3029,10 @@ static int duplicate_channel_object(struct buffer_reg_channel *reg_chan, } /* Duplicate object for stream once the original is in the registry. */ - ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, reg_chan->obj.ust); + ret = ustctl_duplicate_ust_object_data(&ua_chan->obj, buf_reg_chan->obj.ust); if (ret < 0) { ERR("Duplicate channel obj from %p to %p failed with ret: %d", - reg_chan->obj.ust, ua_chan->obj, ret); + buf_reg_chan->obj.ust, ua_chan->obj, ret); goto error; } ua_chan->handle = ua_chan->obj->handle; @@ -3049,14 +3051,14 @@ error_fd_get: * * Return 0 on success or else a negative value. */ -static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan, +static int setup_buffer_reg_streams(struct buffer_reg_channel *buf_reg_chan, struct ust_app_channel *ua_chan, struct ust_app *app) { int ret = 0; struct ust_app_stream *stream, *stmp; - assert(reg_chan); + assert(buf_reg_chan); assert(ua_chan); DBG2("UST app setup buffer registry stream"); @@ -3076,7 +3078,7 @@ static int setup_buffer_reg_streams(struct buffer_reg_channel *reg_chan, */ reg_stream->obj.ust = stream->obj; stream->obj = NULL; - buffer_reg_stream_add(reg_stream, reg_chan); + buffer_reg_stream_add(reg_stream, buf_reg_chan); /* We don't need the streams anymore. */ cds_list_del(&stream->list); @@ -3099,7 +3101,7 @@ static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess, struct ust_app_channel *ua_chan, struct buffer_reg_channel **regp) { int ret; - struct buffer_reg_channel *reg_chan = NULL; + struct buffer_reg_channel *buf_reg_chan = NULL; assert(reg_sess); assert(ua_chan); @@ -3107,14 +3109,14 @@ static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess, DBG2("UST app creating buffer registry channel for %s", ua_chan->name); /* Create buffer registry channel. */ - ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, ®_chan); + ret = buffer_reg_channel_create(ua_chan->tracing_channel_id, &buf_reg_chan); if (ret < 0) { goto error_create; } - assert(reg_chan); - reg_chan->consumer_key = ua_chan->key; - reg_chan->subbuf_size = ua_chan->attr.subbuf_size; - reg_chan->num_subbuf = ua_chan->attr.num_subbuf; + assert(buf_reg_chan); + buf_reg_chan->consumer_key = ua_chan->key; + buf_reg_chan->subbuf_size = ua_chan->attr.subbuf_size; + buf_reg_chan->num_subbuf = ua_chan->attr.num_subbuf; /* Create and add a channel registry to session. */ ret = ust_registry_channel_add(reg_sess->reg.ust, @@ -3122,17 +3124,17 @@ static int create_buffer_reg_channel(struct buffer_reg_session *reg_sess, if (ret < 0) { goto error; } - buffer_reg_channel_add(reg_sess, reg_chan); + buffer_reg_channel_add(reg_sess, buf_reg_chan); if (regp) { - *regp = reg_chan; + *regp = buf_reg_chan; } return 0; error: /* Safe because the registry channel object was not added to any HT. */ - buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST); + buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST); error_create: return ret; } @@ -3144,32 +3146,32 @@ error_create: * Return 0 on success else a negative value. */ static int setup_buffer_reg_channel(struct buffer_reg_session *reg_sess, - struct ust_app_channel *ua_chan, struct buffer_reg_channel *reg_chan, + struct ust_app_channel *ua_chan, struct buffer_reg_channel *buf_reg_chan, struct ust_app *app) { int ret; assert(reg_sess); - assert(reg_chan); + assert(buf_reg_chan); assert(ua_chan); assert(ua_chan->obj); DBG2("UST app setup buffer registry channel for %s", ua_chan->name); /* Setup all streams for the registry. */ - ret = setup_buffer_reg_streams(reg_chan, ua_chan, app); + ret = setup_buffer_reg_streams(buf_reg_chan, ua_chan, app); if (ret < 0) { goto error; } - reg_chan->obj.ust = ua_chan->obj; + buf_reg_chan->obj.ust = ua_chan->obj; ua_chan->obj = NULL; return 0; error: - buffer_reg_channel_remove(reg_sess, reg_chan); - buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST); + buffer_reg_channel_remove(reg_sess, buf_reg_chan); + buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST); return ret; } @@ -3178,21 +3180,21 @@ error: * * Return 0 on success else a negative value. */ -static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan, +static int send_channel_uid_to_ust(struct buffer_reg_channel *buf_reg_chan, struct ust_app *app, struct ust_app_session *ua_sess, struct ust_app_channel *ua_chan) { int ret; struct buffer_reg_stream *reg_stream; - assert(reg_chan); + assert(buf_reg_chan); assert(app); assert(ua_sess); assert(ua_chan); DBG("UST app sending buffer registry channel to ust sock %d", app->sock); - ret = duplicate_channel_object(reg_chan, ua_chan); + ret = duplicate_channel_object(buf_reg_chan, ua_chan); if (ret < 0) { goto error; } @@ -3209,8 +3211,8 @@ static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan, health_code_update(); /* Send all streams to application. */ - pthread_mutex_lock(®_chan->stream_list_lock); - cds_list_for_each_entry(reg_stream, ®_chan->streams, lnode) { + pthread_mutex_lock(&buf_reg_chan->stream_list_lock); + cds_list_for_each_entry(reg_stream, &buf_reg_chan->streams, lnode) { struct ust_app_stream stream; ret = duplicate_stream_object(reg_stream, &stream); @@ -3236,7 +3238,7 @@ static int send_channel_uid_to_ust(struct buffer_reg_channel *reg_chan, ua_chan->is_sent = 1; error_stream_unlock: - pthread_mutex_unlock(®_chan->stream_list_lock); + pthread_mutex_unlock(&buf_reg_chan->stream_list_lock); error: return ret; } @@ -3255,10 +3257,10 @@ static int create_channel_per_uid(struct ust_app *app, { int ret; struct buffer_reg_uid *reg_uid; - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; struct ltt_session *session = NULL; enum lttng_error_code notification_ret; - struct ust_registry_channel *chan_reg; + struct ust_registry_channel *ust_reg_chan; assert(app); assert(usess); @@ -3275,14 +3277,14 @@ static int create_channel_per_uid(struct ust_app *app, */ assert(reg_uid); - reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id, + buf_reg_chan = buffer_reg_channel_find(ua_chan->tracing_channel_id, reg_uid); - if (reg_chan) { + if (buf_reg_chan) { goto send_channel; } /* Create the buffer registry channel object. */ - ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, ®_chan); + ret = create_buffer_reg_channel(reg_uid->registry, ua_chan, &buf_reg_chan); if (ret < 0) { ERR("Error creating the UST channel \"%s\" registry instance", ua_chan->name); @@ -3311,8 +3313,8 @@ static int create_channel_per_uid(struct ust_app *app, */ ust_registry_channel_del_free(reg_uid->registry->reg.ust, ua_chan->tracing_channel_id, false); - buffer_reg_channel_remove(reg_uid->registry, reg_chan); - buffer_reg_channel_destroy(reg_chan, LTTNG_DOMAIN_UST); + buffer_reg_channel_remove(reg_uid->registry, buf_reg_chan); + buffer_reg_channel_destroy(buf_reg_chan, LTTNG_DOMAIN_UST); goto error; } @@ -3320,7 +3322,7 @@ static int create_channel_per_uid(struct ust_app *app, * Setup the streams and add it to the session registry. */ ret = setup_buffer_reg_channel(reg_uid->registry, - ua_chan, reg_chan, app); + ua_chan, buf_reg_chan, app); if (ret < 0) { ERR("Error setting up UST channel \"%s\"", ua_chan->name); goto error; @@ -3328,11 +3330,11 @@ static int create_channel_per_uid(struct ust_app *app, /* Notify the notification subsystem of the channel's creation. */ pthread_mutex_lock(®_uid->registry->reg.ust->lock); - chan_reg = ust_registry_channel_find(reg_uid->registry->reg.ust, + ust_reg_chan = ust_registry_channel_find(reg_uid->registry->reg.ust, ua_chan->tracing_channel_id); - assert(chan_reg); - chan_reg->consumer_key = ua_chan->key; - chan_reg = NULL; + assert(ust_reg_chan); + ust_reg_chan->consumer_key = ua_chan->key; + ust_reg_chan = NULL; pthread_mutex_unlock(®_uid->registry->reg.ust->lock); notification_ret = notification_thread_command_add_channel( @@ -3350,7 +3352,7 @@ static int create_channel_per_uid(struct ust_app *app, send_channel: /* Send buffers to the application. */ - ret = send_channel_uid_to_ust(reg_chan, app, ua_sess, ua_chan); + ret = send_channel_uid_to_ust(buf_reg_chan, app, ua_sess, ua_chan); if (ret < 0) { if (ret != -ENOTCONN) { ERR("Error sending channel to application"); @@ -3382,7 +3384,7 @@ static int create_channel_per_pid(struct ust_app *app, enum lttng_error_code cmd_ret; struct ltt_session *session = NULL; uint64_t chan_reg_key; - struct ust_registry_channel *chan_reg; + struct ust_registry_channel *ust_reg_chan; assert(app); assert(usess); @@ -3431,9 +3433,9 @@ static int create_channel_per_pid(struct ust_app *app, chan_reg_key = ua_chan->key; pthread_mutex_lock(®istry->lock); - chan_reg = ust_registry_channel_find(registry, chan_reg_key); - assert(chan_reg); - chan_reg->consumer_key = ua_chan->key; + ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key); + assert(ust_reg_chan); + ust_reg_chan->consumer_key = ua_chan->key; pthread_mutex_unlock(®istry->lock); cmd_ret = notification_thread_command_add_channel( @@ -5190,7 +5192,7 @@ int ust_app_flush_session(struct ltt_ust_session *usess) /* Flush all per UID buffers associated to that session. */ cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) { struct ust_registry_session *ust_session_reg; - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; struct consumer_socket *socket; /* Get consumer socket to use to push the metadata.*/ @@ -5202,13 +5204,13 @@ int ust_app_flush_session(struct ltt_ust_session *usess) } cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter, - reg_chan, node.node) { + buf_reg_chan, node.node) { /* * The following call will print error values so the return * code is of little importance because whatever happens, we * have to try them all. */ - (void) consumer_flush_channel(socket, reg_chan->consumer_key); + (void) consumer_flush_channel(socket, buf_reg_chan->consumer_key); } ust_session_reg = reg->registry->reg.ust; @@ -5337,7 +5339,7 @@ int ust_app_clear_quiescent_session(struct ltt_ust_session *usess) */ cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) { struct consumer_socket *socket; - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; /* Get associated consumer socket.*/ socket = consumer_find_socket_by_bitness( @@ -5351,7 +5353,7 @@ int ust_app_clear_quiescent_session(struct ltt_ust_session *usess) } cds_lfht_for_each_entry(reg->registry->channels->ht, - &iter.iter, reg_chan, node.node) { + &iter.iter, buf_reg_chan, node.node) { /* * The following call will print error values so * the return code is of little importance @@ -5359,7 +5361,7 @@ int ust_app_clear_quiescent_session(struct ltt_ust_session *usess) * all. */ (void) consumer_clear_quiescent_channel(socket, - reg_chan->consumer_key); + buf_reg_chan->consumer_key); } } break; @@ -5648,12 +5650,12 @@ void ust_app_synchronize_event_notifier_rules(struct ust_app *app) token = lttng_trigger_get_tracer_token(trigger); condition = lttng_trigger_get_condition(trigger); - if (lttng_condition_get_type(condition) != LTTNG_CONDITION_TYPE_EVENT_RULE_HIT) { + if (lttng_condition_get_type(condition) != LTTNG_CONDITION_TYPE_ON_EVENT) { /* Does not apply */ continue; } - condition_status = lttng_condition_event_rule_borrow_rule_mutable(condition, &event_rule); + condition_status = lttng_condition_on_event_borrow_rule_mutable(condition, &event_rule); assert(condition_status == LTTNG_CONDITION_STATUS_OK); if (lttng_event_rule_get_domain_type(event_rule) == LTTNG_DOMAIN_KERNEL) { @@ -5733,38 +5735,20 @@ end: } /* - * The caller must ensure that the application is compatible and is tracked - * by the process attribute trackers. + * RCU read lock must be held by the caller. */ static -void ust_app_synchronize(struct ltt_ust_session *usess, +void ust_app_synchronize_all_channels(struct ltt_ust_session *usess, + struct ust_app_session *ua_sess, struct ust_app *app) { int ret = 0; struct cds_lfht_iter uchan_iter; struct ltt_ust_channel *uchan; - struct ust_app_session *ua_sess = NULL; - /* - * The application's configuration should only be synchronized for - * active sessions. - */ - assert(usess->active); - - ret = find_or_create_ust_app_session(usess, app, &ua_sess, NULL); - if (ret < 0) { - /* Tracer is probably gone or ENOMEM. */ - goto error; - } + assert(usess); assert(ua_sess); - - pthread_mutex_lock(&ua_sess->lock); - if (ua_sess->deleted) { - pthread_mutex_unlock(&ua_sess->lock); - goto end; - } - - rcu_read_lock(); + assert(app); cds_lfht_for_each_entry(usess->domain_global.channels->ht, &uchan_iter, uchan, node.node) { @@ -5783,7 +5767,7 @@ void ust_app_synchronize(struct ltt_ust_session *usess, app, uchan, &ua_chan); if (ret) { /* Tracer is probably gone or ENOMEM. */ - goto error_unlock; + goto end; } if (!ua_chan) { @@ -5796,7 +5780,7 @@ void ust_app_synchronize(struct ltt_ust_session *usess, ret = ust_app_channel_synchronize_event(ua_chan, uevent, ua_sess, app); if (ret) { - goto error_unlock; + goto end; } } @@ -5805,10 +5789,47 @@ void ust_app_synchronize(struct ltt_ust_session *usess, enable_ust_app_channel(ua_sess, uchan, app) : disable_ust_app_channel(ua_sess, ua_chan, app); if (ret) { - goto error_unlock; + goto end; } } } +end: + return; +} + +/* + * The caller must ensure that the application is compatible and is tracked + * by the process attribute trackers. + */ +static +void ust_app_synchronize(struct ltt_ust_session *usess, + struct ust_app *app) +{ + int ret = 0; + struct ust_app_session *ua_sess = NULL; + + /* + * The application's configuration should only be synchronized for + * active sessions. + */ + assert(usess->active); + + ret = find_or_create_ust_app_session(usess, app, &ua_sess, NULL); + if (ret < 0) { + /* Tracer is probably gone or ENOMEM. */ + goto error; + } + assert(ua_sess); + + pthread_mutex_lock(&ua_sess->lock); + if (ua_sess->deleted) { + pthread_mutex_unlock(&ua_sess->lock); + goto end; + } + + rcu_read_lock(); + + ust_app_synchronize_all_channels(usess, ua_sess, app); /* * Create the metadata for the application. This returns gracefully if a @@ -6119,7 +6140,7 @@ static int reply_ust_register_channel(int sock, int cobjd, struct ust_app_channel *ua_chan; struct ust_app_session *ua_sess; struct ust_registry_session *registry; - struct ust_registry_channel *chan_reg; + struct ust_registry_channel *ust_reg_chan; rcu_read_lock(); @@ -6160,30 +6181,30 @@ static int reply_ust_register_channel(int sock, int cobjd, pthread_mutex_lock(®istry->lock); - chan_reg = ust_registry_channel_find(registry, chan_reg_key); - assert(chan_reg); + ust_reg_chan = ust_registry_channel_find(registry, chan_reg_key); + assert(ust_reg_chan); - if (!chan_reg->register_done) { + if (!ust_reg_chan->register_done) { /* * TODO: eventually use the registry event count for * this channel to better guess header type for per-pid * buffers. */ type = USTCTL_CHANNEL_HEADER_LARGE; - chan_reg->nr_ctx_fields = nr_fields; - chan_reg->ctx_fields = fields; + ust_reg_chan->nr_ctx_fields = nr_fields; + ust_reg_chan->ctx_fields = fields; fields = NULL; - chan_reg->header_type = type; + ust_reg_chan->header_type = type; } else { /* Get current already assigned values. */ - type = chan_reg->header_type; + type = ust_reg_chan->header_type; } /* Channel id is set during the object creation. */ - chan_id = chan_reg->chan_id; + chan_id = ust_reg_chan->chan_id; /* Append to metadata */ - if (!chan_reg->metadata_dumped) { - ret_code = ust_metadata_channel_statedump(registry, chan_reg); + if (!ust_reg_chan->metadata_dumped) { + ret_code = ust_metadata_channel_statedump(registry, ust_reg_chan); if (ret_code) { ERR("Error appending channel metadata (errno = %d)", ret_code); goto reply; @@ -6206,7 +6227,7 @@ reply: } /* This channel registry registration is completed. */ - chan_reg->register_done = 1; + ust_reg_chan->register_done = 1; error: pthread_mutex_unlock(®istry->lock); @@ -6648,7 +6669,7 @@ enum lttng_error_code ust_app_snapshot_record( struct buffer_reg_uid *reg; cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) { - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; struct consumer_socket *socket; char pathname[PATH_MAX]; size_t consumer_path_offset = 0; @@ -6685,9 +6706,9 @@ enum lttng_error_code ust_app_snapshot_record( } /* Add the UST default trace dir to path. */ cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter, - reg_chan, node.node) { + buf_reg_chan, node.node) { status = consumer_snapshot_channel(socket, - reg_chan->consumer_key, + buf_reg_chan->consumer_key, output, 0, usess->uid, usess->gid, &trace_path[consumer_path_offset], wait, nb_packets_per_stream); @@ -6815,19 +6836,19 @@ uint64_t ust_app_get_size_one_more_packet_per_stream( struct buffer_reg_uid *reg; cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) { - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; rcu_read_lock(); cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter, - reg_chan, node.node) { - if (cur_nr_packets >= reg_chan->num_subbuf) { + buf_reg_chan, node.node) { + if (cur_nr_packets >= buf_reg_chan->num_subbuf) { /* * Don't take channel into account if we * already grab all its packets. */ continue; } - tot_size += reg_chan->subbuf_size * reg_chan->stream_count; + tot_size += buf_reg_chan->subbuf_size * buf_reg_chan->stream_count; } rcu_read_unlock(); } @@ -7051,7 +7072,7 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session) struct buffer_reg_uid *reg; cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) { - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; struct consumer_socket *socket; if (!reg->registry->reg.ust->metadata_key) { @@ -7069,9 +7090,9 @@ enum lttng_error_code ust_app_rotate_session(struct ltt_session *session) /* Rotate the data channels. */ cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter, - reg_chan, node.node) { + buf_reg_chan, node.node) { ret = consumer_rotate_channel(socket, - reg_chan->consumer_key, + buf_reg_chan->consumer_key, usess->uid, usess->gid, usess->consumer, /* is_metadata_channel */ false); @@ -7308,7 +7329,7 @@ enum lttng_error_code ust_app_clear_session(struct ltt_session *session) struct buffer_reg_uid *reg; cds_list_for_each_entry(reg, &usess->buffer_reg_uid_list, lnode) { - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; struct consumer_socket *socket; /* Get consumer socket to use to push the metadata.*/ @@ -7321,9 +7342,9 @@ enum lttng_error_code ust_app_clear_session(struct ltt_session *session) /* Clear the data channels. */ cds_lfht_for_each_entry(reg->registry->channels->ht, &iter.iter, - reg_chan, node.node) { + buf_reg_chan, node.node) { ret = consumer_clear_channel(socket, - reg_chan->consumer_key); + buf_reg_chan->consumer_key); if (ret < 0) { goto error; } @@ -7460,7 +7481,7 @@ enum lttng_error_code ust_app_open_packets(struct ltt_session *session) cds_list_for_each_entry ( reg, &usess->buffer_reg_uid_list, lnode) { - struct buffer_reg_channel *reg_chan; + struct buffer_reg_channel *buf_reg_chan; struct consumer_socket *socket; socket = consumer_find_socket_by_bitness( @@ -7471,11 +7492,11 @@ enum lttng_error_code ust_app_open_packets(struct ltt_session *session) } cds_lfht_for_each_entry(reg->registry->channels->ht, - &iter.iter, reg_chan, node.node) { + &iter.iter, buf_reg_chan, node.node) { const int open_ret = consumer_open_channel_packets( socket, - reg_chan->consumer_key); + buf_reg_chan->consumer_key); if (open_ret < 0) { ret = LTTNG_ERR_UNK;