jdk-sandbox: comparison src/hotspot/os/aix/os

equal deleted inserted replaced

-:13588c901957
+:9cf78a70fa4f
 #define ERROR_MP_EXTSHM_ACTIVE                       101
 #define ERROR_MP_VMGETINFO_FAILED                    102
 #define ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K 103
 // excerpts from systemcfg.h that might be missing on older os levels
-#ifndef PV_5_Compat
-#define PV_5_Compat 0x0F8000   /* Power PC 5 */
-#endif
-#ifndef PV_6
-#define PV_6 0x100000          /* Power PC 6 */
-#endif
-#ifndef PV_6_1
-#define PV_6_1 0x100001        /* Power PC 6 DD1.x */
-#endif
-#ifndef PV_6_Compat
-#define PV_6_Compat 0x108000   /* Power PC 6 */
-#endif
 #ifndef PV_7
 #define PV_7 0x200000          /* Power PC 7 */
 #endif
 #ifndef PV_7_Compat
 #define PV_7_Compat 0x208000   /* Power PC 7 */
 #define PV_8 0x300000          /* Power PC 8 */
 #endif
 #ifndef PV_8_Compat
 #define PV_8_Compat 0x308000   /* Power PC 8 */
 #endif
+#ifndef PV_9
+#define PV_9 0x400000          /* Power PC 9 */
+#endif
+#ifndef PV_9_Compat
+#define PV_9_Compat  0x408000  /* Power PC 9 */
+#endif
 static address resolve_function_descriptor_to_code_pointer(address p);
 static void vmembk_print_on(outputStream* os);
 struct shmid_ds shm_buf = { 0 };
 shm_buf.shm_pagesize = pagesize;
 if (::shmctl(shmid, SHM_PAGESIZE, &shm_buf) != 0) {
 const int en = errno;
 ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
-trcVerbose("shmctl(SHM_PAGESIZE) failed with errno=%n",
+trcVerbose("shmctl(SHM_PAGESIZE) failed with errno=%d", errno);
-errno);
 } else {
 // Attach and double check pageisze.
 void* p = ::shmat(shmid, NULL, 0);
 ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
 guarantee0(p != (void*) -1); // Should always work.
 const size_t real_pagesize = os::Aix::query_pagesize(p);
 if (real_pagesize != pagesize) {
-trcVerbose("real page size (0x%llX) differs.", real_pagesize);
+trcVerbose("real page size (" SIZE_FORMAT_HEX ") differs.", real_pagesize);
 } else {
 can_use = true;
 }
 ::shmdt(p);
 }
 describe_pagesize(g_multipage_support.textpsize));
 trcVerbose("Thread stack page size (pthread): %s",
 describe_pagesize(g_multipage_support.pthr_stack_pagesize));
 trcVerbose("Default shared memory page size: %s",
 describe_pagesize(g_multipage_support.shmpsize));
