common: index and trace-chunk file creation/open API change

[lttng-tools.git] / src / common / index / index.c

diff --git a/src/common/index/index.c b/src/common/index/index.c
index 52a3c2e3fab9c89e2dcd054b8652f7c9582dcfc5..9f7e5f67a18dd4e8d67827890730695ec41bd2e2 100644 (file)
--- a/src/common/index/index.c
+++ b/src/common/index/index.c
@@ -34,13 +34,13 @@
 #define WRITE_FILE_FLAGS       (O_WRONLY | O_CREAT | O_TRUNC)
 #define READ_ONLY_FILE_FLAGS   O_RDONLY
 
-static struct lttng_index_file *_lttng_index_file_create_from_trace_chunk(
+static enum lttng_trace_chunk_status _lttng_index_file_create_from_trace_chunk(
                struct lttng_trace_chunk *chunk,
                const char *channel_path, const char *stream_name,
                uint64_t stream_file_size, uint64_t stream_file_index,
                uint32_t index_major, uint32_t index_minor,
                bool unlink_existing_file,
-               int flags)
+               int flags, bool expect_no_file, struct lttng_index_file **file)
 {
        struct lttng_index_file *index_file;
        enum lttng_trace_chunk_status chunk_status;
@@ -49,24 +49,30 @@ static struct lttng_index_file *_lttng_index_file_create_from_trace_chunk(
        struct ctf_packet_index_file_hdr hdr;
        char index_directory_path[LTTNG_PATH_MAX];
        char index_file_path[LTTNG_PATH_MAX];
-       const uint32_t element_len = ctf_packet_index_len(index_major,
-                       index_minor);
        const mode_t mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
        const bool acquired_reference = lttng_trace_chunk_get(chunk);
+       const char *separator;
 
        assert(acquired_reference);
 
        index_file = zmalloc(sizeof(*index_file));
        if (!index_file) {
                PERROR("Failed to allocate lttng_index_file");
+               chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
                goto error;
        }
 
        index_file->trace_chunk = chunk;
+       if (channel_path[0] == '\0') {
+               separator = "";
+       } else {
+               separator = "/";
+       }
        ret = snprintf(index_directory_path, sizeof(index_directory_path),
-                       "%s/" DEFAULT_INDEX_DIR, channel_path);
+                       "%s%s" DEFAULT_INDEX_DIR, channel_path, separator);
        if (ret < 0 || ret >= sizeof(index_directory_path)) {
                ERR("Failed to format index directory path");
+               chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
                goto error;
        }
 
@@ -75,6 +81,7 @@ static struct lttng_index_file *_lttng_index_file_create_from_trace_chunk(
                        DEFAULT_INDEX_FILE_SUFFIX,
                        index_file_path, sizeof(index_file_path));
        if (ret) {
+               chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
                goto error;
        }
 
@@ -97,24 +104,61 @@ static struct lttng_index_file *_lttng_index_file_create_from_trace_chunk(
        }
 
        chunk_status = lttng_trace_chunk_open_file(chunk, index_file_path,
-                       flags, mode, &fd);
+                       flags, mode, &fd, expect_no_file);
        if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
                goto error;
        }
 
-       ctf_packet_index_file_hdr_init(&hdr, index_major, index_minor);
-       size_ret = lttng_write(fd, &hdr, sizeof(hdr));
-       if (size_ret < sizeof(hdr)) {
-               PERROR("Failed to write index header");
-               goto error;
+       if (flags == WRITE_FILE_FLAGS) {
+               ctf_packet_index_file_hdr_init(&hdr, index_major, index_minor);
+               size_ret = lttng_write(fd, &hdr, sizeof(hdr));
+               if (size_ret < sizeof(hdr)) {
+                       PERROR("Failed to write index header");
+                       chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
+                       goto error;
+               }
+               index_file->element_len = ctf_packet_index_len(index_major, index_minor);
+       } else {
+               uint32_t element_len;
+
+               size_ret = lttng_read(fd, &hdr, sizeof(hdr));
+               if (size_ret < 0) {
+                       PERROR("Failed to read index header");
+                       chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
+                       goto error;
+               }
+               if (be32toh(hdr.magic) != CTF_INDEX_MAGIC) {
+                       ERR("Invalid header magic");
+                       chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
+                       goto error;
+               }
+               if (index_major != be32toh(hdr.index_major)) {
+                       ERR("Index major number mismatch: %u, expect %u",
+                               be32toh(hdr.index_major), index_major);
+                       chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
+                       goto error;
+               }
+               if (index_minor != be32toh(hdr.index_minor)) {
+                       ERR("Index minor number mismatch: %u, expect %u",
+                               be32toh(hdr.index_minor), index_minor);
+                       chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
+                       goto error;
+               }
+               element_len = be32toh(hdr.packet_index_len);
+               if (element_len > sizeof(struct ctf_packet_index)) {
+                       ERR("Index element length too long");
+                       chunk_status = LTTNG_TRACE_CHUNK_STATUS_ERROR;
+                       goto error;
+               }
+               index_file->element_len = element_len;
        }
        index_file->fd = fd;
        index_file->major = index_major;
        index_file->minor = index_minor;
-       index_file->element_len = element_len;
        urcu_ref_init(&index_file->ref);
 
-       return index_file;
+       *file = index_file;
+       return LTTNG_TRACE_CHUNK_STATUS_OK;
 
 error:
        if (fd >= 0) {
@@ -123,33 +167,35 @@ error:
                        PERROR("Failed to close file descriptor of index file");
                }
        }
+       lttng_trace_chunk_put(chunk);
        free(index_file);
-       return NULL;
+       return chunk_status;
 }
 
-struct lttng_index_file *lttng_index_file_create_from_trace_chunk(
+enum lttng_trace_chunk_status lttng_index_file_create_from_trace_chunk(
                struct lttng_trace_chunk *chunk,
                const char *channel_path, const char *stream_name,
                uint64_t stream_file_size, uint64_t stream_file_index,
                uint32_t index_major, uint32_t index_minor,
-               bool unlink_existing_file)
+               bool unlink_existing_file, struct lttng_index_file **file)
 {
        return _lttng_index_file_create_from_trace_chunk(chunk, channel_path,
                        stream_name, stream_file_size, stream_file_index,
                        index_major, index_minor, unlink_existing_file,
-                       WRITE_FILE_FLAGS);
+                       WRITE_FILE_FLAGS, false, file);
 }
 
-struct lttng_index_file *lttng_index_file_create_from_trace_chunk_read_only(
+enum lttng_trace_chunk_status lttng_index_file_create_from_trace_chunk_read_only(
                struct lttng_trace_chunk *chunk,
                const char *channel_path, const char *stream_name,
                uint64_t stream_file_size, uint64_t stream_file_index,
-               uint32_t index_major, uint32_t index_minor)
+               uint32_t index_major, uint32_t index_minor,
+               bool expect_no_file, struct lttng_index_file **file)
 {
        return _lttng_index_file_create_from_trace_chunk(chunk, channel_path,
                        stream_name, stream_file_size, stream_file_index,
                        index_major, index_minor, false,
-                       READ_ONLY_FILE_FLAGS);
+                       READ_ONLY_FILE_FLAGS, expect_no_file, file);
 }
 
 /*