#include <sys/stat.h>
#include <sys/types.h>
-#include <common/defaults.h>
-#include <common/error.h>
-#include <common/fs-handle-internal.h>
-#include <common/hashtable/hashtable.h>
-#include <common/hashtable/utils.h>
-#include <common/macros.h>
-#include <common/optional.h>
+#include <common/defaults.hpp>
+#include <common/error.hpp>
+#include <common/fs-handle-internal.hpp>
+#include <common/hashtable/hashtable.hpp>
+#include <common/hashtable/utils.hpp>
+#include <common/macros.hpp>
+#include <common/optional.hpp>
-#include "fd-tracker.h"
-#include "inode.h"
+#include "fd-tracker.hpp"
+#include "inode.hpp"
/* Tracker lock must be taken by the user. */
#define TRACKED_COUNT(tracker) \
struct lttng_unlinked_file_pool *unlinked_file_pool;
};
+namespace {
struct open_properties {
int flags;
LTTNG_OPTIONAL(mode_t) mode;
struct rcu_head rcu_head;
};
-static struct {
+struct {
pthread_mutex_t lock;
bool initialized;
unsigned long value;
} seed = {
.lock = PTHREAD_MUTEX_INITIALIZER,
+ .initialized = false,
+ .value = 0,
};
+} /* namespace */
static int match_fd(struct cds_lfht_node *node, const void *key);
static void unsuspendable_fd_destroy(struct unsuspendable_fd *entry);
/* Match function of the tracker's unsuspendable_fds hash table. */
static int match_fd(struct cds_lfht_node *node, const void *key)
{
- struct unsuspendable_fd *entry = caa_container_of(
- node, struct unsuspendable_fd, tracker_node);
+ struct unsuspendable_fd *entry = lttng::utils::container_of(
+ node, &unsuspendable_fd::tracker_node);
return hash_match_key_ulong(
(void *) (unsigned long) entry->fd, (void *) key);
static struct unsuspendable_fd *unsuspendable_fd_create(
const char *name, int fd)
{
- struct unsuspendable_fd *entry = (unsuspendable_fd *) zmalloc(sizeof(*entry));
+ struct unsuspendable_fd *entry = zmalloc<unsuspendable_fd>();
if (!entry) {
goto error;
struct fd_tracker *fd_tracker_create(const char *unlinked_file_path,
unsigned int capacity)
{
- struct fd_tracker *tracker = (fd_tracker *) zmalloc(sizeof(struct fd_tracker));
+ struct fd_tracker *tracker = zmalloc<fd_tracker>();
if (!tracker) {
goto end;
.flags = flags,
.mode = {
.is_set = !!mode,
- .value = mode ? *mode : 0,
+ .value = static_cast<mode_t>(mode ? *mode : 0),
}
};
}
}
- handle = (fs_handle_tracked *) zmalloc(sizeof(*handle));
+ handle = zmalloc<fs_handle_tracked>();
if (!handle) {
goto end;
}
unsigned int active_fds;
struct unsuspendable_fd **entries;
- entries = (unsuspendable_fd **) zmalloc(fd_count * sizeof(*entries));
+ entries = calloc<unsuspendable_fd *>(fd_count);
if (!entries) {
ret = -1;
goto end;
* Maintain a local copy of fds_in as the user's callback may modify its
* contents (e.g. setting the fd(s) to -1 after close).
*/
- fds = (int *) malloc(sizeof(*fds) * fd_count);
+ fds = malloc<int>(sizeof(*fds) * fd_count);
if (!fds) {
ret = -1;
goto end;
ret = -EINVAL;
goto end_unlock;
}
- entry = caa_container_of(
- node, struct unsuspendable_fd, tracker_node);
+ entry = lttng::utils::container_of(
+ node, &unsuspendable_fd::tracker_node);
cds_lfht_del(tracker->unsuspendable_fds, node);
unsuspendable_fd_destroy(entry);
{
int ret;
struct fs_handle_tracked *handle =
- container_of(_handle, struct fs_handle_tracked, parent);
+ lttng::utils::container_of(_handle, &fs_handle_tracked::parent);
/*
* TODO This should be optimized as it is a fairly hot path.
static void fs_handle_tracked_put_fd(struct fs_handle *_handle)
{
struct fs_handle_tracked *handle =
- container_of(_handle, struct fs_handle_tracked, parent);
+ lttng::utils::container_of(_handle, &fs_handle_tracked::parent);
pthread_mutex_lock(&handle->lock);
handle->in_use = false;
{
int ret;
struct fs_handle_tracked *handle =
- container_of(_handle, struct fs_handle_tracked, parent);
+ lttng::utils::container_of(_handle, &fs_handle_tracked::parent);
pthread_mutex_lock(&handle->tracker->lock);
pthread_mutex_lock(&handle->lock);
int ret = 0;
const char *path = NULL;
struct fs_handle_tracked *handle =
- container_of(_handle, struct fs_handle_tracked, parent);
+ lttng::utils::container_of(_handle, &fs_handle_tracked::parent);
struct lttng_directory_handle *inode_directory_handle = NULL;
if (!handle) {