[lttng-tools.git] / src / common / fd-tracker / inode.c

/*
 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
 *
 * SPDX-License-Identifier: GPL-2.0-only
 *
 */

#include <common/defaults.h>
#include <common/error.h>
#include <common/hashtable/utils.h>
#include <common/macros.h>
#include <common/optional.h>
#include <common/string-utils/format.h>
#include <common/utils.h>
#include <inttypes.h>
#include <lttng/constant.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <urcu.h>
#include <urcu/rculfhash.h>
#include <urcu/ref.h>

#include "inode.h"

struct inode_id {
	dev_t device;
	ino_t inode;
};

struct lttng_inode_registry {
	/* Hashtable of inode_id to lttng_inode. */
	struct cds_lfht *inodes;
};

struct lttng_inode {
	struct inode_id id;
	/* Node in the lttng_inode_registry's ht. */
	struct cds_lfht_node registry_node;
	/* Weak reference to ht containing the node. */
	struct cds_lfht *registry_ht;
	struct urcu_ref ref;
	struct rcu_head rcu_head;
	/* Location from which this file can be opened. */
	struct {
		struct lttng_directory_handle *directory_handle;
		char *path;
	} location;
	/* Unlink the underlying file at the release of the inode. */
	bool unlink_pending;
	LTTNG_OPTIONAL(unsigned int) unlinked_id;
	/* Weak reference. */
	struct lttng_unlinked_file_pool *unlinked_file_pool;
};

struct lttng_unlinked_file_pool {
	struct lttng_directory_handle *unlink_directory_handle;
	char *unlink_directory_path;
	unsigned int file_count;
	unsigned int next_id;
};

static struct {
	pthread_mutex_t lock;
	bool initialized;
	unsigned long value;
} seed = {
		.lock = PTHREAD_MUTEX_INITIALIZER,
};

static unsigned long lttng_inode_id_hash(const struct inode_id *id)
{
	uint64_t device = id->device, inode_no = id->inode;

	return hash_key_u64(&device, seed.value) ^
	       hash_key_u64(&inode_no, seed.value);
}

static int lttng_inode_match(struct cds_lfht_node *node, const void *key)
{
	const struct inode_id *id = key;
	const struct lttng_inode *inode = caa_container_of(
			node, struct lttng_inode, registry_node);

	return inode->id.device == id->device && inode->id.inode == id->inode;
}

static void lttng_inode_free(struct rcu_head *head)
{
	struct lttng_inode *inode =
			caa_container_of(head, struct lttng_inode, rcu_head);

	free(inode);
}

static int lttng_unlinked_file_pool_add_inode(
		struct lttng_unlinked_file_pool *pool,
		struct lttng_inode *inode)
{
	int ret;
	const unsigned int unlinked_id = pool->next_id++;
	char *inode_unlinked_name;
	bool reference_acquired;

	DBG("Adding inode of %s to unlinked file pool as id %u",
			inode->location.path, unlinked_id);
	ret = asprintf(&inode_unlinked_name, "%u", unlinked_id);
	if (ret < 0) {
		ERR("Failed to format unlinked inode name");
		ret = -1;
		goto end;
	}

	if (pool->file_count == 0) {
		DBG("Creating unlinked files directory at %s",
				pool->unlink_directory_path);
		assert(!pool->unlink_directory_handle);
		ret = utils_mkdir(pool->unlink_directory_path,
				S_IRWXU | S_IRWXG, -1, -1);
		if (ret) {
			if (errno == EEXIST) {
				/*
				 * Unexpected (previous crash?), but not an
				 * error.
				 */
				DBG("Unlinked file directory \"%s\" already exists",
						pool->unlink_directory_path);
			} else {
				PERROR("Failed to create unlinked files directory at %s",
						pool->unlink_directory_path);
				goto end;
			}
		}
		pool->unlink_directory_handle = lttng_directory_handle_create(
				pool->unlink_directory_path);
		if (!pool->unlink_directory_handle) {
			ERR("Failed to create directory handle to unlinked file pool at %s",
					pool->unlink_directory_path);
			ret = -1;
			goto end;
		}
	}

	ret = lttng_directory_handle_rename(inode->location.directory_handle,
			inode->location.path, pool->unlink_directory_handle,
			inode_unlinked_name);
	if (ret) {
		goto end;
	}

	lttng_directory_handle_put(inode->location.directory_handle);
	inode->location.directory_handle = NULL;
	reference_acquired = lttng_directory_handle_get(
			pool->unlink_directory_handle);
	assert(reference_acquired);
	inode->location.directory_handle = pool->unlink_directory_handle;

