X-Git-Url: http://git.lttng.org/?a=blobdiff_plain;f=libringbuffer%2Fshm.h;h=3a61a39d5e1d86a77d1df100017fe12b7a737ff1;hb=616d3093e1c34557aca7e9f6149338f43cf91886;hp=71624e3999a3974ec4b11ea4c2c5045bc29dbaf1;hpb=1dbfff0c0126804b07e9c11ba2307f65a95a650b;p=lttng-ust.git diff --git a/libringbuffer/shm.h b/libringbuffer/shm.h index 71624e39..3a61a39d 100644 --- a/libringbuffer/shm.h +++ b/libringbuffer/shm.h @@ -4,81 +4,169 @@ /* * libringbuffer/shm.h * - * Copyright 2011 (c) - Mathieu Desnoyers + * Copyright (C) 2011-2012 Mathieu Desnoyers * - * Dual LGPL v2.1/GPL v2 license. + * 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 */ #include -#include -#include "ust/core.h" - -#define SHM_MAGIC 0x54335433 -#define SHM_MAJOR 0 -#define SHM_MINOR 1 +#include +#include +#include "shm_types.h" +#include /* - * Defining a max shm offset, for debugging purposes. + * Pointer dereferencing. We don't trust the shm_ref, so we validate + * both the index and offset with known boundaries. + * + * "shmp" and "shmp_index" guarantee that it's safe to use the pointer + * target type, even in the occurrence of shm_ref modification by an + * untrusted process having write access to the shm_ref. We return a + * NULL pointer if the ranges are invalid. */ -#if (CAA_BITS_PER_LONG == 32) -/* Define the maximum shared memory size to 128MB on 32-bit machines */ -#define MAX_SHM_SIZE 134217728 -#else -/* Define the maximum shared memory size to 8GB on 64-bit machines */ -#define MAX_SHM_SIZE 8589934592 -#endif +static inline +char *_shmp_offset(struct shm_object_table *table, struct shm_ref *ref, + size_t idx, size_t elem_size) +{ + struct shm_object *obj; + size_t objindex, ref_offset; -#define DECLARE_SHMP(type, name) type *****name + objindex = (size_t) ref->index; + if (caa_unlikely(objindex >= table->allocated_len)) + return NULL; + obj = &table->objects[objindex]; + ref_offset = (size_t) ref->offset; + ref_offset += idx * elem_size; + /* Check if part of the element returned would exceed the limits. */ + if (caa_unlikely(ref_offset + elem_size > obj->memory_map_size)) + return NULL; + return &obj->memory_map[ref_offset]; +} -struct shm_header { - uint32_t magic; - uint8_t major; - uint8_t minor; - uint8_t bits_per_long; - size_t shm_size, shm_allocated; +#define shmp_index(handle, ref, index) \ + ({ \ + __typeof__((ref)._type) ____ptr_ret; \ + ____ptr_ret = (__typeof__(____ptr_ret)) _shmp_offset((handle)->table, &(ref)._ref, index, sizeof(*____ptr_ret)); \ + ____ptr_ret; \ + }) - DECLARE_SHMP(struct channel, chan); -}; +#define shmp(handle, ref) shmp_index(handle, ref, 0) + +static inline +void _set_shmp(struct shm_ref *ref, struct shm_ref src) +{ + *ref = src; +} -struct shm_handle { - struct shm_header *header; /* beginning of mapping */ - int shmfd; /* process-local file descriptor */ -}; +#define set_shmp(ref, src) _set_shmp(&(ref)._ref, src) -#define shmp(shm_offset) \ - ((__typeof__(****(shm_offset))) (((char *) &(shm_offset)) + (ptrdiff_t) (shm_offset))) +struct shm_object_table *shm_object_table_create(size_t max_nb_obj); +struct shm_object *shm_object_table_append_shadow(struct shm_object_table *table, + int shm_fd, int wait_fd, size_t memory_map_size); +void shm_object_table_destroy(struct shm_object_table *table); +struct shm_object *shm_object_table_append(struct shm_object_table *table, + size_t memory_map_size); -#define _shmp_abs(a) ((a < 0) ? -(a) : (a)) +/* + * zalloc_shm - allocate memory within a shm object. + * + * Shared memory is already zeroed by shmget. + * *NOT* multithread-safe (should be protected by mutex). + * Returns a -1, -1 tuple on error. + */ +struct shm_ref zalloc_shm(struct shm_object *obj, size_t len); +void align_shm(struct shm_object *obj, size_t align); static inline -void _set_shmp(ptrdiff_t *shm_offset, void *ptr) +int shm_get_wakeup_fd(struct lttng_ust_shm_handle *handle, struct shm_ref *ref) { - *shm_offset = (((char *) ptr) - ((char *) shm_offset)); - assert(_shmp_abs(*shm_offset) < MAX_SHM_SIZE); -} + struct shm_object_table *table = handle->table; + struct shm_object *obj; + size_t index; + + index = (size_t) ref->index; + if (caa_unlikely(index >= table->allocated_len)) + return -EPERM; + obj = &table->objects[index]; -#define set_shmp(shm_offset, ptr) \ - _set_shmp((ptrdiff_t *) ****(shm_offset), ptr) + return obj->wait_fd[1]; +} -/* Shared memory is already zeroed by shmget */ -/* *NOT* multithread-safe (should be protected by mutex) */ static inline -void *zalloc_shm(struct shm_header *shm_header, size_t len) +int shm_open_wakeup_pipe(struct lttng_ust_shm_handle *handle, struct shm_ref *ref) { - void *ret; + struct shm_object_table *table = handle->table; + struct shm_object *obj; + size_t index; + int fd, ret = -1; + + index = (size_t) ref->index; + if (caa_unlikely(index >= table->allocated_len)) + return -EPERM; + + obj = &table->objects[index]; + + if (obj->wait_fd[1] < 0 && obj->wait_pipe_path != NULL) { + fd = open(obj->wait_pipe_path, O_WRONLY); + if (fd < 0) { + ret = -1; + } else { + /* FIXME: What if fcntl fail? */ + fcntl(fd, F_SETFD, FD_CLOEXEC); + obj->wait_fd[1] = fd; + ret = 0; + } + } - if (shm_header->shm_size - shm_header->shm_allocated < len) - return NULL; - ret = (char *) shm_header + shm_header->shm_allocated; - shm_header->shm_allocated += len; return ret; } static inline -void align_shm(struct shm_header *shm_header, size_t align) +int shm_get_wait_fd(struct lttng_ust_shm_handle *handle, struct shm_ref *ref) +{ + struct shm_object_table *table = handle->table; + struct shm_object *obj; + size_t index; + + index = (size_t) ref->index; + if (caa_unlikely(index >= table->allocated_len)) + return -EPERM; + obj = &table->objects[index]; + return obj->wait_fd[0]; +} + +static inline +int shm_get_object_data(struct lttng_ust_shm_handle *handle, struct shm_ref *ref, + int **shm_fd, char **shm_path, + int **wait_fd, char **wait_pipe_path, + uint64_t **memory_map_size) { - size_t offset_len = offset_align(shm_header->shm_allocated, align); - shm_header->shm_allocated += offset_len; + struct shm_object_table *table = handle->table; + struct shm_object *obj; + size_t index; + + index = (size_t) ref->index; + if (caa_unlikely(index >= table->allocated_len)) + return -EPERM; + obj = &table->objects[index]; + *shm_fd = &obj->shm_fd; + *shm_path = obj->shm_path; + *wait_fd = &obj->wait_fd[0]; + *wait_pipe_path = obj->wait_pipe_path; + *memory_map_size = &obj->allocated_len; + return 0; } #endif /* _LIBRINGBUFFER_SHM_H */