hotspot/src/os/linux/vm/perfMemory_linux.cpp
author coleenp
Wed, 31 Mar 2010 16:51:18 -0700
changeset 5237 aab592fd4f44
parent 2131 98f9cef66a34
child 5547 f4b087cbb361
permissions -rw-r--r--
6938627: Make temporary directory use property java.io.tmpdir when specified Summary: Get java.io.tmpdir property in os::get_temp_directory() and call this instead of harcoding "/tmp". Don't assume trailing file_separator either. Reviewed-by: dholmes, kamg
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 2001-2006 Sun Microsystems, Inc.  All Rights Reserved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
# include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
# include "incls/_perfMemory_linux.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// put OS-includes here
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
# include <sys/types.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
# include <sys/mman.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
# include <errno.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
# include <stdio.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
# include <unistd.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
# include <sys/stat.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
# include <signal.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
# include <pwd.h>
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
static char* backing_store_file_name = NULL;  // name of the backing store
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
                                              // file, if successfully created.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// Standard Memory Implementation Details
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
// create the PerfData memory region in standard memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
static char* create_standard_memory(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  // allocate an aligned chuck of memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  char* mapAddress = os::reserve_memory(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  if (mapAddress == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  // commit memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  if (!os::commit_memory(mapAddress, size)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
      warning("Could not commit PerfData memory\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
    os::release_memory(mapAddress, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
  return mapAddress;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
// delete the PerfData memory region
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
static void delete_standard_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  // there are no persistent external resources to cleanup for standard
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
  // memory. since DestroyJavaVM does not support unloading of the JVM,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  // cleanup of the memory resource is not performed. The memory will be
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
  // reclaimed by the OS upon termination of the process.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
// save the specified memory region to the given file
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
// Note: this function might be called from signal handler (by os::abort()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
// don't allocate heap memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
static void save_memory_to_file(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
 const char* destfile = PerfMemory::get_perfdata_file_path();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
 assert(destfile[0] != '\0', "invalid PerfData file path");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  RESTARTABLE(::open(destfile, O_CREAT|O_WRONLY|O_TRUNC, S_IREAD|S_IWRITE),
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
              result);;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
      warning("Could not create Perfdata save file: %s: %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
              destfile, strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    int fd = result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    for (size_t remaining = size; remaining > 0;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
      RESTARTABLE(::write(fd, addr, remaining), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
      if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
        if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
          warning("Could not write Perfdata save file: %s: %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
                  destfile, strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
        break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
      remaining -= (size_t)result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
      addr += result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    RESTARTABLE(::close(fd), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
      if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
        warning("Could not close %s: %s\n", destfile, strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  FREE_C_HEAP_ARRAY(char, destfile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
// Shared Memory Implementation Details
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
// Note: the solaris and linux shared memory implementation uses the mmap
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
// interface with a backing store file to implement named shared memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
// Using the file system as the name space for shared memory allows a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
// common name space to be supported across a variety of platforms. It
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
// also provides a name space that Java applications can deal with through
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
// simple file apis.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
// The solaris and linux implementations store the backing store file in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
// a user specific temporary directory located in the /tmp file system,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
// which is always a local file system and is sometimes a RAM based file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
// system.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
// return the user specific temporary directory name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
// the caller is expected to free the allocated memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
static char* get_user_tmp_dir(const char* user) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  const char* tmpdir = os::get_temp_directory();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  const char* perfdir = PERFDATA_NAME;
5237
aab592fd4f44 6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents: 2131
diff changeset
   148
  size_t nbytes = strlen(tmpdir) + strlen(perfdir) + strlen(user) + 3;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  char* dirname = NEW_C_HEAP_ARRAY(char, nbytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // construct the path name to user specific tmp directory
5237
aab592fd4f44 6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents: 2131
diff changeset
   152
  snprintf(dirname, nbytes, "%s/%s_%s", tmpdir, perfdir, user);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  return dirname;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
// convert the given file name into a process id. if the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
// does not meet the file naming constraints, return 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
static pid_t filename_to_pid(const char* filename) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // a filename that doesn't begin with a digit is not a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // candidate for conversion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  if (!isdigit(*filename)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
  // check if file name can be converted to an integer without
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
  // any leftover characters.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  char* remainder = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
  errno = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  pid_t pid = (pid_t)strtol(filename, &remainder, 10);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  if (errno != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // check for left over characters. If any, then the filename is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  // not a candidate for conversion.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
  if (remainder != NULL && *remainder != '\0') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
    return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  // successful conversion, return the pid
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  return pid;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
// check if the given path is considered a secure directory for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
// the backing store files. Returns true if the directory exists
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
// and is considered a secure location. Returns false if the path
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 1
diff changeset
   195
// is a symbolic link or if an error occurred.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
static bool is_directory_secure(const char* path) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  struct stat statbuf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  int result = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  RESTARTABLE(::lstat(path, &statbuf), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  // the path exists, now check it's mode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  if (S_ISLNK(statbuf.st_mode) || !S_ISDIR(statbuf.st_mode)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
    // the path represents a link or some non-directory file type,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    // which is not what we expected. declare it insecure.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    // we have an existing directory, check if the permissions are safe.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    if ((statbuf.st_mode & (S_IWGRP|S_IWOTH)) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
      // the directory is open for writing and could be subjected
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      // to a symlnk attack. declare it insecure.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
// return the user name for the given user id
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
// the caller is expected to free the allocated memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
static char* get_user_name(uid_t uid) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  struct passwd pwent;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  // determine the max pwbuf size from sysconf, and hardcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  // a default if this not available through sysconf.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  long bufsize = sysconf(_SC_GETPW_R_SIZE_MAX);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  if (bufsize == -1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
    bufsize = 1024;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  char* pwbuf = NEW_C_HEAP_ARRAY(char, bufsize);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  // POSIX interface to getpwuid_r is used on LINUX
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  struct passwd* p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  int result = getpwuid_r(uid, &pwent, pwbuf, (size_t)bufsize, &p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
  if (result != 0 || p == NULL || p->pw_name == NULL || *(p->pw_name) == '\0') {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
      if (result != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
        warning("Could not retrieve passwd entry: %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
                strerror(result));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
      else if (p == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
        // this check is added to protect against an observed problem
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
        // with getpwuid_r() on RedHat 9 where getpwuid_r returns 0,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
        // indicating success, but has p == NULL. This was observed when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
        // inserting a file descriptor exhaustion fault prior to the call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
        // getpwuid_r() call. In this case, error is set to the appropriate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
        // error condition, but this is undocumented behavior. This check
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
        // is safe under any condition, but the use of errno in the output
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
        // message may result in an erroneous message.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
        // Bug Id 89052 was opened with RedHat.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
        //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
        warning("Could not retrieve passwd entry: %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
                strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
      else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
        warning("Could not determine user name: %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
                p->pw_name == NULL ? "pw_name = NULL" :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
                                     "pw_name zero length");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
    FREE_C_HEAP_ARRAY(char, pwbuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  char* user_name = NEW_C_HEAP_ARRAY(char, strlen(p->pw_name) + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  strcpy(user_name, p->pw_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  FREE_C_HEAP_ARRAY(char, pwbuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  return user_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
// return the name of the user that owns the process identified by vmid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
// This method uses a slow directory search algorithm to find the backing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
// store file for the specified vmid and returns the user name, as determined
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
// by the user name suffix of the hsperfdata_<username> directory name.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
// the caller is expected to free the allocated memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
static char* get_user_name_slow(int vmid, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  // short circuit the directory search if the process doesn't even exist.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
  if (kill(vmid, 0) == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
    if (errno == ESRCH) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
      THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
                  "Process not found");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    else /* EPERM */ {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
      THROW_MSG_0(vmSymbols::java_io_IOException(), strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  // directory search
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
  char* oldest_user = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  time_t oldest_ctime = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  const char* tmpdirname = os::get_temp_directory();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  DIR* tmpdirp = os::opendir(tmpdirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  if (tmpdirp == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  // for each entry in the directory that matches the pattern hsperfdata_*,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  // open the directory and check if the file for the given vmid exists.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  // The file with the expected name and the latest creation date is used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
  // to determine the user name for the process id.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  struct dirent* dentry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
  char* tdbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(tmpdirname));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  errno = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  while ((dentry = os::readdir(tmpdirp, (struct dirent *)tdbuf)) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    // check if the directory entry is a hsperfdata file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
    if (strncmp(dentry->d_name, PERFDATA_NAME, strlen(PERFDATA_NAME)) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
    char* usrdir_name = NEW_C_HEAP_ARRAY(char,
5237
aab592fd4f44 6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents: 2131
diff changeset
   334
                              strlen(tmpdirname) + strlen(dentry->d_name) + 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    strcpy(usrdir_name, tmpdirname);
5237
aab592fd4f44 6938627: Make temporary directory use property java.io.tmpdir when specified
coleenp
parents: 2131
diff changeset
   336
    strcat(usrdir_name, "/");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    strcat(usrdir_name, dentry->d_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
    DIR* subdirp = os::opendir(usrdir_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    if (subdirp == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
      FREE_C_HEAP_ARRAY(char, usrdir_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
    // Since we don't create the backing store files in directories
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
    // pointed to by symbolic links, we also don't follow them when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    // looking for the files. We check for a symbolic link after the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    // call to opendir in order to eliminate a small window where the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    // symlink can be exploited.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
    if (!is_directory_secure(usrdir_name)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
      FREE_C_HEAP_ARRAY(char, usrdir_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
      os::closedir(subdirp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    struct dirent* udentry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    char* udbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(usrdir_name));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
    errno = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    while ((udentry = os::readdir(subdirp, (struct dirent *)udbuf)) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
      if (filename_to_pid(udentry->d_name) == vmid) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
        struct stat statbuf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
        int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
        char* filename = NEW_C_HEAP_ARRAY(char,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
                            strlen(usrdir_name) + strlen(udentry->d_name) + 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
        strcpy(filename, usrdir_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
        strcat(filename, "/");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
        strcat(filename, udentry->d_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
        // don't follow symbolic links for the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
        RESTARTABLE(::lstat(filename, &statbuf), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
        if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
           FREE_C_HEAP_ARRAY(char, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
           continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
        // skip over files that are not regular files.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
        if (!S_ISREG(statbuf.st_mode)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
          FREE_C_HEAP_ARRAY(char, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
        // compare and save filename with latest creation time
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
        if (statbuf.st_size > 0 && statbuf.st_ctime > oldest_ctime) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
          if (statbuf.st_ctime > oldest_ctime) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
            char* user = strchr(dentry->d_name, '_') + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
            if (oldest_user != NULL) FREE_C_HEAP_ARRAY(char, oldest_user);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
            oldest_user = NEW_C_HEAP_ARRAY(char, strlen(user)+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
            strcpy(oldest_user, user);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
            oldest_ctime = statbuf.st_ctime;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
        FREE_C_HEAP_ARRAY(char, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
    os::closedir(subdirp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
    FREE_C_HEAP_ARRAY(char, udbuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
    FREE_C_HEAP_ARRAY(char, usrdir_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  os::closedir(tmpdirp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
  FREE_C_HEAP_ARRAY(char, tdbuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  return(oldest_user);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
// return the name of the user that owns the JVM indicated by the given vmid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
static char* get_user_name(int vmid, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  return get_user_name_slow(vmid, CHECK_NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
// return the file name of the backing store file for the named
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
// shared memory region for the given user name and vmid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
// the caller is expected to free the allocated memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
static char* get_sharedmem_filename(const char* dirname, int vmid) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  // add 2 for the file separator and a null terminator.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  size_t nbytes = strlen(dirname) + UINT_CHARS + 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
  char* name = NEW_C_HEAP_ARRAY(char, nbytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
  snprintf(name, nbytes, "%s/%d", dirname, vmid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
  return name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
// remove file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
// this method removes the file specified by the given path
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
static void remove_file(const char* path) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  // if the file is a directory, the following unlink will fail. since
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  // we don't expect to find directories in the user temp directory, we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  // won't try to handle this situation. even if accidentially or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  // maliciously planted, the directory's presence won't hurt anything.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  RESTARTABLE(::unlink(path), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
  if (PrintMiscellaneous && Verbose && result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
    if (errno != ENOENT) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
      warning("Could not unlink shared memory backing"
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
              " store file %s : %s\n", path, strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
// remove file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
// this method removes the file with the given file name in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
// named directory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
static void remove_file(const char* dirname, const char* filename) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  size_t nbytes = strlen(dirname) + strlen(filename) + 2;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  char* path = NEW_C_HEAP_ARRAY(char, nbytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  strcpy(path, dirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  strcat(path, "/");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  strcat(path, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  remove_file(path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  FREE_C_HEAP_ARRAY(char, path);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
// cleanup stale shared memory resources
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
// This method attempts to remove all stale shared memory files in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
// the named user temporary directory. It scans the named directory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
// for files matching the pattern ^$[0-9]*$. For each file found, the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
// process id is extracted from the file name and a test is run to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
// determine if the process is alive. If the process is not alive,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
// any stale file resources are removed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
static void cleanup_sharedmem_resources(const char* dirname) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  // open the user temp directory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  DIR* dirp = os::opendir(dirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  if (dirp == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
    // directory doesn't exist, so there is nothing to cleanup
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  if (!is_directory_secure(dirname)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
    // the directory is not a secure directory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
  // for each entry in the directory that matches the expected file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  // name pattern, determine if the file resources are stale and if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
  // so, remove the file resources. Note, instrumented HotSpot processes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  // for this user may start and/or terminate during this search and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  // remove or create new files in this directory. The behavior of this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  // loop under these conditions is dependent upon the implementation of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  // opendir/readdir.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  struct dirent* entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  char* dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(dirname));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  errno = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  while ((entry = os::readdir(dirp, (struct dirent *)dbuf)) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    pid_t pid = filename_to_pid(entry->d_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
    if (pid == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
      if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
        // attempt to remove all unexpected files, except "." and ".."
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
        remove_file(dirname, entry->d_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
      errno = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
    // we now have a file name that converts to a valid integer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    // that could represent a process id . if this process id
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
    // matches the current process id or the process is not running,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    // then remove the stale file resources.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    // process liveness is detected by sending signal number 0 to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    // the process id (see kill(2)). if kill determines that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    // process does not exist, then the file resources are removed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
    // if kill determines that that we don't have permission to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
    // signal the process, then the file resources are assumed to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    // be stale and are removed because the resources for such a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
    // process should be in a different user specific directory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
    if ((pid == os::current_process_id()) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
        (kill(pid, 0) == OS_ERR && (errno == ESRCH || errno == EPERM))) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
        remove_file(dirname, entry->d_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    errno = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  os::closedir(dirp);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  FREE_C_HEAP_ARRAY(char, dbuf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
// make the user specific temporary directory. Returns true if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
// the directory exists and is secure upon return. Returns false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
// if the directory exists but is either a symlink, is otherwise
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
// insecure, or if an error occurred.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
static bool make_user_tmp_dir(const char* dirname) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  // create the directory with 0755 permissions. note that the directory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  // will be owned by euid::egid, which may not be the same as uid::gid.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  if (mkdir(dirname, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH) == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    if (errno == EEXIST) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
      // The directory already exists and was probably created by another
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
      // JVM instance. However, this could also be the result of a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
      // deliberate symlink. Verify that the existing directory is safe.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
      if (!is_directory_secure(dirname)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
        // directory is not secure
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
        if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
          warning("%s directory is insecure\n", dirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
        return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
      // we encountered some other failure while attempting
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
      // to create the directory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
      if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
        warning("could not create directory %s: %s\n",
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
                dirname, strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
// create the shared memory file resources
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
// This method creates the shared memory file with the given size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
// This method also creates the user specific temporary directory, if
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
// it does not yet exist.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
static int create_sharedmem_resources(const char* dirname, const char* filename, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
  // make the user temporary directory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
  if (!make_user_tmp_dir(dirname)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    // could not make/find the directory or the found directory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
    // was not secure
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
  RESTARTABLE(::open(filename, O_RDWR|O_CREAT|O_TRUNC, S_IREAD|S_IWRITE), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
  if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
      warning("could not create file %s: %s\n", filename, strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  // save the file descriptor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  int fd = result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
  // set the file size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
  RESTARTABLE(::ftruncate(fd, (off_t)size), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
  if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
      warning("could not set shared memory file size: %s\n", strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
    RESTARTABLE(::close(fd), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
    return -1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
  return fd;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
// open the shared memory file for the given user and vmid. returns
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
// the file descriptor for the open file or -1 if the file could not
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
// be opened.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
static int open_sharedmem_file(const char* filename, int oflags, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
  // open the file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
  int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  RESTARTABLE(::open(filename, oflags), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    if (errno == ENOENT) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
      THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
                  "Process not found");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    else if (errno == EACCES) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
      THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
                  "Permission denied");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
    else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
      THROW_MSG_0(vmSymbols::java_io_IOException(), strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
// create a named shared memory region. returns the address of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
// memory region on success or NULL on failure. A return value of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
// NULL will ultimately disable the shared memory feature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
// On Solaris and Linux, the name space for shared memory objects
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
// is the file system name space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
// A monitoring application attaching to a JVM does not need to know
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
// the file system name of the shared memory object. However, it may
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
// be convenient for applications to discover the existence of newly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
// created and terminating JVMs by watching the file system name space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
// for files being created or removed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
static char* mmap_create_shared(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
  int fd;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  char* mapAddress;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
  int vmid = os::current_process_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
  char* user_name = get_user_name(geteuid());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
  if (user_name == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
  char* dirname = get_user_tmp_dir(user_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  char* filename = get_sharedmem_filename(dirname, vmid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  // cleanup any stale shared memory files
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
  cleanup_sharedmem_resources(dirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
  assert(((size > 0) && (size % os::vm_page_size() == 0)),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
         "unexpected PerfMemory region size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
  fd = create_sharedmem_resources(dirname, filename, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
  FREE_C_HEAP_ARRAY(char, user_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  FREE_C_HEAP_ARRAY(char, dirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
  if (fd == -1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
    FREE_C_HEAP_ARRAY(char, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
  mapAddress = (char*)::mmap((char*)0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  // attempt to close the file - restart it if it was interrupted,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  // but ignore other failures
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
  RESTARTABLE(::close(fd), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  assert(result != OS_ERR, "could not close file");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  if (mapAddress == MAP_FAILED) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
      warning("mmap failed -  %s\n", strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    remove_file(filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
    FREE_C_HEAP_ARRAY(char, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  // save the file name for use in delete_shared_memory()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
  backing_store_file_name = filename;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  // clear the shared memory region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  (void)::memset((void*) mapAddress, 0, size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  return mapAddress;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
// release a named shared memory region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
static void unmap_shared(char* addr, size_t bytes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  os::release_memory(addr, bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
// create the PerfData memory region in shared memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
static char* create_shared_memory(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  // create the shared memory region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  return mmap_create_shared(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
// delete the shared PerfData memory region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
static void delete_shared_memory(char* addr, size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  // cleanup the persistent shared memory resources. since DestroyJavaVM does
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  // not support unloading of the JVM, unmapping of the memory resource is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  // not performed. The memory will be reclaimed by the OS upon termination of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  // the process. The backing store file is deleted from the file system.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  assert(!PerfDisableSharedMem, "shouldn't be here");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
  if (backing_store_file_name != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
    remove_file(backing_store_file_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
    // Don't.. Free heap memory could deadlock os::abort() if it is called
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
    // from signal handler. OS will reclaim the heap memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    // FREE_C_HEAP_ARRAY(char, backing_store_file_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
    backing_store_file_name = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
// return the size of the file for the given file descriptor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
// or 0 if it is not a valid size for a shared memory file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
static size_t sharedmem_filesize(int fd, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  struct stat statbuf;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  RESTARTABLE(::fstat(fd, &statbuf), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  if (result == OS_ERR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
      warning("fstat failed: %s\n", strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    THROW_MSG_0(vmSymbols::java_io_IOException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
                "Could not determine PerfMemory size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  if ((statbuf.st_size == 0) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
     ((size_t)statbuf.st_size % os::vm_page_size() != 0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
    THROW_MSG_0(vmSymbols::java_lang_Exception(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
                "Invalid PerfMemory size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  return (size_t)statbuf.st_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
// attach to a named shared memory region.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemoryMode mode, char** addr, size_t* sizep, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
  char* mapAddress;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  int result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  int fd;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  size_t size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  const char* luser = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  int mmap_prot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  int file_flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  // map the high level access mode to the appropriate permission
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  // constructs for the file and the shared memory mapping.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  if (mode == PerfMemory::PERF_MODE_RO) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
    mmap_prot = PROT_READ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
    file_flags = O_RDONLY;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  else if (mode == PerfMemory::PERF_MODE_RW) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
#ifdef LATER
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
    mmap_prot = PROT_READ | PROT_WRITE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
    file_flags = O_RDWR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
#else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
              "Unsupported access mode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
              "Illegal access mode");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  if (user == NULL || strlen(user) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
    luser = get_user_name(vmid, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
    luser = user;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  if (luser == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
              "Could not map vmid to user Name");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  char* dirname = get_user_tmp_dir(luser);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  // since we don't follow symbolic links when creating the backing
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  // store file, we don't follow them when attaching either.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  if (!is_directory_secure(dirname)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    FREE_C_HEAP_ARRAY(char, dirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
              "Process not found");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  char* filename = get_sharedmem_filename(dirname, vmid);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  // copy heap memory to resource memory. the open_sharedmem_file
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  // method below need to use the filename, but could throw an
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  // exception. using a resource array prevents the leak that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
  // would otherwise occur.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  char* rfilename = NEW_RESOURCE_ARRAY(char, strlen(filename) + 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  strcpy(rfilename, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  // free the c heap resources that are no longer needed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
  if (luser != user) FREE_C_HEAP_ARRAY(char, luser);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  FREE_C_HEAP_ARRAY(char, dirname);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  FREE_C_HEAP_ARRAY(char, filename);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  // open the shared memory file for the give vmid
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  fd = open_sharedmem_file(rfilename, file_flags, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  assert(fd != OS_ERR, "unexpected value");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  if (*sizep == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
    size = sharedmem_filesize(fd, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
    assert(size != 0, "unexpected size");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  mapAddress = (char*)::mmap((char*)0, size, mmap_prot, MAP_SHARED, fd, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  // attempt to close the file - restart if it gets interrupted,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  // but ignore other failures
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  RESTARTABLE(::close(fd), result);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  assert(result != OS_ERR, "could not close file");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  if (mapAddress == MAP_FAILED) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
    if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
      warning("mmap failed: %s\n", strerror(errno));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
    THROW_MSG(vmSymbols::java_lang_OutOfMemoryError(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
              "Could not map PerfMemory");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  *addr = mapAddress;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  *sizep = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
  if (PerfTraceMemOps) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
    tty->print("mapped " SIZE_FORMAT " bytes for vmid %d at "
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
               INTPTR_FORMAT "\n", size, vmid, (void*)mapAddress);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
// create the PerfData memory region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
// This method creates the memory region used to store performance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
// data for the JVM. The memory may be created in standard or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
// shared memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
void PerfMemory::create_memory_region(size_t size) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  if (PerfDisableSharedMem) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
    // do not share the memory for the performance data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
    _start = create_standard_memory(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
    _start = create_shared_memory(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
    if (_start == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
      // creation of the shared memory region failed, attempt
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
      // to create a contiguous, non-shared memory region instead.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
      //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
      if (PrintMiscellaneous && Verbose) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
        warning("Reverting to non-shared PerfMemory region.\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
      PerfDisableSharedMem = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
      _start = create_standard_memory(size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  if (_start != NULL) _capacity = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
// delete the PerfData memory region
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
// This method deletes the memory region used to store performance
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
// data for the JVM. The memory region indicated by the <address, size>
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
// tuple will be inaccessible after a call to this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
void PerfMemory::delete_memory_region() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  assert((start() != NULL && capacity() > 0), "verify proper state");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  // If user specifies PerfDataSaveFile, it will save the performance data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
  // to the specified file name no matter whether PerfDataSaveToFile is specified
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
  // or not. In other word, -XX:PerfDataSaveFile=.. overrides flag
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  // -XX:+PerfDataSaveToFile.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  if (PerfDataSaveToFile || PerfDataSaveFile != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
    save_memory_to_file(start(), capacity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
  if (PerfDisableSharedMem) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
    delete_standard_memory(start(), capacity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
    delete_shared_memory(start(), capacity());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
// attach to the PerfData memory region for another JVM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
// This method returns an <address, size> tuple that points to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
// a memory buffer that is kept reasonably synchronized with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
// the PerfData memory region for the indicated JVM. This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
// buffer may be kept in synchronization via shared memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
// or some other mechanism that keeps the buffer updated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
// If the JVM chooses not to support the attachability feature,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
// this method should throw an UnsupportedOperation exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
// This implementation utilizes named shared memory to map
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
// the indicated process's PerfData memory region into this JVMs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
// address space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
void PerfMemory::attach(const char* user, int vmid, PerfMemoryMode mode, char** addrp, size_t* sizep, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  if (vmid == 0 || vmid == os::current_process_id()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
     *addrp = start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
     *sizep = capacity();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
     return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
  mmap_attach_shared(user, vmid, mode, addrp, sizep, CHECK);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
// detach from the PerfData memory region of another JVM
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
// This method detaches the PerfData memory region of another
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
// JVM, specified as an <address, size> tuple of a buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
// in this process's address space. This method may perform
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
// arbitrary actions to accomplish the detachment. The memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
// region specified by <address, size> will be inaccessible after
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
// a call to this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
// If the JVM chooses not to support the attachability feature,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
// this method should throw an UnsupportedOperation exception.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
// This implementation utilizes named shared memory to detach
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
// the indicated process's PerfData memory region from this
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
// process's address space.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
void PerfMemory::detach(char* addr, size_t bytes, TRAPS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  assert(addr != 0, "address sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  assert(bytes > 0, "capacity sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  if (PerfMemory::contains(addr) || PerfMemory::contains(addr + bytes - 1)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
    // prevent accidental detachment of this process's PerfMemory region
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
    return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  unmap_shared(addr, bytes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
char* PerfMemory::backing_store_filename() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  return backing_store_file_name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
}