jdk-sandbox: comparison hotspot/src/os/windows/vm/perfMemory

equal deleted inserted replaced

-:64752e56d721
+:be27e1b6a4b9
 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
 // Note: the win32 shared memory implementation uses two objects to represent
 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;
 else {
 return NULL;
 }
 }
-char* user_name = NEW_C_HEAP_ARRAY(char, strlen(user)+1);
+char* user_name = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal);
 strcpy(user_name, user);
 return user_name;
 }
 // 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;
 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);
 if (::stat(filename, &statbuf) == 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 ((statbuf.st_mode & S_IFMT) != S_IFREG) {
-FREE_C_HEAP_ARRAY(char, filename);
+FREE_C_HEAP_ARRAY(char, filename, mtInternal);
 continue;
 }
 // If we found a matching file with a newer creation time, then
 // save the user name. The newer creation time indicates that
 // later becomes the expected value.
 //
 if (statbuf.st_ctime > latest_ctime) {
 char* user = strchr(dentry->d_name, '_') + 1;
-if (latest_user != NULL) FREE_C_HEAP_ARRAY(char, latest_user);
+if (latest_user != NULL) FREE_C_HEAP_ARRAY(char, latest_user, mtInternal);
-latest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1);
+latest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1, mtInternal);
 strcpy(latest_user, user);
 latest_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(latest_user);
 }
 // return the name of the user that owns the process identified by vmid.
 // the id is converted to an unsigned value here because win32 allows
 // negative process ids. However, OpenFileMapping API complains
 // about a name containing a '-' characters.
 //
 nbytes += UINT_CHARS;
-char* name = NEW_C_HEAP_ARRAY(char, nbytes);
+char* name = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal);
 _snprintf(name, nbytes, "%s_%s_%u", PERFDATA_NAME, user, vmid);
 return name;
 }
 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;
 }
 // method may be unsuccessful in removing the file.
 //
 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);
 " store file %s : %s\n", path, strerror(errno));
 }
 }
 }
-FREE_C_HEAP_ARRAY(char, path);
+FREE_C_HEAP_ARRAY(char, path, mtInternal);
 }
 // returns true if the process represented by pid is alive, otherwise
 // returns false. the validity of the result is only accurate if the
 // target process is owned by the same principal that owns this process.
 // 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) {
 int 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);
 }
 // create a file mapping object with the requested name, and size
 // from the file represented by the given Handle object
 //
 // if an ACL existed and it was not a default acl, then it must
 // be an ACL we enlisted. free the resources.
 //
 if (success && exists && pACL != NULL && !isdefault) {
-FREE_C_HEAP_ARRAY(char, pACL);
+FREE_C_HEAP_ARRAY(char, pACL, mtInternal);
 }
 // free the security descriptor
-FREE_C_HEAP_ARRAY(char, pSD);
+FREE_C_HEAP_ARRAY(char, pSD, mtInternal);
 }
 }
 // method to free up a security attributes structure and any
 // contained security descriptors and ACL
 // free the contained security descriptor and the ACL
 free_security_desc(lpSA->lpSecurityDescriptor);
 lpSA->lpSecurityDescriptor = NULL;
 // free the security attributes structure
-FREE_C_HEAP_ARRAY(char, lpSA);
+FREE_C_HEAP_ARRAY(char, lpSA, mtInternal);
 }
 }
 // get the user SID for the process indicated by the process handle
 //
 CloseHandle(hAccessToken);
 return NULL;
 }
 }
-token_buf = (PTOKEN_USER) NEW_C_HEAP_ARRAY(char, rsize);
+token_buf = (PTOKEN_USER) NEW_C_HEAP_ARRAY(char, rsize, mtInternal);
 // get the user token information
 if (!GetTokenInformation(hAccessToken, TokenUser, token_buf, rsize, &rsize)) {
 if (PrintMiscellaneous && Verbose) {
 warning("GetTokenInformation failure: lasterror = %d,"
 " rsize = %d\n", GetLastError(), rsize);
 }
-FREE_C_HEAP_ARRAY(char, token_buf);
+FREE_C_HEAP_ARRAY(char, token_buf, mtInternal);
 CloseHandle(hAccessToken);
 return NULL;
 }
 DWORD nbytes = GetLengthSid(token_buf->User.Sid);