-trcVerbose("Can use 64K pages dynamically with shared meory: %s",
+trcVerbose("Can use 64K pages dynamically with shared memory: %s",
 (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
 trcVerbose("Can use 16M pages dynamically with shared memory: %s",
 (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
 trcVerbose("Multipage error details: %d",
 g_multipage_support.error);
 // Note that the space for the trailing null is provided
 // by the nulls included by the sizeof operator.
 const size_t bufsize =
 MAX2((size_t)MAXPATHLEN,  // For dll_dir & friends.
 (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR)); // extensions dir
-char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);
+char *buf = NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);
 // sysclasspath, java_home, dll_dir
 {
 char *pslash;
 os::jvm_path(buf, bufsize);
 const char *v_colon = ":";
 if (v == NULL) { v = ""; v_colon = ""; }
 // Concatenate user and invariant part of ld_library_path.
 // That's +1 for the colon and +1 for the trailing '\0'.
-char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char, strlen(v) + 1 + sizeof(DEFAULT_LIBPATH) + 1, mtInternal);
+char *ld_library_path = NEW_C_HEAP_ARRAY(char, strlen(v) + 1 + sizeof(DEFAULT_LIBPATH) + 1, mtInternal);
 sprintf(ld_library_path, "%s%s" DEFAULT_LIBPATH, v, v_colon);
 Arguments::set_library_path(ld_library_path);
 FREE_C_HEAP_ARRAY(char, ld_library_path);
 // Extensions directories.
 // time support
 // Time since start-up in seconds to a fine granularity.
 // Used by VMSelfDestructTimer and the MemProfiler.
 double os::elapsedTime() {
-return (double)(os::elapsed_counter()) * 0.000001;
+return ((double)os::elapsed_counter()) / os::elapsed_frequency(); // nanosecond resolution
 }
 jlong os::elapsed_counter() {
-timeval time;
+return javaTimeNanos() - initial_time_count;
-int status = gettimeofday(&time, NULL);
-return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;
 }
 jlong os::elapsed_frequency() {
-return (1000 * 1000);
+return NANOSECS_PER_SEC; // nanosecond resolution
 }
 bool os::supports_vtime() { return true; }
-bool os::enable_vtime()   { return false; }
-bool os::vtime_enabled()  { return false; }
 double os::elapsedVTime() {
 struct rusage usage;
 int retval = getrusage(RUSAGE_THREAD, &usage);
 if (retval == 0) {
 ::exit(1);
 }
 // Die immediately, no exit hook, no abort hook, no cleanup.
+// Dump a core file, if possible, for debugging.
 void os::die() {
-::abort();
+if (TestUnresponsiveErrorHandler && !CreateCoredumpOnCrash) {
+// For TimeoutInErrorHandlingTest.java, we just kill the VM
+// and don't take the time to generate a core file.
+os::signal_raise(SIGKILL);
+} else {
+::abort();
+}
 }
 intx os::current_thread_id() {
 return (intx)pthread_self();
 }
 // Loads .dll/.so and in case of error it checks if .dll/.so was built
 // for the same architecture as Hotspot is running on.
 void *os::dll_load(const char *filename, char *ebuf, int ebuflen) {
+log_info(os)("attempting shared library load of %s", filename);
 if (ebuf && ebuflen > 0) {
 ebuf[0] = '\0';
 ebuf[ebuflen - 1] = '\0';
 }
 }
 // RTLD_LAZY is currently not implemented. The dl is loaded immediately with all its dependants.
 void * result= ::dlopen(filename, RTLD_LAZY);
 if (result != NULL) {
+Events::log(NULL, "Loaded shared library %s", filename);
 // Reload dll cache. Don't do this in signal handling.
 LoadedLibraries::reload();
+log_info(os)("shared library load of %s was successful", filename);
 return result;
 } else {
 // error analysis when dlopen fails
-const char* const error_report = ::dlerror();
+const char* error_report = ::dlerror();
-if (error_report && ebuf && ebuflen > 0) {
+if (error_report == NULL) {
+error_report = "dlerror returned no error description";
+}
+if (ebuf != NULL && ebuflen > 0) {
 snprintf(ebuf, ebuflen - 1, "%s, LIBPATH=%s, LD_LIBRARY_PATH=%s : %s",
 filename, ::getenv("LIBPATH"), ::getenv("LD_LIBRARY_PATH"), error_report);
 }
+Events::log(NULL, "Loading shared library %s failed, %s", filename, error_report);
+log_info(os)("shared library load of %s failed, %s", filename, error_report);
 }
 return NULL;
 }
 void* os::dll_lookup(void* handle, const char* name) {
 }
 void os::print_os_info(outputStream* st) {
 st->print("OS:");
-st->print("uname:");
+os::Posix::print_uname_info(st);
-struct utsname name;
-uname(&name);
-st->print(name.sysname); st->print(" ");
-st->print(name.nodename); st->print(" ");
-st->print(name.release); st->print(" ");
-st->print(name.version); st->print(" ");
-st->print(name.machine);
-st->cr();
 uint32_t ver = os::Aix::os_version();
 st->print_cr("AIX kernel version %u.%u.%u.%u",
 (ver >> 24) & 0xFF, (ver >> 16) & 0xFF, (ver >> 8) & 0xFF, ver & 0xFF);
 os::Posix::print_rlimit_info(st);
+os::Posix::print_load_average(st);
 // _SC_THREAD_THREADS_MAX is the maximum number of threads within a process.
 long tmax = sysconf(_SC_THREAD_THREADS_MAX);
 st->print_cr("maximum #threads within a process:%ld", tmax);
-// load average
-st->print("load average:");
-double loadavg[3] = {-1.L, -1.L, -1.L};
-os::loadavg(loadavg, 3);
-st->print_cr("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
 // print wpar info
 libperfstat::wparinfo_t wi;
 if (libperfstat::get_wparinfo(&wi)) {
 st->print_cr("wpar info");
 describe_pagesize(g_multipage_support.textpsize));
 st->print_cr("  Thread stack page size (pthread):       %s",
 describe_pagesize(g_multipage_support.pthr_stack_pagesize));
 st->print_cr("  Default shared memory page size:        %s",
 describe_pagesize(g_multipage_support.shmpsize));
-st->print_cr("  Can use 64K pages dynamically with shared meory:  %s",
+st->print_cr("  Can use 64K pages dynamically with shared memory:  %s",
 (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
 st->print_cr("  Can use 16M pages dynamically with shared memory: %s",
 (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
 st->print_cr("  Multipage error: %d",
 g_multipage_support.error);
 // Get a string for the cpuinfo that is a summary of the cpu type
 void os::get_summary_cpu_info(char* buf, size_t buflen) {
 // read _system_configuration.version
 switch (_system_configuration.version) {
+case PV_9:
+strncpy(buf, "Power PC 9", buflen);
+break;
 case PV_8:
 strncpy(buf, "Power PC 8", buflen);
 break;
 case PV_7:
 strncpy(buf, "Power PC 7", buflen);
 strncpy(buf, "PV_7_Compat", buflen);
 break;
 case PV_8_Compat:
 strncpy(buf, "PV_8_Compat", buflen);
 break;
+case PV_9_Compat:
+strncpy(buf, "PV_9_Compat", buflen);
+break;
 default:
 strncpy(buf, "unknown", buflen);
 }
 }
 }
 ////////////////////////////////////////////////////////////////////////////////
 // sun.misc.Signal support
-static volatile jint sigint_count = 0;
 static void
 UserHandler(int sig, void *siginfo, void *context) {
-// 4511530 - sem_post is serialized and handled by the manager thread. When
-// the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
-// don't want to flood the manager thread with sem_post requests.
-if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
-return;
 // Ctrl-C is pressed during error reporting, likely because the error
 // handler fails to abort. Let VM die immediately.
 if (sig == SIGINT && VMError::is_error_reported()) {
 os::die();
 }
 Atomic::inc(&pending_signals[sig]);
 local_sem_post();
 }
 static int check_pending_signals() {
-Atomic::store(0, &sigint_count);
 for (;;) {
 for (int i = 0; i < NSIG + 1; i++) {
 jint n = pending_signals[i];
 if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
 return i;
 // also check that range is fully page aligned to the page size if the block.
 void assert_is_valid_subrange(char* p, size_t s) const {
 if (!contains_range(p, s)) {
 trcVerbose("[" PTR_FORMAT " - " PTR_FORMAT "] is not a sub "
 "range of [" PTR_FORMAT " - " PTR_FORMAT "].",
-p, p + s, addr, addr + size);
+p2i(p), p2i(p + s), p2i(addr), p2i(addr + size));
 guarantee0(false);
 }
 if (!is_aligned_to(p, pagesize) || !is_aligned_to(p + s, pagesize)) {
 trcVerbose("range [" PTR_FORMAT " - " PTR_FORMAT "] is not"
-" aligned to pagesize (%lu)", p, p + s, (unsigned long) pagesize);
+" aligned to pagesize (%lu)", p2i(p), p2i(p + s), (unsigned long) pagesize);
 guarantee0(false);
 }
 }
 };
 char* requested_addr,
 size_t alignment_hint) {
 trcVerbose("reserve_shmated_memory " UINTX_FORMAT " bytes, wishaddress "
 PTR_FORMAT ", alignment_hint " UINTX_FORMAT "...",
-bytes, requested_addr, alignment_hint);
+bytes, p2i(requested_addr), alignment_hint);
 // Either give me wish address or wish alignment but not both.
 assert0(!(requested_addr != NULL && alignment_hint != 0));
 // We must prevent anyone from attaching too close to the
 // BRK because that may cause malloc OOM.
 if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
 trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
-"Will attach anywhere.", requested_addr);
+"Will attach anywhere.", p2i(requested_addr));
 // Act like the OS refused to attach there.
 requested_addr = NULL;
 }
 // For old AS/400's (V5R4 and older) we should not even be here - System V shared memory is not
 assert(false, "failed to remove shared memory segment!");
 }
 // Handle shmat error. If we failed to attach, just return.
 if (addr == (char*)-1) {
-trcVerbose("Failed to attach segment at " PTR_FORMAT " (%d).", requested_addr, errno_shmat);
+trcVerbose("Failed to attach segment at " PTR_FORMAT " (%d).", p2i(requested_addr), errno_shmat);
 return NULL;
 }
 // Just for info: query the real page size. In case setting the page size did not
 // work (see above), the system may have given us something other then 4K (LDR_CNTRL).
 const size_t real_pagesize = os::Aix::query_pagesize(addr);
 if (real_pagesize != shmbuf.shm_pagesize) {
-trcVerbose("pagesize is, surprisingly, %h.", real_pagesize);
+trcVerbose("pagesize is, surprisingly, " SIZE_FORMAT, real_pagesize);
 }
 if (addr) {
 trcVerbose("shm-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes, " UINTX_FORMAT " %s pages)",
-addr, addr + size - 1, size, size/real_pagesize, describe_pagesize(real_pagesize));
+p2i(addr), p2i(addr + size - 1), size, size/real_pagesize, describe_pagesize(real_pagesize));
 } else {
 if (requested_addr != NULL) {
-trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at with address " PTR_FORMAT ".", size, requested_addr);
+trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at with address " PTR_FORMAT ".", size, p2i(requested_addr));
 } else {
 trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at any address.", size);
 }
 }
 }
 static bool release_shmated_memory(char* addr, size_t size) {
 trcVerbose("release_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
-addr, addr + size - 1);
+p2i(addr), p2i(addr + size - 1));
 bool rc = false;
 // TODO: is there a way to verify shm size without doing bookkeeping?
 if (::shmdt(addr) != 0) {
 return rc;
 }
 static bool uncommit_shmated_memory(char* addr, size_t size) {
 trcVerbose("uncommit_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
-addr, addr + size - 1);
+p2i(addr), p2i(addr + size - 1));
 const bool rc = my_disclaim64(addr, size);
 if (!rc) {
-trcVerbose("my_disclaim64(" PTR_FORMAT ", " UINTX_FORMAT ") failed.\n", addr, size);
+trcVerbose("my_disclaim64(" PTR_FORMAT ", " UINTX_FORMAT ") failed.\n", p2i(addr), size);
 return false;
 }
 return true;
 }
 // allocate at an address aligned with the given alignment. Failing that, memory
 // is aligned anywhere.
 static char* reserve_mmaped_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
 trcVerbose("reserve_mmaped_memory " UINTX_FORMAT " bytes, wishaddress " PTR_FORMAT ", "
 "alignment_hint " UINTX_FORMAT "...",
-bytes, requested_addr, alignment_hint);
+bytes, p2i(requested_addr), alignment_hint);
 // If a wish address is given, but not aligned to 4K page boundary, mmap will fail.
 if (requested_addr && !is_aligned_to(requested_addr, os::vm_page_size()) != 0) {
-trcVerbose("Wish address " PTR_FORMAT " not aligned to page boundary.", requested_addr);
+trcVerbose("Wish address " PTR_FORMAT " not aligned to page boundary.", p2i(requested_addr));
 return NULL;
 }
 // We must prevent anyone from attaching too close to the
 // BRK because that may cause malloc OOM.
 if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
 trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
-"Will attach anywhere.", requested_addr);
+"Will attach anywhere.", p2i(requested_addr));
 // Act like the OS refused to attach there.
 requested_addr = NULL;
 }
 // Specify one or the other but not both.
 char* addr = (char*)::mmap(requested_addr, extra_size,
 PROT_READ|PROT_WRITE|PROT_EXEC, flags, -1, 0);
 if (addr == MAP_FAILED) {
-trcVerbose("mmap(" PTR_FORMAT ", " UINTX_FORMAT ", ..) failed (%d)", requested_addr, size, errno);
+trcVerbose("mmap(" PTR_FORMAT ", " UINTX_FORMAT ", ..) failed (%d)", p2i(requested_addr), size, errno);
 return NULL;
 }
 // Handle alignment.
 char* const addr_aligned = align_up(addr, alignment_hint);
 }
 addr = addr_aligned;
 if (addr) {
 trcVerbose("mmap-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes)",
-addr, addr + bytes, bytes);
+p2i(addr), p2i(addr + bytes), bytes);
 } else {
 if (requested_addr != NULL) {
-trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at wish address " PTR_FORMAT ".", bytes, requested_addr);
+trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at wish address " PTR_FORMAT ".", bytes, p2i(requested_addr));
 } else {
 trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at any address.", bytes);
 }
 }
 static bool release_mmaped_memory(char* addr, size_t size) {
 assert0(is_aligned_to(addr, os::vm_page_size()));
 assert0(is_aligned_to(size, os::vm_page_size()));
 trcVerbose("release_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
-addr, addr + size - 1);
+p2i(addr), p2i(addr + size - 1));
 bool rc = false;
 if (::munmap(addr, size) != 0) {
 trcVerbose("failed (%d)\n", errno);
 rc = false;
 assert0(is_aligned_to(addr, os::vm_page_size()));
 assert0(is_aligned_to(size, os::vm_page_size()));
 trcVerbose("uncommit_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
-addr, addr + size - 1);
+p2i(addr), p2i(addr + size - 1));
 bool rc = false;
 // Uncommit mmap memory with msync MS_INVALIDATE.
 if (::msync(addr, size, MS_INVALIDATE) != 0) {
 trcVerbose("failed (%d)\n", errno);
 #ifdef PRODUCT
 static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
 int err) {
 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
-", %d) failed; error='%s' (errno=%d)", addr, size, exec,
+", %d) failed; error='%s' (errno=%d)", p2i(addr), size, exec,
 os::errno_name(err), err);
 }
 #endif
 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
 vmembk_t* const vmi = vmembk_find(addr);
 guarantee0(vmi);
 vmi->assert_is_valid_subrange(addr, size);
