#include "precompiled.hpp"

#include "classfile/vmSymbols.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "oops/oop.inline.hpp"

#include "os_linux.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/perfMemory.hpp"

#include "services/memTracker.hpp"

#include "utilities/exceptions.hpp"

# include <sys/types.h>

# include <sys/mman.h>

# include <errno.h>

# include <stdio.h>

# include <unistd.h>

# include <sys/stat.h>

# include <signal.h>

# include <pwd.h>

static char* backing_store_file_name = NULL; // name of the backing store

// file, if successfully created.

static char* create_standard_memory(size_t size) {

// allocate an aligned chuck of memory

char* mapAddress = os::reserve_memory(size);

if (mapAddress == NULL) {

return NULL;

}

// commit memory

if (!os::commit_memory(mapAddress, size, !ExecMem)) {

if (PrintMiscellaneous && Verbose) {

warning("Could not commit PerfData memory\n");

}

os::release_memory(mapAddress, size);

return NULL;

}

return mapAddress;

}

static void delete_standard_memory(char* addr, size_t size) {

// there are no persistent external resources to cleanup for standard

// memory. since DestroyJavaVM does not support unloading of the JVM,

// cleanup of the memory resource is not performed. The memory will be

// reclaimed by the OS upon termination of the process.

//

return;

}

static void save_memory_to_file(char* addr, size_t size) {

const char* destfile = PerfMemory::get_perfdata_file_path();

assert(destfile[0] != '\0', "invalid PerfData file path");

int result;

RESTARTABLE(::open(destfile, O_CREAT|O_WRONLY|O_TRUNC, S_IREAD|S_IWRITE),

result);;

if (result == OS_ERR) {

if (PrintMiscellaneous && Verbose) {

warning("Could not create Perfdata save file: %s: %s\n",

destfile, strerror(errno));

}

} else {

int fd = result;

for (size_t remaining = size; remaining > 0;) {

RESTARTABLE(::write(fd, addr, remaining), result);

if (result == OS_ERR) {

if (PrintMiscellaneous && Verbose) {

warning("Could not write Perfdata save file: %s: %s\n",

destfile, strerror(errno));

}

break;

}

remaining -= (size_t)result;

addr += result;

}

RESTARTABLE(::close(fd), result);

if (PrintMiscellaneous && Verbose) {

if (result == OS_ERR) {

warning("Could not close %s: %s\n", destfile, strerror(errno));

}

}

}

FREE_C_HEAP_ARRAY(char, destfile, mtInternal);

}

static char* get_user_tmp_dir(const char* user) {

const char* tmpdir = os::get_temp_directory();

const char* perfdir = PERFDATA_NAME;

size_t nbytes = strlen(tmpdir) + strlen(perfdir) + strlen(user) + 3;

char* dirname = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal);

// construct the path name to user specific tmp directory

snprintf(dirname, nbytes, "%s/%s_%s", tmpdir, perfdir, user);

return dirname;

}

static pid_t filename_to_pid(const char* filename) {

// a filename that doesn't begin with a digit is not a

// candidate for conversion.

//

if (!isdigit(*filename)) {

return 0;

}

// check if file name can be converted to an integer without

// any leftover characters.

//

char* remainder = NULL;

errno = 0;

pid_t pid = (pid_t)strtol(filename, &remainder, 10);

if (errno != 0) {

return 0;

}

// check for left over characters. If any, then the filename is

// not a candidate for conversion.

//

if (remainder != NULL && *remainder != '\0') {

return 0;

}

// successful conversion, return the pid

return pid;

}

static bool is_directory_secure(const char* path) {

struct stat statbuf;

int result = 0;

RESTARTABLE(::lstat(path, &statbuf), result);

if (result == OS_ERR) {

return false;

}

// the path exists, now check it's mode

if (S_ISLNK(statbuf.st_mode) || !S_ISDIR(statbuf.st_mode)) {

// the path represents a link or some non-directory file type,

// which is not what we expected. declare it insecure.

//

return false;

}

else {

// we have an existing directory, check if the permissions are safe.

//

if ((statbuf.st_mode & (S_IWGRP|S_IWOTH)) != 0) {

// the directory is open for writing and could be subjected

// to a symlnk attack. declare it insecure.

//

return false;

}

}

return true;

}