	free(inode->location.path);
	inode->location.path = inode_unlinked_name;
	inode_unlinked_name = NULL;
	LTTNG_OPTIONAL_SET(&inode->unlinked_id, unlinked_id);
	pool->file_count++;
end:
	free(inode_unlinked_name);
	return ret;
}

static int lttng_unlinked_file_pool_remove_inode(
		struct lttng_unlinked_file_pool *pool,
		struct lttng_inode *inode)
{
	int ret;

	DBG("Removing inode with unlinked id %u from unlinked file pool",
			LTTNG_OPTIONAL_GET(inode->unlinked_id));

	ret = lttng_directory_handle_unlink_file(
			inode->location.directory_handle, inode->location.path);
	if (ret) {
		PERROR("Failed to unlink file %s from unlinked file directory",
				inode->location.path);
		goto end;
	}
	free(inode->location.path);
	inode->location.path = NULL;
	lttng_directory_handle_put(inode->location.directory_handle);
	inode->location.directory_handle = NULL;

	pool->file_count--;
	if (pool->file_count == 0) {
		ret = utils_recursive_rmdir(pool->unlink_directory_path);
		if (ret) {
			/*
			 * There is nothing the caller can do, don't report an
			 * error except through logging.
			 */
			PERROR("Failed to remove unlinked files directory at %s",
					pool->unlink_directory_path);
		}
		lttng_directory_handle_put(pool->unlink_directory_handle);
		pool->unlink_directory_handle = NULL;
	}
end:
	return ret;
}

static void lttng_inode_destroy(struct lttng_inode *inode)
{
	if (!inode) {
		return;
	}

	rcu_read_lock();
	cds_lfht_del(inode->registry_ht, &inode->registry_node);
	rcu_read_unlock();

	if (inode->unlink_pending) {
		int ret;

		assert(inode->location.directory_handle);
		assert(inode->location.path);
		DBG("Removing %s from unlinked file pool",
				inode->location.path);
		ret = lttng_unlinked_file_pool_remove_inode(inode->unlinked_file_pool, inode);
		if (ret) {
			PERROR("Failed to unlink %s", inode->location.path);
		}
	}

	lttng_directory_handle_put(
			inode->location.directory_handle);
	inode->location.directory_handle = NULL;
	free(inode->location.path);
	inode->location.path = NULL;
	call_rcu(&inode->rcu_head, lttng_inode_free);
}

static void lttng_inode_release(struct urcu_ref *ref)
{
	lttng_inode_destroy(caa_container_of(ref, struct lttng_inode, ref));
}

static void lttng_inode_get(struct lttng_inode *inode)
{
	urcu_ref_get(&inode->ref);
}

LTTNG_HIDDEN struct lttng_unlinked_file_pool *lttng_unlinked_file_pool_create(
		const char *path)
{
	struct lttng_unlinked_file_pool *pool = zmalloc(sizeof(*pool));

	if (!pool) {
		goto error;
	}

	if (!path || *path != '/') {
		ERR("Unlinked file pool must be created with an absolute path, path = \"%s\"",
				path ? path : "NULL");
		goto error;
	}

	pool->unlink_directory_path = strdup(path);
	if (!pool->unlink_directory_path) {
		PERROR("Failed to allocation unlinked file pool path");
		goto error;
	}
	DBG("Unlinked file pool created at: %s", path);
	return pool;
error:
	lttng_unlinked_file_pool_destroy(pool);
	return NULL;
}

LTTNG_HIDDEN void lttng_unlinked_file_pool_destroy(
		struct lttng_unlinked_file_pool *pool)
{
	if (!pool) {
		return;
	}

	assert(pool->file_count == 0);
	lttng_directory_handle_put(pool->unlink_directory_handle);
	free(pool->unlink_directory_path);
	free(pool);
}

LTTNG_HIDDEN void lttng_inode_put(struct lttng_inode *inode)
{
	urcu_ref_put(&inode->ref, lttng_inode_release);
}

LTTNG_HIDDEN struct lttng_directory_handle *
lttng_inode_get_location_directory_handle(
		struct lttng_inode *inode)
{
	if (inode->location.directory_handle) {
		const bool reference_acquired = lttng_directory_handle_get(
				inode->location.directory_handle);

		assert(reference_acquired);
	}
	return inode->location.directory_handle;
}

LTTNG_HIDDEN void lttng_inode_borrow_location(struct lttng_inode *inode,
		const struct lttng_directory_handle **out_directory_handle,
		const char **out_path)
{
	if (out_directory_handle) {
		*out_directory_handle = inode->location.directory_handle;
	}
	if (out_path) {
		*out_path = inode->location.path;
	}
}

