X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=ipc.c;h=8e9dd51a2369e7e60ebd4bda3fa889eaed892248;hp=2cab393700dfbf84a8119228f49a21e705174278;hb=ac1f19d550a81c8408c8fce2e237996c950253ab;hpb=ff5830c9fc83ee59be9351c7ff45c1e376bac22b diff --git a/ipc.c b/ipc.c index 2cab3937..8e9dd51a 100644 --- a/ipc.c +++ b/ipc.c @@ -1,45 +1,44 @@ -/* - * Copyright (C) 2006-2007 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ +/* Copyright (C) 2006 Andre Noll , see file COPYING. */ -/** \file ipc.c interprocess communication and shared memory helpers */ +/** \file ipc.c Inter-process communication and shared memory helpers. */ #include "para.h" #include "error.h" #include "ipc.h" +#include +#include + #include #include #include /** - * define a new mutex + * Define a new mutex. * - * \return the identifier for the new mutex on success, \a -E_SEM_GET + * \return The identifier for the new mutex on success, a negative error code * on errors. * - * \sa semget(2) + * \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 + * Destroy a mutex. * - * \param id the identifier of the mutex to be destroyed + * \param id The identifier of the mutex to be destroyed. * - * \return Positive on success, \a -E_SEM_REMOVE on errors. + * \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) @@ -49,7 +48,7 @@ static void para_semop(int id, struct sembuf *sops, int num) return; } while (errno == EINTR); if (errno == EIDRM) { - PARA_NOTICE_LOG("semaphore set %d was removed\n", id); + PARA_CRIT_LOG("semaphore set %d was removed\n", id); return; } PARA_EMERG_LOG("fatal semop error %s: pid %d\n", strerror(errno), @@ -58,13 +57,13 @@ static void para_semop(int id, struct sembuf *sops, int num) } /** - * lock the given mutex + * Lock the given mutex. * - * \param id of the shared memory area to lock + * \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 \ref misc_meta_data. */ void mutex_lock(int id) { @@ -84,13 +83,13 @@ void mutex_lock(int id) } /** - * unlock a mutex + * Unlock a mutex. * - * \param id the identifier of the mutex + * \param id The identifier of the mutex. * * This function either succeeds or aborts. * - * \sa semop(2), struct misc_meta_data + * \sa semop(2), struct \ref misc_meta_data. */ void mutex_unlock(int id) { @@ -105,69 +104,141 @@ void mutex_unlock(int id) } /** - * create a new shared memory area of given size + * Create a new shared memory area of given size. * - * \param size the size of the shared memory area to create + * \param size The size of the shared memory area to create. * - * \return The id of the shared memory areay on success, \a -E_SHM_GET on errors. + * \return The id of the shared memory array on success, a negative error + * code on errors. * - * \sa shmget(2) + * \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 + * Destroy the given shared memory area. * - * \param id the shared memory id + * \param id The shared memory identifier. * * \return The return value of the underlying shmctl() call on success, - * \a -E_SHM_DESTROY on errors. + * a negative error code on errors. * - * \sa shmctl(2) + * \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 segment + * Attach a shared memory segment. * - * \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 + * \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 positive on success, \a -E_SHM_ATTACH on errors. + * \return Standard. * - * \sa shmat(2) + * \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; +} + +/** + * Get the size of a shared memory segment. + * + * \param id The shared memory segment identifier. + * \param result Size in bytes is returned here, zero on errors. + * + * \return Standard. + * + * \sa shmctl(2). + */ +int shm_size(int id, size_t *result) +{ + struct shmid_ds ds; /* data structure */ + + *result = 0; + if (shmctl(id, IPC_STAT, &ds) < 0) + return -ERRNO_TO_PARA_ERROR(errno); + *result = ds.shm_segsz; + return 1; } /** - * detach a shared memory segment + * Detach a shared memory segment. * - * \param addr the address of the attached segment + * \param addr The address of the attached segment. * - * \return positive on success, \a -E_SHM_DETACH on errors. + * \return Standard. * - * \sa shmdt(2) + * \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__ +#include +# define SYSCTL_SHMMAX_VARIABLE "kern.ipc.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); + } + close(fd); + } + } +#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 resort */ + } + PARA_INFO_LOG("shmmax: %zu\n", shmmax); + return shmmax; }