static char* get_user_name(uid_t uid) {

struct passwd pwent;

// determine the max pwbuf size from sysconf, and hardcode

// a default if this not available through sysconf.

//

long bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);

if (bufsize == -1)

bufsize = 1024;

char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);

// POSIX interface to getpwuid_r is used on LINUX

struct passwd* p;

int result = getpwuid_r(uid, &pwent, pwbuf, (size_t)bufsize, &p);

if (result != 0 || p == NULL || p->pw_name == NULL || *(p->pw_name) == '\0') {

if (PrintMiscellaneous && Verbose) {

if (result != 0) {

warning("Could not retrieve passwd entry: %s\n",

strerror(result));

}

else if (p == NULL) {

// this check is added to protect against an observed problem

// with getpwuid_r() on RedHat 9 where getpwuid_r returns 0,

// indicating success, but has p == NULL. This was observed when

// inserting a file descriptor exhaustion fault prior to the call

// getpwuid_r() call. In this case, error is set to the appropriate

// error condition, but this is undocumented behavior. This check

// is safe under any condition, but the use of errno in the output

// message may result in an erroneous message.

// Bug Id 89052 was opened with RedHat.

//

warning("Could not retrieve passwd entry: %s\n",

strerror(errno));

}

else {

warning("Could not determine user name: %s\n",

p->pw_name == NULL ? "pw_name = NULL" :

"pw_name zero length");

}

}

FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal);

return NULL;

}

char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1, mtInternal);

strcpy(user_name, p->pw_name);

FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal);

return user_name;

}

static char* get_user_name_slow(int vmid, TRAPS) {

// short circuit the directory search if the process doesn't even exist.

if (kill(vmid, 0) == OS_ERR) {

if (errno == ESRCH) {

THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

"Process not found");

}

else /* EPERM */ {

THROW_MSG_0(vmSymbols::java_io_IOException(), strerror(errno));

}

}

// directory search

char* oldest_user = NULL;

time_t oldest_ctime = 0;

const char* tmpdirname = os::get_temp_directory();

DIR* tmpdirp = os::opendir(tmpdirname);

if (tmpdirp == NULL) {

return NULL;

}

// for each entry in the directory that matches the pattern hsperfdata_*,

// open the directory and check if the file for the given vmid exists.

// The file with the expected name and the latest creation date is used

// to determine the user name for the process id.

//

struct dirent* dentry;

char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname), mtInternal);

errno = 0;

while ((dentry = os::readdir(tmpdirp, (struct dirent *)tdbuf)) != NULL) {

// check if the directory entry is a hsperfdata file

if (strncmp(dentry->d_name, PERFDATA_NAME, strlen(PERFDATA_NAME)) != 0) {

continue;

}

char* usrdir_name = NEW_C_HEAP_ARRAY(char,

strlen(tmpdirname) + strlen(dentry->d_name) + 2, mtInternal);

strcpy(usrdir_name, tmpdirname);

strcat(usrdir_name, "/");

strcat(usrdir_name, dentry->d_name);

DIR* subdirp = os::opendir(usrdir_name);

if (subdirp == NULL) {

FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal);

continue;

}

// Since we don't create the backing store files in directories

// pointed to by symbolic links, we also don't follow them when

// looking for the files. We check for a symbolic link after the

// call to opendir in order to eliminate a small window where the

// symlink can be exploited.

//

if (!is_directory_secure(usrdir_name)) {

FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal);

os::closedir(subdirp);

continue;

}

struct dirent* udentry;

char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name), mtInternal);

errno = 0;