LTTNG_HIDDEN int lttng_inode_rename(
		struct lttng_inode *inode,
		struct lttng_directory_handle *old_directory_handle,
		const char *old_path,
		struct lttng_directory_handle *new_directory_handle,
		const char *new_path,
		bool overwrite)
{
	int ret = 0;
	char *new_path_copy = strdup(new_path);
	bool reference_acquired;

	DBG("Performing rename of inode from %s to %s with %s directory handles",
			old_path, new_path,
			lttng_directory_handle_equals(old_directory_handle,
					new_directory_handle) ?
					"identical" :
					"different");

	if (!new_path_copy) {
		ret = -ENOMEM;
		goto end;
	}

	if (inode->unlink_pending) {
		WARN("An attempt to rename an unlinked file from %s to %s has been performed",
				old_path, new_path);
		ret = -ENOENT;
		goto end;
	}

	if (!overwrite) {
		/* Verify that file doesn't exist. */
		struct stat statbuf;

		ret = lttng_directory_handle_stat(
				new_directory_handle, new_path, &statbuf);
		if (ret == 0) {
			ERR("Refusing to rename %s as the destination already exists",
					old_path);
			ret = -EEXIST;
			goto end;
		} else if (ret < 0 && errno != ENOENT) {
			PERROR("Failed to stat() %s", new_path);
			ret = -errno;
			goto end;
		}
	}

	ret = lttng_directory_handle_rename(old_directory_handle, old_path,
			new_directory_handle, new_path);
	if (ret) {
		PERROR("Failed to rename file %s to %s", old_path, new_path);
		ret = -errno;
		goto end;
	}

	reference_acquired = lttng_directory_handle_get(new_directory_handle);
	assert(reference_acquired);
	lttng_directory_handle_put(inode->location.directory_handle);
	free(inode->location.path);
	inode->location.directory_handle = new_directory_handle;
	/* Ownership transferred. */
	inode->location.path = new_path_copy;
	new_path_copy = NULL;
end:
	free(new_path_copy);
	return ret;
}

LTTNG_HIDDEN int lttng_inode_unlink(struct lttng_inode *inode)
{
	int ret = 0;

	DBG("Attempting unlink of inode %s", inode->location.path);

	if (inode->unlink_pending) {
		WARN("An attempt to re-unlink %s has been performed, ignoring.",
				inode->location.path);
		ret = -ENOENT;
		goto end;
	}

	/*
	 * Move to the temporary "deleted" directory until all
	 * references are released.
	 */
	ret = lttng_unlinked_file_pool_add_inode(
			inode->unlinked_file_pool, inode);
	if (ret) {
		PERROR("Failed to add inode \"%s\" to the unlinked file pool",
				inode->location.path);
		goto end;
	}
	inode->unlink_pending = true;
end:
	return ret;
}

static struct lttng_inode *lttng_inode_create(const struct inode_id *id,
		struct cds_lfht *ht,
		struct lttng_unlinked_file_pool *unlinked_file_pool,
		struct lttng_directory_handle *directory_handle,
		const char *path)
{
	struct lttng_inode *inode = NULL;
	char *path_copy;
	bool reference_acquired;

	path_copy = strdup(path);
	if (!path_copy) {
		goto end;
	}

	reference_acquired = lttng_directory_handle_get(directory_handle);
	assert(reference_acquired);

	inode = zmalloc(sizeof(*inode));
	if (!inode) {
		goto end;
	}

	urcu_ref_init(&inode->ref);
	cds_lfht_node_init(&inode->registry_node);
	inode->id = *id;
	inode->registry_ht = ht;
	inode->unlinked_file_pool = unlinked_file_pool;
	/* Ownership of path copy is transferred to inode. */
	inode->location.path = path_copy;
	path_copy = NULL;
	inode->location.directory_handle = directory_handle;
end:
	free(path_copy);
	return inode;
}

LTTNG_HIDDEN struct lttng_inode_registry *lttng_inode_registry_create(void)
{
	struct lttng_inode_registry *registry = zmalloc(sizeof(*registry));

	if (!registry) {
		goto end;
	}

	pthread_mutex_lock(&seed.lock);
	if (!seed.initialized) {
		seed.value = (unsigned long) time(NULL);
		seed.initialized = true;
	}
	pthread_mutex_unlock(&seed.lock);

	registry->inodes = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
			CDS_LFHT_AUTO_RESIZE | CDS_LFHT_ACCOUNTING, NULL);
	if (!registry->inodes) {
		goto error;
	}
end:
	return registry;
error:
	lttng_inode_registry_destroy(registry);
	return NULL;
}

LTTNG_HIDDEN void lttng_inode_registry_destroy(
		struct lttng_inode_registry *registry)
{
	if (!registry) {
		return;
	}
	if (registry->inodes) {
		int ret = cds_lfht_destroy(registry->inodes, NULL);

		assert(!ret);
	}
	free(registry);
}

