graal-jvmci-8: src/os/solaris/vm/os

comparison src/os/solaris/vm/os_solaris.cpp @ 6275:957c266d8bc5

Merge with http://hg.openjdk.java.net/hsx/hsx24/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 21 Aug 2012 10:39:19 +0200
parents	897b7d18bebc 65906dc96aa1
children	e522a00b91aa

comparison

equal deleted inserted replaced

-:fd8832ae511d
+:957c266d8bc5
 uint_t*         id_length) {
 bool result = false;
 // Find the number of processors in the processor set.
 if (pset_info(pset, NULL, id_length, NULL) == 0) {
 // Make up an array to hold their ids.
-*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
+*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
 // Fill in the array with their processor ids.
 if (pset_info(pset, NULL, id_length, *id_array) == 0) {
 result = true;
 }
 }
 uint*           id_length) {
 const processorid_t MAX_PROCESSOR_ID = 100000 ;
 // Find the number of processors online.
 *id_length = sysconf(_SC_NPROCESSORS_ONLN);
 // Make up an array to hold their ids.
-*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
+*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
 // Processors need not be numbered consecutively.
 long found = 0;
 processorid_t next = 0;
 while (found < *id_length && next < MAX_PROCESSOR_ID) {
 processor_info_t info;
 max_id = MAX2(max_id, id_array[m]);
 }
 // The next id, to limit loops.
 const processorid_t limit_id = max_id + 1;
 // Make up markers for available processors.
-bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id);
+bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id, mtInternal);
 for (uint c = 0; c < limit_id; c += 1) {
 available_id[c] = false;
 }
 for (uint a = 0; a < id_length; a += 1) {
 available_id[id_array[a]] = true;
 if (board * processors_per_board + 0 >= limit_id) {
 board = 0;
 }
 }
 if (available_id != NULL) {
-FREE_C_HEAP_ARRAY(bool, available_id);
+FREE_C_HEAP_ARRAY(bool, available_id, mtInternal);
 }
 return true;
 }
 void os::set_native_thread_name(const char *name) {
 } else {
 result = false;
 }
 }
 if (id_array != NULL) {
-FREE_C_HEAP_ARRAY(processorid_t, id_array);
+FREE_C_HEAP_ARRAY(processorid_t, id_array, mtInternal);
 }
 return result;
 }
 bool os::bind_to_processor(uint processor_id) {
 //
 // Important note: if the location of libjvm.so changes this
 // code needs to be changed accordingly.
 // The next few definitions allow the code to be verbatim:
-#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))
+#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal)
-#define free(p) FREE_C_HEAP_ARRAY(char, p)
+#define free(p) FREE_C_HEAP_ARRAY(char, p, mtInternal)
 #define getenv(n) ::getenv(n)
 #define EXTENSIONS_DIR  "/lib/ext"
 #define ENDORSED_DIR    "/lib/endorsed"
 #define COMMON_DIR      "/usr/jdk/packages"
 return false;
 }
 extern "C" void breakpoint() {
 // use debugger to set breakpoint here
-}
-// Returns an estimate of the current stack pointer. Result must be guaranteed to
-// point into the calling threads stack, and be no lower than the current stack
-// pointer.
-address os::current_stack_pointer() {
-volatile int dummy;
-address sp = (address)&dummy + 8;     // %%%% need to confirm if this is right
-return sp;
 }
 static thread_t main_thread;
 // Thread start routine for all new Java threads
 }
 }
 // release the storage
 for (int i = 0 ; i < n ; i++) {
 if (pelements[i] != NULL) {
-FREE_C_HEAP_ARRAY(char, pelements[i]);
+FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
 }
 }
 if (pelements != NULL) {
-FREE_C_HEAP_ARRAY(char*, pelements);
+FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);
 }
 } else {
 snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
 }
 }
 ::close(fd);
 return true;
 }