while ((udentry = os::readdir(subdirp, (struct dirent *)udbuf)) != NULL) {

if (filename_to_pid(udentry->d_name) == vmid) {

struct stat statbuf;

int result;

char* filename = NEW_C_HEAP_ARRAY(char,

strlen(usrdir_name) + strlen(udentry->d_name) + 2, mtInternal);

strcpy(filename, usrdir_name);

strcat(filename, "/");

strcat(filename, udentry->d_name);

// don't follow symbolic links for the file

RESTARTABLE(::lstat(filename, &statbuf), result);

if (result == OS_ERR) {

FREE_C_HEAP_ARRAY(char, filename, mtInternal);

continue;

}

// skip over files that are not regular files.

if (!S_ISREG(statbuf.st_mode)) {

FREE_C_HEAP_ARRAY(char, filename, mtInternal);

continue;

}

// compare and save filename with latest creation time

if (statbuf.st_size > 0 && statbuf.st_ctime > oldest_ctime) {

if (statbuf.st_ctime > oldest_ctime) {

char* user = strchr(dentry->d_name, '_') + 1;

if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user, mtInternal);

oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal);

strcpy(oldest_user, user);

oldest_ctime = statbuf.st_ctime;

}

}

FREE_C_HEAP_ARRAY(char, filename, mtInternal);

}

}

os::closedir(subdirp);

FREE_C_HEAP_ARRAY(char, udbuf, mtInternal);

FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal);

}

os::closedir(tmpdirp);

FREE_C_HEAP_ARRAY(char, tdbuf, mtInternal);

return(oldest_user);

}

static char* get_user_name(int vmid, TRAPS) {

return get_user_name_slow(vmid, CHECK_NULL);

}

static char* get_sharedmem_filename(const char* dirname, int vmid) {

// add 2 for the file separator and a null terminator.

size_t nbytes = strlen(dirname) + UINT_CHARS + 2;

char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal);

snprintf(name, nbytes, "%s/%d", dirname, vmid);

return name;

}

static void remove_file(const char* path) {

int result;

// if the file is a directory, the following unlink will fail. since

// we don't expect to find directories in the user temp directory, we

// won't try to handle this situation. even if accidentially or

// maliciously planted, the directory's presence won't hurt anything.

//

RESTARTABLE(::unlink(path), result);

if (PrintMiscellaneous && Verbose && result == OS_ERR) {

if (errno != ENOENT) {

warning("Could not unlink shared memory backing"

" store file %s : %s\n", path, strerror(errno));

}

}

}

static void remove_file(const char* dirname, const char* filename) {

size_t nbytes = strlen(dirname) + strlen(filename) + 2;

char* path = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal);

strcpy(path, dirname);

strcat(path, "/");

strcat(path, filename);

remove_file(path);

FREE_C_HEAP_ARRAY(char, path, mtInternal);

}

static void cleanup_sharedmem_resources(const char* dirname) {

// open the user temp directory

DIR* dirp = os::opendir(dirname);

if (dirp == NULL) {

// directory doesn't exist, so there is nothing to cleanup

return;

}

if (!is_directory_secure(dirname)) {

// the directory is not a secure directory

return;

}

// for each entry in the directory that matches the expected file

// name pattern, determine if the file resources are stale and if

// so, remove the file resources. Note, instrumented HotSpot processes

// for this user may start and/or terminate during this search and

// remove or create new files in this directory. The behavior of this

// loop under these conditions is dependent upon the implementation of

// opendir/readdir.

//

struct dirent* entry;

char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname), mtInternal);

errno = 0;