LTTNG_HIDDEN struct lttng_inode *lttng_inode_registry_get_inode(
		struct lttng_inode_registry *registry,
		struct lttng_directory_handle *handle,
		const char *path,
		int fd,
		struct lttng_unlinked_file_pool *unlinked_file_pool)
{
	int ret;
	struct stat statbuf;
	struct inode_id id;
	struct cds_lfht_iter iter;
	struct cds_lfht_node *node;
	struct lttng_inode *inode = NULL;

	ret = fstat(fd, &statbuf);
	if (ret < 0) {
		PERROR("stat() failed on fd %i", fd);
		goto end;
	}

	id.device = statbuf.st_dev;
	id.inode = statbuf.st_ino;

	rcu_read_lock();
	cds_lfht_lookup(registry->inodes, lttng_inode_id_hash(&id),
			lttng_inode_match, &id, &iter);
	node = cds_lfht_iter_get_node(&iter);
	if (node) {
		inode = caa_container_of(
				node, struct lttng_inode, registry_node);
		lttng_inode_get(inode);
		goto end_unlock;
	}

	inode = lttng_inode_create(&id, registry->inodes, unlinked_file_pool,
			handle, path);
	if (!inode) {
		goto end_unlock;
	}

	node = cds_lfht_add_unique(registry->inodes,
			lttng_inode_id_hash(&inode->id), lttng_inode_match,
			&inode->id, &inode->registry_node);
	assert(node == &inode->registry_node);
end_unlock:
	rcu_read_unlock();
end:
	return inode;
}
Commit	Line	Data
e0e72660	1	/*
ab5be9fa	2	* Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
e0e72660	3	*
ab5be9fa	4	* SPDX-License-Identifier: GPL-2.0-only
e0e72660	5	*
e0e72660 JG	6	*/
e0e72660 JG	7
5c1f54d1 JG	8	#include <common/defaults.h>
	9	#include <common/error.h>
	10	#include <common/hashtable/utils.h>
	11	#include <common/macros.h>
f7c3ffd7 JG	12	#include <common/optional.h>
	13	#include <common/string-utils/format.h>
	14	#include <common/utils.h>
5c1f54d1 JG	15	#include <inttypes.h>
5c1f54d1 JG	16	#include <lttng/constant.h>
e0e72660	17	#include <sys/stat.h>
5c1f54d1	18	#include <sys/types.h>
e0e72660	19	#include <unistd.h>
e0e72660	20	#include <urcu.h>
e0e72660	21	#include <urcu/rculfhash.h>
5c1f54d1	22	#include <urcu/ref.h>
e0e72660 JG	23
	24	#include "inode.h"
	25
	26	struct inode_id {
	27	dev_t device;
	28	ino_t inode;
	29	};
	30
	31	struct lttng_inode_registry {
	32	/* Hashtable of inode_id to lttng_inode. */
	33	struct cds_lfht *inodes;
	34	};
	35
	36	struct lttng_inode {
	37	struct inode_id id;
e0e72660 JG	38	/* Node in the lttng_inode_registry's ht. */
	39	struct cds_lfht_node registry_node;
	40	/* Weak reference to ht containing the node. */
	41	struct cds_lfht *registry_ht;
	42	struct urcu_ref ref;
	43	struct rcu_head rcu_head;
f7c3ffd7 JG	44	/* Location from which this file can be opened. */
	45	struct {
	46	struct lttng_directory_handle *directory_handle;
	47	char *path;
	48	} location;
	49	/* Unlink the underlying file at the release of the inode. */
	50	bool unlink_pending;
	51	LTTNG_OPTIONAL(unsigned int) unlinked_id;
	52	/* Weak reference. */
	53	struct lttng_unlinked_file_pool *unlinked_file_pool;
	54	};
	55
	56	struct lttng_unlinked_file_pool {
	57	struct lttng_directory_handle *unlink_directory_handle;
	58	char *unlink_directory_path;
	59	unsigned int file_count;
	60	unsigned int next_id;
e0e72660 JG	61	};
	62
	63	static struct {
	64	pthread_mutex_t lock;
	65	bool initialized;
	66	unsigned long value;
	67	} seed = {
5c1f54d1	68	.lock = PTHREAD_MUTEX_INITIALIZER,
e0e72660 JG	69	};
e0e72660 JG	70
f7c3ffd7	71	static unsigned long lttng_inode_id_hash(const struct inode_id *id)
e0e72660 JG	72	{
	73	uint64_t device = id->device, inode_no = id->inode;
	74
5c1f54d1 JG	75	return hash_key_u64(&device, seed.value) ^
5c1f54d1 JG	76	hash_key_u64(&inode_no, seed.value);
e0e72660 JG	77	}
e0e72660 JG	78
5c1f54d1	79	static int lttng_inode_match(struct cds_lfht_node node, const void key)
e0e72660 JG	80	{
e0e72660 JG	81	const struct inode_id *id = key;
f7c3ffd7	82	const struct lttng_inode *inode = caa_container_of(
5c1f54d1	83	node, struct lttng_inode, registry_node);
e0e72660 JG	84
	85	return inode->id.device == id->device && inode->id.inode == id->inode;
	86	}
	87
