X-Git-Url: https://git.lttng.org/?p=lttng-tools.git;a=blobdiff_plain;f=src%2Fcommon%2Findex%2Findex.c;h=52a3c2e3fab9c89e2dcd054b8652f7c9582dcfc5;hp=a00403420dc98f3ead4de96632995a7c07e01a28;hb=2ef0da38417d17ed7e485e92572d234fd9e021b3;hpb=6347a8b5c62a93c52cb11a68598068abb85ad930

diff --git a/src/common/index/index.c b/src/common/index/index.c
index a00403420..52a3c2e3f 100644
--- a/src/common/index/index.c
+++ b/src/common/index/index.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2013 - Julien Desfossez <jdesfossez@efficios.com>
  *                      David Goulet <dgoulet@efficios.com>
+ *               2016 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License, version 2 only, as
@@ -16,175 +17,225 @@
  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
-#define _GNU_SOURCE
+#define _LGPL_SOURCE
 #include <assert.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 
+#include <lttng/constant.h>
 #include <common/common.h>
 #include <common/defaults.h>
+#include <common/compat/endian.h>
 #include <common/utils.h>
 
 #include "index.h"
 
-/*
- * Create the index file associated with a trace file.
- *
- * Return fd on success, a negative value on error.
- */
-int index_create_file(char *path_name, char *stream_name, int uid, int gid,
-		uint64_t size, uint64_t count)
+#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(
+		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)
 {
+	struct lttng_index_file *index_file;
+	enum lttng_trace_chunk_status chunk_status;
 	int ret, fd = -1;
 	ssize_t size_ret;
 	struct ctf_packet_index_file_hdr hdr;
-	char fullpath[PATH_MAX];
+	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);
+
+	assert(acquired_reference);
+
+	index_file = zmalloc(sizeof(*index_file));
+	if (!index_file) {
+		PERROR("Failed to allocate lttng_index_file");
+		goto error;
+	}
 
-	ret = snprintf(fullpath, sizeof(fullpath), "%s/" DEFAULT_INDEX_DIR,
-			path_name);
-	if (ret < 0) {
-		PERROR("snprintf index path");
+	index_file->trace_chunk = chunk;
+	ret = snprintf(index_directory_path, sizeof(index_directory_path),
+			"%s/" DEFAULT_INDEX_DIR, channel_path);
+	if (ret < 0 || ret >= sizeof(index_directory_path)) {
+		ERR("Failed to format index directory path");
 		goto error;
 	}
 
-	/* Create index directory if necessary. */
-	ret = run_as_mkdir(fullpath, S_IRWXU | S_IRWXG, uid, gid);
-	if (ret < 0) {
-		if (ret != -EEXIST) {
-			PERROR("Index trace directory creation error");
+	ret = utils_stream_file_path(index_directory_path, stream_name,
+			stream_file_size, stream_file_index,
+			DEFAULT_INDEX_FILE_SUFFIX,
+			index_file_path, sizeof(index_file_path));
+	if (ret) {
+		goto error;
+	}
+
+	if (unlink_existing_file) {
+		/*
+		 * For tracefile rotation. We need to unlink the old
+		 * file if present to synchronize with the tail of the
+		 * live viewer which could be working on this same file.
+		 * By doing so, any reference to the old index file
+		 * stays valid even if we re-create a new file with the
+		 * same name afterwards.
+		 */
+		chunk_status = lttng_trace_chunk_unlink_file(
+				chunk, index_file_path);
+		if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK &&
+				!(chunk_status == LTTNG_TRACE_CHUNK_STATUS_ERROR &&
+						errno == ENOENT)) {
 			goto error;
 		}
 	}
 
-	ret = utils_create_stream_file(fullpath, stream_name, size, count, uid,
-			gid, DEFAULT_INDEX_FILE_SUFFIX);
-	if (ret < 0) {
+	chunk_status = lttng_trace_chunk_open_file(chunk, index_file_path,
+			flags, mode, &fd);
+	if (chunk_status != LTTNG_TRACE_CHUNK_STATUS_OK) {
 		goto error;
 	}
-	fd = ret;
-
-	hdr.magic = htobe32(CTF_INDEX_MAGIC);
-	hdr.index_major = htobe32(CTF_INDEX_MAJOR);
-	hdr.index_minor = htobe32(CTF_INDEX_MINOR);
-	hdr.packet_index_len = sizeof(struct ctf_packet_index);
 
+	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("write index header");
-		ret = -1;
+		PERROR("Failed to write index header");
 		goto error;
 	}
+	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 fd;
+	return index_file;
 
 error:
 	if (fd >= 0) {
-		int close_ret;
-
-		close_ret = close(fd);
-		if (close_ret < 0) {
-			PERROR("close index fd");
+		ret = close(fd);
+		if (ret < 0) {
+			PERROR("Failed to close file descriptor of index file");
 		}
 	}
-	return ret;
+	free(index_file);
+	return NULL;
+}
+
+struct lttng_index_file *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)
+{
+	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);
+}
+
+struct lttng_index_file *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)
+{
+	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);
 }
 
 /*
- * Write index values to the given fd of size len.
+ * Write index values to the given index file.
  *
- * Return "len" on success or else < len on error. errno contains error
- * details.
+ * Return 0 on success, -1 on error.
  */