while ((entry = os::readdir(dirp, (struct dirent *)dbuf)) != NULL) {

pid_t pid = filename_to_pid(entry->d_name);

if (pid == 0) {

if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {

// attempt to remove all unexpected files, except "." and ".."

remove_file(dirname, entry->d_name);

}

errno = 0;

continue;

}

// we now have a file name that converts to a valid integer

// that could represent a process id . if this process id

// matches the current process id or the process is not running,

// then remove the stale file resources.

//

// process liveness is detected by sending signal number 0 to

// the process id (see kill(2)). if kill determines that the

// process does not exist, then the file resources are removed.

// if kill determines that that we don't have permission to

// signal the process, then the file resources are assumed to

// be stale and are removed because the resources for such a

// process should be in a different user specific directory.

//

if ((pid == os::current_process_id()) ||

(kill(pid, 0) == OS_ERR && (errno == ESRCH || errno == EPERM))) {

remove_file(dirname, entry->d_name);

}

errno = 0;

}

os::closedir(dirp);

FREE_C_HEAP_ARRAY(char, dbuf, mtInternal);

}

static bool make_user_tmp_dir(const char* dirname) {

// create the directory with 0755 permissions. note that the directory

// will be owned by euid::egid, which may not be the same as uid::gid.

//

if (mkdir(dirname, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) == OS_ERR) {

if (errno == EEXIST) {

// The directory already exists and was probably created by another

// JVM instance. However, this could also be the result of a

// deliberate symlink. Verify that the existing directory is safe.

//

if (!is_directory_secure(dirname)) {

// directory is not secure

if (PrintMiscellaneous && Verbose) {

warning("%s directory is insecure\n", dirname);

}

return false;

}

}

else {

// we encountered some other failure while attempting

// to create the directory

//

if (PrintMiscellaneous && Verbose) {

warning("could not create directory %s: %s\n",

dirname, strerror(errno));

}

return false;

}

}

return true;

}

static int create_sharedmem_resources(const char* dirname, const char* filename, size_t size) {

// make the user temporary directory

if (!make_user_tmp_dir(dirname)) {

// could not make/find the directory or the found directory

// was not secure

return -1;

}

int result;

RESTARTABLE(::open(filename, O_RDWR|O_CREAT|O_TRUNC, S_IREAD|S_IWRITE), result);

if (result == OS_ERR) {

if (PrintMiscellaneous && Verbose) {

warning("could not create file %s: %s\n", filename, strerror(errno));

}

return -1;

}

// save the file descriptor

int fd = result;

// set the file size

RESTARTABLE(::ftruncate(fd, (off_t)size), result);

if (result == OS_ERR) {

if (PrintMiscellaneous && Verbose) {

warning("could not set shared memory file size: %s\n", strerror(errno));

}

RESTARTABLE(::close(fd), result);

return -1;

}

// Verify that we have enough disk space for this file.

// We'll get random SIGBUS crashes on memory accesses if

// we don't.

for (size_t seekpos = 0; seekpos < size; seekpos += os::vm_page_size()) {

int zero_int = 0;

result = (int)os::seek_to_file_offset(fd, (jlong)(seekpos));

if (result == -1 ) break;

RESTARTABLE(::write(fd, &zero_int, 1), result);

if (result != 1) {

if (errno == ENOSPC) {

warning("Insufficient space for shared memory file:\n %s\nTry using the -Djava.io.tmpdir= option to select an alternate temp location.\n", filename);

}

break;

}

}

if (result != -1) {

return fd;

} else {

RESTARTABLE(::close(fd), result);

return -1;

}

}

static int open_sharedmem_file(const char* filename, int oflags, TRAPS) {

// open the file

int result;

RESTARTABLE(::open(filename, oflags), result);

if (result == OS_ERR) {

if (errno == ENOENT) {

THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

"Process not found");

}

else if (errno == EACCES) {

THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),

"Permission denied");

}

else {

THROW_MSG_0(vmSymbols::java_io_IOException(), strerror(errno));

}

}

return result;

}

