[babeltrace.git] / src / fd-cache / fd-cache.c

/*
 * fd-cache.c
 *
 * Babeltrace - File descriptor cache
 *
 * Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
 *
 * Author: Francis Deslauriers <francis.deslauriers@efficios.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#define BT_LOG_TAG "FD-CACHE"
#include "logging.h"

#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <glib.h>

#include "common/assert.h"
#include "fd-cache.h"

struct file_key {
	uint64_t dev;
	uint64_t ino;
};

struct fd_handle_internal {
	struct bt_fd_cache_handle fd_handle;
	uint64_t ref_count;
	struct file_key *key;
};

static
void fd_cache_handle_internal_destroy(
		struct fd_handle_internal *internal_fd)
{
	if (!internal_fd) {
		goto end;
	}

	if (internal_fd->fd_handle.fd >= 0) {
		close(internal_fd->fd_handle.fd);
		internal_fd->fd_handle.fd = -1;
	}

end:
	g_free(internal_fd);
}

/*
 * Using simple hash algorithm found on stackoverflow:
 * https://stackoverflow.com/questions/664014/
 */
static inline
uint64_t hash_uint64_t(uint64_t x) {
	x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
	x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
	x = x ^ (x >> 31);
	return x;
}

static
guint file_key_hash(gconstpointer v)
{
	const struct file_key *fk = v;
	return hash_uint64_t(fk->dev) ^ hash_uint64_t(fk->ino);
}

static
gboolean file_key_equal(gconstpointer v1, gconstpointer v2)
{
	const struct file_key *fk1 = v1;
	const struct file_key *fk2 = v2;

	return (fk1->dev == fk2->dev) && (fk1->ino == fk2->ino);
}

static
void file_key_destroy(gpointer data)
{
	struct file_key *fk = data;
	g_free(fk);
}

BT_HIDDEN
int bt_fd_cache_init(struct bt_fd_cache *fdc)
{
	int ret = 0;

	fdc->cache = g_hash_table_new_full(file_key_hash, file_key_equal,
		file_key_destroy, (GDestroyNotify) fd_cache_handle_internal_destroy);
	if (!fdc->cache) {
		ret = -1;
	}

	return ret;
}

BT_HIDDEN
void bt_fd_cache_fini(struct bt_fd_cache *fdc)
{
	BT_ASSERT(fdc->cache);
	/*
	 * All handle should have been removed for the hashtable at this point.
	 */
	BT_ASSERT(g_hash_table_size(fdc->cache) == 0);
	g_hash_table_destroy(fdc->cache);

	return;
}

BT_HIDDEN
struct bt_fd_cache_handle *bt_fd_cache_get_handle(struct bt_fd_cache *fdc,
		const char *path)
{
	struct fd_handle_internal *fd_internal = NULL;
	struct stat statbuf;
	struct file_key fk;
	int ret, fd = -1;

	ret = stat(path, &statbuf);
	if (ret < 0) {
		/*
		 * This is not necessarily an error as we sometimes try to open
		 * files to see if they exist. Log the error as DEBUG severity
		 * level.
		 */
		BT_LOGD_ERRNO("Failed to stat file", ": path=%s", path);
		goto end;
	}

	/*
	 * Use the device number and inode number to uniquely identify a file.
	 * Even if the file has the same path, it may have been replaced so we
	 * must open a new FD for it. This replacement of file is more likely
	 * to happen with a lttng-live source component.
	 */
	fk.dev = statbuf.st_dev;
	fk.ino = statbuf.st_ino;

	fd_internal = g_hash_table_lookup(fdc->cache, &fk);
	if (!fd_internal) {
		struct file_key *file_key;

		fd = open(path, O_RDONLY);
		if (fd < 0) {
			BT_LOGE_ERRNO("Failed to open file", "path=%s", path);
			goto error;
		}

		fd_internal = g_new0(struct fd_handle_internal, 1);
		if (!fd_internal) {
			BT_LOGE_STR("Failed to allocate internal FD handle.");
			goto error;
		}

		file_key = g_new0(struct file_key, 1);
		if (!fd_internal) {
			BT_LOGE_STR("Failed to allocate file key.");
			goto error;
		}

		*file_key = fk;

		fd_internal->fd_handle.fd = fd;
		fd_internal->ref_count = 0;
		fd_internal->key = file_key;

		/* Insert the newly created fd handle. */
		g_hash_table_insert(fdc->cache, fd_internal->key, fd_internal);
	}

	fd_internal->ref_count++;
	goto end;

error:
	/*
	 * Close file descriptor if it was open() and we are currently on error
	 * path.
	 */
	if (fd != -1) {
		ret = close(fd);
		if (ret) {
			BT_LOGE_ERRNO("Failed to close file descriptor",
				": fd=%i, path=%s", fd, path);
		}
	}

	fd_cache_handle_internal_destroy(fd_internal);
	fd_internal = NULL;
end:
	return (struct bt_fd_cache_handle *) fd_internal;
}