+void os::print_os_info_brief(outputStream* st) {
+os::Solaris::print_distro_info(st);
+os::Posix::print_uname_info(st);
+os::Solaris::print_libversion_info(st);
+}
 void os::print_os_info(outputStream* st) {
 st->print("OS:");
+os::Solaris::print_distro_info(st);
+os::Posix::print_uname_info(st);
+os::Solaris::print_libversion_info(st);
+os::Posix::print_rlimit_info(st);
+os::Posix::print_load_average(st);
+}
+void os::Solaris::print_distro_info(outputStream* st) {
 if (!_print_ascii_file("/etc/release", st)) {
 st->print("Solaris");
+}
+st->cr();
+}
+void os::Solaris::print_libversion_info(outputStream* st) {
+if (os::Solaris::T2_libthread()) {
+st->print("  (T2 libthread)");
+}
+else {
+st->print("  (T1 libthread)");
 }
 st->cr();
+}
-// kernel
-st->print("uname:");
-struct utsname name;
-uname(&name);
-st->print(name.sysname); st->print(" ");
-st->print(name.release); st->print(" ");
-st->print(name.version); st->print(" ");
-st->print(name.machine);
-// libthread
-if (os::Solaris::T2_libthread()) st->print("  (T2 libthread)");
-else st->print("  (T1 libthread)");
-st->cr();
-// rlimit
-st->print("rlimit:");
-struct rlimit rlim;
-st->print(" STACK ");
-getrlimit(RLIMIT_STACK, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%uk", rlim.rlim_cur >> 10);
-st->print(", CORE ");
-getrlimit(RLIMIT_CORE, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%uk", rlim.rlim_cur >> 10);
-st->print(", NOFILE ");
-getrlimit(RLIMIT_NOFILE, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%d", rlim.rlim_cur);
-st->print(", AS ");
-getrlimit(RLIMIT_AS, &rlim);
-if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
-else st->print("%uk", rlim.rlim_cur >> 10);
-st->cr();
-// load average
-st->print("load average:");
-double loadavg[3];
-os::loadavg(loadavg, 3);
-st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
-st->cr();
-}
 static bool check_addr0(outputStream* st) {
 jboolean status = false;
 int fd = ::open("/proc/self/map",O_RDONLY);
 if (fd >= 0) {
 Maxlibjsigsigs = Maxsignum;
 // pending_signals has one int per signal
 // The additional signal is for SIGEXIT - exit signal to signal_thread
-pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1));
+pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1), mtInternal);
 memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));
 if (UseSignalChaining) {
 chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)
-* (Maxsignum + 1));
+* (Maxsignum + 1), mtInternal);
 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
-preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1));
+preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
 }
-ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ));
+ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ), mtInternal);
 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
 }
 void os::signal_init_pd() {
 int ret;
 int os::vm_allocation_granularity() {
 assert(page_size != -1, "must call os::init");
 return page_size;
 }
-bool os::commit_memory(char* addr, size_t bytes, bool exec) {
+bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 size_t size = bytes;
 char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot);
 if (res != NULL) {
 if (UseNUMAInterleaving) {
 return true;
 }
 return false;
 }
-bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint,
+bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint,
 bool exec) {
 if (commit_memory(addr, bytes, exec)) {
 if (UseMPSS && alignment_hint > (size_t)vm_page_size()) {
 // If the large page size has been set and the VM
 // is using large pages, use the large page size
 }
 return false;
 }
 // Uncommit the pages in a specified region.
-void os::free_memory(char* addr, size_t bytes, size_t alignment_hint) {
+void os::pd_free_memory(char* addr, size_t bytes, size_t alignment_hint) {
 if (madvise(addr, bytes, MADV_FREE) < 0) {
 debug_only(warning("MADV_FREE failed."));
 return;
 }
 }
-bool os::create_stack_guard_pages(char* addr, size_t size) {
+bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
 return os::commit_memory(addr, size);
 }
 bool os::remove_stack_guard_pages(char* addr, size_t size) {
 return os::uncommit_memory(addr, size);
 }
 // Change the page size in a given range.
-void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
+void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
 assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned.");
 assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned.");
 if (UseLargePages && UseMPSS) {
 Solaris::set_mpss_range(addr, bytes, alignment_hint);
 }
 p = addrs[addrs_count - 1] + page_size;
 }
 return end;
 }