-trcVerbose("commit_memory [" PTR_FORMAT " - " PTR_FORMAT "].", addr, addr + size - 1);
+trcVerbose("commit_memory [" PTR_FORMAT " - " PTR_FORMAT "].", p2i(addr), p2i(addr + size - 1));
 if (UseExplicitCommit) {
 // AIX commits memory on touch. So, touch all pages to be committed.
 for (char* p = addr; p < (addr + size); p += 4*K) {
 *p = '\0';
 60,             // 10 MaxPriority
 60              // 11 CriticalPriority
 };
+static int prio_init() {
+if (ThreadPriorityPolicy == 1) {
+if (geteuid() != 0) {
+if (!FLAG_IS_DEFAULT(ThreadPriorityPolicy)) {
+warning("-XX:ThreadPriorityPolicy=1 may require system level permission, " \
+"e.g., being the root user. If the necessary permission is not " \
+"possessed, changes to priority will be silently ignored.");
+}
+}
+}
+if (UseCriticalJavaThreadPriority) {
+os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority];
+}
+return 0;
+}
 OSReturn os::set_native_priority(Thread* thread, int newpri) {
-if (!UseThreadPriorities) return OS_OK;
+if (!UseThreadPriorities || ThreadPriorityPolicy == 0) return OS_OK;
 pthread_t thr = thread->osthread()->pthread_id();
 int policy = SCHED_OTHER;
 struct sched_param param;
 param.sched_priority = newpri;
 int ret = pthread_setschedparam(thr, policy, &param);
 }
 return (ret == 0) ? OS_OK : OS_ERR;
 }
 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