static char* mmap_create_shared(size_t size) {

int result;

int fd;

char* mapAddress;

int vmid = os::current_process_id();

char* user_name = get_user_name(geteuid());

if (user_name == NULL)

return NULL;

char* dirname = get_user_tmp_dir(user_name);

char* filename = get_sharedmem_filename(dirname, vmid);

// cleanup any stale shared memory files

cleanup_sharedmem_resources(dirname);

assert(((size > 0) && (size % os::vm_page_size() == 0)),

"unexpected PerfMemory region size");

fd = create_sharedmem_resources(dirname, filename, size);

FREE_C_HEAP_ARRAY(char, user_name, mtInternal);

FREE_C_HEAP_ARRAY(char, dirname, mtInternal);

if (fd == -1) {

FREE_C_HEAP_ARRAY(char, filename, mtInternal);

return NULL;

}

mapAddress = (char*)::mmap((char*)0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

// attempt to close the file - restart it if it was interrupted,

// but ignore other failures

RESTARTABLE(::close(fd), result);

assert(result != OS_ERR, "could not close file");

if (mapAddress == MAP_FAILED) {

if (PrintMiscellaneous && Verbose) {

warning("mmap failed - %s\n", strerror(errno));

}

remove_file(filename);

FREE_C_HEAP_ARRAY(char, filename, mtInternal);

return NULL;

}

// save the file name for use in delete_shared_memory()

backing_store_file_name = filename;

// clear the shared memory region

(void)::memset((void*) mapAddress, 0, size);

// it does not go through os api, the operation has to record from here

MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);

return mapAddress;

}

static void unmap_shared(char* addr, size_t bytes) {

os::release_memory(addr, bytes);

}

static char* create_shared_memory(size_t size) {

// create the shared memory region.

return mmap_create_shared(size);

}

static void delete_shared_memory(char* addr, size_t size) {

// cleanup the persistent shared memory resources. since DestroyJavaVM does

// not support unloading of the JVM, unmapping of the memory resource is

// not performed. The memory will be reclaimed by the OS upon termination of

// the process. The backing store file is deleted from the file system.

assert(!PerfDisableSharedMem, "shouldn't be here");

if (backing_store_file_name != NULL) {

remove_file(backing_store_file_name);

// Don't.. Free heap memory could deadlock os::abort() if it is called

// from signal handler. OS will reclaim the heap memory.

// FREE_C_HEAP_ARRAY(char, backing_store_file_name);

backing_store_file_name = NULL;

}

}

static size_t sharedmem_filesize(int fd, TRAPS) {

struct stat statbuf;

int result;

RESTARTABLE(::fstat(fd, &statbuf), result);

if (result == OS_ERR) {

if (PrintMiscellaneous && Verbose) {

warning("fstat failed: %s\n", strerror(errno));

}

THROW_MSG_0(vmSymbols::java_io_IOException(),

"Could not determine PerfMemory size");

}

if ((statbuf.st_size == 0) ||

((size_t)statbuf.st_size % os::vm_page_size() != 0)) {

THROW_MSG_0(vmSymbols::java_lang_Exception(),

"Invalid PerfMemory size");

}

return (size_t)statbuf.st_size;

}

static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemoryMode mode, char** addr, size_t* sizep, TRAPS) {

char* mapAddress;

int result;

int fd;

size_t size;

const char* luser = NULL;

int mmap_prot;

int file_flags;

ResourceMark rm;

// map the high level access mode to the appropriate permission

// constructs for the file and the shared memory mapping.

if (mode == PerfMemory::PERF_MODE_RO) {

mmap_prot = PROT_READ;

file_flags = O_RDONLY;

}

else if (mode == PerfMemory::PERF_MODE_RW) {

#ifdef LATER

mmap_prot = PROT_READ | PROT_WRITE;

file_flags = O_RDWR;

#else

THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),

"Unsupported access mode");

#endif

}

else {

THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),

"Illegal access mode");

}

if (user == NULL || strlen(user) == 0) {

luser = get_user_name(vmid, CHECK);

}

else {

luser = user;

}

if (luser == NULL) {

THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),

"Could not map vmid to user Name");

}

char* dirname = get_user_tmp_dir(luser);

// since we don't follow symbolic links when creating the backing

// store file, we don't follow them when attaching either.

//

if (!is_directory_secure(dirname)) {

FREE_C_HEAP_ARRAY(char, dirname, mtInternal);

THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),