-bool os::uncommit_memory(char* addr, size_t bytes) {
+bool os::pd_uncommit_memory(char* addr, size_t bytes) {
 size_t size = bytes;
 // Map uncommitted pages PROT_NONE so we fail early if we touch an
 // uncommitted page. Otherwise, the read/write might succeed if we
 // have enough swap space to back the physical page.
 return
 // uncommitted page. Otherwise, the read/write might succeed if we
 // have enough swap space to back the physical page.
 return mmap_chunk(addr, bytes, flags, PROT_NONE);
 }
-char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
+char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
 char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL));
 guarantee(requested_addr == NULL || requested_addr == addr,
 "OS failed to return requested mmap address.");
 return addr;
 }
 // Reserve memory at an arbitrary address, only if that area is
 // available (and not reserved for something else).
-char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
+char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
 const int max_tries = 10;
 char* base[max_tries];
 size_t size[max_tries];
 // Solaris adds a gap between mmap'ed regions.  The size of the gap
 }
 return (i < max_tries) ? requested_addr : NULL;
 }
-bool os::release_memory(char* addr, size_t bytes) {
+bool os::pd_release_memory(char* addr, size_t bytes) {
 size_t size = bytes;
 return munmap(addr, size) == 0;
 }
 static bool solaris_mprotect(char* addr, size_t bytes, int prot) {
 return false;
 }
 lwpSize = 16*1024;
 for (;;) {
 ::lseek64 (lwpFile, 0, SEEK_SET);
-lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize);
+lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize, mtInternal);
 if (::read(lwpFile, lwpArray, lwpSize) < 0) {
 if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n");
 break;
 }
 if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) {
 }
 if (aslwpcount == 0) isT2 = true;
 break;
 }
 lwpSize = lwpArray->pr_nent * lwpArray->pr_entsize;
-FREE_C_HEAP_ARRAY(char, lwpArray);  // retry.
+FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal);  // retry.
 }
-FREE_C_HEAP_ARRAY(char, lwpArray);
+FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal);
 ::close (lwpFile);
 if (ThreadPriorityVerbose) {
 if (isT2) tty->print_cr("We are running with a T2 libthread\n");
 else tty->print_cr("We are not running with a T2 libthread\n");
 }
 if (UseNUMA) {
 if (!Solaris::liblgrp_init()) {
 UseNUMA = false;
 } else {
 size_t lgrp_limit = os::numa_get_groups_num();
-int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit);
+int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit, mtInternal);
 size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit);
-FREE_C_HEAP_ARRAY(int, lgrp_ids);
+FREE_C_HEAP_ARRAY(int, lgrp_ids, mtInternal);
 if (lgrp_num < 2) {
 // There's only one locality group, disable NUMA.
 UseNUMA = false;
 }
 }
 *bytes = end - cur;
 return 1;
 }
 // Map a block of memory.
-char* os::map_memory(int fd, const char* file_name, size_t file_offset,
+char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 int prot;
 int flags;
 return mapped_address;
 }
 // Remap a block of memory.
-char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
+char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 // same as map_memory() on this OS
 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
 allow_exec);
 }
 // Unmap a block of memory.
-bool os::unmap_memory(char* addr, size_t bytes) {
+bool os::pd_unmap_memory(char* addr, size_t bytes) {
 return munmap(addr, bytes) == 0;
 }
 void os::pause() {
 char filename[MAX_PATH];
 int os::bind(int fd, struct sockaddr* him, socklen_t len) {
 INTERRUPTIBLE_RETURN_INT_NORESTART(::bind(fd, him, len),\
 os::Solaris::clear_interrupted);
 }
+// Get the default path to the core file
+// Returns the length of the string
+int os::get_core_path(char* buffer, size_t bufferSize) {
+const char* p = get_current_directory(buffer, bufferSize);
+if (p == NULL) {
+assert(p != NULL, "failed to get current directory");
+return 0;
+}
+return strlen(buffer);
+}

Mercurial > hg > graal-jvmci-8

comparison src/os/solaris/vm/os_solaris.cpp @ 6275:957c266d8bc5