X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=ipc.c;h=576bfe5bcd815ee296da0b56d49a7f3ea5d97e4e;hp=ae9ad574bbd5840be8cee0c034c8f9e0e48cc7cc;hb=53077ea78f01e197e84529ae42558af5c3a68429;hpb=c5517c98d28a74a89086b0641e3633d16eaf9df7 diff --git a/ipc.c b/ipc.c index ae9ad574..576bfe5b 100644 --- a/ipc.c +++ b/ipc.c @@ -1,35 +1,74 @@ +/* + * Copyright (C) 2006-2011 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ + +/** \file ipc.c Inter-process communication and shared memory helpers. */ + #include "para.h" #include "error.h" #include "ipc.h" +#include +#include +#include + #include #include +#include - +/** + * Define a new mutex. + * + * \return The identifier for the new mutex on success, a negative error code + * on errors. + * + * \sa semget(2). + */ int mutex_new(void) { int ret = semget(IPC_PRIVATE, 1, IPC_CREAT | 0666); - return ret < 0? -E_SEM_GET : ret; + return ret < 0? -ERRNO_TO_PARA_ERROR(errno) : ret; } +/** + * Destroy a mutex. + * + * \param id The identifier of the mutex to be destroyed. + * + * \return Standard. + * + * \sa semctl(2) + */ int mutex_destroy(int id) { int ret = semctl(id, 0, IPC_RMID); - return ret < 0? -E_SEM_REMOVE : 1; + return ret < 0? -ERRNO_TO_PARA_ERROR(errno) : 1; } static void para_semop(int id, struct sembuf *sops, int num) { - if (semop(id, sops, num) >= 0) + do { + if (semop(id, sops, num) >= 0) + return; + } while (errno == EINTR); + if (errno == EIDRM) { + PARA_CRIT_LOG("semaphore set %d was removed\n", id); return; - PARA_WARNING_LOG("semop failed (%s), retrying\n", strerror(errno)); - while (semop(id, sops, num) < 0) - ; /* nothing */ + } + PARA_EMERG_LOG("fatal semop error %s: pid %d\n", strerror(errno), + (int)getpid()); + exit(EXIT_FAILURE); } /** - * lock the given mutex + * Lock the given mutex. + * + * \param id The identifier of the shared memory area to lock. + * + * This function either succeeds or aborts. * - * \sa semop(2), struct misc_meta_data + * \sa semop(2), struct misc_meta_data. */ void mutex_lock(int id) { @@ -49,9 +88,13 @@ void mutex_lock(int id) } /** - * unlock a mutex + * Unlock a mutex. * - * \sa semop(2), struct misc_meta_data + * \param id The identifier of the mutex. + * + * This function either succeeds or aborts. + * + * \sa semop(2), struct misc_meta_data. */ void mutex_unlock(int id) { @@ -66,44 +109,120 @@ void mutex_unlock(int id) } /** - * create a new shared memory area of given size - * - * \sa shmget(2) + * Create a new shared memory area of given size. + * + * \param size The size of the shared memory area to create. + * + * \return The id of the shared memory array on success, a negative error + * code on errors. + * + * \sa shmget(2). */ int shm_new(size_t size) { int ret = shmget(IPC_PRIVATE, size, IPC_CREAT | IPC_EXCL | 0600); - return ret < 0 ? -E_SHM_GET : ret; + return ret < 0 ? -ERRNO_TO_PARA_ERROR(errno) : ret; } /** - * destroy the given shared memory area - * \sa shmctl(2) - **/ + * Destroy the given shared memory area. + * + * \param id The shared memory identifier. + * + * \return The return value of the underlying shmctl() call on success, + * a negative error code on errors. + * + * \sa shmctl(2). + */ int shm_destroy(int id) { struct shmid_ds shm_desc; int ret = shmctl(id, IPC_RMID, &shm_desc); - return ret < 0? -E_SHM_DESTROY : ret; + return ret < 0? -ERRNO_TO_PARA_ERROR(errno) : ret; } /** - * attach a shared memory area + * Attach a shared memory segment. * - * \sa semop(2) + * \param id The identifier of the shared memory segment to attach. + * \param mode Either ATTACH_RO (read only) or ATTACH_RW (read/write). + * \param result Points to the attached area just attached on success. + * + * \return Standard. + * + * \sa shmat(2). */ int shm_attach(int id, enum shm_attach_mode mode, void **result) { - if (mode == ATTACH_RW) { + if (mode == ATTACH_RW) *result = shmat(id, NULL, 0); - return *result? 1 : -E_SHM_ATTACH; - } - *result = shmat(id, NULL, SHM_RDONLY); - return *result? 1 : -E_SHM_ATTACH; + else + *result = shmat(id, NULL, SHM_RDONLY); + return *result == (void *) -1? -ERRNO_TO_PARA_ERROR(errno) : 1; } +/** + * Detach a shared memory segment. + * + * \param addr The address of the attached segment. + * + * \return Standard. + * + * \sa shmdt(2). + */ int shm_detach(void *addr) { int ret = shmdt(addr); - return ret < 0? -E_SHM_DETACH : 1; + return ret < 0? -ERRNO_TO_PARA_ERROR(errno) : 1; +} + +# if defined __FreeBSD__ || defined __NetBSD__ +# define SYSCTL_SHMMAX_VARIABLE "kern.ipc.shmmax" +# elif defined __APPLE__ +# define SYSCTL_SHMMAX_VARIABLE "kern.sysv.shmmax" +# else +# undef SYSCTL_SHMMAX_VARIABLE +# endif + +/** + * Get the maximal size of a shared memory area. + * + * The value is only computed once when the function is called for the first + * time. Subsequent calls return the number which was computed during the + * first call. + * + * \return A number suitable as an argument to \ref shm_new(). + */ +size_t shm_get_shmmax(void) +{ + static size_t shmmax; + + if (shmmax > 0) /* only dance once */ + return shmmax; +#ifdef __linux__ /* get it from proc fs */ + { + int fd = open("/proc/sys/kernel/shmmax", O_RDONLY); + if (fd >= 0) { + char buf[100] = ""; + int ret = read(fd, buf, sizeof(buf) - 1); + if (ret > 0) { + buf[ret] = '\0'; + shmmax = strtoul(buf, NULL, 10); + } + } + } +#elif defined SYSCTL_SHMMAX_VARIABLE + { + size_t len = sizeof(shmmax); + sysctlbyname(SYSCTL_SHMMAX_VARIABLE, &shmmax, &len, NULL, 0); + } +#elif defined SHMMAX + shmmax = SHMMAX; +#endif + if (shmmax == 0) { + PARA_WARNING_LOG("unable to determine shmmax\n"); + shmmax = 65535; /* last ressort */ + } + PARA_INFO_LOG("shmmax: %zu\n", shmmax); + return shmmax; }