f7c3ffd7	88	static void lttng_inode_free(struct rcu_head *head)
e0e72660	89	{
5c1f54d1 JG	90	struct lttng_inode *inode =
5c1f54d1 JG	91	caa_container_of(head, struct lttng_inode, rcu_head);
e0e72660	92
e0e72660 JG	93	free(inode);
	94	}
	95
f7c3ffd7 JG	96	static int lttng_unlinked_file_pool_add_inode(
	97	struct lttng_unlinked_file_pool *pool,
	98	struct lttng_inode *inode)
	99	{
	100	int ret;
	101	const unsigned int unlinked_id = pool->next_id++;
	102	char *inode_unlinked_name;
	103	bool reference_acquired;
	104
	105	DBG("Adding inode of %s to unlinked file pool as id %u",
	106	inode->location.path, unlinked_id);
	107	ret = asprintf(&inode_unlinked_name, "%u", unlinked_id);
	108	if (ret < 0) {
	109	ERR("Failed to format unlinked inode name");
	110	ret = -1;
	111	goto end;
	112	}
	113
	114	if (pool->file_count == 0) {
	115	DBG("Creating unlinked files directory at %s",
	116	pool->unlink_directory_path);
	117	assert(!pool->unlink_directory_handle);
	118	ret = utils_mkdir(pool->unlink_directory_path,
	119	S_IRWXU \| S_IRWXG, -1, -1);
	120	if (ret) {
	121	if (errno == EEXIST) {
	122	/*
	123	* Unexpected (previous crash?), but not an
	124	* error.
	125	*/
	126	DBG("Unlinked file directory \"%s\" already exists",
	127	pool->unlink_directory_path);
	128	} else {
	129	PERROR("Failed to create unlinked files directory at %s",
	130	pool->unlink_directory_path);
	131	goto end;
	132	}
	133	}
	134	pool->unlink_directory_handle = lttng_directory_handle_create(
	135	pool->unlink_directory_path);
d05a3d93 JG	136	if (!pool->unlink_directory_handle) {
	137	ERR("Failed to create directory handle to unlinked file pool at %s",
	138	pool->unlink_directory_path);
	139	ret = -1;
	140	goto end;
	141	}
f7c3ffd7 JG	142	}
	143
	144	ret = lttng_directory_handle_rename(inode->location.directory_handle,
	145	inode->location.path, pool->unlink_directory_handle,
	146	inode_unlinked_name);
	147	if (ret) {
	148	goto end;
	149	}
	150
	151	lttng_directory_handle_put(inode->location.directory_handle);
	152	inode->location.directory_handle = NULL;
	153	reference_acquired = lttng_directory_handle_get(
	154	pool->unlink_directory_handle);
	155	assert(reference_acquired);
	156	inode->location.directory_handle = pool->unlink_directory_handle;
	157
	158	free(inode->location.path);
	159	inode->location.path = inode_unlinked_name;
	160	inode_unlinked_name = NULL;
	161	LTTNG_OPTIONAL_SET(&inode->unlinked_id, unlinked_id);
	162	pool->file_count++;
	163	end:
	164	free(inode_unlinked_name);
	165	return ret;
	166	}
	167
	168	static int lttng_unlinked_file_pool_remove_inode(
	169	struct lttng_unlinked_file_pool *pool,
	170	struct lttng_inode *inode)
	171	{
	172	int ret;
	173
	174	DBG("Removing inode with unlinked id %u from unlinked file pool",
	175	LTTNG_OPTIONAL_GET(inode->unlinked_id));
	176
	177	ret = lttng_directory_handle_unlink_file(
	178	inode->location.directory_handle, inode->location.path);
	179	if (ret) {
	180	PERROR("Failed to unlink file %s from unlinked file directory",
	181	inode->location.path);
	182	goto end;
	183	}
	184	free(inode->location.path);
	185	inode->location.path = NULL;
	186	lttng_directory_handle_put(inode->location.directory_handle);
	187	inode->location.directory_handle = NULL;
	188
	189	pool->file_count--;
	190	if (pool->file_count == 0) {
	191	ret = utils_recursive_rmdir(pool->unlink_directory_path);
	192	if (ret) {
	193	/*
	194	* There is nothing the caller can do, don't report an
	195	* error except through logging.
	196	*/
	197	PERROR("Failed to remove unlinked files directory at %s",
	198	pool->unlink_directory_path);
	199	}
	200	lttng_directory_handle_put(pool->unlink_directory_handle);
	201	pool->unlink_directory_handle = NULL;
	202	}
	203	end:
	204	return ret;
	205	}