-if (!UseThreadPriorities) {
+if (!UseThreadPriorities || ThreadPriorityPolicy == 0) {
 *priority_ptr = java_to_os_priority[NormPriority];
 return OS_OK;
 }
 pthread_t thr = thread->osthread()->pthread_id();
 int policy = SCHED_OTHER;
 // attempt to switch the state, we assume we had a SUSPEND_REQUEST
 os::SuspendResume::State state = osthread->sr.suspended();
 if (state == os::SuspendResume::SR_SUSPENDED) {
 sigset_t suspend_set;  // signals for sigsuspend()
+sigemptyset(&suspend_set);
 // get current set of blocked signals and unblock resume signal
 pthread_sigmask(SIG_BLOCK, NULL, &suspend_set);
 sigdelset(&suspend_set, SR_signum);
 // wait here until we are resumed
 actp->sa_handler = SIG_DFL;
 }
 // try to honor the signal mask
 sigset_t oset;
+sigemptyset(&oset);
 pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset);
 // call into the chained handler
 if (siginfo_flag_set) {
 (*sa)(sig, siginfo, context);
 } else {
 (*hand)(sig);
 }
 // restore the signal mask
-pthread_sigmask(SIG_SETMASK, &oset, 0);
+pthread_sigmask(SIG_SETMASK, &oset, NULL);
 }
 // Tell jvm's signal handler the signal is taken care of.
 return true;
 }
 init_random(1234567);
 // _main_thread points to the thread that created/loaded the JVM.
 Aix::_main_thread = pthread_self();