-ssize_t index_write(int fd, struct ctf_packet_index *index, size_t len)
+int lttng_index_file_write(const struct lttng_index_file *index_file,
+		const struct ctf_packet_index *element)
 {
+	int fd;
+	size_t len;
 	ssize_t ret;
 
-	assert(index);
+	assert(index_file);
+	assert(element);
+
+	fd = index_file->fd;
+	len = index_file->element_len;
 
 	if (fd < 0) {
-		ret = -EINVAL;
 		goto error;
 	}
 
-	ret = lttng_write(fd, index, len);
+	ret = lttng_write(fd, element, len);
 	if (ret < len) {
 		PERROR("writing index file");
+		goto error;
 	}
+	return 0;
 
 error:
-	return ret;
+	return -1;
 }
 
 /*
- * Open index file using a given path, channel name and tracefile count.
+ * Read index values from the given index file.
  *
- * Return read only FD on success or else a negative value.
+ * Return 0 on success, -1 on error.
  */
-int index_open(const char *path_name, const char *channel_name,
-		uint64_t tracefile_count, uint64_t tracefile_count_current)
+int lttng_index_file_read(const struct lttng_index_file *index_file,
+		struct ctf_packet_index *element)
 {
-	int ret, read_fd;
-	ssize_t read_len;
-	char fullpath[PATH_MAX];
-	struct ctf_packet_index_file_hdr hdr;
+	ssize_t ret;
+	int fd = index_file->fd;
+	size_t len = index_file->element_len;
 
-	assert(path_name);
-	assert(channel_name);
+	assert(element);
 
-	if (tracefile_count > 0) {
-		ret = snprintf(fullpath, sizeof(fullpath), "%s/" DEFAULT_INDEX_DIR "/%s_%"
-				PRIu64 DEFAULT_INDEX_FILE_SUFFIX, path_name,
-				channel_name, tracefile_count_current);
-	} else {
-		ret = snprintf(fullpath, sizeof(fullpath), "%s/" DEFAULT_INDEX_DIR "/%s"
-				DEFAULT_INDEX_FILE_SUFFIX, path_name, channel_name);
-	}
-	if (ret < 0) {
-		PERROR("snprintf index path");
+	if (fd < 0) {
 		goto error;
 	}
 
-	DBG("Index opening file %s in read only", fullpath);
-	read_fd = open(fullpath, O_RDONLY);
-	if (read_fd < 0) {
-		if (errno == ENOENT) {
-			ret = -ENOENT;
-		} else {
-			PERROR("opening index in read-only");
-		}
+	ret = lttng_read(fd, element, len);
+	if (ret < 0) {
+		PERROR("read index file");
 		goto error;
 	}
-
-	read_len = lttng_read(read_fd, &hdr, sizeof(hdr));
-	if (read_len < 0) {
-		PERROR("Reading index header");
-		goto error_close;
+	if (ret < len) {
+		ERR("lttng_read expected %zu, returned %zd", len, ret);
+		goto error;
 	}
+	return 0;
 
-	if (be32toh(hdr.magic) != CTF_INDEX_MAGIC) {
-		ERR("Invalid header magic");
-		goto error_close;
-	}
-	if (be32toh(hdr.index_major) != CTF_INDEX_MAJOR ||
-			be32toh(hdr.index_minor) != CTF_INDEX_MINOR) {
-		ERR("Invalid header version");
-		goto error_close;
-	}
+error:
+	return -1;
+}
 
-	return read_fd;
+void lttng_index_file_get(struct lttng_index_file *index_file)
+{
+	urcu_ref_get(&index_file->ref);
+}
 
-error_close:
-	if (read_fd >= 0) {
-		int close_ret;
+static void lttng_index_file_release(struct urcu_ref *ref)
+{
+	struct lttng_index_file *index_file = caa_container_of(ref,
+			struct lttng_index_file, ref);
 
-		close_ret = close(read_fd);
-		if (close_ret < 0) {
-			PERROR("close read fd %d", read_fd);
-		}
+	if (close(index_file->fd)) {
+		PERROR("close index fd");
 	}
-	ret = -1;
+	lttng_trace_chunk_put(index_file->trace_chunk);
+	free(index_file);
+}
 
-error:
-	return ret;
+void lttng_index_file_put(struct lttng_index_file *index_file)
+{
+	urcu_ref_put(&index_file->ref, lttng_index_file_release);
 }