You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
339 lines
8.4 KiB
339 lines
8.4 KiB
/*-
|
|
* See the file LICENSE for redistribution information.
|
|
*
|
|
* Copyright (c) 1996, 1997, 1998, 1999
|
|
* Sleepycat Software. All rights reserved.
|
|
*/
|
|
|
|
#include "db_config.h"
|
|
|
|
#ifndef lint
|
|
static const char sccsid[] = "@(#)os_map.c 11.10 (Sleepycat) 10/31/99";
|
|
#endif /* not lint */
|
|
|
|
#ifdef _MSC_VER /* _WIN32 */
|
|
#include <windows.h>
|
|
#endif
|
|
|
|
#ifndef NO_SYSTEM_INCLUDES
|
|
#include <sys/types.h>
|
|
#ifdef HAVE_MMAP
|
|
#include <sys/mman.h>
|
|
#endif
|
|
|
|
#ifdef HAVE_SHMGET
|
|
#include <sys/ipc.h>
|
|
#include <sys/shm.h>
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#endif
|
|
|
|
#include "db_int.h"
|
|
#include "os_jump.h"
|
|
|
|
#ifdef HAVE_MMAP
|
|
static int CDB___os_map __P((DB_ENV *, char *, DB_FH *, size_t, int, int, void **));
|
|
#endif
|
|
|
|
/*
|
|
* CDB___os_r_sysattach --
|
|
* Create/join a shared memory region.
|
|
*
|
|
* PUBLIC: int CDB___os_r_sysattach __P((DB_ENV *, REGINFO *, REGION *));
|
|
*/
|
|
int
|
|
CDB___os_r_sysattach(dbenv, infop, rp)
|
|
DB_ENV *dbenv;
|
|
REGINFO *infop;
|
|
REGION *rp;
|
|
{
|
|
DB_FH fh;
|
|
int ret;
|
|
|
|
if (F_ISSET(dbenv, DB_ENV_SYSTEM_MEM)) {
|
|
/*
|
|
* If the region is in system memory on UNIX, we use shmget(2).
|
|
*
|
|
* !!!
|
|
* There exist spinlocks that don't work in shmget memory, e.g.,
|
|
* the HP/UX msemaphore interface. If we don't have locks that
|
|
* will work in shmget memory, we better be private and not be
|
|
* threaded. If we reach this point, we know we're public, so
|
|
* it's an error.
|
|
*/
|
|
#if defined(MUTEX_NO_SHMGET_LOCKS)
|
|
CDB___db_err(dbenv, "%s",
|
|
"architecture does not support locks inside system (shmget(2)) memory");
|
|
CDB___db_err(dbenv, "%s",
|
|
"application must specify DB_PRIVATE or not specify DB_SYSTEM_MEM");
|
|
return (EINVAL);
|
|
#endif
|
|
#if defined(HAVE_SHMGET)
|
|
if (F_ISSET(infop, REGION_CREATE) &&
|
|
(rp->segid = shmget(0, rp->size, IPC_PRIVATE | 0600)) == -1)
|
|
return (CDB___os_get_errno());
|
|
|
|
if ((infop->addr = shmat(rp->segid, NULL, 0)) == (void *)-1) {
|
|
infop->addr = NULL;
|
|
return (CDB___os_get_errno());
|
|
}
|
|
|
|
return (0);
|
|
#else
|
|
CDB___db_err(dbenv,
|
|
"architecture lacks shmget(2), environments in system memory not possible");
|
|
return (CDB___db_eopnotsup(dbenv));
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAVE_MMAP
|
|
/*
|
|
* Try to open/create the file. We DO NOT need to ensure that multiple
|
|
* threads/processes attempting to simultaneously create the region are
|
|
* properly ordered, our caller has already taken care of that.
|
|
*/
|
|
if ((ret = CDB___os_open(infop->name,
|
|
F_ISSET(infop, REGION_CREATE_OK) ? DB_OSO_CREATE: 0,
|
|
infop->mode, &fh)) != 0)
|
|
CDB___db_err(dbenv, "%s: %s", infop->name, CDB_db_strerror(ret));
|
|
|
|
/*
|
|
* If we created the file, grow it to its full size before mapping
|
|
* it in. We really want to avoid touching the buffer cache after
|
|
* mmap(2) is called, doing anything else confuses the hell out of
|
|
* systems without merged VM/buffer cache systems, or, more to the
|
|
* point, *badly* merged VM/buffer cache systems.
|
|
*/
|
|
if (ret == 0 && F_ISSET(infop, REGION_CREATE))
|
|
ret = CDB___os_finit(&fh, rp->size, DB_GLOBAL(db_region_init));
|
|
|
|
/* Map the file in. */
|
|
if (ret == 0)
|
|
ret = CDB___os_map(dbenv,
|
|
infop->name, &fh, rp->size, 1, 0, &infop->addr);
|
|
|
|
(void)CDB___os_closehandle(&fh);
|
|
|
|
return (ret);
|
|
#else
|
|
CDB___db_err(dbenv,
|
|
"architecture lacks mmap(2), shared environments not possible");
|
|
return (CDB___db_eopnotsup(dbenv));
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* CDB___os_r_sysdetach --
|
|
* Detach from a shared memory region.
|
|
*
|
|
* PUBLIC: int CDB___os_r_sysdetach __P((DB_ENV *, REGINFO *, int));
|
|
*/
|
|
int
|
|
CDB___os_r_sysdetach(dbenv, infop, destroy)
|
|
DB_ENV *dbenv;
|
|
REGINFO *infop;
|
|
int destroy;
|
|
{
|
|
REGION *rp;
|
|
int segid;
|
|
|
|
rp = infop->rp;
|
|
|
|
if (F_ISSET(dbenv, DB_ENV_SYSTEM_MEM)) {
|
|
#ifdef HAVE_SHMGET
|
|
/*
|
|
* We may be about to remove the memory referenced by rp,
|
|
* save the segment ID, and (optionally) wipe the original.
|
|
*/
|
|
segid = rp->segid;
|
|
if (destroy)
|
|
rp->segid = INVALID_REGION_SEGID;
|
|
|
|
if (shmdt(infop->addr) != 0)
|
|
return (CDB___os_get_errno());
|
|
|
|
if (destroy)
|
|
if (shmctl(segid, IPC_RMID, NULL) != 0)
|
|
return (CDB___os_get_errno());
|
|
|
|
return (0);
|
|
#else
|
|
return (EINVAL);
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAVE_MMAP
|
|
#ifdef HAVE_MUNLOCK
|
|
if (F_ISSET(dbenv, DB_ENV_LOCKDOWN))
|
|
(void)munlock(infop->addr, rp->size);
|
|
#endif
|
|
if (munmap(infop->addr, rp->size) != 0)
|
|
return (CDB___os_get_errno());
|
|
|
|
if (destroy && CDB___os_unlink(infop->name) != 0)
|
|
return (CDB___os_get_errno());
|
|
return (0);
|
|
#else
|
|
return (EINVAL);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* CDB___os_mapfile --
|
|
* Map in a shared memory file.
|
|
*
|
|
* PUBLIC: int CDB___os_mapfile __P((DB_ENV *,
|
|
* PUBLIC: char *, DB_FH *, size_t, int, void **));
|
|
*/
|
|
int
|
|
CDB___os_mapfile(dbenv, path, fhp, len, is_rdonly, addrp)
|
|
DB_ENV *dbenv;
|
|
char *path;
|
|
DB_FH *fhp;
|
|
int is_rdonly;
|
|
size_t len;
|
|
void **addrp;
|
|
{
|
|
#ifdef HAVE_MMAP
|
|
return (CDB___os_map(dbenv, path, fhp, len, 0, is_rdonly, addrp));
|
|
#else
|
|
COMPQUIET(dbenv, NULL);
|
|
return (EINVAL);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* CDB___os_unmapfile --
|
|
* Unmap the shared memory file.
|
|
*
|
|
* PUBLIC: int CDB___os_unmapfile __P((DB_ENV *, void *, size_t));
|
|
*/
|
|
int
|
|
CDB___os_unmapfile(dbenv, addr, len)
|
|
DB_ENV *dbenv;
|
|
void *addr;
|
|
size_t len;
|
|
{
|
|
/* If the user replaced the map call, call through their interface. */
|
|
if (CDB___db_jump.j_unmap != NULL)
|
|
return (CDB___db_jump.j_unmap(addr, len));
|
|
|
|
#ifdef HAVE_MMAP
|
|
#ifdef HAVE_MUNLOCK
|
|
if (F_ISSET(dbenv, DB_ENV_LOCKDOWN))
|
|
(void)munlock(addr, len);
|
|
#else
|
|
COMPQUIET(dbenv, NULL);
|
|
#endif
|
|
return (munmap(addr, len) ? CDB___os_get_errno() : 0);
|
|
#else
|
|
COMPQUIET(dbenv, NULL);
|
|
|
|
return (EINVAL);
|
|
#endif
|
|
}
|
|
|
|
#ifdef HAVE_MMAP
|
|
/*
|
|
* CDB___os_map --
|
|
* Call the mmap(2) function.
|
|
*/
|
|
static int
|
|
CDB___os_map(dbenv, path, fhp, len, is_region, is_rdonly, addrp)
|
|
DB_ENV *dbenv;
|
|
char *path;
|
|
DB_FH *fhp;
|
|
int is_region, is_rdonly;
|
|
size_t len;
|
|
void **addrp;
|
|
{
|
|
void *p;
|
|
int flags, prot;
|
|
|
|
/* If the user replaced the map call, call through their interface. */
|
|
if (CDB___db_jump.j_map != NULL)
|
|
return (CDB___db_jump.j_map
|
|
(path, len, is_region, is_rdonly, addrp));
|
|
|
|
/*
|
|
* If it's read-only, it's private, and if it's not, it's shared.
|
|
* Don't bother with an additional parameter.
|
|
*/
|
|
flags = is_rdonly ? MAP_PRIVATE : MAP_SHARED;
|
|
|
|
#ifdef MAP_FILE
|
|
/*
|
|
* Historically, MAP_FILE was required for mapping regular files,
|
|
* even though it was the default. Some systems have it, some
|
|
* don't, some that have it set it to 0.
|
|
*/
|
|
flags |= MAP_FILE;
|
|
#endif
|
|
|
|
/*
|
|
* I know of no systems that implement the flag to tell the system
|
|
* that the region contains semaphores, but it's not an unreasonable
|
|
* thing to do, and has been part of the design since forever. I
|
|
* don't think anyone will object, but don't set it for read-only
|
|
* files, it doesn't make sense.
|
|
*/
|
|
#ifdef MAP_HASSEMAPHORE
|
|
if (is_region && !is_rdonly)
|
|
flags |= MAP_HASSEMAPHORE;
|
|
#else
|
|
COMPQUIET(is_region, 0);
|
|
#endif
|
|
|
|
prot = PROT_READ | (is_rdonly ? 0 : PROT_WRITE);
|
|
|
|
/*
|
|
* XXX
|
|
* Work around a bug in the VMS V7.1 mmap() implementation. To map
|
|
* a file into memory on VMS it needs to be opened in a certain way,
|
|
* originally. To get the file opened in that certain way, the VMS
|
|
* mmap() closes the file and re-opens it. When it does this, it
|
|
* doesn't flush any caches out to disk before closing. The problem
|
|
* this causes us is that when the memory cache doesn't get written
|
|
* out, the file isn't big enough to match the memory chunk and the
|
|
* mmap() call fails. This call to fsync() fixes the problem. DEC
|
|
* thinks this isn't a bug because of language in XPG5 discussing user
|
|
* responsibility for on-disk and in-memory synchronization.
|
|
*/
|
|
#ifdef VMS
|
|
if (CDB___os_fsync(fhp) == -1)
|
|
return(CDB___os_get_errno());
|
|
#endif
|
|
|
|
/* MAP_FAILED was not defined in early mmap implementations. */
|
|
#ifndef MAP_FAILED
|
|
#define MAP_FAILED -1
|
|
#endif
|
|
if ((p = mmap(NULL,
|
|
len, prot, flags, fhp->fd, (off_t)0)) == (void *)MAP_FAILED)
|
|
return (CDB___os_get_errno());
|
|
|
|
#ifdef HAVE_MLOCK
|
|
/*
|
|
* If it's a region, we want to make sure that the memory isn't paged.
|
|
* For example, Solaris will page large mpools because it thinks that
|
|
* I/O buffer memory is more important than we are. The mlock system
|
|
* call may or may not succeed (mlock is restricted to the super-user
|
|
* on some systems). Currently, the only other use of mmap in DB is
|
|
* to map read-only databases -- we don't want them paged, either, so
|
|
* the call isn't conditional.
|
|
*/
|
|
if (F_ISSET(dbenv, DB_ENV_LOCKDOWN) && mlock(p, len) != 0) {
|
|
(void)munmap(p, len);
|
|
return (CDB___os_get_errno());
|
|
}
|
|
#else
|
|
COMPQUIET(dbenv, NULL);
|
|
#endif
|
|
|
|
*addrp = p;
|
|
return (0);
|
|
}
|
|
#endif
|