206
5c1f54d1	207	static void lttng_inode_destroy(struct lttng_inode *inode)
e0e72660 JG	208	{
	209	if (!inode) {
	210	return;
	211	}
f7c3ffd7 JG	212
	213	rcu_read_lock();
	214	cds_lfht_del(inode->registry_ht, &inode->registry_node);
	215	rcu_read_unlock();
	216
e0e72660	217	if (inode->unlink_pending) {
f7c3ffd7	218	int ret;
e0e72660	219
f7c3ffd7 JG	220	assert(inode->location.directory_handle);
	221	assert(inode->location.path);
	222	DBG("Removing %s from unlinked file pool",
	223	inode->location.path);
	224	ret = lttng_unlinked_file_pool_remove_inode(inode->unlinked_file_pool, inode);
e0e72660	225	if (ret) {
f7c3ffd7	226	PERROR("Failed to unlink %s", inode->location.path);
e0e72660 JG	227	}
e0e72660 JG	228	}
f7c3ffd7 JG	229
	230	lttng_directory_handle_put(
	231	inode->location.directory_handle);
	232	inode->location.directory_handle = NULL;
	233	free(inode->location.path);
	234	inode->location.path = NULL;
	235	call_rcu(&inode->rcu_head, lttng_inode_free);
e0e72660 JG	236	}
e0e72660 JG	237
5c1f54d1	238	static void lttng_inode_release(struct urcu_ref *ref)
e0e72660	239	{
5c1f54d1	240	lttng_inode_destroy(caa_container_of(ref, struct lttng_inode, ref));
e0e72660 JG	241	}
e0e72660 JG	242
5c1f54d1	243	static void lttng_inode_get(struct lttng_inode *inode)
e0e72660 JG	244	{
	245	urcu_ref_get(&inode->ref);
	246	}
	247
938bd422	248	LTTNG_HIDDEN struct lttng_unlinked_file_pool *lttng_unlinked_file_pool_create(
f7c3ffd7 JG	249	const char *path)
	250	{
	251	struct lttng_unlinked_file_pool pool = zmalloc(sizeof(pool));
	252
9604bd17 JG	253	if (!pool) {
	254	goto error;
	255	}
	256
f7c3ffd7 JG	257	if (!path \|\| *path != '/') {
	258	ERR("Unlinked file pool must be created with an absolute path, path = \"%s\"",
	259	path ? path : "NULL");
	260	goto error;
	261	}
	262
	263	pool->unlink_directory_path = strdup(path);
	264	if (!pool->unlink_directory_path) {
	265	PERROR("Failed to allocation unlinked file pool path");
	266	goto error;
	267	}
	268	DBG("Unlinked file pool created at: %s", path);
	269	return pool;
	270	error:
	271	lttng_unlinked_file_pool_destroy(pool);
	272	return NULL;
	273	}
	274
938bd422	275	LTTNG_HIDDEN void lttng_unlinked_file_pool_destroy(
f7c3ffd7 JG	276	struct lttng_unlinked_file_pool *pool)
	277	{
	278	if (!pool) {
	279	return;
	280	}
	281
	282	assert(pool->file_count == 0);
	283	lttng_directory_handle_put(pool->unlink_directory_handle);
	284	free(pool->unlink_directory_path);
	285	free(pool);
	286	}
	287
938bd422	288	LTTNG_HIDDEN void lttng_inode_put(struct lttng_inode *inode)
e0e72660 JG	289	{
	290	urcu_ref_put(&inode->ref, lttng_inode_release);
	291	}
	292
938bd422 JG	293	LTTNG_HIDDEN struct lttng_directory_handle *
938bd422 JG	294	lttng_inode_get_location_directory_handle(
dd95933f JG	295	struct lttng_inode *inode)
	296	{
	297	if (inode->location.directory_handle) {
	298	const bool reference_acquired = lttng_directory_handle_get(
	299	inode->location.directory_handle);
	300
	301	assert(reference_acquired);
	302	}
	303	return inode->location.directory_handle;
	304	}
	305
938bd422	306	LTTNG_HIDDEN void lttng_inode_borrow_location(struct lttng_inode *inode,
f7c3ffd7 JG	307	const struct lttng_directory_handle **out_directory_handle,
f7c3ffd7 JG	308	const char **out_path)
e0e72660	309	{
f7c3ffd7 JG	310	if (out_directory_handle) {
	311	*out_directory_handle = inode->location.directory_handle;
	312	}
	313	if (out_path) {
	314	*out_path = inode->location.path;
	315	}
e0e72660 JG	316	}
e0e72660 JG	317
938bd422	318	LTTNG_HIDDEN int lttng_inode_rename(
f7c3ffd7 JG	319	struct lttng_inode *inode,
	320	struct lttng_directory_handle *old_directory_handle,
	321	const char *old_path,
	322	struct lttng_directory_handle *new_directory_handle,
	323	const char *new_path,
	324	bool overwrite)