-initial_time_count = os::elapsed_counter();
+initial_time_count = javaTimeNanos();
 os::Posix::init();
 }
 // This is called _after_ the global arguments have been parsed.
 if (atexit(perfMemory_exit_helper) != 0) {
 warning("os::init_2 atexit(perfMemory_exit_helper) failed");
 }
 }
+// initialize thread priority policy
+prio_init();
 return JNI_OK;
 }
 // Mark the polling page as unreadable
 void os::make_polling_page_unreadable(void) {
 }
 void os::set_native_thread_name(const char *name) {
 // Not yet implemented.
 return;
-}
-bool os::distribute_processes(uint length, uint* distribution) {
-// Not yet implemented.
-return false;
 }
 bool os::bind_to_processor(uint processor_id) {
 // Not yet implemented.
 return false;
 }
 void os::pause() {
 char filename[MAX_PATH];
 if (PauseAtStartupFile && PauseAtStartupFile[0]) {
-jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
+jio_snprintf(filename, MAX_PATH, "%s", PauseAtStartupFile);
 } else {
 jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
 }
 int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 assert(major > 0, "invalid OS version");
 const int minor = atoi(uts.release);
 assert(minor > 0, "invalid OS release");
 _os_version = (major << 24) | (minor << 16);
 char ver_str[20] = {0};
-char *name_str = "unknown OS";
+const char* name_str = "unknown OS";
 if (strcmp(uts.sysname, "OS400") == 0) {
 // We run on AS/400 PASE. We do not support versions older than V5R4M0.
 _on_pase = 1;
 if (os_version_short() < 0x0504) {
 trcVerbose("OS/400 releases older than V5R4M0 not supported.");
 assert(false, "OS/400 release too old.");
 }
 name_str = "OS/400 (pase)";
 jio_snprintf(ver_str, sizeof(ver_str), "%u.%u", major, minor);
 } else if (strcmp(uts.sysname, "AIX") == 0) {
-// We run on AIX. We do not support versions older than AIX 5.3.
+// We run on AIX. We do not support versions older than AIX 7.1.
 _on_pase = 0;
 // Determine detailed AIX version: Version, Release, Modification, Fix Level.
 odmWrapper::determine_os_kernel_version(&_os_version);
-if (os_version_short() < 0x0503) {
+if (os_version_short() < 0x0701) {
-trcVerbose("AIX release older than AIX 5.3 not supported.");
+trcVerbose("AIX releases older than AIX 7.1 are not supported.");
 assert(false, "AIX release too old.");
 }
 name_str = "AIX";
 jio_snprintf(ver_str, sizeof(ver_str), "%u.%u.%u.%u",
 major, minor, (_os_version >> 8) & 0xFF, _os_version & 0xFF);
 } else {
-assert(false, name_str);
+assert(false, "%s", name_str);
 }
 trcVerbose("We run on %s %s", name_str, ver_str);
 }
 guarantee(_on_pase != -1 && _os_version, "Could not determine AIX/OS400 release");
 // Run the specified command in a separate process. Return its exit value,
 // or -1 on failure (e.g. can't fork a new process).
 // Unlike system(), this function can be called from signal handler. It
 // doesn't block SIGINT et al.
 int os::fork_and_exec(char* cmd, bool use_vfork_if_available) {
-char * argv[4] = {"sh", "-c", cmd, NULL};
+char* argv[4] = { (char*)"sh", (char*)"-c", cmd, NULL};
 pid_t pid = fork();
 if (pid < 0) {
 // fork failed
 int os::compare_file_modified_times(const char* file1, const char* file2) {
 time_t t1 = get_mtime(file1);
 time_t t2 = get_mtime(file2);
 return t1 - t2;
 }
+bool os::supports_map_sync() {
+return false;
+}

branch	datagramsocketimpl-branch
changeset 58678	9cf78a70fa4f
parent 55044	d3afe760b392
child 58679	9c3209ff7550