blob: d64f73f4aaca50f78ff246f190d1a643db11dbd7 [file] [log] [blame]
/***************************************************************************
*
* memattr.cpp - source for C++ Standard Library helper functions
* to determine the attributes of regions of memory
*
* $Id$
*
***************************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied. See the License for the specific language governing
* permissions and limitations under the License.
*
* Copyright 2005-2007 Rogue Wave Software, Inc.
*
**************************************************************************/
#define _RWSTD_LIB_SRC
#include <errno.h> // for ENOMEM, errno
#include <string.h> // for memchr(), size_t
#ifndef EFAULT
# define EFAULT 14 // Linux value
#endif // EFAULT
#ifdef __CYGWIN__
// use the Windows API on Cygwin
# define _WIN32
#endif
#ifndef _WIN32
# ifdef __SUNPRO_CC
// working around SunOS bug #568
# include <time.h>
# endif
# include <unistd.h> // for getpagesize(), sysconf()
# if defined (_RWSTD_OS_LINUX) && !defined (__USE_BSD)
// needed for caddr_t, madvise, and MADV_WILLNEED
# define __USE_BSD
# endif // _RWSTD_OS_LINUX && !__USE_BSD
# include <sys/mman.h> // for mincore()
# include <sys/types.h>
# if defined (_RWSTD_OS_SUNOS) && defined (_RWSTD_NO_POSIX_MADVISE)
// can't get a proper prototype for madvise with C++ defines in Solaris 10
extern "C" int madvise(caddr_t, size_t, int);
# endif
# ifndef _SC_PAGE_SIZE
// fall back on the alternative macro if it exists,
// or use getpagesize() otherwise
# ifndef _SC_PAGESIZE
# define GETPAGESIZE() getpagesize ()
# else
# define GETPAGESIZE() sysconf (_SC_PAGESIZE)
# endif
# else
# define GETPAGESIZE() sysconf (_SC_PAGE_SIZE)
# endif // _SC_PAGE_SIZE
#else
# include <windows.h> // for everything (ugh)
#endif // _WIN32
#include <rw/_defs.h>
// define ENOMEM if it's not #defined (e.g., when using pure libc headers)
#ifndef ENOMEM
# define ENOMEM 12 /* HP-UX, Solaris, Tru64, ... */
#endif // ENOMEM
// FIXME: implement PROT_READ and PROT_WRITE correctly
#ifndef _RWSTD_PROT_READ
# define _RWSTD_PROT_READ -1
#endif
#ifndef _RWSTD_PROT_WRITE
# define _RWSTD_PROT_WRITE 0
#endif
#define DIST(addr1, addr2) \
( _RWSTD_REINTERPRET_CAST (const char*, addr1) \
- _RWSTD_REINTERPRET_CAST (const char*, addr2))
_RWSTD_NAMESPACE (__rw) {
_RWSTD_EXPORT _RWSTD_SSIZE_T
__rw_memattr (const void *addr, size_t nbytes, int attr)
{
// FIXME: allow attr to be set to the equivalent of PROT_READ,
// PROT_WRITE, and (perhaps also) PROT_EXEC, or any combination
// of the three, in addition to 0 (PROT_NONE)
_RWSTD_UNUSED (attr);
#ifndef _WIN32
const int errno_save = errno;
// determine the system page size in bytes
static const size_t pgsz = size_t (GETPAGESIZE ());
// compute the address of the beginning of the page
// to which the address `addr' belongs
caddr_t const page =
_RWSTD_REINTERPRET_CAST (caddr_t,
_RWSTD_REINTERPRET_CAST (size_t, addr) & ~(pgsz - 1));
// compute the maximum number of pages occuppied by the memory
// region pointed to by `addr' (nbytes may be -1 as a request
// to compute, in a safe way, the length of the string pointed
// to by `addr')
size_t npages = nbytes ? nbytes / pgsz + 1 : 0;
for (size_t i = 0; i < npages; ++i) {
const caddr_t next = _RWSTD_REINTERPRET_CAST (char*, page) + i * pgsz;
# ifdef _RWSTD_OS_SUNOS
# ifndef _RWSTD_NO_POSIX_MADVISE
const int advice = POSIX_MADV_WILLNEED;
// on Solaris use posix_madvise if available
if (-1 == posix_madvise (next, 1, advice)) {
# else
const int advice = MADV_WILLNEED;
// on Solaris use madvise if available
if (-1 == madvise (next, 1, advice)) {
# endif // _RWSTD_NO_POSIX_MADVISE
const int err = errno;
errno = errno_save;
if (ENOMEM == err)
return next == page ? -1 : DIST (next, addr);
}
# elif defined (_RWSTD_OS_OSF1)
// use Tru64 mvalid()
if (-1 == mvalid (next, 1, PROT_READ)) {
const int err = errno;
errno = errno_save;
if (err)
return next == page ? -1 : DIST (next, addr);
}
# elif defined (_RWSTD_OS_IRIX64)
// as of 6.5, IRIX has no mincore() or mvalid() call,
// or posix_madvise(), and madvise() is unreliable
// use msync() instead
if (-1 == msync (next, 1, MS_ASYNC)) {
const int err = errno;
errno = errno_save;
if (err)
return next == page ? -1 : DIST (next, addr);
}
# elif !defined (_RWSTD_NO_MADVISE)
# ifdef _RWSTD_OS_IRIX64
// IRIX 6.5 recognizes only MADV_DONTNEED
const int advice = MADV_DONTNEED;
# else
const int advice = MADV_WILLNEED;
# endif
// on HP-UX, Linux, use madvise() as opposed to mincore()
// since the latter fails for address ranges that aren't
// backed by a file (such as stack variables)
if (-1 == madvise (next, 1, advice)) {
const int err = errno;
errno = errno_save;
bool bad_address;
# ifdef _RWSTD_OS_LINUX
// Linux fails with EBADF when "the map exists,
// but the area maps something that isn't a file"
bad_address = EFAULT == err || ENOMEM == err;
# else // not Linux
// EINVAL implies bad (e.g., unimplemented, such as
// IRIX 6.5) advice, misaligned addr (not on page size
// boundary), or zero size
bad_address = !(0 == err || EINVAL == err);
# endif // Linux
if (bad_address)
return next == page ? -1 : DIST (next, addr);
}
# else
_RWSTD_UNUSED (errno_save);
# endif
if (_RWSTD_SIZE_MAX == nbytes) {
// when the size of the region is unspecified look
// for the first NUL byte and when found, return
// the total size of the memory region between
// `addr' and the NUL byte (i.e., the length of
// the string pointed to by `addr'); this should
// be safe since the first byte of the range has
// been determined to be readable
const size_t maxpage =
next == page ? pgsz - DIST (addr, next) : pgsz;
const void* const pnul =
memchr (next == page ? addr : next, '\0', maxpage);
if (pnul) {
nbytes = DIST (pnul, addr);
npages = nbytes / pgsz + 1;
break;
}
}
}
return _RWSTD_STATIC_CAST (_RWSTD_SSIZE_T, nbytes);
#else // ifdef _WIN32
LPVOID const ptr = _RWSTD_CONST_CAST (LPVOID, addr);
if (_RWSTD_SIZE_MAX == nbytes) {
// treat the address as a pointer to a NUL-terminated string
if (IsBadStringPtr (_RWSTD_STATIC_CAST (LPCSTR, ptr), nbytes))
return -1;
// compute the length of the string
nbytes = strlen (_RWSTD_STATIC_CAST (const char*, addr));
// disable read checking below (since it was done above)
attr &= ~_RWSTD_PROT_READ;
}
if ((attr & _RWSTD_PROT_READ) && IsBadReadPtr (ptr, nbytes))
return -1;
if ((attr & _RWSTD_PROT_WRITE) && IsBadWritePtr (ptr, nbytes))
return -1;
return _RWSTD_STATIC_CAST (_RWSTD_SSIZE_T, nbytes);
#endif // _RWSTD_NO_INCORE
}
}