2 * Copyright (C) 2020 Jérémie Galarneau <jeremie.galarneau@efficios.com>
4 * SPDX-License-Identifier: GPL-2.0-only
8 #include <common/defaults.h>
9 #include <common/error.h>
10 #include <common/hashtable/utils.h>
11 #include <common/macros.h>
12 #include <common/optional.h>
13 #include <common/string-utils/format.h>
14 #include <common/utils.h>
16 #include <lttng/constant.h>
18 #include <sys/types.h>
21 #include <urcu/rculfhash.h>
31 struct lttng_inode_registry
{
32 /* Hashtable of inode_id to lttng_inode. */
33 struct cds_lfht
*inodes
;
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
;
43 struct rcu_head rcu_head
;
44 /* Location from which this file can be opened. */
46 struct lttng_directory_handle
*directory_handle
;
49 /* Unlink the underlying file at the release of the inode. */
51 LTTNG_OPTIONAL(unsigned int) unlinked_id
;
53 struct lttng_unlinked_file_pool
*unlinked_file_pool
;
56 struct lttng_unlinked_file_pool
{
57 struct lttng_directory_handle
*unlink_directory_handle
;
58 char *unlink_directory_path
;
59 unsigned int file_count
;
68 .lock
= PTHREAD_MUTEX_INITIALIZER
,
71 static unsigned long lttng_inode_id_hash(const struct inode_id
*id
)
73 uint64_t device
= id
->device
, inode_no
= id
->inode
;
75 return hash_key_u64(&device
, seed
.value
) ^
76 hash_key_u64(&inode_no
, seed
.value
);
79 static int lttng_inode_match(struct cds_lfht_node
*node
, const void *key
)
81 const struct inode_id
*id
= key
;
82 const struct lttng_inode
*inode
= caa_container_of(
83 node
, struct lttng_inode
, registry_node
);
85 return inode
->id
.device
== id
->device
&& inode
->id
.inode
== id
->inode
;
88 static void lttng_inode_free(struct rcu_head
*head
)
90 struct lttng_inode
*inode
=
91 caa_container_of(head
, struct lttng_inode
, rcu_head
);
96 static int lttng_unlinked_file_pool_add_inode(
97 struct lttng_unlinked_file_pool
*pool
,
98 struct lttng_inode
*inode
)
101 const unsigned int unlinked_id
= pool
->next_id
++;
102 char *inode_unlinked_name
;
103 bool reference_acquired
;
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
);
109 ERR("Failed to format unlinked inode name");
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);
121 if (errno
== EEXIST
) {
123 * Unexpected (previous crash?), but not an
126 DBG("Unlinked file directory \"%s\" already exists",
127 pool
->unlink_directory_path
);
129 PERROR("Failed to create unlinked files directory at %s",
130 pool
->unlink_directory_path
);
134 pool
->unlink_directory_handle
= lttng_directory_handle_create(
135 pool
->unlink_directory_path
);
136 if (!pool
->unlink_directory_handle
) {
137 ERR("Failed to create directory handle to unlinked file pool at %s",
138 pool
->unlink_directory_path
);
144 ret
= lttng_directory_handle_rename(inode
->location
.directory_handle
,
145 inode
->location
.path
, pool
->unlink_directory_handle
,
146 inode_unlinked_name
);
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
;
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
);
164 free(inode_unlinked_name
);
168 static int lttng_unlinked_file_pool_remove_inode(
169 struct lttng_unlinked_file_pool
*pool
,
170 struct lttng_inode
*inode
)
174 DBG("Removing inode with unlinked id %u from unlinked file pool",
175 LTTNG_OPTIONAL_GET(inode
->unlinked_id
));
177 ret
= lttng_directory_handle_unlink_file(
178 inode
->location
.directory_handle
, inode
->location
.path
);
180 PERROR("Failed to unlink file %s from unlinked file directory",
181 inode
->location
.path
);
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
;
190 if (pool
->file_count
== 0) {
191 ret
= utils_recursive_rmdir(pool
->unlink_directory_path
);
194 * There is nothing the caller can do, don't report an
195 * error except through logging.
197 PERROR("Failed to remove unlinked files directory at %s",
198 pool
->unlink_directory_path
);
200 lttng_directory_handle_put(pool
->unlink_directory_handle
);
201 pool
->unlink_directory_handle
= NULL
;
207 static void lttng_inode_destroy(struct lttng_inode
*inode
)
214 cds_lfht_del(inode
->registry_ht
, &inode
->registry_node
);
217 if (inode
->unlink_pending
) {
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
);
226 PERROR("Failed to unlink %s", inode
->location
.path
);
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
);
238 static void lttng_inode_release(struct urcu_ref
*ref
)
240 lttng_inode_destroy(caa_container_of(ref
, struct lttng_inode
, ref
));
243 static void lttng_inode_get(struct lttng_inode
*inode
)
245 urcu_ref_get(&inode
->ref
);
248 LTTNG_HIDDEN
struct lttng_unlinked_file_pool
*lttng_unlinked_file_pool_create(
251 struct lttng_unlinked_file_pool
*pool
= zmalloc(sizeof(*pool
));
253 if (!path
|| *path
!= '/') {
254 ERR("Unlinked file pool must be created with an absolute path, path = \"%s\"",
255 path
? path
: "NULL");
259 pool
->unlink_directory_path
= strdup(path
);
260 if (!pool
->unlink_directory_path
) {
261 PERROR("Failed to allocation unlinked file pool path");
264 DBG("Unlinked file pool created at: %s", path
);
267 lttng_unlinked_file_pool_destroy(pool
);
271 LTTNG_HIDDEN
void lttng_unlinked_file_pool_destroy(
272 struct lttng_unlinked_file_pool
*pool
)
278 assert(pool
->file_count
== 0);
279 lttng_directory_handle_put(pool
->unlink_directory_handle
);
280 free(pool
->unlink_directory_path
);
284 LTTNG_HIDDEN
void lttng_inode_put(struct lttng_inode
*inode
)
286 urcu_ref_put(&inode
->ref
, lttng_inode_release
);
289 LTTNG_HIDDEN
struct lttng_directory_handle
*
290 lttng_inode_get_location_directory_handle(
291 struct lttng_inode
*inode
)
293 if (inode
->location
.directory_handle
) {
294 const bool reference_acquired
= lttng_directory_handle_get(
295 inode
->location
.directory_handle
);
297 assert(reference_acquired
);
299 return inode
->location
.directory_handle
;
302 LTTNG_HIDDEN
void lttng_inode_borrow_location(struct lttng_inode
*inode
,
303 const struct lttng_directory_handle
**out_directory_handle
,
304 const char **out_path
)
306 if (out_directory_handle
) {
307 *out_directory_handle
= inode
->location
.directory_handle
;
310 *out_path
= inode
->location
.path
;
314 LTTNG_HIDDEN
int lttng_inode_rename(
315 struct lttng_inode
*inode
,
316 struct lttng_directory_handle
*old_directory_handle
,
317 const char *old_path
,
318 struct lttng_directory_handle
*new_directory_handle
,
319 const char *new_path
,
323 char *new_path_copy
= strdup(new_path
);
324 bool reference_acquired
;
326 DBG("Performing rename of inode from %s to %s with %s directory handles",
328 lttng_directory_handle_equals(old_directory_handle
,
329 new_directory_handle
) ?
333 if (!new_path_copy
) {
338 if (inode
->unlink_pending
) {
339 WARN("An attempt to rename an unlinked file from %s to %s has been performed",
346 /* Verify that file doesn't exist. */
349 ret
= lttng_directory_handle_stat(
350 new_directory_handle
, new_path
, &statbuf
);
352 ERR("Refusing to rename %s as the destination already exists",
356 } else if (ret
< 0 && errno
!= ENOENT
) {
357 PERROR("Failed to stat() %s", new_path
);
363 ret
= lttng_directory_handle_rename(old_directory_handle
, old_path
,
364 new_directory_handle
, new_path
);
366 PERROR("Failed to rename file %s to %s", old_path
, new_path
);
371 reference_acquired
= lttng_directory_handle_get(new_directory_handle
);
372 assert(reference_acquired
);
373 lttng_directory_handle_put(inode
->location
.directory_handle
);
374 free(inode
->location
.path
);
375 inode
->location
.directory_handle
= new_directory_handle
;
376 /* Ownership transferred. */
377 inode
->location
.path
= new_path_copy
;
378 new_path_copy
= NULL
;
384 LTTNG_HIDDEN
int lttng_inode_unlink(struct lttng_inode
*inode
)
388 DBG("Attempting unlink of inode %s", inode
->location
.path
);
390 if (inode
->unlink_pending
) {
391 WARN("An attempt to re-unlink %s has been performed, ignoring.",
392 inode
->location
.path
);
398 * Move to the temporary "deleted" directory until all
399 * references are released.
401 ret
= lttng_unlinked_file_pool_add_inode(
402 inode
->unlinked_file_pool
, inode
);
404 PERROR("Failed to add inode \"%s\" to the unlinked file pool",
405 inode
->location
.path
);
408 inode
->unlink_pending
= true;
413 static struct lttng_inode
*lttng_inode_create(const struct inode_id
*id
,
415 struct lttng_unlinked_file_pool
*unlinked_file_pool
,
416 struct lttng_directory_handle
*directory_handle
,
419 struct lttng_inode
*inode
= NULL
;
421 bool reference_acquired
;
423 path_copy
= strdup(path
);
428 reference_acquired
= lttng_directory_handle_get(directory_handle
);
429 assert(reference_acquired
);
431 inode
= zmalloc(sizeof(*inode
));
436 urcu_ref_init(&inode
->ref
);
437 cds_lfht_node_init(&inode
->registry_node
);
439 inode
->registry_ht
= ht
;
440 inode
->unlinked_file_pool
= unlinked_file_pool
;
441 /* Ownership of path copy is transferred to inode. */
442 inode
->location
.path
= path_copy
;
444 inode
->location
.directory_handle
= directory_handle
;
450 LTTNG_HIDDEN
struct lttng_inode_registry
*lttng_inode_registry_create(void)
452 struct lttng_inode_registry
*registry
= zmalloc(sizeof(*registry
));
458 pthread_mutex_lock(&seed
.lock
);
459 if (!seed
.initialized
) {
460 seed
.value
= (unsigned long) time(NULL
);
461 seed
.initialized
= true;
463 pthread_mutex_unlock(&seed
.lock
);
465 registry
->inodes
= cds_lfht_new(DEFAULT_HT_SIZE
, 1, 0,
466 CDS_LFHT_AUTO_RESIZE
| CDS_LFHT_ACCOUNTING
, NULL
);
467 if (!registry
->inodes
) {
473 lttng_inode_registry_destroy(registry
);
477 LTTNG_HIDDEN
void lttng_inode_registry_destroy(
478 struct lttng_inode_registry
*registry
)
483 if (registry
->inodes
) {
484 int ret
= cds_lfht_destroy(registry
->inodes
, NULL
);
491 LTTNG_HIDDEN
struct lttng_inode
*lttng_inode_registry_get_inode(
492 struct lttng_inode_registry
*registry
,
493 struct lttng_directory_handle
*handle
,
496 struct lttng_unlinked_file_pool
*unlinked_file_pool
)
501 struct cds_lfht_iter iter
;
502 struct cds_lfht_node
*node
;
503 struct lttng_inode
*inode
= NULL
;
505 ret
= fstat(fd
, &statbuf
);
507 PERROR("stat() failed on fd %i", fd
);
511 id
.device
= statbuf
.st_dev
;
512 id
.inode
= statbuf
.st_ino
;
515 cds_lfht_lookup(registry
->inodes
, lttng_inode_id_hash(&id
),
516 lttng_inode_match
, &id
, &iter
);
517 node
= cds_lfht_iter_get_node(&iter
);
519 inode
= caa_container_of(
520 node
, struct lttng_inode
, registry_node
);
521 lttng_inode_get(inode
);
525 inode
= lttng_inode_create(&id
, registry
->inodes
, unlinked_file_pool
,
531 node
= cds_lfht_add_unique(registry
->inodes
,
532 lttng_inode_id_hash(&inode
->id
), lttng_inode_match
,
533 &inode
->id
, &inode
->registry_node
);
534 assert(node
== &inode
->registry_node
);