/*
- * libringbuffer/shm.c
+ * SPDX-License-Identifier: LGPL-2.1-only
*
* Copyright (C) 2005-2012 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; only
- * version 2.1 of the License.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
+#define _LGPL_SOURCE
#include "shm.h"
#include <unistd.h>
#include <fcntl.h>
#include <dirent.h>
#include <lttng/align.h>
#include <limits.h>
+#include <stdbool.h>
+#include <stdint.h>
+#ifdef HAVE_LIBNUMA
+#include <numa.h>
+#include <numaif.h>
+#endif
#include <helper.h>
+#include <ust-fd.h>
+#include "mmap.h"
/*
* Ensure we have the required amount of space available by writing 0
}
memcpy(obj->wait_fd, waitfd, sizeof(waitfd));
- /* create shm */
+ /*
+ * Set POSIX shared memory object size
+ *
+ * First, use ftruncate() to set its size, some implementations won't
+ * allow writes past the size set by ftruncate.
+ * Then, use write() to fill it with zeros, this allows us to fully
+ * allocate it and detect a shortage of shm space without dealing with
+ * a SIGBUS.
+ */
shmfd = stream_fd;
+ ret = ftruncate(shmfd, memory_map_size);
+ if (ret) {
+ PERROR("ftruncate");
+ goto error_ftruncate;
+ }
ret = zero_file(shmfd, memory_map_size);
if (ret) {
PERROR("zero_file");
goto error_zero_file;
}
- ret = ftruncate(shmfd, memory_map_size);
- if (ret) {
- PERROR("ftruncate");
- goto error_ftruncate;
+
+ /*
+ * Also ensure the file metadata is synced with the storage by using
+ * fsync(2). Some platforms don't allow fsync on POSIX shm fds, ignore
+ * EINVAL accordingly.
+ */
+ ret = fsync(shmfd);
+ if (ret && errno != EINVAL) {
+ PERROR("fsync");
+ goto error_fsync;
}
obj->shm_fd_ownership = 0;
obj->shm_fd = shmfd;
/* memory_map: mmap */
memory_map = mmap(NULL, memory_map_size, PROT_READ | PROT_WRITE,
- MAP_SHARED, shmfd, 0);
+ MAP_SHARED | LTTNG_MAP_POPULATE, shmfd, 0);
if (memory_map == MAP_FAILED) {
PERROR("mmap");
goto error_mmap;
return obj;
error_mmap:
+error_fsync:
error_ftruncate:
error_zero_file:
error_fcntl:
return NULL;
}
+/*
+ * libnuma prints errors on the console even for numa_available().
+ * Work-around this limitation by using get_mempolicy() directly to
+ * check whether the kernel supports mempolicy.
+ */
+#ifdef HAVE_LIBNUMA
+static bool lttng_is_numa_available(void)
+{
+ int ret;
+
+ ret = get_mempolicy(NULL, NULL, 0, NULL, 0);
+ if (ret && errno == ENOSYS) {
+ return false;
+ }
+ return numa_available() > 0;
+}
+#endif
+
struct shm_object *shm_object_table_alloc(struct shm_object_table *table,
size_t memory_map_size,
enum shm_object_type type,
- int stream_fd)
+ int stream_fd,
+ int cpu)
{
+ struct shm_object *shm_object;
+#ifdef HAVE_LIBNUMA
+ int oldnode = 0, node;
+ bool numa_avail;
+
+ numa_avail = lttng_is_numa_available();
+ if (numa_avail) {
+ oldnode = numa_preferred();
+ if (cpu >= 0) {
+ node = numa_node_of_cpu(cpu);
+ if (node >= 0)
+ numa_set_preferred(node);
+ }
+ if (cpu < 0 || node < 0)
+ numa_set_localalloc();
+ }
+#endif /* HAVE_LIBNUMA */
switch (type) {
case SHM_OBJECT_SHM:
- return _shm_object_table_alloc_shm(table, memory_map_size,
+ shm_object = _shm_object_table_alloc_shm(table, memory_map_size,
stream_fd);
+ break;
case SHM_OBJECT_MEM:
- return _shm_object_table_alloc_mem(table, memory_map_size);
+ shm_object = _shm_object_table_alloc_mem(table, memory_map_size);
+ break;
default:
assert(0);
}
- return NULL;
+#ifdef HAVE_LIBNUMA
+ if (numa_avail)
+ numa_set_preferred(oldnode);
+#endif /* HAVE_LIBNUMA */
+ return shm_object;
}
struct shm_object *shm_object_table_append_shm(struct shm_object_table *table,
obj->shm_fd = shm_fd;
obj->shm_fd_ownership = 1;
- ret = fcntl(obj->wait_fd[1], F_SETFD, FD_CLOEXEC);
- if (ret < 0) {
- PERROR("fcntl");
- goto error_fcntl;
- }
/* The write end of the pipe needs to be non-blocking */
ret = fcntl(obj->wait_fd[1], F_SETFL, O_NONBLOCK);
if (ret < 0) {
/* memory_map: mmap */
memory_map = mmap(NULL, memory_map_size, PROT_READ | PROT_WRITE,
- MAP_SHARED, shm_fd, 0);
+ MAP_SHARED | LTTNG_MAP_POPULATE, shm_fd, 0);
if (memory_map == MAP_FAILED) {
PERROR("mmap");
goto error_mmap;
}
static
-void shmp_object_destroy(struct shm_object *obj)
+void shmp_object_destroy(struct shm_object *obj, int consumer)
{
switch (obj->type) {
case SHM_OBJECT_SHM:
PERROR("umnmap");
assert(0);
}
+
if (obj->shm_fd_ownership) {
- ret = close(obj->shm_fd);
- if (ret) {
- PERROR("close");
- assert(0);
+ /* Delete FDs only if called from app (not consumer). */
+ if (!consumer) {
+ lttng_ust_lock_fd_tracker();
+ ret = close(obj->shm_fd);
+ if (!ret) {
+ lttng_ust_delete_fd_from_tracker(obj->shm_fd);
+ } else {
+ PERROR("close");
+ assert(0);
+ }
+ lttng_ust_unlock_fd_tracker();
+ } else {
+ ret = close(obj->shm_fd);
+ if (ret) {
+ PERROR("close");
+ assert(0);
+ }
}
}
for (i = 0; i < 2; i++) {
if (obj->wait_fd[i] < 0)
continue;
- ret = close(obj->wait_fd[i]);
- if (ret) {
- PERROR("close");
- assert(0);
+ if (!consumer) {
+ lttng_ust_lock_fd_tracker();
+ ret = close(obj->wait_fd[i]);
+ if (!ret) {
+ lttng_ust_delete_fd_from_tracker(obj->wait_fd[i]);
+ } else {
+ PERROR("close");
+ assert(0);
+ }
+ lttng_ust_unlock_fd_tracker();
+ } else {
+ ret = close(obj->wait_fd[i]);
+ if (ret) {
+ PERROR("close");
+ assert(0);
+ }
}
}
break;
for (i = 0; i < 2; i++) {
if (obj->wait_fd[i] < 0)
continue;
- ret = close(obj->wait_fd[i]);
- if (ret) {
- PERROR("close");
- assert(0);
+ if (!consumer) {
+ lttng_ust_lock_fd_tracker();
+ ret = close(obj->wait_fd[i]);
+ if (!ret) {
+ lttng_ust_delete_fd_from_tracker(obj->wait_fd[i]);
+ } else {
+ PERROR("close");
+ assert(0);
+ }
+ lttng_ust_unlock_fd_tracker();
+ } else {
+ ret = close(obj->wait_fd[i]);
+ if (ret) {
+ PERROR("close");
+ assert(0);
+ }
}
}
free(obj->memory_map);
}
}
-void shm_object_table_destroy(struct shm_object_table *table)
+void shm_object_table_destroy(struct shm_object_table *table, int consumer)
{
int i;
for (i = 0; i < table->allocated_len; i++)
- shmp_object_destroy(&table->objects[i]);
+ shmp_object_destroy(&table->objects[i], consumer);
free(table);
}
void align_shm(struct shm_object *obj, size_t align)
{
- size_t offset_len = offset_align(obj->allocated_len, align);
+ size_t offset_len = lttng_ust_offset_align(obj->allocated_len, align);
obj->allocated_len += offset_len;
}
projects / lttng-ust.git / blobdiff