truffle: src/os/bsd/vm/perfMemory

comparison src/os/bsd/vm/perfMemory_bsd.cpp @ 6197:d2a62e0f25eb

6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain

author	zgu
date	Thu, 28 Jun 2012 17:03:16 -0400
parents	f08d439fab8c
children	b9a9ed0f8eeb

comparison

equal deleted inserted replaced

-:74533f63b116
+:d2a62e0f25eb
 if (result == OS_ERR) {
 warning("Could not close %s: %s\n", destfile, strerror(errno));
 }
 }
 }
-FREE_C_HEAP_ARRAY(char, destfile);
+FREE_C_HEAP_ARRAY(char, destfile, mtInternal);
 }
 // Shared Memory Implementation Details
 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);
+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;
 //
 long bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
 if (bufsize == -1)
 bufsize = 1024;
-char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize);
+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);
 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);
+FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal);
 return NULL;
 }
-char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1);
+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);
+FREE_C_HEAP_ARRAY(char, pwbuf, mtInternal);
 return user_name;
 }
 // return the name of the user that owns the process identified by vmid.
 //
 // 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));
+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);
+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);
+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);
+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));
+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);
+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);
+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);
+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);
+if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user, mtInternal);
-oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1);
+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);
+FREE_C_HEAP_ARRAY(char, filename, mtInternal);
 }
 }
 os::closedir(subdirp);
-FREE_C_HEAP_ARRAY(char, udbuf);
+FREE_C_HEAP_ARRAY(char, udbuf, mtInternal);
-FREE_C_HEAP_ARRAY(char, usrdir_name);
+FREE_C_HEAP_ARRAY(char, usrdir_name, mtInternal);
 }
 os::closedir(tmpdirp);
-FREE_C_HEAP_ARRAY(char, tdbuf);
+FREE_C_HEAP_ARRAY(char, tdbuf, mtInternal);
 return(oldest_user);
 }
 // return the name of the user that owns the JVM indicated by the given vmid.
 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);
+char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal);
 snprintf(name, nbytes, "%s/%d", dirname, vmid);
 return name;
 }
 // named directory.
 //
 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);
+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);
+FREE_C_HEAP_ARRAY(char, path, mtInternal);
 }
 // cleanup stale shared memory resources
 //
 // 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));
+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);
 remove_file(dirname, entry->d_name);
 }
 errno = 0;
 }
 os::closedir(dirp);
-FREE_C_HEAP_ARRAY(char, dbuf);
+FREE_C_HEAP_ARRAY(char, dbuf, mtInternal);
 }
 // make the user specific temporary directory. Returns true if
 // the directory exists and is secure upon return. Returns false
 // if the directory exists but is either a symlink, is otherwise
 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);
+FREE_C_HEAP_ARRAY(char, user_name, mtInternal);
-FREE_C_HEAP_ARRAY(char, dirname);
+FREE_C_HEAP_ARRAY(char, dirname, mtInternal);
 if (fd == -1) {
-FREE_C_HEAP_ARRAY(char, filename);
+FREE_C_HEAP_ARRAY(char, filename, mtInternal);
 return NULL;
 }
 mapAddress = (char*)::mmap((char*)0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
 if (mapAddress == MAP_FAILED) {
 if (PrintMiscellaneous && Verbose) {
 warning("mmap failed -  %s\n", strerror(errno));
 }
 remove_file(filename);
-FREE_C_HEAP_ARRAY(char, 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;
 // 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);
+FREE_C_HEAP_ARRAY(char, dirname, mtInternal);
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
 "Process not found");
 }
 char* filename = get_sharedmem_filename(dirname, vmid);
 // 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);
+if (luser != user) FREE_C_HEAP_ARRAY(char, luser, mtInternal);
-FREE_C_HEAP_ARRAY(char, dirname);
+FREE_C_HEAP_ARRAY(char, dirname, mtInternal);
-FREE_C_HEAP_ARRAY(char, filename);
+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");

Mercurial > hg > truffle

comparison src/os/bsd/vm/perfMemory_bsd.cpp @ 6197:d2a62e0f25eb