e0e72660 JG	325	{
e0e72660 JG	326	int ret = 0;
f7c3ffd7 JG	327	char *new_path_copy = strdup(new_path);
	328	bool reference_acquired;
	329
	330	DBG("Performing rename of inode from %s to %s with %s directory handles",
	331	old_path, new_path,
	332	lttng_directory_handle_equals(old_directory_handle,
	333	new_directory_handle) ?
	334	"identical" :
	335	"different");
	336
	337	if (!new_path_copy) {
	338	ret = -ENOMEM;
	339	goto end;
	340	}
e0e72660 JG	341
e0e72660 JG	342	if (inode->unlink_pending) {
f7c3ffd7 JG	343	WARN("An attempt to rename an unlinked file from %s to %s has been performed",
f7c3ffd7 JG	344	old_path, new_path);
e0e72660 JG	345	ret = -ENOENT;
	346	goto end;
	347	}
	348
	349	if (!overwrite) {
f7c3ffd7	350	/* Verify that file doesn't exist. */
e0e72660 JG	351	struct stat statbuf;
e0e72660 JG	352
f7c3ffd7 JG	353	ret = lttng_directory_handle_stat(
f7c3ffd7 JG	354	new_directory_handle, new_path, &statbuf);
e0e72660	355	if (ret == 0) {
f7c3ffd7 JG	356	ERR("Refusing to rename %s as the destination already exists",
f7c3ffd7 JG	357	old_path);
e0e72660 JG	358	ret = -EEXIST;
	359	goto end;
	360	} else if (ret < 0 && errno != ENOENT) {
	361	PERROR("Failed to stat() %s", new_path);
	362	ret = -errno;
	363	goto end;
	364	}
	365	}
	366
f7c3ffd7 JG	367	ret = lttng_directory_handle_rename(old_directory_handle, old_path,
f7c3ffd7 JG	368	new_directory_handle, new_path);
e0e72660	369	if (ret) {
f7c3ffd7	370	PERROR("Failed to rename file %s to %s", old_path, new_path);
e0e72660 JG	371	ret = -errno;
	372	goto end;
	373	}
	374
f7c3ffd7 JG	375	reference_acquired = lttng_directory_handle_get(new_directory_handle);
	376	assert(reference_acquired);
	377	lttng_directory_handle_put(inode->location.directory_handle);
	378	free(inode->location.path);
	379	inode->location.directory_handle = new_directory_handle;
	380	/* Ownership transferred. */
	381	inode->location.path = new_path_copy;
e0e72660 JG	382	new_path_copy = NULL;
	383	end:
	384	free(new_path_copy);
	385	return ret;
	386	}
	387
938bd422	388	LTTNG_HIDDEN int lttng_inode_unlink(struct lttng_inode *inode)
e0e72660 JG	389	{
e0e72660 JG	390	int ret = 0;
f7c3ffd7 JG	391
f7c3ffd7 JG	392	DBG("Attempting unlink of inode %s", inode->location.path);
e0e72660 JG	393
	394	if (inode->unlink_pending) {
	395	WARN("An attempt to re-unlink %s has been performed, ignoring.",
f7c3ffd7	396	inode->location.path);
e0e72660 JG	397	ret = -ENOENT;
	398	goto end;
	399	}
	400
f7c3ffd7 JG	401	/*
	402	* Move to the temporary "deleted" directory until all
	403	* references are released.
	404	*/
	405	ret = lttng_unlinked_file_pool_add_inode(
	406	inode->unlinked_file_pool, inode);
	407	if (ret) {
	408	PERROR("Failed to add inode \"%s\" to the unlinked file pool",
	409	inode->location.path);
e0e72660 JG	410	goto end;
e0e72660 JG	411	}
f7c3ffd7	412	inode->unlink_pending = true;
e0e72660 JG	413	end:
	414	return ret;
	415	}
	416
5c1f54d1	417	static struct lttng_inode lttng_inode_create(const struct inode_id id,
f7c3ffd7 JG	418	struct cds_lfht *ht,
	419	struct lttng_unlinked_file_pool *unlinked_file_pool,
	420	struct lttng_directory_handle *directory_handle,
	421	const char *path)