BT_HIDDEN
void bt_fd_cache_put_handle(struct bt_fd_cache *fdc,
		struct bt_fd_cache_handle *handle)
{
	struct fd_handle_internal *fd_internal;

	if (!handle) {
		goto end;
	}

	fd_internal = (struct fd_handle_internal *) handle;

	BT_ASSERT(fd_internal->ref_count > 0);

	if (fd_internal->ref_count > 1) {
		fd_internal->ref_count--;
	} else {
		gboolean ret;
		int close_ret;

		close_ret = close(fd_internal->fd_handle.fd);
		if (close_ret == -1) {
			BT_LOGE_ERRNO("Failed to close file descriptor",
				": fd=%d", fd_internal->fd_handle.fd);
		}
		ret = g_hash_table_remove(fdc->cache, fd_internal->key);
		BT_ASSERT(ret);
	}

end:
	return;
}
Commit	Line	Data
1e638f98 FD	1	/*
	2	* fd-cache.c
	3	*
	4	* Babeltrace - File descriptor cache
	5	*
	6	* Copyright 2019 Francis Deslauriers <francis.deslauriers@efficios.com>
	7	*
	8	* Author: Francis Deslauriers <francis.deslauriers@efficios.com>
	9	*
	10	* Permission is hereby granted, free of charge, to any person obtaining a copy
	11	* of this software and associated documentation files (the "Software"), to deal
	12	* in the Software without restriction, including without limitation the rights
	13	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	14	* copies of the Software, and to permit persons to whom the Software is
	15	* furnished to do so, subject to the following conditions:
	16	*
	17	* The above copyright notice and this permission notice shall be included in
	18	* all copies or substantial portions of the Software.
	19	*
	20	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	21	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	23	* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	24	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	25	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	26	* SOFTWARE.
	27	*/
	28
	29	#define BT_LOG_TAG "FD-CACHE"
	30	#include "logging.h"
	31
	32	#include <fcntl.h>
	33	#include <sys/stat.h>
	34	#include <sys/types.h>
	35	#include <unistd.h>
	36	#include <glib.h>
	37
578e048b MJ	38	#include "common/assert.h"
578e048b MJ	39	#include "fd-cache.h"
1e638f98 FD	40
	41	struct file_key {
	42	uint64_t dev;
	43	uint64_t ino;
	44	};
	45
	46	struct fd_handle_internal {
	47	struct bt_fd_cache_handle fd_handle;
	48	uint64_t ref_count;
	49	struct file_key *key;
	50	};
	51
	52	static
	53	void fd_cache_handle_internal_destroy(
	54	struct fd_handle_internal *internal_fd)
	55	{
	56	if (!internal_fd) {
	57	goto end;
	58	}
	59
	60	if (internal_fd->fd_handle.fd >= 0) {
	61	close(internal_fd->fd_handle.fd);
	62	internal_fd->fd_handle.fd = -1;
	63	}
	64
	65	end:
	66	g_free(internal_fd);
	67	}
	68
	69	/*
	70	* Using simple hash algorithm found on stackoverflow:
	71	* https://stackoverflow.com/questions/664014/
	72	*/
	73	static inline
	74	uint64_t hash_uint64_t(uint64_t x) {
	75	x = (x ^ (x >> 30)) * UINT64_C(0xbf58476d1ce4e5b9);
	76	x = (x ^ (x >> 27)) * UINT64_C(0x94d049bb133111eb);
	77	x = x ^ (x >> 31);
	78	return x;
	79	}
	80
	81	static
	82	guint file_key_hash(gconstpointer v)
	83	{
	84	const struct file_key *fk = v;
	85	return hash_uint64_t(fk->dev) ^ hash_uint64_t(fk->ino);
	86	}
	87
	88	static
	89	gboolean file_key_equal(gconstpointer v1, gconstpointer v2)
	90	{
	91	const struct file_key *fk1 = v1;
	92	const struct file_key *fk2 = v2;
	93
	94	return (fk1->dev == fk2->dev) && (fk1->ino == fk2->ino);
	95	}
	96
	97	static
	98	void file_key_destroy(gpointer data)
	99	{
	100	struct file_key *fk = data;
	101	g_free(fk);
	102	}
	103