-PSID pSID = NEW_C_HEAP_ARRAY(char, nbytes);
+PSID pSID = NEW_C_HEAP_ARRAY(char, nbytes, mtInternal);
 if (!CopySid(nbytes, pSID, token_buf->User.Sid)) {
 if (PrintMiscellaneous && Verbose) {
 warning("GetTokenInformation failure: lasterror = %d,"
 " rsize = %d\n", GetLastError(), rsize);
 }
-FREE_C_HEAP_ARRAY(char, token_buf);
+FREE_C_HEAP_ARRAY(char, token_buf, mtInternal);
-FREE_C_HEAP_ARRAY(char, pSID);
+FREE_C_HEAP_ARRAY(char, pSID, mtInternal);
 CloseHandle(hAccessToken);
 return NULL;
 }
 // close the access token.
 CloseHandle(hAccessToken);
-FREE_C_HEAP_ARRAY(char, token_buf);
+FREE_C_HEAP_ARRAY(char, token_buf, mtInternal);
 return pSID;
 }
 // structure used to consolidate access control entry information
 assert(aces[i].pSid != 0, "pSid should not be 0");
 newACLsize += GetLengthSid(aces[i].pSid);
 }
 // create the new ACL
-newACL = (PACL) NEW_C_HEAP_ARRAY(char, newACLsize);
+newACL = (PACL) NEW_C_HEAP_ARRAY(char, newACLsize, mtInternal);
 if (!InitializeAcl(newACL, newACLsize, ACL_REVISION)) {
 if (PrintMiscellaneous && Verbose) {
 warning("InitializeAcl failure: lasterror = %d \n", GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 unsigned int ace_index = 0;
 // copy any existing ACEs from the old ACL (if any) to the new ACL.
 LPVOID ace;
 if (!GetAce(oldACL, ace_index, &ace)) {
 if (PrintMiscellaneous && Verbose) {
 warning("InitializeAcl failure: lasterror = %d \n", GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 if (((ACCESS_ALLOWED_ACE *)ace)->Header.AceFlags && INHERITED_ACE) {
 // this is an inherited, allowed ACE; break from loop so we can
 // add the new access allowed, non-inherited ACE in the correct
 if (!AddAce(newACL, ACL_REVISION, MAXDWORD, ace,
 ((PACE_HEADER)ace)->AceSize)) {
 if (PrintMiscellaneous && Verbose) {
 warning("AddAce failure: lasterror = %d \n", GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 }
 ace_index++;
 }
 aces[i].mask, aces[i].pSid)) {
 if (PrintMiscellaneous && Verbose) {
 warning("AddAccessAllowedAce failure: lasterror = %d \n",
 GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 }
 // now copy the rest of the inherited ACEs from the old ACL
 LPVOID ace;
 if (!GetAce(oldACL, ace_index, &ace)) {
 if (PrintMiscellaneous && Verbose) {
 warning("InitializeAcl failure: lasterror = %d \n", GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 if (!AddAce(newACL, ACL_REVISION, MAXDWORD, ace,
 ((PACE_HEADER)ace)->AceSize)) {
 if (PrintMiscellaneous && Verbose) {
 warning("AddAce failure: lasterror = %d \n", GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 ace_index++;
 }
 }
 if (!SetSecurityDescriptorDacl(pSD, TRUE, newACL, FALSE)) {
 if (PrintMiscellaneous && Verbose) {
 warning("SetSecurityDescriptorDacl failure:"
 " lasterror = %d \n", GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 // if running on windows 2000 or later, set the automatic inheritance
 // control flags.
 SE_DACL_PROTECTED)) {
 if (PrintMiscellaneous && Verbose) {
 warning("SetSecurityDescriptorControl failure:"
 " lasterror = %d \n", GetLastError());
 }
-FREE_C_HEAP_ARRAY(char, newACL);
+FREE_C_HEAP_ARRAY(char, newACL, mtInternal);
 return false;
 }
 }
 // Note, the security descriptor maintains a reference to the newACL, not
 // a copy of it. Therefore, the newACL is not freed here. It is freed when
 //
 static LPSECURITY_ATTRIBUTES make_security_attr(ace_data_t aces[], int count) {
 // allocate space for a security descriptor
 PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR)
-NEW_C_HEAP_ARRAY(char, SECURITY_DESCRIPTOR_MIN_LENGTH);
+NEW_C_HEAP_ARRAY(char, SECURITY_DESCRIPTOR_MIN_LENGTH, mtInternal);
 // initialize the security descriptor
 if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION)) {
 if (PrintMiscellaneous && Verbose) {
 warning("InitializeSecurityDescriptor failure: "
 // allocate and initialize the security attributes structure and
 // return it to the caller.
 //
 LPSECURITY_ATTRIBUTES lpSA = (LPSECURITY_ATTRIBUTES)
-NEW_C_HEAP_ARRAY(char, sizeof(SECURITY_ATTRIBUTES));
+NEW_C_HEAP_ARRAY(char, sizeof(SECURITY_ATTRIBUTES), mtInternal);
 lpSA->nLength = sizeof(SECURITY_ATTRIBUTES);
 lpSA->lpSecurityDescriptor = pSD;
 lpSA->bInheritHandle = FALSE;
 return(lpSA);
 aces[2].mask = emask;
 // create a security attributes structure with access control
 // entries as initialized above.
 LPSECURITY_ATTRIBUTES lpSA = make_security_attr(aces, 3);
-FREE_C_HEAP_ARRAY(char, aces[0].pSid);
+FREE_C_HEAP_ARRAY(char, aces[0].pSid, mtInternal);
 FreeSid(everybodySid);
 FreeSid(administratorsSid);
 return(lpSA);
 }
 cleanup_sharedmem_resources(dirname);
 assert(((size != 0) && (size % os::vm_page_size() == 0)),
 "unexpected PerfMemry region size");
-FREE_C_HEAP_ARRAY(char, user);
+FREE_C_HEAP_ARRAY(char, user, mtInternal);
 // create the shared memory resources
 sharedmem_fileMapHandle =
 create_sharedmem_resources(dirname, filename, objectname, size);
-FREE_C_HEAP_ARRAY(char, filename);
+FREE_C_HEAP_ARRAY(char, filename, mtInternal);
-FREE_C_HEAP_ARRAY(char, objectname);
+FREE_C_HEAP_ARRAY(char, objectname, mtInternal);
-FREE_C_HEAP_ARRAY(char, dirname);
+FREE_C_HEAP_ARRAY(char, dirname, mtInternal);
 if (sharedmem_fileMapHandle == NULL) {
 return NULL;
 }
 // since we don't follow symbolic links when creating the backing
 // store file, we also don't following them when attaching
 //
 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);
 char* robjectname = NEW_RESOURCE_ARRAY(char, strlen(objectname) + 1);
 strcpy(rfilename, filename);
 strcpy(robjectname, objectname);
 // 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);
-FREE_C_HEAP_ARRAY(char, objectname);
+FREE_C_HEAP_ARRAY(char, objectname, mtInternal);
 if (*sizep == 0) {
 size = sharedmem_filesize(rfilename, CHECK);
 assert(size != 0, "unexpected size");
 }

changeset 13195	be27e1b6a4b9
parent 8306	e8b13a27a0e2
child 13963	e5b53c306fb5