e0e72660	422	{
f7c3ffd7 JG	423	struct lttng_inode *inode = NULL;
	424	char *path_copy;
	425	bool reference_acquired;
	426
	427	path_copy = strdup(path);
	428	if (!path_copy) {
	429	goto end;
	430	}
e0e72660	431
f7c3ffd7 JG	432	reference_acquired = lttng_directory_handle_get(directory_handle);
	433	assert(reference_acquired);
	434
	435	inode = zmalloc(sizeof(*inode));
e0e72660 JG	436	if (!inode) {
	437	goto end;
	438	}
	439
	440	urcu_ref_init(&inode->ref);
	441	cds_lfht_node_init(&inode->registry_node);
	442	inode->id = *id;
e0e72660	443	inode->registry_ht = ht;
f7c3ffd7 JG	444	inode->unlinked_file_pool = unlinked_file_pool;
	445	/* Ownership of path copy is transferred to inode. */
	446	inode->location.path = path_copy;
	447	path_copy = NULL;
	448	inode->location.directory_handle = directory_handle;
e0e72660	449	end:
f7c3ffd7	450	free(path_copy);
e0e72660	451	return inode;
e0e72660 JG	452	}
e0e72660 JG	453
938bd422	454	LTTNG_HIDDEN struct lttng_inode_registry *lttng_inode_registry_create(void)
e0e72660 JG	455	{
	456	struct lttng_inode_registry registry = zmalloc(sizeof(registry));
	457
	458	if (!registry) {
	459	goto end;
	460	}
	461
	462	pthread_mutex_lock(&seed.lock);
	463	if (!seed.initialized) {
	464	seed.value = (unsigned long) time(NULL);
	465	seed.initialized = true;
	466	}
	467	pthread_mutex_unlock(&seed.lock);
	468
	469	registry->inodes = cds_lfht_new(DEFAULT_HT_SIZE, 1, 0,
	470	CDS_LFHT_AUTO_RESIZE \| CDS_LFHT_ACCOUNTING, NULL);
	471	if (!registry->inodes) {
	472	goto error;
	473	}
	474	end:
	475	return registry;
	476	error:
	477	lttng_inode_registry_destroy(registry);
	478	return NULL;
	479	}
	480
938bd422 JG	481	LTTNG_HIDDEN void lttng_inode_registry_destroy(
938bd422 JG	482	struct lttng_inode_registry *registry)
e0e72660 JG	483	{
	484	if (!registry) {
	485	return;
	486	}
	487	if (registry->inodes) {
	488	int ret = cds_lfht_destroy(registry->inodes, NULL);
	489
	490	assert(!ret);
	491	}
	492	free(registry);
	493	}
	494
938bd422	495	LTTNG_HIDDEN struct lttng_inode *lttng_inode_registry_get_inode(
f7c3ffd7 JG	496	struct lttng_inode_registry *registry,
	497	struct lttng_directory_handle *handle,
	498	const char *path,
	499	int fd,
	500	struct lttng_unlinked_file_pool *unlinked_file_pool)
e0e72660 JG	501	{
	502	int ret;
	503	struct stat statbuf;
	504	struct inode_id id;
	505	struct cds_lfht_iter iter;
	506	struct cds_lfht_node *node;
	507	struct lttng_inode *inode = NULL;
	508
	509	ret = fstat(fd, &statbuf);
	510	if (ret < 0) {
f7c3ffd7	511	PERROR("stat() failed on fd %i", fd);
e0e72660 JG	512	goto end;
	513	}
	514
	515	id.device = statbuf.st_dev;
	516	id.inode = statbuf.st_ino;
	517
	518	rcu_read_lock();
5c1f54d1 JG	519	cds_lfht_lookup(registry->inodes, lttng_inode_id_hash(&id),
5c1f54d1 JG	520	lttng_inode_match, &id, &iter);
e0e72660 JG	521	node = cds_lfht_iter_get_node(&iter);
e0e72660 JG	522	if (node) {
5c1f54d1 JG	523	inode = caa_container_of(
5c1f54d1 JG	524	node, struct lttng_inode, registry_node);
e0e72660 JG	525	lttng_inode_get(inode);
	526	goto end_unlock;
	527	}
	528
f7c3ffd7 JG	529	inode = lttng_inode_create(&id, registry->inodes, unlinked_file_pool,
f7c3ffd7 JG	530	handle, path);
640b9481 JR	531	if (!inode) {
	532	goto end_unlock;
	533	}
	534
e0e72660	535	node = cds_lfht_add_unique(registry->inodes,
5c1f54d1 JG	536	lttng_inode_id_hash(&inode->id), lttng_inode_match,
5c1f54d1 JG	537	&inode->id, &inode->registry_node);
e0e72660 JG	538	assert(node == &inode->registry_node);
	539	end_unlock:
	540	rcu_read_unlock();
	541	end:
	542	return inode;
	543	}