104	BT_HIDDEN
105	int bt_fd_cache_init(struct bt_fd_cache *fdc)
106	{
107	int ret = 0;
108
109	fdc->cache = g_hash_table_new_full(file_key_hash, file_key_equal,
110	file_key_destroy, (GDestroyNotify) fd_cache_handle_internal_destroy);
111	if (!fdc->cache) {
112	ret = -1;
113	}
114
115	return ret;
116	}
117
118	BT_HIDDEN
119	void bt_fd_cache_fini(struct bt_fd_cache *fdc)
120	{
121	BT_ASSERT(fdc->cache);
122	/*
123	* All handle should have been removed for the hashtable at this point.
124	*/
125	BT_ASSERT(g_hash_table_size(fdc->cache) == 0);
126	g_hash_table_destroy(fdc->cache);
127
128	return;
129	}
130
131	BT_HIDDEN
132	struct bt_fd_cache_handle bt_fd_cache_get_handle(struct bt_fd_cache fdc,
133	const char *path)
134	{
135	struct fd_handle_internal *fd_internal = NULL;
136	struct stat statbuf;
137	struct file_key fk;
2431859f	138	int ret, fd = -1;
1e638f98 FD	139
	140	ret = stat(path, &statbuf);
	141	if (ret < 0) {
093946c0 FD	142	/*
	143	* This is not necessarily an error as we sometimes try to open
	144	* files to see if they exist. Log the error as DEBUG severity
	145	* level.
	146	*/
	147	BT_LOGD_ERRNO("Failed to stat file", ": path=%s", path);
1e638f98 FD	148	goto end;
	149	}
	150
	151	/*
	152	* Use the device number and inode number to uniquely identify a file.
093946c0	153	* Even if the file has the same path, it may have been replaced so we
1e638f98 FD	154	* must open a new FD for it. This replacement of file is more likely
	155	* to happen with a lttng-live source component.
	156	*/
	157	fk.dev = statbuf.st_dev;
	158	fk.ino = statbuf.st_ino;
	159
	160	fd_internal = g_hash_table_lookup(fdc->cache, &fk);
	161	if (!fd_internal) {
1e638f98 FD	162	struct file_key *file_key;
1e638f98 FD	163
2431859f	164	fd = open(path, O_RDONLY);
1e638f98 FD	165	if (fd < 0) {
	166	BT_LOGE_ERRNO("Failed to open file", "path=%s", path);
	167	goto error;
	168	}
	169
	170	fd_internal = g_new0(struct fd_handle_internal, 1);
	171	if (!fd_internal) {
3f7d4d90	172	BT_LOGE_STR("Failed to allocate internal FD handle.");
1e638f98 FD	173	goto error;
	174	}
	175
	176	file_key = g_new0(struct file_key, 1);
	177	if (!fd_internal) {
3f7d4d90	178	BT_LOGE_STR("Failed to allocate file key.");
1e638f98 FD	179	goto error;
	180	}
	181
	182	*file_key = fk;
	183
	184	fd_internal->fd_handle.fd = fd;
	185	fd_internal->ref_count = 0;
	186	fd_internal->key = file_key;
	187
	188	/* Insert the newly created fd handle. */
95dc9c84	189	g_hash_table_insert(fdc->cache, fd_internal->key, fd_internal);
1e638f98 FD	190	}
1e638f98 FD	191
1e638f98 FD	192	fd_internal->ref_count++;
	193	goto end;
	194
	195	error:
2431859f FD	196	/*
	197	* Close file descriptor if it was open() and we are currently on error
	198	* path.
	199	*/
	200	if (fd != -1) {
	201	ret = close(fd);
	202	if (ret) {
	203	BT_LOGE_ERRNO("Failed to close file descriptor",
	204	": fd=%i, path=%s", fd, path);
	205	}
	206	}
	207
1e638f98 FD	208	fd_cache_handle_internal_destroy(fd_internal);
	209	fd_internal = NULL;
	210	end:
	211	return (struct bt_fd_cache_handle *) fd_internal;
	212	}
	213
	214	BT_HIDDEN
	215	void bt_fd_cache_put_handle(struct bt_fd_cache *fdc,
	216	struct bt_fd_cache_handle *handle)
	217	{
	218	struct fd_handle_internal *fd_internal;
	219
	220	if (!handle) {
	221	goto end;
	222	}
	223
	224	fd_internal = (struct fd_handle_internal *) handle;
	225
	226	BT_ASSERT(fd_internal->ref_count > 0);
	227
	228	if (fd_internal->ref_count > 1) {
	229	fd_internal->ref_count--;
	230	} else {
	231	gboolean ret;
	232	int close_ret;
	233
	234	close_ret = close(fd_internal->fd_handle.fd);
	235	if (close_ret == -1) {
3f7d4d90	236	BT_LOGE_ERRNO("Failed to close file descriptor",
1e638f98 FD	237	": fd=%d", fd_internal->fd_handle.fd);
	238	}
	239	ret = g_hash_table_remove(fdc->cache, fd_internal->key);
	240	BT_ASSERT(ret);
	241	}
	242
	243	end:
	244	return;
	245	}