"Process not found");

}

char* filename = get_sharedmem_filename(dirname, vmid);

// copy heap memory to resource memory. the open_sharedmem_file

// method below need to use the filename, but could throw an

// exception. using a resource array prevents the leak that

// would otherwise occur.

char* rfilename = NEW_RESOURCE_ARRAY(char, strlen(filename) + 1);

strcpy(rfilename, filename);

// free the c heap resources that are no longer needed

if (luser != user) FREE_C_HEAP_ARRAY(char, luser, mtInternal);

FREE_C_HEAP_ARRAY(char, dirname, mtInternal);

FREE_C_HEAP_ARRAY(char, filename, mtInternal);

// open the shared memory file for the give vmid

fd = open_sharedmem_file(rfilename, file_flags, CHECK);

assert(fd != OS_ERR, "unexpected value");

if (*sizep == 0) {

size = sharedmem_filesize(fd, CHECK);

assert(size != 0, "unexpected size");

}

mapAddress = (char*)::mmap((char*)0, size, mmap_prot, MAP_SHARED, fd, 0);

// attempt to close the file - restart if it gets interrupted,

// but ignore other failures

RESTARTABLE(::close(fd), result);

assert(result != OS_ERR, "could not close file");

if (mapAddress == MAP_FAILED) {

if (PrintMiscellaneous && Verbose) {

warning("mmap failed: %s\n", strerror(errno));

}

THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),

"Could not map PerfMemory");

}

// it does not go through os api, the operation has to record from here

MemTracker::record_virtual_memory_reserve((address)mapAddress, size, mtInternal, CURRENT_PC);

*addr = mapAddress;

*sizep = size;

if (PerfTraceMemOps) {

tty->print("mapped " SIZE_FORMAT " bytes for vmid %d at "

INTPTR_FORMAT "\n", size, vmid, (void*)mapAddress);

}

}

void PerfMemory::create_memory_region(size_t size) {

if (PerfDisableSharedMem) {

// do not share the memory for the performance data.

_start = create_standard_memory(size);

}

else {

_start = create_shared_memory(size);

if (_start == NULL) {

// creation of the shared memory region failed, attempt

// to create a contiguous, non-shared memory region instead.

//

if (PrintMiscellaneous && Verbose) {

warning("Reverting to non-shared PerfMemory region.\n");

}

PerfDisableSharedMem = true;

_start = create_standard_memory(size);

}

}

if (_start != NULL) _capacity = size;

}

void PerfMemory::delete_memory_region() {

assert((start() != NULL && capacity() > 0), "verify proper state");

// If user specifies PerfDataSaveFile, it will save the performance data

// to the specified file name no matter whether PerfDataSaveToFile is specified

// or not. In other word, -XX:PerfDataSaveFile=.. overrides flag

// -XX:+PerfDataSaveToFile.

if (PerfDataSaveToFile || PerfDataSaveFile != NULL) {

save_memory_to_file(start(), capacity());

}

if (PerfDisableSharedMem) {

delete_standard_memory(start(), capacity());

}

else {

delete_shared_memory(start(), capacity());

}

}

void PerfMemory::attach(const char* user, int vmid, PerfMemoryMode mode, char** addrp, size_t* sizep, TRAPS) {

if (vmid == 0 || vmid == os::current_process_id()) {

*addrp = start();

*sizep = capacity();

return;

}

mmap_attach_shared(user, vmid, mode, addrp, sizep, CHECK);

}

void PerfMemory::detach(char* addr, size_t bytes, TRAPS) {

assert(addr != 0, "address sanity check");

assert(bytes > 0, "capacity sanity check");

if (PerfMemory::contains(addr) || PerfMemory::contains(addr + bytes - 1)) {

// prevent accidental detachment of this process's PerfMemory region

return;

}

unmap_shared(addr, bytes);

}

char* PerfMemory::backing_store_filename() {

return backing_store_file_name;

}