#include "db_config.h"
#include "db_int.h"
#ifdef HAVE_SYSTEM_INCLUDE_FILES
#ifdef HAVE_MMAP
#include <sys/mman.h>
#endif
#ifdef HAVE_SHMGET
#include <sys/ipc.h>
#include <sys/shm.h>
#endif
#endif
#ifdef HAVE_MMAP
static int __os_map __P((ENV *, char *, DB_FH *, size_t, int, int, void **));
#endif
#ifdef HAVE_SHMGET
static int __shm_mode __P((ENV *));
#else
static int __no_system_mem __P((ENV *));
#endif
int
__os_attach(env, infop, rp)
ENV *env;
REGINFO *infop;
REGION *rp;
{
DB_ENV *dbenv;
int create_ok, ret;
DB_ASSERT(env, env != NULL && env->dbenv != NULL);
dbenv = env->dbenv;
if (DB_GLOBAL(j_region_map) != NULL) {
create_ok = F_ISSET(infop, REGION_CREATE) ? 1 : 0;
ret = DB_GLOBAL(j_region_map)
(dbenv, infop->name, rp->size, &create_ok, &infop->addr);
if (create_ok)
F_SET(infop, REGION_CREATE);
else
F_CLR(infop, REGION_CREATE);
return (ret);
}
if (F_ISSET(env, ENV_SYSTEM_MEM)) {
#if defined(HAVE_MUTEX_HPPA_MSEM_INIT)
__db_errx(env,
"architecture does not support locks inside system shared memory");
return (EINVAL);
#endif
#if defined(HAVE_SHMGET)
{
key_t segid;
int id, mode;
if (F_ISSET(infop, REGION_CREATE)) {
if (dbenv->shm_key == INVALID_REGION_SEGID) {
__db_errx(env,
"no base system shared memory ID specified");
return (EINVAL);
}
segid = (key_t)
((u_long)dbenv->shm_key + (infop->id - 1));
if ((id = shmget(segid, 0, 0)) != -1) {
(void)shmctl(id, IPC_RMID, NULL);
if ((id = shmget(segid, 0, 0)) != -1) {
__db_errx(env,
"shmget: key: %ld: shared system memory region already exists",
(long)segid);
return (EAGAIN);
}
}
mode = IPC_CREAT | __shm_mode(env);
if ((id = shmget(segid, rp->size, mode)) == -1) {
ret = __os_get_syserr();
__db_syserr(env, ret,
"shmget: key: %ld: unable to create shared system memory region",
(long)segid);
return (__os_posix_err(ret));
}
rp->segid = id;
} else
id = rp->segid;
if ((infop->addr = shmat(id, NULL, 0)) == (void *)-1) {
infop->addr = NULL;
ret = __os_get_syserr();
__db_syserr(env, ret,
"shmat: id %d: unable to attach to shared system memory region", id);
return (__os_posix_err(ret));
}
if (F_ISSET(env, ENV_LOCKDOWN)) {
#ifdef HAVE_SHMCTL_SHM_LOCK
ret = shmctl(
id, SHM_LOCK, NULL) == 0 ? 0 : __os_get_syserr();
#else
ret = DB_OPNOTSUP;
#endif
if (ret != 0) {
__db_syserr(env, ret,
"shmctl/SHM_LOCK: id %d: unable to lock down shared memory region", id);
return (__os_posix_err(ret));
}
}
return (0);
}
#else
return (__no_system_mem(env));
#endif
}
#ifdef HAVE_MMAP
{
DB_FH *fhp;
fhp = NULL;
if ((ret = __os_open(env, infop->name, 0,
DB_OSO_REGION |
(F_ISSET(infop, REGION_CREATE_OK) ? DB_OSO_CREATE : 0),
env->db_mode, &fhp)) != 0)
__db_err(env, ret, "%s", infop->name);
if (ret == 0 && F_ISSET(infop, REGION_CREATE)) {
if (F_ISSET(dbenv, DB_ENV_REGION_INIT))
ret = __db_file_write(env, fhp,
rp->size / MEGABYTE, rp->size % MEGABYTE, 0x00);
else
ret = __db_file_extend(env, fhp, rp->size);
}
if (ret == 0)
ret = __os_map(env,
infop->name, fhp, rp->size, 1, 0, &infop->addr);
if (fhp != NULL)
(void)__os_closehandle(env, fhp);
return (ret);
}
#else
COMPQUIET(infop, NULL);
COMPQUIET(rp, NULL);
__db_errx(env,
"architecture lacks mmap(2), shared environments not possible");
return (DB_OPNOTSUP);
#endif
}
int
__os_detach(env, infop, destroy)
ENV *env;
REGINFO *infop;
int destroy;
{
DB_ENV *dbenv;
REGION *rp;
int ret;
DB_ASSERT(env, env != NULL && env->dbenv != NULL);
dbenv = env->dbenv;
rp = infop->rp;
if (DB_GLOBAL(j_region_unmap) != NULL)
return (DB_GLOBAL(j_region_unmap)(dbenv, infop->addr));
if (F_ISSET(env, ENV_SYSTEM_MEM)) {
#ifdef HAVE_SHMGET
int segid;
segid = rp->segid;
if (destroy)
rp->segid = INVALID_REGION_SEGID;
if (shmdt(infop->addr) != 0) {
ret = __os_get_syserr();
__db_syserr(env, ret, "shmdt");
return (__os_posix_err(ret));
}
if (destroy && shmctl(segid, IPC_RMID,
NULL) != 0 && (ret = __os_get_syserr()) != EINVAL) {
__db_syserr(env, ret,
"shmctl: id %d: unable to delete system shared memory region",
segid);
return (__os_posix_err(ret));
}
return (0);
#else
return (__no_system_mem(env));
#endif
}
#ifdef HAVE_MMAP
#ifdef HAVE_MUNLOCK
if (F_ISSET(env, ENV_LOCKDOWN))
(void)munlock(infop->addr, rp->size);
#endif
if (munmap(infop->addr, rp->size) != 0) {
ret = __os_get_syserr();
__db_syserr(env, ret, "munmap");
return (__os_posix_err(ret));
}
if (destroy && (ret = __os_unlink(env, infop->name, 1)) != 0)
return (ret);
return (0);
#else
COMPQUIET(destroy, 0);
COMPQUIET(ret, 0);
return (EINVAL);
#endif
}
int
__os_mapfile(env, path, fhp, len, is_rdonly, addrp)
ENV *env;
char *path;
DB_FH *fhp;
int is_rdonly;
size_t len;
void **addrp;
{
#if defined(HAVE_MMAP) && !defined(HAVE_QNX)
DB_ENV *dbenv;
if (DB_GLOBAL(j_file_map) != NULL) {
DB_ASSERT(env, env != NULL && env->dbenv != NULL);
dbenv = env->dbenv;
return (
DB_GLOBAL(j_file_map)(dbenv, path, len, is_rdonly, addrp));
}
return (__os_map(env, path, fhp, len, 0, is_rdonly, addrp));
#else
COMPQUIET(env, NULL);
COMPQUIET(path, NULL);
COMPQUIET(fhp, NULL);
COMPQUIET(is_rdonly, 0);
COMPQUIET(len, 0);
COMPQUIET(addrp, NULL);
return (DB_OPNOTSUP);
#endif
}
int
__os_unmapfile(env, addr, len)
ENV *env;
void *addr;
size_t len;
{
DB_ENV *dbenv;
int ret;
DB_ASSERT(env, env != NULL && env->dbenv != NULL);
dbenv = env->dbenv;
if (FLD_ISSET(dbenv->verbose, DB_VERB_FILEOPS | DB_VERB_FILEOPS_ALL))
__db_msg(env, "fileops: munmap");
if (DB_GLOBAL(j_file_unmap) != NULL)
return (DB_GLOBAL(j_file_unmap)(dbenv, addr));
#ifdef HAVE_MMAP
#ifdef HAVE_MUNLOCK
if (F_ISSET(env, ENV_LOCKDOWN))
RETRY_CHK((munlock(addr, len)), ret);
#else
COMPQUIET(env, NULL);
#endif
RETRY_CHK((munmap(addr, len)), ret);
ret = __os_posix_err(ret);
#else
COMPQUIET(env, NULL);
ret = EINVAL;
#endif
return (ret);
}
#ifdef HAVE_MMAP
static int
__os_map(env, path, fhp, len, is_region, is_rdonly, addrp)
ENV *env;
char *path;
DB_FH *fhp;
int is_region, is_rdonly;
size_t len;
void **addrp;
{
DB_ENV *dbenv;
int flags, prot, ret;
void *p;
DB_ASSERT(env, env != NULL && env->dbenv != NULL);
dbenv = env->dbenv;
if (FLD_ISSET(dbenv->verbose, DB_VERB_FILEOPS | DB_VERB_FILEOPS_ALL))
__db_msg(env, "fileops: mmap %s", path);
DB_ASSERT(env, F_ISSET(fhp, DB_FH_OPENED) && fhp->fd != -1);
flags = is_rdonly ? MAP_PRIVATE : MAP_SHARED;
#ifdef MAP_FILE
flags |= MAP_FILE;
#endif
#ifdef MAP_HASSEMAPHORE
if (is_region && !is_rdonly)
flags |= MAP_HASSEMAPHORE;
#else
COMPQUIET(is_region, 0);
#endif
#ifdef MAP_NOSYNC
flags |= MAP_NOSYNC;
#endif
prot = PROT_READ | (is_rdonly ? 0 : PROT_WRITE);
#ifdef VMS
if (__os_fsync(env, fhp) == -1)
return (__os_posix_err(__os_get_syserr()));
#endif
#ifndef MAP_FAILED
#define MAP_FAILED -1
#endif
if ((p = mmap(NULL,
len, prot, flags, fhp->fd, (off_t)0)) == (void *)MAP_FAILED) {
ret = __os_get_syserr();
__db_syserr(env, ret, "mmap");
return (__os_posix_err(ret));
}
if (F_ISSET(env, ENV_LOCKDOWN)) {
#ifdef HAVE_MLOCK
ret = mlock(p, len) == 0 ? 0 : __os_get_syserr();
#else
ret = DB_OPNOTSUP;
#endif
if (ret != 0) {
__db_syserr(env, ret, "mlock");
return (__os_posix_err(ret));
}
}
*addrp = p;
return (0);
}
#endif
#ifdef HAVE_SHMGET
#ifndef SHM_R
#define SHM_R 0400
#endif
#ifndef SHM_W
#define SHM_W 0200
#endif
static int
__shm_mode(env)
ENV *env;
{
int mode;
if (env->db_mode == 0)
return (SHM_R | SHM_W | SHM_R >> 3 | SHM_W >> 3);
mode = 0;
if (env->db_mode & S_IRUSR)
mode |= SHM_R;
if (env->db_mode & S_IWUSR)
mode |= SHM_W;
if (env->db_mode & S_IRGRP)
mode |= SHM_R >> 3;
if (env->db_mode & S_IWGRP)
mode |= SHM_W >> 3;
if (env->db_mode & S_IROTH)
mode |= SHM_R >> 6;
if (env->db_mode & S_IWOTH)
mode |= SHM_W >> 6;
return (mode);
}
#else
static int
__no_system_mem(env)
ENV *env;
{
__db_errx(env,
"architecture doesn't support environments in system memory");
return (DB_OPNOTSUP);
}
#endif