X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Ftrace-chunk.cpp;fp=src%2Fcommon%2Ftrace-chunk.cpp;h=8267af0ec8ba473cb27b83874c4aa0cda691608d;hp=488d0814620f32e4351913231d7596abff0fbdae;hb=28ab034a2c3582d07d3423d2d746731f87d3969f;hpb=52e345b9ac912d033c2a2c25a170a01cf209839d diff --git a/src/common/trace-chunk.cpp b/src/common/trace-chunk.cpp index 488d08146..8267af0ec 100644 --- a/src/common/trace-chunk.cpp +++ b/src/common/trace-chunk.cpp @@ -12,8 +12,8 @@ #include #include #include -#include #include +#include #include #include #include @@ -22,6 +22,7 @@ #include #include #include + #include #include @@ -36,7 +37,7 @@ * index, i.e. --. */ #define GENERATED_CHUNK_NAME_LEN (2 * sizeof("YYYYmmddTHHMMSS+HHMM") + MAX_INT_DEC_LEN(uint64_t)) -#define DIR_CREATION_MODE (S_IRWXU | S_IRWXG) +#define DIR_CREATION_MODE (S_IRWXU | S_IRWXG) enum trace_chunk_mode { TRACE_CHUNK_MODE_USER, @@ -52,17 +53,13 @@ enum trace_chunk_mode { typedef int (*chunk_command)(struct lttng_trace_chunk *trace_chunk); /* Move a completed trace chunk to the 'completed' trace archive folder. */ -static -int lttng_trace_chunk_move_to_completed_post_release(struct lttng_trace_chunk *trace_chunk); +static int lttng_trace_chunk_move_to_completed_post_release(struct lttng_trace_chunk *trace_chunk); /* Empty callback. */ -static -int lttng_trace_chunk_no_operation(struct lttng_trace_chunk *trace_chunk); +static int lttng_trace_chunk_no_operation(struct lttng_trace_chunk *trace_chunk); /* Unlink old chunk files. */ -static -int lttng_trace_chunk_delete_post_release(struct lttng_trace_chunk *trace_chunk); -static -enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( - struct lttng_trace_chunk *chunk, const char *path); +static int lttng_trace_chunk_delete_post_release(struct lttng_trace_chunk *trace_chunk); +static enum lttng_trace_chunk_status +lttng_trace_chunk_rename_path_no_lock(struct lttng_trace_chunk *chunk, const char *path); namespace { struct chunk_credentials { @@ -150,18 +147,13 @@ struct fs_handle_untracked { }; } /* namespace */ -static -int fs_handle_untracked_get_fd(struct fs_handle *handle); -static -void fs_handle_untracked_put_fd(struct fs_handle *handle); -static -int fs_handle_untracked_unlink(struct fs_handle *handle); -static -int fs_handle_untracked_close(struct fs_handle *handle); - -static -const char *lttng_trace_chunk_command_type_str( - lttng_trace_chunk_command_type type) { +static int fs_handle_untracked_get_fd(struct fs_handle *handle); +static void fs_handle_untracked_put_fd(struct fs_handle *handle); +static int fs_handle_untracked_unlink(struct fs_handle *handle); +static int fs_handle_untracked_close(struct fs_handle *handle); + +static const char *lttng_trace_chunk_command_type_str(lttng_trace_chunk_command_type type) +{ switch (type) { case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED: return "move to completed chunk folder"; @@ -176,9 +168,8 @@ const char *lttng_trace_chunk_command_type_str( abort(); }; -static -chunk_command close_command_get_post_release_func( - lttng_trace_chunk_command_type type) { +static chunk_command close_command_get_post_release_func(lttng_trace_chunk_command_type type) +{ switch (type) { case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED: return lttng_trace_chunk_move_to_completed_post_release; @@ -193,11 +184,9 @@ chunk_command close_command_get_post_release_func( abort(); }; -static -struct fs_handle *fs_handle_untracked_create( - struct lttng_directory_handle *directory_handle, - const char *path, - int fd) +static struct fs_handle *fs_handle_untracked_create(struct lttng_directory_handle *directory_handle, + const char *path, + int fd) { struct fs_handle_untracked *handle = NULL; bool reference_acquired; @@ -215,7 +204,7 @@ struct fs_handle *fs_handle_untracked_create( goto end; } - handle->parent = (typeof(handle->parent)) { + handle->parent = (typeof(handle->parent)){ .get_fd = fs_handle_untracked_get_fd, .put_fd = fs_handle_untracked_put_fd, .unlink = fs_handle_untracked_unlink, @@ -234,55 +223,48 @@ end: return handle ? &handle->parent : NULL; } -static -int fs_handle_untracked_get_fd(struct fs_handle *_handle) +static int fs_handle_untracked_get_fd(struct fs_handle *_handle) { - struct fs_handle_untracked *handle = lttng::utils::container_of( - _handle, &fs_handle_untracked::parent); + struct fs_handle_untracked *handle = + lttng::utils::container_of(_handle, &fs_handle_untracked::parent); return handle->fd; } -static -void fs_handle_untracked_put_fd(struct fs_handle *_handle __attribute__((unused))) +static void fs_handle_untracked_put_fd(struct fs_handle *_handle __attribute__((unused))) { /* no-op. */ } -static -int fs_handle_untracked_unlink(struct fs_handle *_handle) +static int fs_handle_untracked_unlink(struct fs_handle *_handle) { - struct fs_handle_untracked *handle = lttng::utils::container_of( - _handle, &fs_handle_untracked::parent); + struct fs_handle_untracked *handle = + lttng::utils::container_of(_handle, &fs_handle_untracked::parent); - return lttng_directory_handle_unlink_file( - handle->location.directory_handle, - handle->location.path); + return lttng_directory_handle_unlink_file(handle->location.directory_handle, + handle->location.path); } -static -void fs_handle_untracked_destroy(struct fs_handle_untracked *handle) +static void fs_handle_untracked_destroy(struct fs_handle_untracked *handle) { lttng_directory_handle_put(handle->location.directory_handle); free(handle->location.path); free(handle); } -static -int fs_handle_untracked_close(struct fs_handle *_handle) +static int fs_handle_untracked_close(struct fs_handle *_handle) { - struct fs_handle_untracked *handle = lttng::utils::container_of( - _handle, &fs_handle_untracked::parent); + struct fs_handle_untracked *handle = + lttng::utils::container_of(_handle, &fs_handle_untracked::parent); int ret = close(handle->fd); fs_handle_untracked_destroy(handle); return ret; } -static -bool lttng_trace_chunk_registry_element_equals( - const struct lttng_trace_chunk_registry_element *a, - const struct lttng_trace_chunk_registry_element *b) +static bool +lttng_trace_chunk_registry_element_equals(const struct lttng_trace_chunk_registry_element *a, + const struct lttng_trace_chunk_registry_element *b) { if (a->session_id != b->session_id) { goto not_equal; @@ -298,24 +280,19 @@ not_equal: return false; } -static -int lttng_trace_chunk_registry_element_match(struct cds_lfht_node *node, - const void *key) +static int lttng_trace_chunk_registry_element_match(struct cds_lfht_node *node, const void *key) { const struct lttng_trace_chunk_registry_element *element_a, *element_b; element_a = (const struct lttng_trace_chunk_registry_element *) key; - element_b = caa_container_of(node, typeof(*element_b), - trace_chunk_registry_ht_node); + element_b = caa_container_of(node, typeof(*element_b), trace_chunk_registry_ht_node); return lttng_trace_chunk_registry_element_equals(element_a, element_b); } -static -unsigned long lttng_trace_chunk_registry_element_hash( - const struct lttng_trace_chunk_registry_element *element) +static unsigned long +lttng_trace_chunk_registry_element_hash(const struct lttng_trace_chunk_registry_element *element) { - unsigned long hash = hash_key_u64(&element->session_id, - lttng_ht_seed); + unsigned long hash = hash_key_u64(&element->session_id, lttng_ht_seed); if (element->chunk.id.is_set) { hash ^= hash_key_u64(&element->chunk.id.value, lttng_ht_seed); @@ -324,19 +301,16 @@ unsigned long lttng_trace_chunk_registry_element_hash( return hash; } -static -char *generate_chunk_name(uint64_t chunk_id, time_t creation_timestamp, - const time_t *close_timestamp) +static char * +generate_chunk_name(uint64_t chunk_id, time_t creation_timestamp, const time_t *close_timestamp) { int ret = 0; - char *new_name= NULL; + char *new_name = NULL; char start_datetime[ISO8601_STR_LEN] = {}; /* Add 1 for a '-' prefix. */ char end_datetime_suffix[ISO8601_STR_LEN + 1] = {}; - ret = time_to_iso8601_str( - creation_timestamp, - start_datetime, sizeof(start_datetime)); + ret = time_to_iso8601_str(creation_timestamp, start_datetime, sizeof(start_datetime)); if (ret) { ERR("Failed to format trace chunk start date time"); goto error; @@ -344,9 +318,7 @@ char *generate_chunk_name(uint64_t chunk_id, time_t creation_timestamp, if (close_timestamp) { *end_datetime_suffix = '-'; ret = time_to_iso8601_str( - *close_timestamp, - end_datetime_suffix + 1, - sizeof(end_datetime_suffix) - 1); + *close_timestamp, end_datetime_suffix + 1, sizeof(end_datetime_suffix) - 1); if (ret) { ERR("Failed to format trace chunk end date time"); goto error; @@ -357,8 +329,12 @@ char *generate_chunk_name(uint64_t chunk_id, time_t creation_timestamp, ERR("Failed to allocate buffer for automatically-generated trace chunk name"); goto error; } - ret = snprintf(new_name, GENERATED_CHUNK_NAME_LEN, "%s%s-%" PRIu64, - start_datetime, end_datetime_suffix, chunk_id); + ret = snprintf(new_name, + GENERATED_CHUNK_NAME_LEN, + "%s%s-%" PRIu64, + start_datetime, + end_datetime_suffix, + chunk_id); if (ret >= GENERATED_CHUNK_NAME_LEN || ret == -1) { ERR("Failed to format trace chunk name"); goto error; @@ -370,8 +346,7 @@ error: return NULL; } -static -void lttng_trace_chunk_init(struct lttng_trace_chunk *chunk) +static void lttng_trace_chunk_init(struct lttng_trace_chunk *chunk) { urcu_ref_init(&chunk->ref); pthread_mutex_init(&chunk->lock, NULL); @@ -379,12 +354,10 @@ void lttng_trace_chunk_init(struct lttng_trace_chunk *chunk) lttng_dynamic_pointer_array_init(&chunk->files, free); } -static -void lttng_trace_chunk_fini(struct lttng_trace_chunk *chunk) +static void lttng_trace_chunk_fini(struct lttng_trace_chunk *chunk) { if (chunk->session_output_directory) { - lttng_directory_handle_put( - chunk->session_output_directory); + lttng_directory_handle_put(chunk->session_output_directory); chunk->session_output_directory = NULL; } if (chunk->chunk_directory) { @@ -400,8 +373,7 @@ void lttng_trace_chunk_fini(struct lttng_trace_chunk *chunk) pthread_mutex_destroy(&chunk->lock); } -static -struct lttng_trace_chunk *lttng_trace_chunk_allocate(void) +static struct lttng_trace_chunk *lttng_trace_chunk_allocate(void) { struct lttng_trace_chunk *chunk = NULL; @@ -421,8 +393,8 @@ struct lttng_trace_chunk *lttng_trace_chunk_create_anonymous(void) return lttng_trace_chunk_allocate(); } -struct lttng_trace_chunk *lttng_trace_chunk_create( - uint64_t chunk_id, time_t chunk_creation_time, const char *path) +struct lttng_trace_chunk * +lttng_trace_chunk_create(uint64_t chunk_id, time_t chunk_creation_time, const char *path) { struct lttng_trace_chunk *chunk; char chunk_creation_datetime_buf[16] = {}; @@ -435,16 +407,17 @@ struct lttng_trace_chunk *lttng_trace_chunk_create( /* Don't fail because of this; it is only used for logging. */ strftime_ret = strftime(chunk_creation_datetime_buf, - sizeof(chunk_creation_datetime_buf), - "%Y%m%d-%H%M%S", timeinfo); + sizeof(chunk_creation_datetime_buf), + "%Y%m%d-%H%M%S", + timeinfo); if (strftime_ret) { - chunk_creation_datetime_str = - chunk_creation_datetime_buf; + chunk_creation_datetime_str = chunk_creation_datetime_buf; } } DBG("Creating trace chunk: chunk_id = %" PRIu64 ", creation time = %s", - chunk_id, chunk_creation_datetime_str); + chunk_id, + chunk_creation_datetime_str); chunk = lttng_trace_chunk_allocate(); if (!chunk) { goto end; @@ -453,8 +426,7 @@ struct lttng_trace_chunk *lttng_trace_chunk_create( LTTNG_OPTIONAL_SET(&chunk->id, chunk_id); LTTNG_OPTIONAL_SET(&chunk->timestamp_creation, chunk_creation_time); if (chunk_id != 0) { - chunk->name = generate_chunk_name(chunk_id, - chunk_creation_time, NULL); + chunk->name = generate_chunk_name(chunk_id, chunk_creation_time, NULL); if (!chunk->name) { ERR("Failed to allocate trace chunk name storage"); goto error; @@ -474,7 +446,7 @@ struct lttng_trace_chunk *lttng_trace_chunk_create( } } - DBG("Chunk name set to \"%s\"", chunk->name ? : "(none)"); + DBG("Chunk name set to \"%s\"", chunk->name ?: "(none)"); end: return chunk; error: @@ -483,7 +455,7 @@ error: } void lttng_trace_chunk_set_fd_tracker(struct lttng_trace_chunk *chunk, - struct fd_tracker *fd_tracker) + struct fd_tracker *fd_tracker) { LTTNG_ASSERT(!chunk->session_output_directory); LTTNG_ASSERT(!chunk->chunk_directory); @@ -491,8 +463,7 @@ void lttng_trace_chunk_set_fd_tracker(struct lttng_trace_chunk *chunk, chunk->fd_tracker = fd_tracker; } -struct lttng_trace_chunk *lttng_trace_chunk_copy( - struct lttng_trace_chunk *source_chunk) +struct lttng_trace_chunk *lttng_trace_chunk_copy(struct lttng_trace_chunk *source_chunk) { struct lttng_trace_chunk *new_chunk = lttng_trace_chunk_allocate(); @@ -505,7 +476,7 @@ struct lttng_trace_chunk *lttng_trace_chunk_copy( * A new chunk is always a user; it shall create no new trace * subdirectories. */ - new_chunk->mode = (typeof(new_chunk->mode)) { + new_chunk->mode = (typeof(new_chunk->mode)){ .is_set = true, .value = TRACE_CHUNK_MODE_USER, }; @@ -519,16 +490,14 @@ struct lttng_trace_chunk *lttng_trace_chunk_copy( if (source_chunk->name) { new_chunk->name = strdup(source_chunk->name); if (!new_chunk->name) { - ERR("Failed to copy source trace chunk name in %s()", - __FUNCTION__); + ERR("Failed to copy source trace chunk name in %s()", __FUNCTION__); goto error_unlock; } } if (source_chunk->path) { new_chunk->path = strdup(source_chunk->path); if (!new_chunk->path) { - ERR("Failed to copy source trace chunk path in %s()", - __FUNCTION__); + ERR("Failed to copy source trace chunk path in %s()", __FUNCTION__); } } new_chunk->id = source_chunk->id; @@ -536,16 +505,15 @@ struct lttng_trace_chunk *lttng_trace_chunk_copy( new_chunk->timestamp_close = source_chunk->timestamp_close; new_chunk->credentials = source_chunk->credentials; if (source_chunk->session_output_directory) { - const bool reference_acquired = lttng_directory_handle_get( - source_chunk->session_output_directory); + const bool reference_acquired = + lttng_directory_handle_get(source_chunk->session_output_directory); LTTNG_ASSERT(reference_acquired); - new_chunk->session_output_directory = - source_chunk->session_output_directory; + new_chunk->session_output_directory = source_chunk->session_output_directory; } if (source_chunk->chunk_directory) { - const bool reference_acquired = lttng_directory_handle_get( - source_chunk->chunk_directory); + const bool reference_acquired = + lttng_directory_handle_get(source_chunk->chunk_directory); LTTNG_ASSERT(reference_acquired); new_chunk->chunk_directory = source_chunk->chunk_directory; @@ -561,8 +529,8 @@ error_unlock: return NULL; } -enum lttng_trace_chunk_status lttng_trace_chunk_get_id( - struct lttng_trace_chunk *chunk, uint64_t *id) +enum lttng_trace_chunk_status lttng_trace_chunk_get_id(struct lttng_trace_chunk *chunk, + uint64_t *id) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -576,8 +544,8 @@ enum lttng_trace_chunk_status lttng_trace_chunk_get_id( return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_get_creation_timestamp( - struct lttng_trace_chunk *chunk, time_t *creation_ts) +enum lttng_trace_chunk_status +lttng_trace_chunk_get_creation_timestamp(struct lttng_trace_chunk *chunk, time_t *creation_ts) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -592,8 +560,8 @@ enum lttng_trace_chunk_status lttng_trace_chunk_get_creation_timestamp( return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_get_close_timestamp( - struct lttng_trace_chunk *chunk, time_t *close_ts) +enum lttng_trace_chunk_status lttng_trace_chunk_get_close_timestamp(struct lttng_trace_chunk *chunk, + time_t *close_ts) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -607,8 +575,8 @@ enum lttng_trace_chunk_status lttng_trace_chunk_get_close_timestamp( return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_set_close_timestamp( - struct lttng_trace_chunk *chunk, time_t close_ts) +enum lttng_trace_chunk_status lttng_trace_chunk_set_close_timestamp(struct lttng_trace_chunk *chunk, + time_t close_ts) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -629,15 +597,16 @@ enum lttng_trace_chunk_status lttng_trace_chunk_set_close_timestamp( */ if (chunk->timestamp_creation.value > close_ts) { WARN("Set trace chunk close timestamp: close timestamp is before creation timestamp, begin : %ld, close : %ld", - chunk->timestamp_creation.value, close_ts); + chunk->timestamp_creation.value, + close_ts); } LTTNG_OPTIONAL_SET(&chunk->timestamp_close, close_ts); if (!chunk->name_overridden) { free(chunk->name); chunk->name = generate_chunk_name(LTTNG_OPTIONAL_GET(chunk->id), - LTTNG_OPTIONAL_GET(chunk->timestamp_creation), - &close_ts); + LTTNG_OPTIONAL_GET(chunk->timestamp_creation), + &close_ts); if (!chunk->name) { status = LTTNG_TRACE_CHUNK_STATUS_ERROR; } @@ -647,9 +616,9 @@ end: return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_get_name( - struct lttng_trace_chunk *chunk, const char **name, - bool *name_overridden) +enum lttng_trace_chunk_status lttng_trace_chunk_get_name(struct lttng_trace_chunk *chunk, + const char **name, + bool *name_overridden) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -677,8 +646,7 @@ bool lttng_trace_chunk_get_name_overridden(struct lttng_trace_chunk *chunk) return name_overridden; } -static -bool is_valid_chunk_name(const char *name) +static bool is_valid_chunk_name(const char *name) { size_t len; @@ -698,8 +666,8 @@ bool is_valid_chunk_name(const char *name) return true; } -enum lttng_trace_chunk_status lttng_trace_chunk_override_name( - struct lttng_trace_chunk *chunk, const char *name) +enum lttng_trace_chunk_status lttng_trace_chunk_override_name(struct lttng_trace_chunk *chunk, + const char *name) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -707,8 +675,7 @@ enum lttng_trace_chunk_status lttng_trace_chunk_override_name( DBG("Override trace chunk name from %s to %s", chunk->name, name); if (!is_valid_chunk_name(name)) { - ERR("Attempted to set an invalid name on a trace chunk: name = %s", - name ? : "NULL"); + ERR("Attempted to set an invalid name on a trace chunk: name = %s", name ?: "NULL"); status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT; goto end; } @@ -716,7 +683,7 @@ enum lttng_trace_chunk_status lttng_trace_chunk_override_name( pthread_mutex_lock(&chunk->lock); if (!chunk->id.is_set) { ERR("Attempted to set an override name on an anonymous trace chunk: name = %s", - name); + name); status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION; goto end_unlock; } @@ -746,9 +713,8 @@ end: return status; } -static -enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( - struct lttng_trace_chunk *chunk, const char *path) +static enum lttng_trace_chunk_status +lttng_trace_chunk_rename_path_no_lock(struct lttng_trace_chunk *chunk, const char *path) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -764,8 +730,7 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( old_path = chunk->path; DBG("lttng_trace_chunk_rename_path from %s to %s", old_path, path); - if ((!old_path && !path) || - (old_path && path && !strcmp(old_path, path))) { + if ((!old_path && !path) || (old_path && path && !strcmp(old_path, path))) { goto end; } /* @@ -786,8 +751,7 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( * is not set (yet), or the session_output_directory is not set * (interacting with a relay daemon), there is no rename to perform. */ - if (!chunk->chunk_directory || - !chunk->session_output_directory) { + if (!chunk->chunk_directory || !chunk->session_output_directory) { goto skip_move; } @@ -803,18 +767,16 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( &chunk->credentials.value.user); if (ret) { PERROR("Failed to move trace chunk directory \"%s\" to \"%s\"", - old_path, path); + old_path, + path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } rename_directory = chunk->fd_tracker ? - fd_tracker_create_directory_handle_from_handle( - chunk->fd_tracker, - chunk->session_output_directory, - path) : - lttng_directory_handle_create_from_handle( - path, - chunk->session_output_directory); + fd_tracker_create_directory_handle_from_handle( + chunk->fd_tracker, chunk->session_output_directory, path) : + lttng_directory_handle_create_from_handle(path, + chunk->session_output_directory); if (!rename_directory) { ERR("Failed to get handle to trace chunk rename directory"); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; @@ -830,25 +792,25 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( chunk->chunk_directory = rename_directory; rename_directory = NULL; } else if (old_path && old_path[0] == '\0') { - size_t i, count = lttng_dynamic_pointer_array_get_count( + size_t i, + count = lttng_dynamic_pointer_array_get_count( &chunk->top_level_directories); ret = lttng_directory_handle_create_subdirectory_as_user( - chunk->session_output_directory, - path, - DIR_CREATION_MODE, - LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ? - NULL : - &chunk->credentials.value.user); + chunk->session_output_directory, + path, + DIR_CREATION_MODE, + LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ? + NULL : + &chunk->credentials.value.user); if (ret) { - PERROR("Failed to create trace chunk rename directory \"%s\"", - path); + PERROR("Failed to create trace chunk rename directory \"%s\"", path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } rename_directory = lttng_directory_handle_create_from_handle( - path, chunk->session_output_directory); + path, chunk->session_output_directory); if (!rename_directory) { ERR("Failed to get handle to trace chunk rename directory"); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; @@ -862,16 +824,16 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( &chunk->top_level_directories, i); ret = lttng_directory_handle_rename_as_user( - chunk->chunk_directory, - top_level_name, - rename_directory, - top_level_name, - LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ? - NULL : - &chunk->credentials.value.user); + chunk->chunk_directory, + top_level_name, + rename_directory, + top_level_name, + LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ? + NULL : + &chunk->credentials.value.user); if (ret) { PERROR("Failed to move \"%s\" to trace chunk rename directory", - top_level_name); + top_level_name); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } @@ -885,10 +847,11 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( chunk->chunk_directory = rename_directory; rename_directory = NULL; } else if (old_path) { - size_t i, count = lttng_dynamic_pointer_array_get_count( + size_t i, + count = lttng_dynamic_pointer_array_get_count( &chunk->top_level_directories); - const bool reference_acquired = lttng_directory_handle_get( - chunk->session_output_directory); + const bool reference_acquired = + lttng_directory_handle_get(chunk->session_output_directory); LTTNG_ASSERT(reference_acquired); rename_directory = chunk->session_output_directory; @@ -900,16 +863,16 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( &chunk->top_level_directories, i); ret = lttng_directory_handle_rename_as_user( - chunk->chunk_directory, - top_level_name, - rename_directory, - top_level_name, - LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ? - NULL : - &chunk->credentials.value.user); + chunk->chunk_directory, + top_level_name, + rename_directory, + top_level_name, + LTTNG_OPTIONAL_GET(chunk->credentials).use_current_user ? + NULL : + &chunk->credentials.value.user); if (ret) { PERROR("Failed to move \"%s\" to trace chunk rename directory", - top_level_name); + top_level_name); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } @@ -925,11 +888,9 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path_no_lock( /* Remove old directory. */ status = (lttng_trace_chunk_status) lttng_directory_handle_remove_subdirectory( - chunk->session_output_directory, - old_path); + chunk->session_output_directory, old_path); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { - ERR("Error removing subdirectory '%s' file when deleting chunk", - old_path); + ERR("Error removing subdirectory '%s' file when deleting chunk", old_path); goto end; } } else { @@ -952,8 +913,8 @@ end: return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_rename_path( - struct lttng_trace_chunk *chunk, const char *path) +enum lttng_trace_chunk_status lttng_trace_chunk_rename_path(struct lttng_trace_chunk *chunk, + const char *path) { enum lttng_trace_chunk_status status; @@ -965,9 +926,9 @@ enum lttng_trace_chunk_status lttng_trace_chunk_rename_path( return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_get_credentials( - struct lttng_trace_chunk *chunk, - struct lttng_credentials *credentials) +enum lttng_trace_chunk_status +lttng_trace_chunk_get_credentials(struct lttng_trace_chunk *chunk, + struct lttng_credentials *credentials) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -986,9 +947,9 @@ enum lttng_trace_chunk_status lttng_trace_chunk_get_credentials( return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials( - struct lttng_trace_chunk *chunk, - const struct lttng_credentials *user_credentials) +enum lttng_trace_chunk_status +lttng_trace_chunk_set_credentials(struct lttng_trace_chunk *chunk, + const struct lttng_credentials *user_credentials) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; const struct chunk_credentials credentials = { @@ -1007,8 +968,8 @@ end: return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_set_credentials_current_user( - struct lttng_trace_chunk *chunk) +enum lttng_trace_chunk_status +lttng_trace_chunk_set_credentials_current_user(struct lttng_trace_chunk *chunk) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; const struct chunk_credentials credentials = { @@ -1027,10 +988,9 @@ end: return status; } - -enum lttng_trace_chunk_status lttng_trace_chunk_set_as_owner( - struct lttng_trace_chunk *chunk, - struct lttng_directory_handle *session_output_directory) +enum lttng_trace_chunk_status +lttng_trace_chunk_set_as_owner(struct lttng_trace_chunk *chunk, + struct lttng_directory_handle *session_output_directory) { int ret; enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1053,26 +1013,22 @@ enum lttng_trace_chunk_status lttng_trace_chunk_set_as_owner( } if (chunk->path && chunk->path[0] != '\0') { ret = lttng_directory_handle_create_subdirectory_as_user( - session_output_directory, - chunk->path, - DIR_CREATION_MODE, - !chunk->credentials.value.use_current_user ? - &chunk->credentials.value.user : NULL); + session_output_directory, + chunk->path, + DIR_CREATION_MODE, + !chunk->credentials.value.use_current_user ? + &chunk->credentials.value.user : + NULL); if (ret) { - PERROR("Failed to create chunk output directory \"%s\"", - chunk->path); + PERROR("Failed to create chunk output directory \"%s\"", chunk->path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } - chunk_directory_handle = - chunk->fd_tracker ? - fd_tracker_create_directory_handle_from_handle( - chunk->fd_tracker, - session_output_directory, - chunk->path) : - lttng_directory_handle_create_from_handle( - chunk->path, - session_output_directory); + chunk_directory_handle = chunk->fd_tracker ? + fd_tracker_create_directory_handle_from_handle( + chunk->fd_tracker, session_output_directory, chunk->path) : + lttng_directory_handle_create_from_handle(chunk->path, + session_output_directory); if (!chunk_directory_handle) { /* The function already logs on all error paths. */ status = LTTNG_TRACE_CHUNK_STATUS_ERROR; @@ -1083,16 +1039,14 @@ enum lttng_trace_chunk_status lttng_trace_chunk_set_as_owner( * A nameless chunk does not need its own output directory. * The session's output directory will be used. */ - reference_acquired = lttng_directory_handle_get( - session_output_directory); + reference_acquired = lttng_directory_handle_get(session_output_directory); LTTNG_ASSERT(reference_acquired); chunk_directory_handle = session_output_directory; } chunk->chunk_directory = chunk_directory_handle; chunk_directory_handle = NULL; - reference_acquired = lttng_directory_handle_get( - session_output_directory); + reference_acquired = lttng_directory_handle_get(session_output_directory); LTTNG_ASSERT(reference_acquired); chunk->session_output_directory = session_output_directory; LTTNG_OPTIONAL_SET(&chunk->mode, TRACE_CHUNK_MODE_OWNER); @@ -1101,9 +1055,9 @@ end: return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_set_as_user( - struct lttng_trace_chunk *chunk, - struct lttng_directory_handle *chunk_directory) +enum lttng_trace_chunk_status +lttng_trace_chunk_set_as_user(struct lttng_trace_chunk *chunk, + struct lttng_directory_handle *chunk_directory) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; bool reference_acquired; @@ -1128,9 +1082,8 @@ end: } enum lttng_trace_chunk_status -lttng_trace_chunk_get_session_output_directory_handle( - struct lttng_trace_chunk *chunk, - struct lttng_directory_handle **handle) +lttng_trace_chunk_get_session_output_directory_handle(struct lttng_trace_chunk *chunk, + struct lttng_directory_handle **handle) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1140,8 +1093,8 @@ lttng_trace_chunk_get_session_output_directory_handle( *handle = NULL; goto end; } else { - const bool reference_acquired = lttng_directory_handle_get( - chunk->session_output_directory); + const bool reference_acquired = + lttng_directory_handle_get(chunk->session_output_directory); LTTNG_ASSERT(reference_acquired); *handle = chunk->session_output_directory; @@ -1151,9 +1104,9 @@ end: return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_borrow_chunk_directory_handle( - struct lttng_trace_chunk *chunk, - const struct lttng_directory_handle **handle) +enum lttng_trace_chunk_status +lttng_trace_chunk_borrow_chunk_directory_handle(struct lttng_trace_chunk *chunk, + const struct lttng_directory_handle **handle) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1170,21 +1123,18 @@ end: } /* Add a top-level directory to the trace chunk if it was previously unknown. */ -static -int add_top_level_directory_unique(struct lttng_trace_chunk *chunk, - const char *new_path) +static int add_top_level_directory_unique(struct lttng_trace_chunk *chunk, const char *new_path) { int ret = 0; bool found = false; - size_t i, count = lttng_dynamic_pointer_array_get_count( - &chunk->top_level_directories); + size_t i, count = lttng_dynamic_pointer_array_get_count(&chunk->top_level_directories); const char *new_path_separator_pos = strchr(new_path, '/'); - const ptrdiff_t new_path_top_level_len = new_path_separator_pos ? - new_path_separator_pos - new_path : strlen(new_path); + const ptrdiff_t new_path_top_level_len = + new_path_separator_pos ? new_path_separator_pos - new_path : strlen(new_path); for (i = 0; i < count; i++) { const char *path = (const char *) lttng_dynamic_pointer_array_get_pointer( - &chunk->top_level_directories, i); + &chunk->top_level_directories, i); const ptrdiff_t path_top_level_len = strlen(path); if (path_top_level_len != new_path_top_level_len) { @@ -1200,14 +1150,14 @@ int add_top_level_directory_unique(struct lttng_trace_chunk *chunk, char *copy = lttng_strndup(new_path, new_path_top_level_len); DBG("Adding new top-level directory \"%s\" to trace chunk \"%s\"", - new_path, chunk->name ? : "(unnamed)"); + new_path, + chunk->name ?: "(unnamed)"); if (!copy) { PERROR("Failed to copy path"); ret = -1; goto end; } - ret = lttng_dynamic_pointer_array_add_pointer( - &chunk->top_level_directories, copy); + ret = lttng_dynamic_pointer_array_add_pointer(&chunk->top_level_directories, copy); if (ret) { ERR("Allocation failure while adding top-level directory entry to a trace chunk"); free(copy); @@ -1218,9 +1168,8 @@ end: return ret; } -enum lttng_trace_chunk_status lttng_trace_chunk_create_subdirectory( - struct lttng_trace_chunk *chunk, - const char *path) +enum lttng_trace_chunk_status lttng_trace_chunk_create_subdirectory(struct lttng_trace_chunk *chunk, + const char *path) { int ret; enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1233,37 +1182,34 @@ enum lttng_trace_chunk_status lttng_trace_chunk_create_subdirectory( * directory is created. */ ERR("Credentials of trace chunk are unset: refusing to create subdirectory \"%s\"", - path); + path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } - if (!chunk->mode.is_set || - chunk->mode.value != TRACE_CHUNK_MODE_OWNER) { + if (!chunk->mode.is_set || chunk->mode.value != TRACE_CHUNK_MODE_OWNER) { ERR("Attempted to create trace chunk subdirectory \"%s\" through a non-owner chunk", - path); + path); status = LTTNG_TRACE_CHUNK_STATUS_INVALID_OPERATION; goto end; } if (!chunk->chunk_directory) { ERR("Attempted to create trace chunk subdirectory \"%s\" before setting the chunk output directory", - path); + path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } if (*path == '/') { - ERR("Refusing to create absolute trace chunk directory \"%s\"", - path); + ERR("Refusing to create absolute trace chunk directory \"%s\"", path); status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT; goto end; } ret = lttng_directory_handle_create_subdirectory_recursive_as_user( - chunk->chunk_directory, path, - DIR_CREATION_MODE, - chunk->credentials.value.use_current_user ? - NULL : &chunk->credentials.value.user); + chunk->chunk_directory, + path, + DIR_CREATION_MODE, + chunk->credentials.value.use_current_user ? NULL : &chunk->credentials.value.user); if (ret) { - PERROR("Failed to create trace chunk subdirectory \"%s\"", - path); + PERROR("Failed to create trace chunk subdirectory \"%s\"", path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } @@ -1280,17 +1226,15 @@ end: /* * TODO: Implement O(1) lookup. */ -static -bool lttng_trace_chunk_find_file(struct lttng_trace_chunk *chunk, - const char *path, size_t *index) +static bool +lttng_trace_chunk_find_file(struct lttng_trace_chunk *chunk, const char *path, size_t *index) { size_t i, count; count = lttng_dynamic_pointer_array_get_count(&chunk->files); for (i = 0; i < count; i++) { const char *iter_path = - (const char *) lttng_dynamic_pointer_array_get_pointer( - &chunk->files, i); + (const char *) lttng_dynamic_pointer_array_get_pointer(&chunk->files, i); if (!strcmp(iter_path, path)) { if (index) { *index = i; @@ -1301,10 +1245,8 @@ bool lttng_trace_chunk_find_file(struct lttng_trace_chunk *chunk, return false; } -static -enum lttng_trace_chunk_status lttng_trace_chunk_add_file( - struct lttng_trace_chunk *chunk, - const char *path) +static enum lttng_trace_chunk_status lttng_trace_chunk_add_file(struct lttng_trace_chunk *chunk, + const char *path) { char *copy; int ret; @@ -1313,16 +1255,14 @@ enum lttng_trace_chunk_status lttng_trace_chunk_add_file( if (lttng_trace_chunk_find_file(chunk, path, NULL)) { return LTTNG_TRACE_CHUNK_STATUS_OK; } - DBG("Adding new file \"%s\" to trace chunk \"%s\"", - path, chunk->name ? : "(unnamed)"); + DBG("Adding new file \"%s\" to trace chunk \"%s\"", path, chunk->name ?: "(unnamed)"); copy = strdup(path); if (!copy) { PERROR("Failed to copy path"); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } - ret = lttng_dynamic_pointer_array_add_pointer( - &chunk->files, copy); + ret = lttng_dynamic_pointer_array_add_pointer(&chunk->files, copy); if (ret) { ERR("Allocation failure while adding file to a trace chunk"); free(copy); @@ -1333,10 +1273,7 @@ end: return status; } -static -void lttng_trace_chunk_remove_file( - struct lttng_trace_chunk *chunk, - const char *path) +static void lttng_trace_chunk_remove_file(struct lttng_trace_chunk *chunk, const char *path) { size_t index; bool found; @@ -1346,19 +1283,17 @@ void lttng_trace_chunk_remove_file( if (!found) { return; } - ret = lttng_dynamic_pointer_array_remove_pointer( - &chunk->files, index); + ret = lttng_dynamic_pointer_array_remove_pointer(&chunk->files, index); LTTNG_ASSERT(!ret); } -static -enum lttng_trace_chunk_status _lttng_trace_chunk_open_fs_handle_locked( - struct lttng_trace_chunk *chunk, - const char *file_path, - int flags, - mode_t mode, - struct fs_handle **out_handle, - bool expect_no_file) +static enum lttng_trace_chunk_status +_lttng_trace_chunk_open_fs_handle_locked(struct lttng_trace_chunk *chunk, + const char *file_path, + int flags, + mode_t mode, + struct fs_handle **out_handle, + bool expect_no_file) { int ret; enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1370,13 +1305,13 @@ enum lttng_trace_chunk_status _lttng_trace_chunk_open_fs_handle_locked( * file is created. */ ERR("Credentials of trace chunk are unset: refusing to open file \"%s\"", - file_path); + file_path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } if (!chunk->chunk_directory) { ERR("Attempted to open trace chunk file \"%s\" before setting the chunk output directory", - file_path); + file_path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } @@ -1386,18 +1321,20 @@ enum lttng_trace_chunk_status _lttng_trace_chunk_open_fs_handle_locked( } if (chunk->fd_tracker) { LTTNG_ASSERT(chunk->credentials.value.use_current_user); - *out_handle = fd_tracker_open_fs_handle(chunk->fd_tracker, - chunk->chunk_directory, file_path, flags, &mode); + *out_handle = fd_tracker_open_fs_handle( + chunk->fd_tracker, chunk->chunk_directory, file_path, flags, &mode); ret = *out_handle ? 0 : -1; } else { ret = lttng_directory_handle_open_file_as_user( - chunk->chunk_directory, file_path, flags, mode, - chunk->credentials.value.use_current_user ? - NULL : - &chunk->credentials.value.user); + chunk->chunk_directory, + file_path, + flags, + mode, + chunk->credentials.value.use_current_user ? NULL : + &chunk->credentials.value.user); if (ret >= 0) { - *out_handle = fs_handle_untracked_create( - chunk->chunk_directory, file_path, ret); + *out_handle = + fs_handle_untracked_create(chunk->chunk_directory, file_path, ret); if (!*out_handle) { status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; @@ -1409,7 +1346,9 @@ enum lttng_trace_chunk_status _lttng_trace_chunk_open_fs_handle_locked( status = LTTNG_TRACE_CHUNK_STATUS_NO_FILE; } else { PERROR("Failed to open file relative to trace chunk file_path = \"%s\", flags = %d, mode = %d", - file_path, flags, (int) mode); + file_path, + flags, + (int) mode); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; } lttng_trace_chunk_remove_file(chunk, file_path); @@ -1419,30 +1358,28 @@ end: return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_open_fs_handle( - struct lttng_trace_chunk *chunk, - const char *file_path, - int flags, - mode_t mode, - struct fs_handle **out_handle, - bool expect_no_file) +enum lttng_trace_chunk_status lttng_trace_chunk_open_fs_handle(struct lttng_trace_chunk *chunk, + const char *file_path, + int flags, + mode_t mode, + struct fs_handle **out_handle, + bool expect_no_file) { enum lttng_trace_chunk_status status; pthread_mutex_lock(&chunk->lock); - status = _lttng_trace_chunk_open_fs_handle_locked(chunk, file_path, - flags, mode, out_handle, expect_no_file); + status = _lttng_trace_chunk_open_fs_handle_locked( + chunk, file_path, flags, mode, out_handle, expect_no_file); pthread_mutex_unlock(&chunk->lock); return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_open_file( - struct lttng_trace_chunk *chunk, - const char *file_path, - int flags, - mode_t mode, - int *out_fd, - bool expect_no_file) +enum lttng_trace_chunk_status lttng_trace_chunk_open_file(struct lttng_trace_chunk *chunk, + const char *file_path, + int flags, + mode_t mode, + int *out_fd, + bool expect_no_file) { enum lttng_trace_chunk_status status; struct fs_handle *fs_handle; @@ -1453,8 +1390,8 @@ enum lttng_trace_chunk_status lttng_trace_chunk_open_file( * used since the resulting file descriptor would not be tracked. */ LTTNG_ASSERT(!chunk->fd_tracker); - status = _lttng_trace_chunk_open_fs_handle_locked(chunk, file_path, - flags, mode, &fs_handle, expect_no_file); + status = _lttng_trace_chunk_open_fs_handle_locked( + chunk, file_path, flags, mode, &fs_handle, expect_no_file); pthread_mutex_unlock(&chunk->lock); if (status == LTTNG_TRACE_CHUNK_STATUS_OK) { @@ -1462,15 +1399,14 @@ enum lttng_trace_chunk_status lttng_trace_chunk_open_file( /* * Does not close the fd; we just "unbox" it from the fs_handle. */ - fs_handle_untracked_destroy(lttng::utils::container_of( - fs_handle, &fs_handle_untracked::parent)); + fs_handle_untracked_destroy( + lttng::utils::container_of(fs_handle, &fs_handle_untracked::parent)); } return status; } -int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk *chunk, - const char *file_path) +int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk *chunk, const char *file_path) { int ret; enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1483,20 +1419,20 @@ int lttng_trace_chunk_unlink_file(struct lttng_trace_chunk *chunk, * file is unlinked. */ ERR("Credentials of trace chunk are unset: refusing to unlink file \"%s\"", - file_path); + file_path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } if (!chunk->chunk_directory) { ERR("Attempted to unlink trace chunk file \"%s\" before setting the chunk output directory", - file_path); + file_path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } ret = lttng_directory_handle_unlink_file_as_user( - chunk->chunk_directory, file_path, - chunk->credentials.value.use_current_user ? - NULL : &chunk->credentials.value.user); + chunk->chunk_directory, + file_path, + chunk->credentials.value.use_current_user ? NULL : &chunk->credentials.value.user); if (ret < 0) { status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; @@ -1507,9 +1443,8 @@ end: return status; } -static -int lttng_trace_chunk_remove_subdirectory_recursive(struct lttng_trace_chunk *chunk, - const char *path) +static int lttng_trace_chunk_remove_subdirectory_recursive(struct lttng_trace_chunk *chunk, + const char *path) { int ret; enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1522,21 +1457,21 @@ int lttng_trace_chunk_remove_subdirectory_recursive(struct lttng_trace_chunk *ch * directory is removed. */ ERR("Credentials of trace chunk are unset: refusing to recursively remove directory \"%s\"", - path); + path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } if (!chunk->chunk_directory) { ERR("Attempted to recursively remove trace chunk directory \"%s\" before setting the chunk output directory", - path); + path); status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; } ret = lttng_directory_handle_remove_subdirectory_recursive_as_user( - chunk->chunk_directory, path, - chunk->credentials.value.use_current_user ? - NULL : &chunk->credentials.value.user, - LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG); + chunk->chunk_directory, + path, + chunk->credentials.value.use_current_user ? NULL : &chunk->credentials.value.user, + LTTNG_DIRECTORY_HANDLE_SKIP_NON_EMPTY_FLAG); if (ret < 0) { status = LTTNG_TRACE_CHUNK_STATUS_ERROR; goto end; @@ -1546,23 +1481,18 @@ end: return status; } -static -int lttng_trace_chunk_move_to_completed_post_release( - struct lttng_trace_chunk *trace_chunk) +static int lttng_trace_chunk_move_to_completed_post_release(struct lttng_trace_chunk *trace_chunk) { int ret = 0; char *archived_chunk_name = NULL; const uint64_t chunk_id = LTTNG_OPTIONAL_GET(trace_chunk->id); - const time_t creation_timestamp = - LTTNG_OPTIONAL_GET(trace_chunk->timestamp_creation); - const time_t close_timestamp = - LTTNG_OPTIONAL_GET(trace_chunk->timestamp_close); + const time_t creation_timestamp = LTTNG_OPTIONAL_GET(trace_chunk->timestamp_creation); + const time_t close_timestamp = LTTNG_OPTIONAL_GET(trace_chunk->timestamp_close); struct lttng_directory_handle *archived_chunks_directory = NULL; enum lttng_trace_chunk_status status; - if (!trace_chunk->mode.is_set || - trace_chunk->mode.value != TRACE_CHUNK_MODE_OWNER || - !trace_chunk->session_output_directory) { + if (!trace_chunk->mode.is_set || trace_chunk->mode.value != TRACE_CHUNK_MODE_OWNER || + !trace_chunk->session_output_directory) { /* * This command doesn't need to run if the output is remote * or if the trace chunk is not owned by this process. @@ -1574,8 +1504,7 @@ int lttng_trace_chunk_move_to_completed_post_release( LTTNG_ASSERT(!trace_chunk->name_overridden); LTTNG_ASSERT(trace_chunk->path); - archived_chunk_name = generate_chunk_name(chunk_id, creation_timestamp, - &close_timestamp); + archived_chunk_name = generate_chunk_name(chunk_id, creation_timestamp, &close_timestamp); if (!archived_chunk_name) { ERR("Failed to generate archived trace chunk name while renaming trace chunk"); ret = -1; @@ -1583,26 +1512,25 @@ int lttng_trace_chunk_move_to_completed_post_release( } ret = lttng_directory_handle_create_subdirectory_as_user( - trace_chunk->session_output_directory, - DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY, - DIR_CREATION_MODE, - !trace_chunk->credentials.value.use_current_user ? - &trace_chunk->credentials.value.user : - NULL); + trace_chunk->session_output_directory, + DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY, + DIR_CREATION_MODE, + !trace_chunk->credentials.value.use_current_user ? + &trace_chunk->credentials.value.user : + NULL); if (ret) { PERROR("Failed to create \"" DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY - "\" directory for archived trace chunks"); + "\" directory for archived trace chunks"); goto end; } archived_chunks_directory = trace_chunk->fd_tracker ? - fd_tracker_create_directory_handle_from_handle( - trace_chunk->fd_tracker, - trace_chunk->session_output_directory, - DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY) : - lttng_directory_handle_create_from_handle( - DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY, - trace_chunk->session_output_directory); + fd_tracker_create_directory_handle_from_handle( + trace_chunk->fd_tracker, + trace_chunk->session_output_directory, + DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY) : + lttng_directory_handle_create_from_handle(DEFAULT_ARCHIVED_TRACE_CHUNKS_DIRECTORY, + trace_chunk->session_output_directory); if (!archived_chunks_directory) { PERROR("Failed to get handle to archived trace chunks directory"); ret = -1; @@ -1614,10 +1542,9 @@ int lttng_trace_chunk_move_to_completed_post_release( * the creation of the next chunk. This happens if a rotation is * performed while tracing is stopped. */ - if (!trace_chunk->path || strcmp(trace_chunk->path, - DEFAULT_CHUNK_TMP_OLD_DIRECTORY)) { + if (!trace_chunk->path || strcmp(trace_chunk->path, DEFAULT_CHUNK_TMP_OLD_DIRECTORY)) { status = lttng_trace_chunk_rename_path_no_lock(trace_chunk, - DEFAULT_CHUNK_TMP_OLD_DIRECTORY); + DEFAULT_CHUNK_TMP_OLD_DIRECTORY); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ERR("Failed to rename chunk to %s", DEFAULT_CHUNK_TMP_OLD_DIRECTORY); ret = -1; @@ -1626,17 +1553,17 @@ int lttng_trace_chunk_move_to_completed_post_release( } ret = lttng_directory_handle_rename_as_user( - trace_chunk->session_output_directory, - trace_chunk->path, - archived_chunks_directory, - archived_chunk_name, - LTTNG_OPTIONAL_GET(trace_chunk->credentials).use_current_user ? - NULL : - &trace_chunk->credentials.value.user); + trace_chunk->session_output_directory, + trace_chunk->path, + archived_chunks_directory, + archived_chunk_name, + LTTNG_OPTIONAL_GET(trace_chunk->credentials).use_current_user ? + NULL : + &trace_chunk->credentials.value.user); if (ret) { PERROR("Failed to rename folder \"%s\" to \"%s\"", - trace_chunk->path, - archived_chunk_name); + trace_chunk->path, + archived_chunk_name); } end: @@ -1645,15 +1572,13 @@ end: return ret; } -static -int lttng_trace_chunk_no_operation(struct lttng_trace_chunk *trace_chunk __attribute__((unused))) +static int lttng_trace_chunk_no_operation(struct lttng_trace_chunk *trace_chunk + __attribute__((unused))) { return 0; } -static -int lttng_trace_chunk_delete_post_release_user( - struct lttng_trace_chunk *trace_chunk) +static int lttng_trace_chunk_delete_post_release_user(struct lttng_trace_chunk *trace_chunk) { int ret = 0; @@ -1665,10 +1590,11 @@ int lttng_trace_chunk_delete_post_release_user( const char *path; /* Remove first. */ - path = (const char *) lttng_dynamic_pointer_array_get_pointer( - &trace_chunk->files, 0); + path = (const char *) lttng_dynamic_pointer_array_get_pointer(&trace_chunk->files, + 0); DBG("Unlink file: %s", path); - status = (lttng_trace_chunk_status) lttng_trace_chunk_unlink_file(trace_chunk, path); + status = + (lttng_trace_chunk_status) lttng_trace_chunk_unlink_file(trace_chunk, path); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ERR("Error unlinking file '%s' when deleting chunk", path); ret = -1; @@ -1679,9 +1605,7 @@ end: return ret; } -static -int lttng_trace_chunk_delete_post_release_owner( - struct lttng_trace_chunk *trace_chunk) +static int lttng_trace_chunk_delete_post_release_owner(struct lttng_trace_chunk *trace_chunk) { enum lttng_trace_chunk_status status; size_t i, count; @@ -1698,18 +1622,17 @@ int lttng_trace_chunk_delete_post_release_owner( LTTNG_ASSERT(trace_chunk->chunk_directory); /* Remove empty directories. */ - count = lttng_dynamic_pointer_array_get_count( - &trace_chunk->top_level_directories); + count = lttng_dynamic_pointer_array_get_count(&trace_chunk->top_level_directories); for (i = 0; i < count; i++) { - const char *top_level_name = - (const char *) lttng_dynamic_pointer_array_get_pointer( - &trace_chunk->top_level_directories, i); + const char *top_level_name = (const char *) lttng_dynamic_pointer_array_get_pointer( + &trace_chunk->top_level_directories, i); - status = (lttng_trace_chunk_status) lttng_trace_chunk_remove_subdirectory_recursive(trace_chunk, top_level_name); + status = (lttng_trace_chunk_status) lttng_trace_chunk_remove_subdirectory_recursive( + trace_chunk, top_level_name); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ERR("Error recursively removing subdirectory '%s' file when deleting chunk", - top_level_name); + top_level_name); ret = -1; break; } @@ -1719,12 +1642,12 @@ int lttng_trace_chunk_delete_post_release_owner( trace_chunk->chunk_directory = NULL; if (trace_chunk->path && trace_chunk->path[0] != '\0') { - status = (lttng_trace_chunk_status) lttng_directory_handle_remove_subdirectory( - trace_chunk->session_output_directory, - trace_chunk->path); + status = (lttng_trace_chunk_status) + lttng_directory_handle_remove_subdirectory( + trace_chunk->session_output_directory, trace_chunk->path); if (status != LTTNG_TRACE_CHUNK_STATUS_OK) { ERR("Error removing subdirectory '%s' file when deleting chunk", - trace_chunk->path); + trace_chunk->path); ret = -1; } } @@ -1741,9 +1664,7 @@ end: * session daemon is the owner of the chunk. Unlink all files owned by each * consumer daemon. */ -static -int lttng_trace_chunk_delete_post_release( - struct lttng_trace_chunk *trace_chunk) +static int lttng_trace_chunk_delete_post_release(struct lttng_trace_chunk *trace_chunk) { if (!trace_chunk->chunk_directory) { return 0; @@ -1756,9 +1677,9 @@ int lttng_trace_chunk_delete_post_release( } } -enum lttng_trace_chunk_status lttng_trace_chunk_get_close_command( - struct lttng_trace_chunk *chunk, - enum lttng_trace_chunk_command_type *command_type) +enum lttng_trace_chunk_status +lttng_trace_chunk_get_close_command(struct lttng_trace_chunk *chunk, + enum lttng_trace_chunk_command_type *command_type) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; @@ -1773,14 +1694,14 @@ enum lttng_trace_chunk_status lttng_trace_chunk_get_close_command( return status; } -enum lttng_trace_chunk_status lttng_trace_chunk_set_close_command( - struct lttng_trace_chunk *chunk, - enum lttng_trace_chunk_command_type close_command) +enum lttng_trace_chunk_status +lttng_trace_chunk_set_close_command(struct lttng_trace_chunk *chunk, + enum lttng_trace_chunk_command_type close_command) { enum lttng_trace_chunk_status status = LTTNG_TRACE_CHUNK_STATUS_OK; if (close_command < LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED || - close_command >= LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX) { + close_command >= LTTNG_TRACE_CHUNK_COMMAND_TYPE_MAX) { status = LTTNG_TRACE_CHUNK_STATUS_INVALID_ARGUMENT; goto end; } @@ -1788,11 +1709,11 @@ enum lttng_trace_chunk_status lttng_trace_chunk_set_close_command( pthread_mutex_lock(&chunk->lock); if (chunk->close_command.is_set) { DBG("Overriding trace chunk close command from \"%s\" to \"%s\"", - lttng_trace_chunk_command_type_str(chunk->close_command.value), - lttng_trace_chunk_command_type_str(close_command)); + lttng_trace_chunk_command_type_str(chunk->close_command.value), + lttng_trace_chunk_command_type_str(close_command)); } else { DBG("Setting trace chunk close command to \"%s\"", - lttng_trace_chunk_command_type_str(close_command)); + lttng_trace_chunk_command_type_str(close_command)); } /* * Unset close command for no-op for backward compatibility with relayd @@ -1808,8 +1729,7 @@ end: return status; } -const char *lttng_trace_chunk_command_type_get_name( - enum lttng_trace_chunk_command_type command) +const char *lttng_trace_chunk_command_type_get_name(enum lttng_trace_chunk_command_type command) { switch (command) { case LTTNG_TRACE_CHUNK_COMMAND_TYPE_MOVE_TO_COMPLETED: @@ -1824,7 +1744,7 @@ const char *lttng_trace_chunk_command_type_get_name( } bool lttng_trace_chunk_ids_equal(const struct lttng_trace_chunk *chunk_a, - const struct lttng_trace_chunk *chunk_b) + const struct lttng_trace_chunk *chunk_b) { bool equal = false; @@ -1858,26 +1778,25 @@ bool lttng_trace_chunk_get(struct lttng_trace_chunk *chunk) return urcu_ref_get_unless_zero(&chunk->ref); } -static -void free_lttng_trace_chunk_registry_element(struct rcu_head *node) +static void free_lttng_trace_chunk_registry_element(struct rcu_head *node) { - struct lttng_trace_chunk_registry_element *element = lttng::utils::container_of( - node, <tng_trace_chunk_registry_element::rcu_node); + struct lttng_trace_chunk_registry_element *element = + lttng::utils::container_of(node, <tng_trace_chunk_registry_element::rcu_node); free(element); } -static -void lttng_trace_chunk_release(struct urcu_ref *ref) +static void lttng_trace_chunk_release(struct urcu_ref *ref) { struct lttng_trace_chunk *chunk = lttng::utils::container_of(ref, <tng_trace_chunk::ref); if (chunk->close_command.is_set) { - chunk_command func = close_command_get_post_release_func(chunk->close_command.value); + chunk_command func = + close_command_get_post_release_func(chunk->close_command.value); if (func(chunk)) { ERR("Trace chunk post-release command %s has failed.", - lttng_trace_chunk_command_type_str(chunk->close_command.value)); + lttng_trace_chunk_command_type_str(chunk->close_command.value)); } } @@ -1902,19 +1821,16 @@ void lttng_trace_chunk_release(struct urcu_ref *ref) */ lttng_trace_chunk_fini(chunk); - element = lttng::utils::container_of( - chunk, <tng_trace_chunk_registry_element::chunk); + element = lttng::utils::container_of(chunk, + <tng_trace_chunk_registry_element::chunk); if (element->registry) { rcu_read_lock(); - cds_lfht_del(element->registry->ht, - &element->trace_chunk_registry_ht_node); + cds_lfht_del(element->registry->ht, &element->trace_chunk_registry_ht_node); rcu_read_unlock(); - call_rcu(&element->rcu_node, - free_lttng_trace_chunk_registry_element); + call_rcu(&element->rcu_node, free_lttng_trace_chunk_registry_element); } else { /* Never published, can be free'd immediately. */ - free_lttng_trace_chunk_registry_element( - &element->rcu_node); + free_lttng_trace_chunk_registry_element(&element->rcu_node); } } else { /* Not RCU-protected, free immediately. */ @@ -1941,8 +1857,8 @@ struct lttng_trace_chunk_registry *lttng_trace_chunk_registry_create(void) goto end; } - registry->ht = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0, - CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); + registry->ht = cds_lfht_new( + DEFAULT_HT_SIZE, 1, 0, CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL); if (!registry->ht) { goto error; } @@ -1953,8 +1869,7 @@ error: return NULL; } -void lttng_trace_chunk_registry_destroy( - struct lttng_trace_chunk_registry *registry) +void lttng_trace_chunk_registry_destroy(struct lttng_trace_chunk_registry *registry) { if (!registry) { return; @@ -1966,10 +1881,9 @@ void lttng_trace_chunk_registry_destroy( free(registry); } -static -struct lttng_trace_chunk_registry_element * -lttng_trace_chunk_registry_element_create_from_chunk( - struct lttng_trace_chunk *chunk, uint64_t session_id) +static struct lttng_trace_chunk_registry_element * +lttng_trace_chunk_registry_element_create_from_chunk(struct lttng_trace_chunk *chunk, + uint64_t session_id) { struct lttng_trace_chunk_registry_element *element = zmalloc(); @@ -1984,8 +1898,7 @@ lttng_trace_chunk_registry_element_create_from_chunk( lttng_trace_chunk_init(&element->chunk); if (chunk->session_output_directory) { /* Transferred ownership. */ - element->chunk.session_output_directory = - chunk->session_output_directory; + element->chunk.session_output_directory = chunk->session_output_directory; chunk->session_output_directory = NULL; } if (chunk->chunk_directory) { @@ -2006,29 +1919,26 @@ end: } struct lttng_trace_chunk * -lttng_trace_chunk_registry_publish_chunk( - struct lttng_trace_chunk_registry *registry, - uint64_t session_id, - struct lttng_trace_chunk *chunk) +lttng_trace_chunk_registry_publish_chunk(struct lttng_trace_chunk_registry *registry, + uint64_t session_id, + struct lttng_trace_chunk *chunk) { bool unused; - return lttng_trace_chunk_registry_publish_chunk( - registry, session_id, chunk, &unused); + return lttng_trace_chunk_registry_publish_chunk(registry, session_id, chunk, &unused); } struct lttng_trace_chunk * -lttng_trace_chunk_registry_publish_chunk( - struct lttng_trace_chunk_registry *registry, - uint64_t session_id, struct lttng_trace_chunk *chunk, - bool *previously_published) +lttng_trace_chunk_registry_publish_chunk(struct lttng_trace_chunk_registry *registry, + uint64_t session_id, + struct lttng_trace_chunk *chunk, + bool *previously_published) { struct lttng_trace_chunk_registry_element *element; unsigned long element_hash; pthread_mutex_lock(&chunk->lock); - element = lttng_trace_chunk_registry_element_create_from_chunk(chunk, - session_id); + element = lttng_trace_chunk_registry_element_create_from_chunk(chunk, session_id); pthread_mutex_unlock(&chunk->lock); if (!element) { goto end; @@ -2047,10 +1957,10 @@ lttng_trace_chunk_registry_publish_chunk( struct lttng_trace_chunk_registry_element *published_element; published_node = cds_lfht_add_unique(registry->ht, - element_hash, - lttng_trace_chunk_registry_element_match, - element, - &element->trace_chunk_registry_ht_node); + element_hash, + lttng_trace_chunk_registry_element_match, + element, + &element->trace_chunk_registry_ht_node); if (published_node == &element->trace_chunk_registry_ht_node) { /* Successfully published the new element. */ element->registry = registry; @@ -2076,8 +1986,9 @@ lttng_trace_chunk_registry_publish_chunk( * already published and release the reference to the copy we * created if successful. */ - published_element = lttng::utils::container_of(published_node, - <tng_trace_chunk_registry_element::trace_chunk_registry_ht_node); + published_element = lttng::utils::container_of( + published_node, + <tng_trace_chunk_registry_element::trace_chunk_registry_ht_node); published_chunk = &published_element->chunk; if (lttng_trace_chunk_get(published_chunk)) { lttng_trace_chunk_put(&element->chunk); @@ -2105,20 +2016,16 @@ end: * IOW, holding a reference guarantees the existence of the object for the * caller. */ -static -struct lttng_trace_chunk *_lttng_trace_chunk_registry_find_chunk( - const struct lttng_trace_chunk_registry *registry, - uint64_t session_id, uint64_t *chunk_id) +static struct lttng_trace_chunk *_lttng_trace_chunk_registry_find_chunk( + const struct lttng_trace_chunk_registry *registry, uint64_t session_id, uint64_t *chunk_id) { - lttng_trace_chunk_registry_element target_element {}; + lttng_trace_chunk_registry_element target_element{}; target_element.chunk.id.is_set = !!chunk_id; target_element.chunk.id.value = chunk_id ? *chunk_id : 0; target_element.session_id = session_id; - const unsigned long element_hash = - lttng_trace_chunk_registry_element_hash( - &target_element); + const unsigned long element_hash = lttng_trace_chunk_registry_element_hash(&target_element); struct cds_lfht_node *published_node; struct lttng_trace_chunk_registry_element *published_element; struct lttng_trace_chunk *published_chunk = NULL; @@ -2135,8 +2042,8 @@ struct lttng_trace_chunk *_lttng_trace_chunk_registry_find_chunk( goto end; } - published_element = lttng::utils::container_of(published_node, - <tng_trace_chunk_registry_element::trace_chunk_registry_ht_node); + published_element = lttng::utils::container_of( + published_node, <tng_trace_chunk_registry_element::trace_chunk_registry_ht_node); if (lttng_trace_chunk_get(&published_element->chunk)) { published_chunk = &published_element->chunk; } @@ -2145,18 +2052,16 @@ end: return published_chunk; } -struct lttng_trace_chunk * -lttng_trace_chunk_registry_find_chunk( - const struct lttng_trace_chunk_registry *registry, - uint64_t session_id, uint64_t chunk_id) +struct lttng_trace_chunk *lttng_trace_chunk_registry_find_chunk( + const struct lttng_trace_chunk_registry *registry, uint64_t session_id, uint64_t chunk_id) { - return _lttng_trace_chunk_registry_find_chunk(registry, - session_id, &chunk_id); + return _lttng_trace_chunk_registry_find_chunk(registry, session_id, &chunk_id); } -int lttng_trace_chunk_registry_chunk_exists( - const struct lttng_trace_chunk_registry *registry, - uint64_t session_id, uint64_t chunk_id, bool *chunk_exists) +int lttng_trace_chunk_registry_chunk_exists(const struct lttng_trace_chunk_registry *registry, + uint64_t session_id, + uint64_t chunk_id, + bool *chunk_exists) { int ret = 0; lttng_trace_chunk_registry_element target_element; @@ -2165,9 +2070,7 @@ int lttng_trace_chunk_registry_chunk_exists( target_element.chunk.id.value = chunk_id; target_element.session_id = session_id; - const unsigned long element_hash = - lttng_trace_chunk_registry_element_hash( - &target_element); + const unsigned long element_hash = lttng_trace_chunk_registry_element_hash(&target_element); struct cds_lfht_node *published_node; struct cds_lfht_iter iter; @@ -2190,16 +2093,14 @@ end: } struct lttng_trace_chunk * -lttng_trace_chunk_registry_find_anonymous_chunk( - const struct lttng_trace_chunk_registry *registry, - uint64_t session_id) +lttng_trace_chunk_registry_find_anonymous_chunk(const struct lttng_trace_chunk_registry *registry, + uint64_t session_id) { - return _lttng_trace_chunk_registry_find_chunk(registry, - session_id, NULL); + return _lttng_trace_chunk_registry_find_chunk(registry, session_id, NULL); } -unsigned int lttng_trace_chunk_registry_put_each_chunk( - const struct lttng_trace_chunk_registry *registry) +unsigned int +lttng_trace_chunk_registry_put_each_chunk(const struct lttng_trace_chunk_registry *registry) { struct cds_lfht_iter iter; struct lttng_trace_chunk_registry_element *chunk_element; @@ -2207,8 +2108,7 @@ unsigned int lttng_trace_chunk_registry_put_each_chunk( DBG("Releasing trace chunk registry to all trace chunks"); rcu_read_lock(); - cds_lfht_for_each_entry(registry->ht, - &iter, chunk_element, trace_chunk_registry_ht_node) { + cds_lfht_for_each_entry (registry->ht, &iter, chunk_element, trace_chunk_registry_ht_node) { const char *chunk_id_str = "none"; char chunk_id_buf[MAX_INT_DEC_LEN(uint64_t)]; @@ -2216,9 +2116,10 @@ unsigned int lttng_trace_chunk_registry_put_each_chunk( if (chunk_element->chunk.id.is_set) { int fmt_ret; - fmt_ret = snprintf(chunk_id_buf, sizeof(chunk_id_buf), - "%" PRIu64, - chunk_element->chunk.id.value); + fmt_ret = snprintf(chunk_id_buf, + sizeof(chunk_id_buf), + "%" PRIu64, + chunk_element->chunk.id.value); if (fmt_ret < 0 || fmt_ret >= sizeof(chunk_id_buf)) { chunk_id_str = "formatting error"; } else { @@ -2227,19 +2128,17 @@ unsigned int lttng_trace_chunk_registry_put_each_chunk( } DBG("Releasing reference to trace chunk: session_id = %" PRIu64 - "chunk_id = %s, name = \"%s\", status = %s", - chunk_element->session_id, - chunk_id_str, - chunk_element->chunk.name ? : "none", - chunk_element->chunk.close_command.is_set ? - "open" : "closed"); + "chunk_id = %s, name = \"%s\", status = %s", + chunk_element->session_id, + chunk_id_str, + chunk_element->chunk.name ?: "none", + chunk_element->chunk.close_command.is_set ? "open" : "closed"); pthread_mutex_unlock(&chunk_element->chunk.lock); lttng_trace_chunk_put(&chunk_element->chunk); trace_chunks_left++; } rcu_read_unlock(); - DBG("Released reference to %u trace chunks in %s()", trace_chunks_left, - __FUNCTION__); + DBG("Released reference to %u trace chunks in %s()", trace_chunks_left, __FUNCTION__); return trace_chunks_left; }