os_aix.cpp revision 8473:0d3c3c622f96
1/*
2 * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
3 * Copyright 2012, 2015 SAP AG. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation.
9 *
10 * This code is distributed in the hope that it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
13 * version 2 for more details (a copy is included in the LICENSE file that
14 * accompanied this code).
15 *
16 * You should have received a copy of the GNU General Public License version
17 * 2 along with this work; if not, write to the Free Software Foundation,
18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
19 *
20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
21 * or visit www.oracle.com if you need additional information or have any
22 * questions.
23 *
24 */
25
26// According to the AIX OS doc #pragma alloca must be used
27// with C++ compiler before referencing the function alloca()
28#pragma alloca
29
30// no precompiled headers
31#include "classfile/classLoader.hpp"
32#include "classfile/systemDictionary.hpp"
33#include "classfile/vmSymbols.hpp"
34#include "code/icBuffer.hpp"
35#include "code/vtableStubs.hpp"
36#include "compiler/compileBroker.hpp"
37#include "interpreter/interpreter.hpp"
38#include "jvm_aix.h"
39#include "libperfstat_aix.hpp"
40#include "loadlib_aix.hpp"
41#include "memory/allocation.inline.hpp"
42#include "memory/filemap.hpp"
43#include "mutex_aix.inline.hpp"
44#include "oops/oop.inline.hpp"
45#include "os_aix.inline.hpp"
46#include "os_share_aix.hpp"
47#include "porting_aix.hpp"
48#include "prims/jniFastGetField.hpp"
49#include "prims/jvm.h"
50#include "prims/jvm_misc.hpp"
51#include "runtime/arguments.hpp"
52#include "runtime/atomic.inline.hpp"
53#include "runtime/extendedPC.hpp"
54#include "runtime/globals.hpp"
55#include "runtime/interfaceSupport.hpp"
56#include "runtime/java.hpp"
57#include "runtime/javaCalls.hpp"
58#include "runtime/mutexLocker.hpp"
59#include "runtime/objectMonitor.hpp"
60#include "runtime/orderAccess.inline.hpp"
61#include "runtime/os.hpp"
62#include "runtime/osThread.hpp"
63#include "runtime/perfMemory.hpp"
64#include "runtime/sharedRuntime.hpp"
65#include "runtime/statSampler.hpp"
66#include "runtime/stubRoutines.hpp"
67#include "runtime/thread.inline.hpp"
68#include "runtime/threadCritical.hpp"
69#include "runtime/timer.hpp"
70#include "runtime/vm_version.hpp"
71#include "services/attachListener.hpp"
72#include "services/runtimeService.hpp"
73#include "utilities/decoder.hpp"
74#include "utilities/defaultStream.hpp"
75#include "utilities/events.hpp"
76#include "utilities/growableArray.hpp"
77#include "utilities/vmError.hpp"
78
79// put OS-includes here (sorted alphabetically)
80#include <errno.h>
81#include <fcntl.h>
82#include <inttypes.h>
83#include <poll.h>
84#include <procinfo.h>
85#include <pthread.h>
86#include <pwd.h>
87#include <semaphore.h>
88#include <signal.h>
89#include <stdint.h>
90#include <stdio.h>
91#include <string.h>
92#include <unistd.h>
93#include <sys/ioctl.h>
94#include <sys/ipc.h>
95#include <sys/mman.h>
96#include <sys/resource.h>
97#include <sys/select.h>
98#include <sys/shm.h>
99#include <sys/socket.h>
100#include <sys/stat.h>
101#include <sys/sysinfo.h>
102#include <sys/systemcfg.h>
103#include <sys/time.h>
104#include <sys/times.h>
105#include <sys/types.h>
106#include <sys/utsname.h>
107#include <sys/vminfo.h>
108#include <sys/wait.h>
109
110// If RUSAGE_THREAD for getrusage() has not been defined, do it here. The code calling
111// getrusage() is prepared to handle the associated failure.
112#ifndef RUSAGE_THREAD
113#define RUSAGE_THREAD   (1)               /* only the calling thread */
114#endif
115
116// PPC port
117static const uintx Use64KPagesThreshold       = 1*M;
118static const uintx MaxExpectedDataSegmentSize = SIZE_4G*2;
119
120// Add missing declarations (should be in procinfo.h but isn't until AIX 6.1).
121#if !defined(_AIXVERSION_610)
122extern "C" {
123  int getthrds64(pid_t ProcessIdentifier,
124                 struct thrdentry64* ThreadBuffer,
125                 int ThreadSize,
126                 tid64_t* IndexPointer,
127                 int Count);
128}
129#endif
130
131#define MAX_PATH (2 * K)
132
133// for timer info max values which include all bits
134#define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
135// for multipage initialization error analysis (in 'g_multipage_error')
136#define ERROR_MP_OS_TOO_OLD                          100
137#define ERROR_MP_EXTSHM_ACTIVE                       101
138#define ERROR_MP_VMGETINFO_FAILED                    102
139#define ERROR_MP_VMGETINFO_CLAIMS_NO_SUPPORT_FOR_64K 103
140
141// The semantics in this file are thus that codeptr_t is a *real code ptr*.
142// This means that any function taking codeptr_t as arguments will assume
143// a real codeptr and won't handle function descriptors (eg getFuncName),
144// whereas functions taking address as args will deal with function
145// descriptors (eg os::dll_address_to_library_name).
146typedef unsigned int* codeptr_t;
147
148// Typedefs for stackslots, stack pointers, pointers to op codes.
149typedef unsigned long stackslot_t;
150typedef stackslot_t* stackptr_t;
151
152// Excerpts from systemcfg.h definitions newer than AIX 5.3.
153#ifndef PV_7
154#define PV_7 0x200000          /* Power PC 7 */
155#define PV_7_Compat 0x208000   /* Power PC 7 */
156#endif
157#ifndef PV_8
158#define PV_8 0x300000          /* Power PC 8 */
159#define PV_8_Compat 0x308000   /* Power PC 8 */
160#endif
161
162#define trcVerbose(fmt, ...) { /* PPC port */  \
163  if (Verbose) { \
164    fprintf(stderr, fmt, ##__VA_ARGS__); \
165    fputc('\n', stderr); fflush(stderr); \
166  } \
167}
168#define trc(fmt, ...)        /* PPC port */
169
170#define ERRBYE(s) { \
171    trcVerbose(s); \
172    return -1; \
173}
174
175// Query dimensions of the stack of the calling thread.
176static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size);
177
178// function to check a given stack pointer against given stack limits
179inline bool is_valid_stackpointer(stackptr_t sp, stackptr_t stack_base, size_t stack_size) {
180  if (((uintptr_t)sp) & 0x7) {
181    return false;
182  }
183  if (sp > stack_base) {
184    return false;
185  }
186  if (sp < (stackptr_t) ((address)stack_base - stack_size)) {
187    return false;
188  }
189  return true;
190}
191
192// returns true if function is a valid codepointer
193inline bool is_valid_codepointer(codeptr_t p) {
194  if (!p) {
195    return false;
196  }
197  if (((uintptr_t)p) & 0x3) {
198    return false;
199  }
200  if (LoadedLibraries::find_for_text_address((address)p) == NULL) {
201    return false;
202  }
203  return true;
204}
205
206// Macro to check a given stack pointer against given stack limits and to die if test fails.
207#define CHECK_STACK_PTR(sp, stack_base, stack_size) { \
208    guarantee(is_valid_stackpointer((stackptr_t)(sp), (stackptr_t)(stack_base), stack_size), "Stack Pointer Invalid"); \
209}
210
211// Macro to check the current stack pointer against given stacklimits.
212#define CHECK_CURRENT_STACK_PTR(stack_base, stack_size) { \
213  address sp; \
214  sp = os::current_stack_pointer(); \
215  CHECK_STACK_PTR(sp, stack_base, stack_size); \
216}
217
218////////////////////////////////////////////////////////////////////////////////
219// global variables (for a description see os_aix.hpp)
220
221julong    os::Aix::_physical_memory = 0;
222pthread_t os::Aix::_main_thread = ((pthread_t)0);
223int       os::Aix::_page_size = -1;
224int       os::Aix::_on_pase = -1;
225int       os::Aix::_os_version = -1;
226int       os::Aix::_stack_page_size = -1;
227int       os::Aix::_xpg_sus_mode = -1;
228int       os::Aix::_extshm = -1;
229int       os::Aix::_logical_cpus = -1;
230
231////////////////////////////////////////////////////////////////////////////////
232// local variables
233
234static int      g_multipage_error  = -1;   // error analysis for multipage initialization
235static jlong    initial_time_count = 0;
236static int      clock_tics_per_sec = 100;
237static sigset_t check_signal_done;         // For diagnostics to print a message once (see run_periodic_checks)
238static bool     check_signals      = true;
239static pid_t    _initial_pid       = 0;
240static int      SR_signum          = SIGUSR2; // Signal used to suspend/resume a thread (must be > SIGSEGV, see 4355769)
241static sigset_t SR_sigset;
242
243// This describes the state of multipage support of the underlying
244// OS. Note that this is of no interest to the outsize world and
245// therefore should not be defined in AIX class.
246//
247// AIX supports four different page sizes - 4K, 64K, 16MB, 16GB. The
248// latter two (16M "large" resp. 16G "huge" pages) require special
249// setup and are normally not available.
250//
251// AIX supports multiple page sizes per process, for:
252//  - Stack (of the primordial thread, so not relevant for us)
253//  - Data - data, bss, heap, for us also pthread stacks
254//  - Text - text code
255//  - shared memory
256//
257// Default page sizes can be set via linker options (-bdatapsize, -bstacksize, ...)
258// and via environment variable LDR_CNTRL (DATAPSIZE, STACKPSIZE, ...).
259//
260// For shared memory, page size can be set dynamically via
261// shmctl(). Different shared memory regions can have different page
262// sizes.
263//
264// More information can be found at AIBM info center:
265//   http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/multiple_page_size_app_support.htm
266//
267static struct {
268  size_t pagesize;            // sysconf _SC_PAGESIZE (4K)
269  size_t datapsize;           // default data page size (LDR_CNTRL DATAPSIZE)
270  size_t shmpsize;            // default shared memory page size (LDR_CNTRL SHMPSIZE)
271  size_t pthr_stack_pagesize; // stack page size of pthread threads
272  size_t textpsize;           // default text page size (LDR_CNTRL STACKPSIZE)
273  bool can_use_64K_pages;     // True if we can alloc 64K pages dynamically with Sys V shm.
274  bool can_use_16M_pages;     // True if we can alloc 16M pages dynamically with Sys V shm.
275  int error;                  // Error describing if something went wrong at multipage init.
276} g_multipage_support = {
277  (size_t) -1,
278  (size_t) -1,
279  (size_t) -1,
280  (size_t) -1,
281  (size_t) -1,
282  false, false,
283  0
284};
285
286// We must not accidentally allocate memory close to the BRK - even if
287// that would work - because then we prevent the BRK segment from
288// growing which may result in a malloc OOM even though there is
289// enough memory. The problem only arises if we shmat() or mmap() at
290// a specific wish address, e.g. to place the heap in a
291// compressed-oops-friendly way.
292static bool is_close_to_brk(address a) {
293  address a1 = (address) sbrk(0);
294  if (a >= a1 && a < (a1 + MaxExpectedDataSegmentSize)) {
295    return true;
296  }
297  return false;
298}
299
300julong os::available_memory() {
301  return Aix::available_memory();
302}
303
304julong os::Aix::available_memory() {
305  os::Aix::meminfo_t mi;
306  if (os::Aix::get_meminfo(&mi)) {
307    return mi.real_free;
308  } else {
309    return 0xFFFFFFFFFFFFFFFFLL;
310  }
311}
312
313julong os::physical_memory() {
314  return Aix::physical_memory();
315}
316
317// Return true if user is running as root.
318
319bool os::have_special_privileges() {
320  static bool init = false;
321  static bool privileges = false;
322  if (!init) {
323    privileges = (getuid() != geteuid()) || (getgid() != getegid());
324    init = true;
325  }
326  return privileges;
327}
328
329// Helper function, emulates disclaim64 using multiple 32bit disclaims
330// because we cannot use disclaim64() on AS/400 and old AIX releases.
331static bool my_disclaim64(char* addr, size_t size) {
332
333  if (size == 0) {
334    return true;
335  }
336
337  // Maximum size 32bit disclaim() accepts. (Theoretically 4GB, but I just do not trust that.)
338  const unsigned int maxDisclaimSize = 0x40000000;
339
340  const unsigned int numFullDisclaimsNeeded = (size / maxDisclaimSize);
341  const unsigned int lastDisclaimSize = (size % maxDisclaimSize);
342
343  char* p = addr;
344
345  for (int i = 0; i < numFullDisclaimsNeeded; i ++) {
346    if (::disclaim(p, maxDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
347      trc("Cannot disclaim %p - %p (errno %d)\n", p, p + maxDisclaimSize, errno);
348      return false;
349    }
350    p += maxDisclaimSize;
351  }
352
353  if (lastDisclaimSize > 0) {
354    if (::disclaim(p, lastDisclaimSize, DISCLAIM_ZEROMEM) != 0) {
355      trc("Cannot disclaim %p - %p (errno %d)\n", p, p + lastDisclaimSize, errno);
356      return false;
357    }
358  }
359
360  return true;
361}
362
363// Cpu architecture string
364#if defined(PPC32)
365static char cpu_arch[] = "ppc";
366#elif defined(PPC64)
367static char cpu_arch[] = "ppc64";
368#else
369#error Add appropriate cpu_arch setting
370#endif
371
372
373// Given an address, returns the size of the page backing that address.
374size_t os::Aix::query_pagesize(void* addr) {
375
376  vm_page_info pi;
377  pi.addr = (uint64_t)addr;
378  if (::vmgetinfo(&pi, VM_PAGE_INFO, sizeof(pi)) == 0) {
379    return pi.pagesize;
380  } else {
381    fprintf(stderr, "vmgetinfo failed to retrieve page size for address %p (errno %d).\n", addr, errno);
382    assert(false, "vmgetinfo failed to retrieve page size");
383    return SIZE_4K;
384  }
385
386}
387
388// Returns the kernel thread id of the currently running thread.
389pid_t os::Aix::gettid() {
390  return (pid_t) thread_self();
391}
392
393void os::Aix::initialize_system_info() {
394
395  // Get the number of online(logical) cpus instead of configured.
396  os::_processor_count = sysconf(_SC_NPROCESSORS_ONLN);
397  assert(_processor_count > 0, "_processor_count must be > 0");
398
399  // Retrieve total physical storage.
400  os::Aix::meminfo_t mi;
401  if (!os::Aix::get_meminfo(&mi)) {
402    fprintf(stderr, "os::Aix::get_meminfo failed.\n"); fflush(stderr);
403    assert(false, "os::Aix::get_meminfo failed.");
404  }
405  _physical_memory = (julong) mi.real_total;
406}
407
408// Helper function for tracing page sizes.
409static const char* describe_pagesize(size_t pagesize) {
410  switch (pagesize) {
411    case SIZE_4K : return "4K";
412    case SIZE_64K: return "64K";
413    case SIZE_16M: return "16M";
414    case SIZE_16G: return "16G";
415    case -1:       return "not set";
416    default:
417      assert(false, "surprise");
418      return "??";
419  }
420}
421
422// Probe OS for multipage support.
423// Will fill the global g_multipage_support structure.
424// Must be called before calling os::large_page_init().
425static void query_multipage_support() {
426
427  guarantee(g_multipage_support.pagesize == -1,
428            "do not call twice");
429
430  g_multipage_support.pagesize = ::sysconf(_SC_PAGESIZE);
431
432  // This really would surprise me.
433  assert(g_multipage_support.pagesize == SIZE_4K, "surprise!");
434
435  // Query default data page size (default page size for C-Heap, pthread stacks and .bss).
436  // Default data page size is defined either by linker options (-bdatapsize)
437  // or by environment variable LDR_CNTRL (suboption DATAPSIZE). If none is given,
438  // default should be 4K.
439  {
440    void* p = ::malloc(SIZE_16M);
441    g_multipage_support.datapsize = os::Aix::query_pagesize(p);
442    ::free(p);
443  }
444
445  // Query default shm page size (LDR_CNTRL SHMPSIZE).
446  {
447    const int shmid = ::shmget(IPC_PRIVATE, 1, IPC_CREAT | S_IRUSR | S_IWUSR);
448    guarantee(shmid != -1, "shmget failed");
449    void* p = ::shmat(shmid, NULL, 0);
450    ::shmctl(shmid, IPC_RMID, NULL);
451    guarantee(p != (void*) -1, "shmat failed");
452    g_multipage_support.shmpsize = os::Aix::query_pagesize(p);
453    ::shmdt(p);
454  }
455
456  // Before querying the stack page size, make sure we are not running as primordial
457  // thread (because primordial thread's stack may have different page size than
458  // pthread thread stacks). Running a VM on the primordial thread won't work for a
459  // number of reasons so we may just as well guarantee it here.
460  guarantee0(!os::Aix::is_primordial_thread());
461
462  // Query pthread stack page size.
463  {
464    int dummy = 0;
465    g_multipage_support.pthr_stack_pagesize = os::Aix::query_pagesize(&dummy);
466  }
467
468  // Query default text page size (LDR_CNTRL TEXTPSIZE).
469  /* PPC port: so far unused.
470  {
471    address any_function =
472      (address) resolve_function_descriptor_to_code_pointer((address)describe_pagesize);
473    g_multipage_support.textpsize = os::Aix::query_pagesize(any_function);
474  }
475  */
476
477  // Now probe for support of 64K pages and 16M pages.
478
479  // Before OS/400 V6R1, there is no support for pages other than 4K.
480  if (os::Aix::on_pase_V5R4_or_older()) {
481    Unimplemented();
482    goto query_multipage_support_end;
483  }
484
485  // Now check which page sizes the OS claims it supports, and of those, which actually can be used.
486  {
487    const int MAX_PAGE_SIZES = 4;
488    psize_t sizes[MAX_PAGE_SIZES];
489    const int num_psizes = ::vmgetinfo(sizes, VMINFO_GETPSIZES, MAX_PAGE_SIZES);
490    if (num_psizes == -1) {
491      trc("vmgetinfo(VMINFO_GETPSIZES) failed (errno: %d)\n", errno);
492      trc("disabling multipage support.\n");
493      g_multipage_support.error = ERROR_MP_VMGETINFO_FAILED;
494      goto query_multipage_support_end;
495    }
496    guarantee(num_psizes > 0, "vmgetinfo(.., VMINFO_GETPSIZES, ...) failed.");
497    assert(num_psizes <= MAX_PAGE_SIZES, "Surprise! more than 4 page sizes?");
498    trcVerbose("vmgetinfo(.., VMINFO_GETPSIZES, ...) returns %d supported page sizes: ", num_psizes);
499    for (int i = 0; i < num_psizes; i ++) {
500      trcVerbose(" %s ", describe_pagesize(sizes[i]));
501    }
502
503    // Can we use 64K, 16M pages?
504    for (int i = 0; i < num_psizes; i ++) {
505      const size_t pagesize = sizes[i];
506      if (pagesize != SIZE_64K && pagesize != SIZE_16M) {
507        continue;
508      }
509      bool can_use = false;
510      trcVerbose("Probing support for %s pages...", describe_pagesize(pagesize));
511      const int shmid = ::shmget(IPC_PRIVATE, pagesize,
512        IPC_CREAT | S_IRUSR | S_IWUSR);
513      guarantee0(shmid != -1); // Should always work.
514      // Try to set pagesize.
515      struct shmid_ds shm_buf = { 0 };
516      shm_buf.shm_pagesize = pagesize;
517      if (::shmctl(shmid, SHM_PAGESIZE, &shm_buf) != 0) {
518        const int en = errno;
519        ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
520        // PPC port trcVerbose("shmctl(SHM_PAGESIZE) failed with %s",
521        // PPC port  MiscUtils::describe_errno(en));
522      } else {
523        // Attach and double check pageisze.
524        void* p = ::shmat(shmid, NULL, 0);
525        ::shmctl(shmid, IPC_RMID, NULL); // As early as possible!
526        guarantee0(p != (void*) -1); // Should always work.
527        const size_t real_pagesize = os::Aix::query_pagesize(p);
528        if (real_pagesize != pagesize) {
529          trcVerbose("real page size (0x%llX) differs.", real_pagesize);
530        } else {
531          can_use = true;
532        }
533        ::shmdt(p);
534      }
535      trcVerbose("Can use: %s", (can_use ? "yes" : "no"));
536      if (pagesize == SIZE_64K) {
537        g_multipage_support.can_use_64K_pages = can_use;
538      } else if (pagesize == SIZE_16M) {
539        g_multipage_support.can_use_16M_pages = can_use;
540      }
541    }
542
543  } // end: check which pages can be used for shared memory
544
545query_multipage_support_end:
546
547  trcVerbose("base page size (sysconf _SC_PAGESIZE): %s\n",
548      describe_pagesize(g_multipage_support.pagesize));
549  trcVerbose("Data page size (C-Heap, bss, etc): %s\n",
550      describe_pagesize(g_multipage_support.datapsize));
551  trcVerbose("Text page size: %s\n",
552      describe_pagesize(g_multipage_support.textpsize));
553  trcVerbose("Thread stack page size (pthread): %s\n",
554      describe_pagesize(g_multipage_support.pthr_stack_pagesize));
555  trcVerbose("Default shared memory page size: %s\n",
556      describe_pagesize(g_multipage_support.shmpsize));
557  trcVerbose("Can use 64K pages dynamically with shared meory: %s\n",
558      (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
559  trcVerbose("Can use 16M pages dynamically with shared memory: %s\n",
560      (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
561  trcVerbose("Multipage error details: %d\n",
562      g_multipage_support.error);
563
564  // sanity checks
565  assert0(g_multipage_support.pagesize == SIZE_4K);
566  assert0(g_multipage_support.datapsize == SIZE_4K || g_multipage_support.datapsize == SIZE_64K);
567  // PPC port: so far unused.assert0(g_multipage_support.textpsize == SIZE_4K || g_multipage_support.textpsize == SIZE_64K);
568  assert0(g_multipage_support.pthr_stack_pagesize == g_multipage_support.datapsize);
569  assert0(g_multipage_support.shmpsize == SIZE_4K || g_multipage_support.shmpsize == SIZE_64K);
570
571} // end os::Aix::query_multipage_support()
572
573void os::init_system_properties_values() {
574
575#define DEFAULT_LIBPATH "/usr/lib:/lib"
576#define EXTENSIONS_DIR  "/lib/ext"
577
578  // Buffer that fits several sprintfs.
579  // Note that the space for the trailing null is provided
580  // by the nulls included by the sizeof operator.
581  const size_t bufsize =
582    MAX2((size_t)MAXPATHLEN,  // For dll_dir & friends.
583         (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR)); // extensions dir
584  char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);
585
586  // sysclasspath, java_home, dll_dir
587  {
588    char *pslash;
589    os::jvm_path(buf, bufsize);
590
591    // Found the full path to libjvm.so.
592    // Now cut the path to <java_home>/jre if we can.
593    *(strrchr(buf, '/')) = '\0'; // Get rid of /libjvm.so.
594    pslash = strrchr(buf, '/');
595    if (pslash != NULL) {
596      *pslash = '\0';            // Get rid of /{client|server|hotspot}.
597    }
598    Arguments::set_dll_dir(buf);
599
600    if (pslash != NULL) {
601      pslash = strrchr(buf, '/');
602      if (pslash != NULL) {
603        *pslash = '\0';          // Get rid of /<arch>.
604        pslash = strrchr(buf, '/');
605        if (pslash != NULL) {
606          *pslash = '\0';        // Get rid of /lib.
607        }
608      }
609    }
610    Arguments::set_java_home(buf);
611    set_boot_path('/', ':');
612  }
613
614  // Where to look for native libraries.
615
616  // On Aix we get the user setting of LIBPATH.
617  // Eventually, all the library path setting will be done here.
618  // Get the user setting of LIBPATH.
619  const char *v = ::getenv("LIBPATH");
620  const char *v_colon = ":";
621  if (v == NULL) { v = ""; v_colon = ""; }
622
623  // Concatenate user and invariant part of ld_library_path.
624  // That's +1 for the colon and +1 for the trailing '\0'.
625  char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char, strlen(v) + 1 + sizeof(DEFAULT_LIBPATH) + 1, mtInternal);
626  sprintf(ld_library_path, "%s%s" DEFAULT_LIBPATH, v, v_colon);
627  Arguments::set_library_path(ld_library_path);
628  FREE_C_HEAP_ARRAY(char, ld_library_path);
629
630  // Extensions directories.
631  sprintf(buf, "%s" EXTENSIONS_DIR, Arguments::get_java_home());
632  Arguments::set_ext_dirs(buf);
633
634  FREE_C_HEAP_ARRAY(char, buf);
635
636#undef DEFAULT_LIBPATH
637#undef EXTENSIONS_DIR
638}
639
640////////////////////////////////////////////////////////////////////////////////
641// breakpoint support
642
643void os::breakpoint() {
644  BREAKPOINT;
645}
646
647extern "C" void breakpoint() {
648  // use debugger to set breakpoint here
649}
650
651////////////////////////////////////////////////////////////////////////////////
652// signal support
653
654debug_only(static bool signal_sets_initialized = false);
655static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
656
657bool os::Aix::is_sig_ignored(int sig) {
658  struct sigaction oact;
659  sigaction(sig, (struct sigaction*)NULL, &oact);
660  void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*, oact.sa_sigaction)
661    : CAST_FROM_FN_PTR(void*, oact.sa_handler);
662  if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
663    return true;
664  } else {
665    return false;
666  }
667}
668
669void os::Aix::signal_sets_init() {
670  // Should also have an assertion stating we are still single-threaded.
671  assert(!signal_sets_initialized, "Already initialized");
672  // Fill in signals that are necessarily unblocked for all threads in
673  // the VM. Currently, we unblock the following signals:
674  // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
675  //                         by -Xrs (=ReduceSignalUsage));
676  // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
677  // other threads. The "ReduceSignalUsage" boolean tells us not to alter
678  // the dispositions or masks wrt these signals.
679  // Programs embedding the VM that want to use the above signals for their
680  // own purposes must, at this time, use the "-Xrs" option to prevent
681  // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
682  // (See bug 4345157, and other related bugs).
683  // In reality, though, unblocking these signals is really a nop, since
684  // these signals are not blocked by default.
685  sigemptyset(&unblocked_sigs);
686  sigemptyset(&allowdebug_blocked_sigs);
687  sigaddset(&unblocked_sigs, SIGILL);
688  sigaddset(&unblocked_sigs, SIGSEGV);
689  sigaddset(&unblocked_sigs, SIGBUS);
690  sigaddset(&unblocked_sigs, SIGFPE);
691  sigaddset(&unblocked_sigs, SIGTRAP);
692  sigaddset(&unblocked_sigs, SIGDANGER);
693  sigaddset(&unblocked_sigs, SR_signum);
694
695  if (!ReduceSignalUsage) {
696   if (!os::Aix::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
697     sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
698     sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
699   }
700   if (!os::Aix::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
701     sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
702     sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
703   }
704   if (!os::Aix::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
705     sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
706     sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
707   }
708  }
709  // Fill in signals that are blocked by all but the VM thread.
710  sigemptyset(&vm_sigs);
711  if (!ReduceSignalUsage)
712    sigaddset(&vm_sigs, BREAK_SIGNAL);
713  debug_only(signal_sets_initialized = true);
714}
715
716// These are signals that are unblocked while a thread is running Java.
717// (For some reason, they get blocked by default.)
718sigset_t* os::Aix::unblocked_signals() {
719  assert(signal_sets_initialized, "Not initialized");
720  return &unblocked_sigs;
721}
722
723// These are the signals that are blocked while a (non-VM) thread is
724// running Java. Only the VM thread handles these signals.
725sigset_t* os::Aix::vm_signals() {
726  assert(signal_sets_initialized, "Not initialized");
727  return &vm_sigs;
728}
729
730// These are signals that are blocked during cond_wait to allow debugger in
731sigset_t* os::Aix::allowdebug_blocked_signals() {
732  assert(signal_sets_initialized, "Not initialized");
733  return &allowdebug_blocked_sigs;
734}
735
736void os::Aix::hotspot_sigmask(Thread* thread) {
737
738  //Save caller's signal mask before setting VM signal mask
739  sigset_t caller_sigmask;
740  pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);
741
742  OSThread* osthread = thread->osthread();
743  osthread->set_caller_sigmask(caller_sigmask);
744
745  pthread_sigmask(SIG_UNBLOCK, os::Aix::unblocked_signals(), NULL);
746
747  if (!ReduceSignalUsage) {
748    if (thread->is_VM_thread()) {
749      // Only the VM thread handles BREAK_SIGNAL ...
750      pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);
751    } else {
752      // ... all other threads block BREAK_SIGNAL
753      pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);
754    }
755  }
756}
757
758// retrieve memory information.
759// Returns false if something went wrong;
760// content of pmi undefined in this case.
761bool os::Aix::get_meminfo(meminfo_t* pmi) {
762
763  assert(pmi, "get_meminfo: invalid parameter");
764
765  memset(pmi, 0, sizeof(meminfo_t));
766
767  if (os::Aix::on_pase()) {
768
769    Unimplemented();
770    return false;
771
772  } else {
773
774    // On AIX, I use the (dynamically loaded) perfstat library to retrieve memory statistics
775    // See:
776    // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
777    //        ?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_memtot.htm
778    // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
779    //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
780
781    perfstat_memory_total_t psmt;
782    memset (&psmt, '\0', sizeof(psmt));
783    const int rc = libperfstat::perfstat_memory_total(NULL, &psmt, sizeof(psmt), 1);
784    if (rc == -1) {
785      fprintf(stderr, "perfstat_memory_total() failed (errno=%d)\n", errno);
786      assert(0, "perfstat_memory_total() failed");
787      return false;
788    }
789
790    assert(rc == 1, "perfstat_memory_total() - weird return code");
791
792    // excerpt from
793    // http://publib.boulder.ibm.com/infocenter/systems/index.jsp
794    //        ?topic=/com.ibm.aix.files/doc/aixfiles/libperfstat.h.htm
795    // The fields of perfstat_memory_total_t:
796    // u_longlong_t virt_total         Total virtual memory (in 4 KB pages).
797    // u_longlong_t real_total         Total real memory (in 4 KB pages).
798    // u_longlong_t real_free          Free real memory (in 4 KB pages).
799    // u_longlong_t pgsp_total         Total paging space (in 4 KB pages).
800    // u_longlong_t pgsp_free          Free paging space (in 4 KB pages).
801
802    pmi->virt_total = psmt.virt_total * 4096;
803    pmi->real_total = psmt.real_total * 4096;
804    pmi->real_free = psmt.real_free * 4096;
805    pmi->pgsp_total = psmt.pgsp_total * 4096;
806    pmi->pgsp_free = psmt.pgsp_free * 4096;
807
808    return true;
809
810  }
811} // end os::Aix::get_meminfo
812
813// Retrieve global cpu information.
814// Returns false if something went wrong;
815// the content of pci is undefined in this case.
816bool os::Aix::get_cpuinfo(cpuinfo_t* pci) {
817  assert(pci, "get_cpuinfo: invalid parameter");
818  memset(pci, 0, sizeof(cpuinfo_t));
819
820  perfstat_cpu_total_t psct;
821  memset (&psct, '\0', sizeof(psct));
822
823  if (-1 == libperfstat::perfstat_cpu_total(NULL, &psct, sizeof(perfstat_cpu_total_t), 1)) {
824    fprintf(stderr, "perfstat_cpu_total() failed (errno=%d)\n", errno);
825    assert(0, "perfstat_cpu_total() failed");
826    return false;
827  }
828
829  // global cpu information
830  strcpy (pci->description, psct.description);
831  pci->processorHZ = psct.processorHZ;
832  pci->ncpus = psct.ncpus;
833  os::Aix::_logical_cpus = psct.ncpus;
834  for (int i = 0; i < 3; i++) {
835    pci->loadavg[i] = (double) psct.loadavg[i] / (1 << SBITS);
836  }
837
838  // get the processor version from _system_configuration
839  switch (_system_configuration.version) {
840  case PV_8:
841    strcpy(pci->version, "Power PC 8");
842    break;
843  case PV_7:
844    strcpy(pci->version, "Power PC 7");
845    break;
846  case PV_6_1:
847    strcpy(pci->version, "Power PC 6 DD1.x");
848    break;
849  case PV_6:
850    strcpy(pci->version, "Power PC 6");
851    break;
852  case PV_5:
853    strcpy(pci->version, "Power PC 5");
854    break;
855  case PV_5_2:
856    strcpy(pci->version, "Power PC 5_2");
857    break;
858  case PV_5_3:
859    strcpy(pci->version, "Power PC 5_3");
860    break;
861  case PV_5_Compat:
862    strcpy(pci->version, "PV_5_Compat");
863    break;
864  case PV_6_Compat:
865    strcpy(pci->version, "PV_6_Compat");
866    break;
867  case PV_7_Compat:
868    strcpy(pci->version, "PV_7_Compat");
869    break;
870  case PV_8_Compat:
871    strcpy(pci->version, "PV_8_Compat");
872    break;
873  default:
874    strcpy(pci->version, "unknown");
875  }
876
877  return true;
878
879} //end os::Aix::get_cpuinfo
880
881//////////////////////////////////////////////////////////////////////////////
882// detecting pthread library
883
884void os::Aix::libpthread_init() {
885  return;
886}
887
888//////////////////////////////////////////////////////////////////////////////
889// create new thread
890
891// Thread start routine for all newly created threads
892static void *java_start(Thread *thread) {
893
894  // find out my own stack dimensions
895  {
896    // actually, this should do exactly the same as thread->record_stack_base_and_size...
897    address base = 0;
898    size_t size = 0;
899    query_stack_dimensions(&base, &size);
900    thread->set_stack_base(base);
901    thread->set_stack_size(size);
902  }
903
904  // Do some sanity checks.
905  CHECK_CURRENT_STACK_PTR(thread->stack_base(), thread->stack_size());
906
907  // Try to randomize the cache line index of hot stack frames.
908  // This helps when threads of the same stack traces evict each other's
909  // cache lines. The threads can be either from the same JVM instance, or
910  // from different JVM instances. The benefit is especially true for
911  // processors with hyperthreading technology.
912
913  static int counter = 0;
914  int pid = os::current_process_id();
915  alloca(((pid ^ counter++) & 7) * 128);
916
917  ThreadLocalStorage::set_thread(thread);
918
919  OSThread* osthread = thread->osthread();
920
921  // thread_id is kernel thread id (similar to Solaris LWP id)
922  osthread->set_thread_id(os::Aix::gettid());
923
924  // initialize signal mask for this thread
925  os::Aix::hotspot_sigmask(thread);
926
927  // initialize floating point control register
928  os::Aix::init_thread_fpu_state();
929
930  assert(osthread->get_state() == RUNNABLE, "invalid os thread state");
931
932  // call one more level start routine
933  thread->run();
934
935  return 0;
936}
937
938bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
939
940  // We want the whole function to be synchronized.
941  ThreadCritical cs;
942
943  assert(thread->osthread() == NULL, "caller responsible");
944
945  // Allocate the OSThread object
946  OSThread* osthread = new OSThread(NULL, NULL);
947  if (osthread == NULL) {
948    return false;
949  }
950
951  // set the correct thread state
952  osthread->set_thread_type(thr_type);
953
954  // Initial state is ALLOCATED but not INITIALIZED
955  osthread->set_state(ALLOCATED);
956
957  thread->set_osthread(osthread);
958
959  // init thread attributes
960  pthread_attr_t attr;
961  pthread_attr_init(&attr);
962  guarantee(pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0, "???");
963
964  // Make sure we run in 1:1 kernel-user-thread mode.
965  if (os::Aix::on_aix()) {
966    guarantee(pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM) == 0, "???");
967    guarantee(pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) == 0, "???");
968  } // end: aix
969
970  // Start in suspended state, and in os::thread_start, wake the thread up.
971  guarantee(pthread_attr_setsuspendstate_np(&attr, PTHREAD_CREATE_SUSPENDED_NP) == 0, "???");
972
973  // calculate stack size if it's not specified by caller
974  if (os::Aix::supports_variable_stack_size()) {
975    if (stack_size == 0) {
976      stack_size = os::Aix::default_stack_size(thr_type);
977
978      switch (thr_type) {
979      case os::java_thread:
980        // Java threads use ThreadStackSize whose default value can be changed with the flag -Xss.
981        assert(JavaThread::stack_size_at_create() > 0, "this should be set");
982        stack_size = JavaThread::stack_size_at_create();
983        break;
984      case os::compiler_thread:
985        if (CompilerThreadStackSize > 0) {
986          stack_size = (size_t)(CompilerThreadStackSize * K);
987          break;
988        } // else fall through:
989          // use VMThreadStackSize if CompilerThreadStackSize is not defined
990      case os::vm_thread:
991      case os::pgc_thread:
992      case os::cgc_thread:
993      case os::watcher_thread:
994        if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
995        break;
996      }
997    }
998
999    stack_size = MAX2(stack_size, os::Aix::min_stack_allowed);
1000    pthread_attr_setstacksize(&attr, stack_size);
1001  } //else let thread_create() pick the default value (96 K on AIX)
1002
1003  pthread_t tid;
1004  int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);
1005
1006  pthread_attr_destroy(&attr);
1007
1008  if (ret == 0) {
1009    // PPC port traceOsMisc(("Created New Thread : pthread-id %u", tid));
1010  } else {
1011    if (PrintMiscellaneous && (Verbose || WizardMode)) {
1012      perror("pthread_create()");
1013    }
1014    // Need to clean up stuff we've allocated so far
1015    thread->set_osthread(NULL);
1016    delete osthread;
1017    return false;
1018  }
1019
1020  // Store pthread info into the OSThread
1021  osthread->set_pthread_id(tid);
1022
1023  return true;
1024}
1025
1026/////////////////////////////////////////////////////////////////////////////
1027// attach existing thread
1028
1029// bootstrap the main thread
1030bool os::create_main_thread(JavaThread* thread) {
1031  assert(os::Aix::_main_thread == pthread_self(), "should be called inside main thread");
1032  return create_attached_thread(thread);
1033}
1034
1035bool os::create_attached_thread(JavaThread* thread) {
1036#ifdef ASSERT
1037    thread->verify_not_published();
1038#endif
1039
1040  // Allocate the OSThread object
1041  OSThread* osthread = new OSThread(NULL, NULL);
1042
1043  if (osthread == NULL) {
1044    return false;
1045  }
1046
1047  // Store pthread info into the OSThread
1048  osthread->set_thread_id(os::Aix::gettid());
1049  osthread->set_pthread_id(::pthread_self());
1050
1051  // initialize floating point control register
1052  os::Aix::init_thread_fpu_state();
1053
1054  // some sanity checks
1055  CHECK_CURRENT_STACK_PTR(thread->stack_base(), thread->stack_size());
1056
1057  // Initial thread state is RUNNABLE
1058  osthread->set_state(RUNNABLE);
1059
1060  thread->set_osthread(osthread);
1061
1062  if (UseNUMA) {
1063    int lgrp_id = os::numa_get_group_id();
1064    if (lgrp_id != -1) {
1065      thread->set_lgrp_id(lgrp_id);
1066    }
1067  }
1068
1069  // initialize signal mask for this thread
1070  // and save the caller's signal mask
1071  os::Aix::hotspot_sigmask(thread);
1072
1073  return true;
1074}
1075
1076void os::pd_start_thread(Thread* thread) {
1077  int status = pthread_continue_np(thread->osthread()->pthread_id());
1078  assert(status == 0, "thr_continue failed");
1079}
1080
1081// Free OS resources related to the OSThread
1082void os::free_thread(OSThread* osthread) {
1083  assert(osthread != NULL, "osthread not set");
1084
1085  if (Thread::current()->osthread() == osthread) {
1086    // Restore caller's signal mask
1087    sigset_t sigmask = osthread->caller_sigmask();
1088    pthread_sigmask(SIG_SETMASK, &sigmask, NULL);
1089   }
1090
1091  delete osthread;
1092}
1093
1094//////////////////////////////////////////////////////////////////////////////
1095// thread local storage
1096
1097int os::allocate_thread_local_storage() {
1098  pthread_key_t key;
1099  int rslt = pthread_key_create(&key, NULL);
1100  assert(rslt == 0, "cannot allocate thread local storage");
1101  return (int)key;
1102}
1103
1104// Note: This is currently not used by VM, as we don't destroy TLS key
1105// on VM exit.
1106void os::free_thread_local_storage(int index) {
1107  int rslt = pthread_key_delete((pthread_key_t)index);
1108  assert(rslt == 0, "invalid index");
1109}
1110
1111void os::thread_local_storage_at_put(int index, void* value) {
1112  int rslt = pthread_setspecific((pthread_key_t)index, value);
1113  assert(rslt == 0, "pthread_setspecific failed");
1114}
1115
1116extern "C" Thread* get_thread() {
1117  return ThreadLocalStorage::thread();
1118}
1119
1120////////////////////////////////////////////////////////////////////////////////
1121// time support
1122
1123// Time since start-up in seconds to a fine granularity.
1124// Used by VMSelfDestructTimer and the MemProfiler.
1125double os::elapsedTime() {
1126  return (double)(os::elapsed_counter()) * 0.000001;
1127}
1128
1129jlong os::elapsed_counter() {
1130  timeval time;
1131  int status = gettimeofday(&time, NULL);
1132  return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;
1133}
1134
1135jlong os::elapsed_frequency() {
1136  return (1000 * 1000);
1137}
1138
1139bool os::supports_vtime() { return true; }
1140bool os::enable_vtime()   { return false; }
1141bool os::vtime_enabled()  { return false; }
1142
1143double os::elapsedVTime() {
1144  struct rusage usage;
1145  int retval = getrusage(RUSAGE_THREAD, &usage);
1146  if (retval == 0) {
1147    return usage.ru_utime.tv_sec + usage.ru_stime.tv_sec + (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec) / (1000.0 * 1000);
1148  } else {
1149    // better than nothing, but not much
1150    return elapsedTime();
1151  }
1152}
1153
1154jlong os::javaTimeMillis() {
1155  timeval time;
1156  int status = gettimeofday(&time, NULL);
1157  assert(status != -1, "aix error at gettimeofday()");
1158  return jlong(time.tv_sec) * 1000 + jlong(time.tv_usec / 1000);
1159}
1160
1161void os::javaTimeSystemUTC(jlong &seconds, jlong &nanos) {
1162  timeval time;
1163  int status = gettimeofday(&time, NULL);
1164  assert(status != -1, "aix error at gettimeofday()");
1165  seconds = jlong(time.tv_sec);
1166  nanos = jlong(time.tv_usec) * 1000;
1167}
1168
1169
1170// We need to manually declare mread_real_time,
1171// because IBM didn't provide a prototype in time.h.
1172// (they probably only ever tested in C, not C++)
1173extern "C"
1174int mread_real_time(timebasestruct_t *t, size_t size_of_timebasestruct_t);
1175
1176jlong os::javaTimeNanos() {
1177  if (os::Aix::on_pase()) {
1178    Unimplemented();
1179    return 0;
1180  } else {
1181    // On AIX use the precision of processors real time clock
1182    // or time base registers.
1183    timebasestruct_t time;
1184    int rc;
1185
1186    // If the CPU has a time register, it will be used and
1187    // we have to convert to real time first. After convertion we have following data:
1188    // time.tb_high [seconds since 00:00:00 UTC on 1.1.1970]
1189    // time.tb_low  [nanoseconds after the last full second above]
1190    // We better use mread_real_time here instead of read_real_time
1191    // to ensure that we will get a monotonic increasing time.
1192    if (mread_real_time(&time, TIMEBASE_SZ) != RTC_POWER) {
1193      rc = time_base_to_time(&time, TIMEBASE_SZ);
1194      assert(rc != -1, "aix error at time_base_to_time()");
1195    }
1196    return jlong(time.tb_high) * (1000 * 1000 * 1000) + jlong(time.tb_low);
1197  }
1198}
1199
1200void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1201  info_ptr->max_value = ALL_64_BITS;
1202  // mread_real_time() is monotonic (see 'os::javaTimeNanos()')
1203  info_ptr->may_skip_backward = false;
1204  info_ptr->may_skip_forward = false;
1205  info_ptr->kind = JVMTI_TIMER_ELAPSED;    // elapsed not CPU time
1206}
1207
1208// Return the real, user, and system times in seconds from an
1209// arbitrary fixed point in the past.
1210bool os::getTimesSecs(double* process_real_time,
1211                      double* process_user_time,
1212                      double* process_system_time) {
1213  struct tms ticks;
1214  clock_t real_ticks = times(&ticks);
1215
1216  if (real_ticks == (clock_t) (-1)) {
1217    return false;
1218  } else {
1219    double ticks_per_second = (double) clock_tics_per_sec;
1220    *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
1221    *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
1222    *process_real_time = ((double) real_ticks) / ticks_per_second;
1223
1224    return true;
1225  }
1226}
1227
1228char * os::local_time_string(char *buf, size_t buflen) {
1229  struct tm t;
1230  time_t long_time;
1231  time(&long_time);
1232  localtime_r(&long_time, &t);
1233  jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
1234               t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
1235               t.tm_hour, t.tm_min, t.tm_sec);
1236  return buf;
1237}
1238
1239struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
1240  return localtime_r(clock, res);
1241}
1242
1243////////////////////////////////////////////////////////////////////////////////
1244// runtime exit support
1245
1246// Note: os::shutdown() might be called very early during initialization, or
1247// called from signal handler. Before adding something to os::shutdown(), make
1248// sure it is async-safe and can handle partially initialized VM.
1249void os::shutdown() {
1250
1251  // allow PerfMemory to attempt cleanup of any persistent resources
1252  perfMemory_exit();
1253
1254  // needs to remove object in file system
1255  AttachListener::abort();
1256
1257  // flush buffered output, finish log files
1258  ostream_abort();
1259
1260  // Check for abort hook
1261  abort_hook_t abort_hook = Arguments::abort_hook();
1262  if (abort_hook != NULL) {
1263    abort_hook();
1264  }
1265}
1266
1267// Note: os::abort() might be called very early during initialization, or
1268// called from signal handler. Before adding something to os::abort(), make
1269// sure it is async-safe and can handle partially initialized VM.
1270void os::abort(bool dump_core, void* siginfo, void* context) {
1271  os::shutdown();
1272  if (dump_core) {
1273#ifndef PRODUCT
1274    fdStream out(defaultStream::output_fd());
1275    out.print_raw("Current thread is ");
1276    char buf[16];
1277    jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1278    out.print_raw_cr(buf);
1279    out.print_raw_cr("Dumping core ...");
1280#endif
1281    ::abort(); // dump core
1282  }
1283
1284  ::exit(1);
1285}
1286
1287// Die immediately, no exit hook, no abort hook, no cleanup.
1288void os::die() {
1289  ::abort();
1290}
1291
1292// This method is a copy of JDK's sysGetLastErrorString
1293// from src/solaris/hpi/src/system_md.c
1294
1295size_t os::lasterror(char *buf, size_t len) {
1296  if (errno == 0) return 0;
1297
1298  const char *s = ::strerror(errno);
1299  size_t n = ::strlen(s);
1300  if (n >= len) {
1301    n = len - 1;
1302  }
1303  ::strncpy(buf, s, n);
1304  buf[n] = '\0';
1305  return n;
1306}
1307
1308intx os::current_thread_id() { return (intx)pthread_self(); }
1309
1310int os::current_process_id() {
1311
1312  // This implementation returns a unique pid, the pid of the
1313  // launcher thread that starts the vm 'process'.
1314
1315  // Under POSIX, getpid() returns the same pid as the
1316  // launcher thread rather than a unique pid per thread.
1317  // Use gettid() if you want the old pre NPTL behaviour.
1318
1319  // if you are looking for the result of a call to getpid() that
1320  // returns a unique pid for the calling thread, then look at the
1321  // OSThread::thread_id() method in osThread_linux.hpp file
1322
1323  return (int)(_initial_pid ? _initial_pid : getpid());
1324}
1325
1326// DLL functions
1327
1328const char* os::dll_file_extension() { return ".so"; }
1329
1330// This must be hard coded because it's the system's temporary
1331// directory not the java application's temp directory, ala java.io.tmpdir.
1332const char* os::get_temp_directory() { return "/tmp"; }
1333
1334static bool file_exists(const char* filename) {
1335  struct stat statbuf;
1336  if (filename == NULL || strlen(filename) == 0) {
1337    return false;
1338  }
1339  return os::stat(filename, &statbuf) == 0;
1340}
1341
1342bool os::dll_build_name(char* buffer, size_t buflen,
1343                        const char* pname, const char* fname) {
1344  bool retval = false;
1345  // Copied from libhpi
1346  const size_t pnamelen = pname ? strlen(pname) : 0;
1347
1348  // Return error on buffer overflow.
1349  if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
1350    *buffer = '\0';
1351    return retval;
1352  }
1353
1354  if (pnamelen == 0) {
1355    snprintf(buffer, buflen, "lib%s.so", fname);
1356    retval = true;
1357  } else if (strchr(pname, *os::path_separator()) != NULL) {
1358    int n;
1359    char** pelements = split_path(pname, &n);
1360    for (int i = 0; i < n; i++) {
1361      // Really shouldn't be NULL, but check can't hurt
1362      if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
1363        continue; // skip the empty path values
1364      }
1365      snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);
1366      if (file_exists(buffer)) {
1367        retval = true;
1368        break;
1369      }
1370    }
1371    // release the storage
1372    for (int i = 0; i < n; i++) {
1373      if (pelements[i] != NULL) {
1374        FREE_C_HEAP_ARRAY(char, pelements[i]);
1375      }
1376    }
1377    if (pelements != NULL) {
1378      FREE_C_HEAP_ARRAY(char*, pelements);
1379    }
1380  } else {
1381    snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
1382    retval = true;
1383  }
1384  return retval;
1385}
1386
1387// Check if addr is inside libjvm.so.
1388bool os::address_is_in_vm(address addr) {
1389
1390  // Input could be a real pc or a function pointer literal. The latter
1391  // would be a function descriptor residing in the data segment of a module.
1392
1393  const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(addr);
1394  if (lib) {
1395    if (strcmp(lib->get_shortname(), "libjvm.so") == 0) {
1396      return true;
1397    } else {
1398      return false;
1399    }
1400  } else {
1401    lib = LoadedLibraries::find_for_data_address(addr);
1402    if (lib) {
1403      if (strcmp(lib->get_shortname(), "libjvm.so") == 0) {
1404        return true;
1405      } else {
1406        return false;
1407      }
1408    } else {
1409      return false;
1410    }
1411  }
1412}
1413
1414// Resolve an AIX function descriptor literal to a code pointer.
1415// If the input is a valid code pointer to a text segment of a loaded module,
1416//   it is returned unchanged.
1417// If the input is a valid AIX function descriptor, it is resolved to the
1418//   code entry point.
1419// If the input is neither a valid function descriptor nor a valid code pointer,
1420//   NULL is returned.
1421static address resolve_function_descriptor_to_code_pointer(address p) {
1422
1423  const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(p);
1424  if (lib) {
1425    // its a real code pointer
1426    return p;
1427  } else {
1428    lib = LoadedLibraries::find_for_data_address(p);
1429    if (lib) {
1430      // pointer to data segment, potential function descriptor
1431      address code_entry = (address)(((FunctionDescriptor*)p)->entry());
1432      if (LoadedLibraries::find_for_text_address(code_entry)) {
1433        // Its a function descriptor
1434        return code_entry;
1435      }
1436    }
1437  }
1438  return NULL;
1439}
1440
1441bool os::dll_address_to_function_name(address addr, char *buf,
1442                                      int buflen, int *offset) {
1443  if (offset) {
1444    *offset = -1;
1445  }
1446  // Buf is not optional, but offset is optional.
1447  assert(buf != NULL, "sanity check");
1448  buf[0] = '\0';
1449
1450  // Resolve function ptr literals first.
1451  addr = resolve_function_descriptor_to_code_pointer(addr);
1452  if (!addr) {
1453    return false;
1454  }
1455
1456  // Go through Decoder::decode to call getFuncName which reads the name from the traceback table.
1457  return Decoder::decode(addr, buf, buflen, offset);
1458}
1459
1460static int getModuleName(codeptr_t pc,                    // [in] program counter
1461                         char* p_name, size_t namelen,    // [out] optional: function name
1462                         char* p_errmsg, size_t errmsglen // [out] optional: user provided buffer for error messages
1463                         ) {
1464
1465  // initialize output parameters
1466  if (p_name && namelen > 0) {
1467    *p_name = '\0';
1468  }
1469  if (p_errmsg && errmsglen > 0) {
1470    *p_errmsg = '\0';
1471  }
1472
1473  const LoadedLibraryModule* const lib = LoadedLibraries::find_for_text_address((address)pc);
1474  if (lib) {
1475    if (p_name && namelen > 0) {
1476      sprintf(p_name, "%.*s", namelen, lib->get_shortname());
1477    }
1478    return 0;
1479  }
1480
1481  trcVerbose("pc outside any module");
1482
1483  return -1;
1484}
1485
1486bool os::dll_address_to_library_name(address addr, char* buf,
1487                                     int buflen, int* offset) {
1488  if (offset) {
1489    *offset = -1;
1490  }
1491  // Buf is not optional, but offset is optional.
1492  assert(buf != NULL, "sanity check");
1493  buf[0] = '\0';
1494
1495  // Resolve function ptr literals first.
1496  addr = resolve_function_descriptor_to_code_pointer(addr);
1497  if (!addr) {
1498    return false;
1499  }
1500
1501  if (::getModuleName((codeptr_t) addr, buf, buflen, 0, 0) == 0) {
1502    return true;
1503  }
1504  return false;
1505}
1506
1507// Loads .dll/.so and in case of error it checks if .dll/.so was built
1508// for the same architecture as Hotspot is running on.
1509void *os::dll_load(const char *filename, char *ebuf, int ebuflen) {
1510
1511  if (ebuf && ebuflen > 0) {
1512    ebuf[0] = '\0';
1513    ebuf[ebuflen - 1] = '\0';
1514  }
1515
1516  if (!filename || strlen(filename) == 0) {
1517    ::strncpy(ebuf, "dll_load: empty filename specified", ebuflen - 1);
1518    return NULL;
1519  }
1520
1521  // RTLD_LAZY is currently not implemented. The dl is loaded immediately with all its dependants.
1522  void * result= ::dlopen(filename, RTLD_LAZY);
1523  if (result != NULL) {
1524    // Reload dll cache. Don't do this in signal handling.
1525    LoadedLibraries::reload();
1526    return result;
1527  } else {
1528    // error analysis when dlopen fails
1529    const char* const error_report = ::dlerror();
1530    if (error_report && ebuf && ebuflen > 0) {
1531      snprintf(ebuf, ebuflen - 1, "%s, LIBPATH=%s, LD_LIBRARY_PATH=%s : %s",
1532               filename, ::getenv("LIBPATH"), ::getenv("LD_LIBRARY_PATH"), error_report);
1533    }
1534  }
1535  return NULL;
1536}
1537
1538void* os::dll_lookup(void* handle, const char* name) {
1539  void* res = dlsym(handle, name);
1540  return res;
1541}
1542
1543void* os::get_default_process_handle() {
1544  return (void*)::dlopen(NULL, RTLD_LAZY);
1545}
1546
1547void os::print_dll_info(outputStream *st) {
1548  st->print_cr("Dynamic libraries:");
1549  LoadedLibraries::print(st);
1550}
1551
1552void os::print_os_info(outputStream* st) {
1553  st->print("OS:");
1554
1555  st->print("uname:");
1556  struct utsname name;
1557  uname(&name);
1558  st->print(name.sysname); st->print(" ");
1559  st->print(name.nodename); st->print(" ");
1560  st->print(name.release); st->print(" ");
1561  st->print(name.version); st->print(" ");
1562  st->print(name.machine);
1563  st->cr();
1564
1565  // rlimit
1566  st->print("rlimit:");
1567  struct rlimit rlim;
1568
1569  st->print(" STACK ");
1570  getrlimit(RLIMIT_STACK, &rlim);
1571  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1572  else st->print("%uk", rlim.rlim_cur >> 10);
1573
1574  st->print(", CORE ");
1575  getrlimit(RLIMIT_CORE, &rlim);
1576  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1577  else st->print("%uk", rlim.rlim_cur >> 10);
1578
1579  st->print(", NPROC ");
1580  st->print("%d", sysconf(_SC_CHILD_MAX));
1581
1582  st->print(", NOFILE ");
1583  getrlimit(RLIMIT_NOFILE, &rlim);
1584  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1585  else st->print("%d", rlim.rlim_cur);
1586
1587  st->print(", AS ");
1588  getrlimit(RLIMIT_AS, &rlim);
1589  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1590  else st->print("%uk", rlim.rlim_cur >> 10);
1591
1592  // Print limits on DATA, because it limits the C-heap.
1593  st->print(", DATA ");
1594  getrlimit(RLIMIT_DATA, &rlim);
1595  if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
1596  else st->print("%uk", rlim.rlim_cur >> 10);
1597  st->cr();
1598
1599  // load average
1600  st->print("load average:");
1601  double loadavg[3] = {-1.L, -1.L, -1.L};
1602  os::loadavg(loadavg, 3);
1603  st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
1604  st->cr();
1605}
1606
1607void os::print_memory_info(outputStream* st) {
1608
1609  st->print_cr("Memory:");
1610
1611  st->print_cr("  default page size: %s", describe_pagesize(os::vm_page_size()));
1612  st->print_cr("  default stack page size: %s", describe_pagesize(os::vm_page_size()));
1613  st->print_cr("  Default shared memory page size:        %s",
1614    describe_pagesize(g_multipage_support.shmpsize));
1615  st->print_cr("  Can use 64K pages dynamically with shared meory:  %s",
1616    (g_multipage_support.can_use_64K_pages ? "yes" :"no"));
1617  st->print_cr("  Can use 16M pages dynamically with shared memory: %s",
1618    (g_multipage_support.can_use_16M_pages ? "yes" :"no"));
1619  if (g_multipage_error != 0) {
1620    st->print_cr("  multipage error: %d", g_multipage_error);
1621  }
1622
1623  // print out LDR_CNTRL because it affects the default page sizes
1624  const char* const ldr_cntrl = ::getenv("LDR_CNTRL");
1625  st->print_cr("  LDR_CNTRL=%s.", ldr_cntrl ? ldr_cntrl : "<unset>");
1626
1627  const char* const extshm = ::getenv("EXTSHM");
1628  st->print_cr("  EXTSHM=%s.", extshm ? extshm : "<unset>");
1629  if ( (strcmp(extshm, "on") == 0) || (strcmp(extshm, "ON") == 0) ) {
1630    st->print_cr("  *** Unsupported! Please remove EXTSHM from your environment! ***");
1631  }
1632
1633  // Call os::Aix::get_meminfo() to retrieve memory statistics.
1634  os::Aix::meminfo_t mi;
1635  if (os::Aix::get_meminfo(&mi)) {
1636    char buffer[256];
1637    if (os::Aix::on_aix()) {
1638      jio_snprintf(buffer, sizeof(buffer),
1639                   "  physical total : %llu\n"
1640                   "  physical free  : %llu\n"
1641                   "  swap total     : %llu\n"
1642                   "  swap free      : %llu\n",
1643                   mi.real_total,
1644                   mi.real_free,
1645                   mi.pgsp_total,
1646                   mi.pgsp_free);
1647    } else {
1648      Unimplemented();
1649    }
1650    st->print_raw(buffer);
1651  } else {
1652    st->print_cr("  (no more information available)");
1653  }
1654}
1655
1656void os::pd_print_cpu_info(outputStream* st) {
1657  // cpu
1658  st->print("CPU:");
1659  st->print("total %d", os::processor_count());
1660  // It's not safe to query number of active processors after crash
1661  // st->print("(active %d)", os::active_processor_count());
1662  st->print(" %s", VM_Version::cpu_features());
1663  st->cr();
1664}
1665
1666void os::print_siginfo(outputStream* st, void* siginfo) {
1667  // Use common posix version.
1668  os::Posix::print_siginfo_brief(st, (const siginfo_t*) siginfo);
1669  st->cr();
1670}
1671
1672static void print_signal_handler(outputStream* st, int sig,
1673                                 char* buf, size_t buflen);
1674
1675void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
1676  st->print_cr("Signal Handlers:");
1677  print_signal_handler(st, SIGSEGV, buf, buflen);
1678  print_signal_handler(st, SIGBUS , buf, buflen);
1679  print_signal_handler(st, SIGFPE , buf, buflen);
1680  print_signal_handler(st, SIGPIPE, buf, buflen);
1681  print_signal_handler(st, SIGXFSZ, buf, buflen);
1682  print_signal_handler(st, SIGILL , buf, buflen);
1683  print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
1684  print_signal_handler(st, SR_signum, buf, buflen);
1685  print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);
1686  print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
1687  print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);
1688  print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
1689  print_signal_handler(st, SIGTRAP, buf, buflen);
1690  print_signal_handler(st, SIGDANGER, buf, buflen);
1691}
1692
1693static char saved_jvm_path[MAXPATHLEN] = {0};
1694
1695// Find the full path to the current module, libjvm.so.
1696void os::jvm_path(char *buf, jint buflen) {
1697  // Error checking.
1698  if (buflen < MAXPATHLEN) {
1699    assert(false, "must use a large-enough buffer");
1700    buf[0] = '\0';
1701    return;
1702  }
1703  // Lazy resolve the path to current module.
1704  if (saved_jvm_path[0] != 0) {
1705    strcpy(buf, saved_jvm_path);
1706    return;
1707  }
1708
1709  Dl_info dlinfo;
1710  int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
1711  assert(ret != 0, "cannot locate libjvm");
1712  char* rp = realpath((char *)dlinfo.dli_fname, buf);
1713  assert(rp != NULL, "error in realpath(): maybe the 'path' argument is too long?");
1714
1715  strncpy(saved_jvm_path, buf, sizeof(saved_jvm_path));
1716  saved_jvm_path[sizeof(saved_jvm_path) - 1] = '\0';
1717}
1718
1719void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
1720  // no prefix required, not even "_"
1721}
1722
1723void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
1724  // no suffix required
1725}
1726
1727////////////////////////////////////////////////////////////////////////////////
1728// sun.misc.Signal support
1729
1730static volatile jint sigint_count = 0;
1731
1732static void
1733UserHandler(int sig, void *siginfo, void *context) {
1734  // 4511530 - sem_post is serialized and handled by the manager thread. When
1735  // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
1736  // don't want to flood the manager thread with sem_post requests.
1737  if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
1738    return;
1739
1740  // Ctrl-C is pressed during error reporting, likely because the error
1741  // handler fails to abort. Let VM die immediately.
1742  if (sig == SIGINT && is_error_reported()) {
1743    os::die();
1744  }
1745
1746  os::signal_notify(sig);
1747}
1748
1749void* os::user_handler() {
1750  return CAST_FROM_FN_PTR(void*, UserHandler);
1751}
1752
1753extern "C" {
1754  typedef void (*sa_handler_t)(int);
1755  typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
1756}
1757
1758void* os::signal(int signal_number, void* handler) {
1759  struct sigaction sigAct, oldSigAct;
1760
1761  sigfillset(&(sigAct.sa_mask));
1762
1763  // Do not block out synchronous signals in the signal handler.
1764  // Blocking synchronous signals only makes sense if you can really
1765  // be sure that those signals won't happen during signal handling,
1766  // when the blocking applies. Normal signal handlers are lean and
1767  // do not cause signals. But our signal handlers tend to be "risky"
1768  // - secondary SIGSEGV, SIGILL, SIGBUS' may and do happen.
1769  // On AIX, PASE there was a case where a SIGSEGV happened, followed
1770  // by a SIGILL, which was blocked due to the signal mask. The process
1771  // just hung forever. Better to crash from a secondary signal than to hang.
1772  sigdelset(&(sigAct.sa_mask), SIGSEGV);
1773  sigdelset(&(sigAct.sa_mask), SIGBUS);
1774  sigdelset(&(sigAct.sa_mask), SIGILL);
1775  sigdelset(&(sigAct.sa_mask), SIGFPE);
1776  sigdelset(&(sigAct.sa_mask), SIGTRAP);
1777
1778  sigAct.sa_flags   = SA_RESTART|SA_SIGINFO;
1779
1780  sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
1781
1782  if (sigaction(signal_number, &sigAct, &oldSigAct)) {
1783    // -1 means registration failed
1784    return (void *)-1;
1785  }
1786
1787  return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
1788}
1789
1790void os::signal_raise(int signal_number) {
1791  ::raise(signal_number);
1792}
1793
1794//
1795// The following code is moved from os.cpp for making this
1796// code platform specific, which it is by its very nature.
1797//
1798
1799// Will be modified when max signal is changed to be dynamic
1800int os::sigexitnum_pd() {
1801  return NSIG;
1802}
1803
1804// a counter for each possible signal value
1805static volatile jint pending_signals[NSIG+1] = { 0 };
1806
1807// Linux(POSIX) specific hand shaking semaphore.
1808static sem_t sig_sem;
1809
1810void os::signal_init_pd() {
1811  // Initialize signal structures
1812  ::memset((void*)pending_signals, 0, sizeof(pending_signals));
1813
1814  // Initialize signal semaphore
1815  int rc = ::sem_init(&sig_sem, 0, 0);
1816  guarantee(rc != -1, "sem_init failed");
1817}
1818
1819void os::signal_notify(int sig) {
1820  Atomic::inc(&pending_signals[sig]);
1821  ::sem_post(&sig_sem);
1822}
1823
1824static int check_pending_signals(bool wait) {
1825  Atomic::store(0, &sigint_count);
1826  for (;;) {
1827    for (int i = 0; i < NSIG + 1; i++) {
1828      jint n = pending_signals[i];
1829      if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
1830        return i;
1831      }
1832    }
1833    if (!wait) {
1834      return -1;
1835    }
1836    JavaThread *thread = JavaThread::current();
1837    ThreadBlockInVM tbivm(thread);
1838
1839    bool threadIsSuspended;
1840    do {
1841      thread->set_suspend_equivalent();
1842      // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
1843
1844      ::sem_wait(&sig_sem);
1845
1846      // were we externally suspended while we were waiting?
1847      threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
1848      if (threadIsSuspended) {
1849        //
1850        // The semaphore has been incremented, but while we were waiting
1851        // another thread suspended us. We don't want to continue running
1852        // while suspended because that would surprise the thread that
1853        // suspended us.
1854        //
1855        ::sem_post(&sig_sem);
1856
1857        thread->java_suspend_self();
1858      }
1859    } while (threadIsSuspended);
1860  }
1861}
1862
1863int os::signal_lookup() {
1864  return check_pending_signals(false);
1865}
1866
1867int os::signal_wait() {
1868  return check_pending_signals(true);
1869}
1870
1871////////////////////////////////////////////////////////////////////////////////
1872// Virtual Memory
1873
1874// We need to keep small simple bookkeeping for os::reserve_memory and friends.
1875
1876#define VMEM_MAPPED  1
1877#define VMEM_SHMATED 2
1878
1879struct vmembk_t {
1880  int type;         // 1 - mmap, 2 - shmat
1881  char* addr;
1882  size_t size;      // Real size, may be larger than usersize.
1883  size_t pagesize;  // page size of area
1884  vmembk_t* next;
1885
1886  bool contains_addr(char* p) const {
1887    return p >= addr && p < (addr + size);
1888  }
1889
1890  bool contains_range(char* p, size_t s) const {
1891    return contains_addr(p) && contains_addr(p + s - 1);
1892  }
1893
1894  void print_on(outputStream* os) const {
1895    os->print("[" PTR_FORMAT " - " PTR_FORMAT "] (" UINTX_FORMAT
1896      " bytes, %d %s pages), %s",
1897      addr, addr + size - 1, size, size / pagesize, describe_pagesize(pagesize),
1898      (type == VMEM_SHMATED ? "shmat" : "mmap")
1899    );
1900  }
1901
1902  // Check that range is a sub range of memory block (or equal to memory block);
1903  // also check that range is fully page aligned to the page size if the block.
1904  void assert_is_valid_subrange(char* p, size_t s) const {
1905    if (!contains_range(p, s)) {
1906      fprintf(stderr, "[" PTR_FORMAT " - " PTR_FORMAT "] is not a sub "
1907              "range of [" PTR_FORMAT " - " PTR_FORMAT "].\n",
1908              p, p + s - 1, addr, addr + size - 1);
1909      guarantee0(false);
1910    }
1911    if (!is_aligned_to(p, pagesize) || !is_aligned_to(p + s, pagesize)) {
1912      fprintf(stderr, "range [" PTR_FORMAT " - " PTR_FORMAT "] is not"
1913              " aligned to pagesize (%s)\n", p, p + s);
1914      guarantee0(false);
1915    }
1916  }
1917};
1918
1919static struct {
1920  vmembk_t* first;
1921  MiscUtils::CritSect cs;
1922} vmem;
1923
1924static void vmembk_add(char* addr, size_t size, size_t pagesize, int type) {
1925  vmembk_t* p = (vmembk_t*) ::malloc(sizeof(vmembk_t));
1926  assert0(p);
1927  if (p) {
1928    MiscUtils::AutoCritSect lck(&vmem.cs);
1929    p->addr = addr; p->size = size;
1930    p->pagesize = pagesize;
1931    p->type = type;
1932    p->next = vmem.first;
1933    vmem.first = p;
1934  }
1935}
1936
1937static vmembk_t* vmembk_find(char* addr) {
1938  MiscUtils::AutoCritSect lck(&vmem.cs);
1939  for (vmembk_t* p = vmem.first; p; p = p->next) {
1940    if (p->addr <= addr && (p->addr + p->size) > addr) {
1941      return p;
1942    }
1943  }
1944  return NULL;
1945}
1946
1947static void vmembk_remove(vmembk_t* p0) {
1948  MiscUtils::AutoCritSect lck(&vmem.cs);
1949  assert0(p0);
1950  assert0(vmem.first); // List should not be empty.
1951  for (vmembk_t** pp = &(vmem.first); *pp; pp = &((*pp)->next)) {
1952    if (*pp == p0) {
1953      *pp = p0->next;
1954      ::free(p0);
1955      return;
1956    }
1957  }
1958  assert0(false); // Not found?
1959}
1960
1961static void vmembk_print_on(outputStream* os) {
1962  MiscUtils::AutoCritSect lck(&vmem.cs);
1963  for (vmembk_t* vmi = vmem.first; vmi; vmi = vmi->next) {
1964    vmi->print_on(os);
1965    os->cr();
1966  }
1967}
1968
1969// Reserve and attach a section of System V memory.
1970// If <requested_addr> is not NULL, function will attempt to attach the memory at the given
1971// address. Failing that, it will attach the memory anywhere.
1972// If <requested_addr> is NULL, function will attach the memory anywhere.
1973//
1974// <alignment_hint> is being ignored by this function. It is very probable however that the
1975// alignment requirements are met anyway, because shmat() attaches at 256M boundaries.
1976// Should this be not enogh, we can put more work into it.
1977static char* reserve_shmated_memory (
1978  size_t bytes,
1979  char* requested_addr,
1980  size_t alignment_hint) {
1981
1982  trcVerbose("reserve_shmated_memory " UINTX_FORMAT " bytes, wishaddress "
1983    PTR_FORMAT ", alignment_hint " UINTX_FORMAT "...",
1984    bytes, requested_addr, alignment_hint);
1985
1986  // Either give me wish address or wish alignment but not both.
1987  assert0(!(requested_addr != NULL && alignment_hint != 0));
1988
1989  // We must prevent anyone from attaching too close to the
1990  // BRK because that may cause malloc OOM.
1991  if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
1992    trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
1993      "Will attach anywhere.", requested_addr);
1994    // Act like the OS refused to attach there.
1995    requested_addr = NULL;
1996  }
1997
1998  // For old AS/400's (V5R4 and older) we should not even be here - System V shared memory is not
1999  // really supported (max size 4GB), so reserve_mmapped_memory should have been used instead.
2000  if (os::Aix::on_pase_V5R4_or_older()) {
2001    ShouldNotReachHere();
2002  }
2003
2004  // Align size of shm up to 64K to avoid errors if we later try to change the page size.
2005  const size_t size = align_size_up(bytes, SIZE_64K);
2006
2007  // Reserve the shared segment.
2008  int shmid = shmget(IPC_PRIVATE, size, IPC_CREAT | S_IRUSR | S_IWUSR);
2009  if (shmid == -1) {
2010    trc("shmget(.., " UINTX_FORMAT ", ..) failed (errno: %d).", size, errno);
2011    return NULL;
2012  }
2013
2014  // Important note:
2015  // It is very important that we, upon leaving this function, do not leave a shm segment alive.
2016  // We must right after attaching it remove it from the system. System V shm segments are global and
2017  // survive the process.
2018  // So, from here on: Do not assert, do not return, until we have called shmctl(IPC_RMID) (A).
2019
2020  struct shmid_ds shmbuf;
2021  memset(&shmbuf, 0, sizeof(shmbuf));
2022  shmbuf.shm_pagesize = SIZE_64K;
2023  if (shmctl(shmid, SHM_PAGESIZE, &shmbuf) != 0) {
2024    trcVerbose("Failed to set page size (need " UINTX_FORMAT " 64K pages) - shmctl failed with %d.",
2025               size / SIZE_64K, errno);
2026    // I want to know if this ever happens.
2027    assert(false, "failed to set page size for shmat");
2028  }
2029
2030  // Now attach the shared segment.
2031  // Note that I attach with SHM_RND - which means that the requested address is rounded down, if
2032  // needed, to the next lowest segment boundary. Otherwise the attach would fail if the address
2033  // were not a segment boundary.
2034  char* const addr = (char*) shmat(shmid, requested_addr, SHM_RND);
2035  const int errno_shmat = errno;
2036
2037  // (A) Right after shmat and before handing shmat errors delete the shm segment.
2038  if (::shmctl(shmid, IPC_RMID, NULL) == -1) {
2039    trc("shmctl(%u, IPC_RMID) failed (%d)\n", shmid, errno);
2040    assert(false, "failed to remove shared memory segment!");
2041  }
2042
2043  // Handle shmat error. If we failed to attach, just return.
2044  if (addr == (char*)-1) {
2045    trcVerbose("Failed to attach segment at " PTR_FORMAT " (%d).", requested_addr, errno_shmat);
2046    return NULL;
2047  }
2048
2049  // Just for info: query the real page size. In case setting the page size did not
2050  // work (see above), the system may have given us something other then 4K (LDR_CNTRL).
2051  const size_t real_pagesize = os::Aix::query_pagesize(addr);
2052  if (real_pagesize != shmbuf.shm_pagesize) {
2053    trcVerbose("pagesize is, surprisingly, %h.", real_pagesize);
2054  }
2055
2056  if (addr) {
2057    trcVerbose("shm-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes, " UINTX_FORMAT " %s pages)",
2058      addr, addr + size - 1, size, size/real_pagesize, describe_pagesize(real_pagesize));
2059  } else {
2060    if (requested_addr != NULL) {
2061      trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at with address " PTR_FORMAT ".", size, requested_addr);
2062    } else {
2063      trcVerbose("failed to shm-allocate " UINTX_FORMAT " bytes at any address.", size);
2064    }
2065  }
2066
2067  // book-keeping
2068  vmembk_add(addr, size, real_pagesize, VMEM_SHMATED);
2069  assert0(is_aligned_to(addr, os::vm_page_size()));
2070
2071  return addr;
2072}
2073
2074static bool release_shmated_memory(char* addr, size_t size) {
2075
2076  trcVerbose("release_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2077    addr, addr + size - 1);
2078
2079  bool rc = false;
2080
2081  // TODO: is there a way to verify shm size without doing bookkeeping?
2082  if (::shmdt(addr) != 0) {
2083    trcVerbose("error (%d).", errno);
2084  } else {
2085    trcVerbose("ok.");
2086    rc = true;
2087  }
2088  return rc;
2089}
2090
2091static bool uncommit_shmated_memory(char* addr, size_t size) {
2092  trcVerbose("uncommit_shmated_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2093    addr, addr + size - 1);
2094
2095  const bool rc = my_disclaim64(addr, size);
2096
2097  if (!rc) {
2098    trcVerbose("my_disclaim64(" PTR_FORMAT ", " UINTX_FORMAT ") failed.\n", addr, size);
2099    return false;
2100  }
2101  return true;
2102}
2103
2104// Reserve memory via mmap.
2105// If <requested_addr> is given, an attempt is made to attach at the given address.
2106// Failing that, memory is allocated at any address.
2107// If <alignment_hint> is given and <requested_addr> is NULL, an attempt is made to
2108// allocate at an address aligned with the given alignment. Failing that, memory
2109// is aligned anywhere.
2110static char* reserve_mmaped_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
2111  trcVerbose("reserve_mmaped_memory " UINTX_FORMAT " bytes, wishaddress " PTR_FORMAT ", "
2112    "alignment_hint " UINTX_FORMAT "...",
2113    bytes, requested_addr, alignment_hint);
2114
2115  // If a wish address is given, but not aligned to 4K page boundary, mmap will fail.
2116  if (requested_addr && !is_aligned_to(requested_addr, os::vm_page_size()) != 0) {
2117    trcVerbose("Wish address " PTR_FORMAT " not aligned to page boundary.", requested_addr);
2118    return NULL;
2119  }
2120
2121  // We must prevent anyone from attaching too close to the
2122  // BRK because that may cause malloc OOM.
2123  if (requested_addr != NULL && is_close_to_brk((address)requested_addr)) {
2124    trcVerbose("Wish address " PTR_FORMAT " is too close to the BRK segment. "
2125      "Will attach anywhere.", requested_addr);
2126    // Act like the OS refused to attach there.
2127    requested_addr = NULL;
2128  }
2129
2130  // Specify one or the other but not both.
2131  assert0(!(requested_addr != NULL && alignment_hint > 0));
2132
2133  // In 64K mode, we claim the global page size (os::vm_page_size())
2134  // is 64K. This is one of the few points where that illusion may
2135  // break, because mmap() will always return memory aligned to 4K. So
2136  // we must ensure we only ever return memory aligned to 64k.
2137  if (alignment_hint) {
2138    alignment_hint = lcm(alignment_hint, os::vm_page_size());
2139  } else {
2140    alignment_hint = os::vm_page_size();
2141  }
2142
2143  // Size shall always be a multiple of os::vm_page_size (esp. in 64K mode).
2144  const size_t size = align_size_up(bytes, os::vm_page_size());
2145
2146  // alignment: Allocate memory large enough to include an aligned range of the right size and
2147  // cut off the leading and trailing waste pages.
2148  assert0(alignment_hint != 0 && is_aligned_to(alignment_hint, os::vm_page_size())); // see above
2149  const size_t extra_size = size + alignment_hint;
2150
2151  // Note: MAP_SHARED (instead of MAP_PRIVATE) needed to be able to
2152  // later use msync(MS_INVALIDATE) (see os::uncommit_memory).
2153  int flags = MAP_ANONYMOUS | MAP_SHARED;
2154
2155  // MAP_FIXED is needed to enforce requested_addr - manpage is vague about what
2156  // it means if wishaddress is given but MAP_FIXED is not set.
2157  //
2158  // Important! Behaviour differs depending on whether SPEC1170 mode is active or not.
2159  // SPEC1170 mode active: behaviour like POSIX, MAP_FIXED will clobber existing mappings.
2160  // SPEC1170 mode not active: behaviour, unlike POSIX, is that no existing mappings will
2161  // get clobbered.
2162  if (requested_addr != NULL) {
2163    if (!os::Aix::xpg_sus_mode()) {  // not SPEC1170 Behaviour
2164      flags |= MAP_FIXED;
2165    }
2166  }
2167
2168  char* addr = (char*)::mmap(requested_addr, extra_size,
2169      PROT_READ|PROT_WRITE|PROT_EXEC, flags, -1, 0);
2170
2171  if (addr == MAP_FAILED) {
2172    trcVerbose("mmap(" PTR_FORMAT ", " UINTX_FORMAT ", ..) failed (%d)", requested_addr, size, errno);
2173    return NULL;
2174  }
2175
2176  // Handle alignment.
2177  char* const addr_aligned = (char *)align_ptr_up(addr, alignment_hint);
2178  const size_t waste_pre = addr_aligned - addr;
2179  char* const addr_aligned_end = addr_aligned + size;
2180  const size_t waste_post = extra_size - waste_pre - size;
2181  if (waste_pre > 0) {
2182    ::munmap(addr, waste_pre);
2183  }
2184  if (waste_post > 0) {
2185    ::munmap(addr_aligned_end, waste_post);
2186  }
2187  addr = addr_aligned;
2188
2189  if (addr) {
2190    trcVerbose("mmap-allocated " PTR_FORMAT " .. " PTR_FORMAT " (" UINTX_FORMAT " bytes)",
2191      addr, addr + bytes, bytes);
2192  } else {
2193    if (requested_addr != NULL) {
2194      trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at wish address " PTR_FORMAT ".", bytes, requested_addr);
2195    } else {
2196      trcVerbose("failed to mmap-allocate " UINTX_FORMAT " bytes at any address.", bytes);
2197    }
2198  }
2199
2200  // bookkeeping
2201  vmembk_add(addr, size, SIZE_4K, VMEM_MAPPED);
2202
2203  // Test alignment, see above.
2204  assert0(is_aligned_to(addr, os::vm_page_size()));
2205
2206  return addr;
2207}
2208
2209static bool release_mmaped_memory(char* addr, size_t size) {
2210  assert0(is_aligned_to(addr, os::vm_page_size()));
2211  assert0(is_aligned_to(size, os::vm_page_size()));
2212
2213  trcVerbose("release_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2214    addr, addr + size - 1);
2215  bool rc = false;
2216
2217  if (::munmap(addr, size) != 0) {
2218    trcVerbose("failed (%d)\n", errno);
2219    rc = false;
2220  } else {
2221    trcVerbose("ok.");
2222    rc = true;
2223  }
2224
2225  return rc;
2226}
2227
2228static bool uncommit_mmaped_memory(char* addr, size_t size) {
2229
2230  assert0(is_aligned_to(addr, os::vm_page_size()));
2231  assert0(is_aligned_to(size, os::vm_page_size()));
2232
2233  trcVerbose("uncommit_mmaped_memory [" PTR_FORMAT " - " PTR_FORMAT "].",
2234    addr, addr + size - 1);
2235  bool rc = false;
2236
2237  // Uncommit mmap memory with msync MS_INVALIDATE.
2238  if (::msync(addr, size, MS_INVALIDATE) != 0) {
2239    trcVerbose("failed (%d)\n", errno);
2240    rc = false;
2241  } else {
2242    trcVerbose("ok.");
2243    rc = true;
2244  }
2245
2246  return rc;
2247}
2248
2249// End: shared memory bookkeeping
2250////////////////////////////////////////////////////////////////////////////////////////////////////
2251
2252int os::vm_page_size() {
2253  // Seems redundant as all get out.
2254  assert(os::Aix::page_size() != -1, "must call os::init");
2255  return os::Aix::page_size();
2256}
2257
2258// Aix allocates memory by pages.
2259int os::vm_allocation_granularity() {
2260  assert(os::Aix::page_size() != -1, "must call os::init");
2261  return os::Aix::page_size();
2262}
2263
2264#ifdef PRODUCT
2265static void warn_fail_commit_memory(char* addr, size_t size, bool exec,
2266                                    int err) {
2267  warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2268          ", %d) failed; error='%s' (errno=%d)", addr, size, exec,
2269          strerror(err), err);
2270}
2271#endif
2272
2273void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
2274                                  const char* mesg) {
2275  assert(mesg != NULL, "mesg must be specified");
2276  if (!pd_commit_memory(addr, size, exec)) {
2277    // Add extra info in product mode for vm_exit_out_of_memory():
2278    PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)
2279    vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);
2280  }
2281}
2282
2283bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
2284
2285  assert0(is_aligned_to(addr, os::vm_page_size()));
2286  assert0(is_aligned_to(size, os::vm_page_size()));
2287
2288  vmembk_t* const vmi = vmembk_find(addr);
2289  assert0(vmi);
2290  vmi->assert_is_valid_subrange(addr, size);
2291
2292  trcVerbose("commit_memory [" PTR_FORMAT " - " PTR_FORMAT "].", addr, addr + size - 1);
2293
2294  return true;
2295}
2296
2297bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint, bool exec) {
2298  return pd_commit_memory(addr, size, exec);
2299}
2300
2301void os::pd_commit_memory_or_exit(char* addr, size_t size,
2302                                  size_t alignment_hint, bool exec,
2303                                  const char* mesg) {
2304  // Alignment_hint is ignored on this OS.
2305  pd_commit_memory_or_exit(addr, size, exec, mesg);
2306}
2307
2308bool os::pd_uncommit_memory(char* addr, size_t size) {
2309  assert0(is_aligned_to(addr, os::vm_page_size()));
2310  assert0(is_aligned_to(size, os::vm_page_size()));
2311
2312  // Dynamically do different things for mmap/shmat.
2313  const vmembk_t* const vmi = vmembk_find(addr);
2314  assert0(vmi);
2315  vmi->assert_is_valid_subrange(addr, size);
2316
2317  if (vmi->type == VMEM_SHMATED) {
2318    return uncommit_shmated_memory(addr, size);
2319  } else {
2320    return uncommit_mmaped_memory(addr, size);
2321  }
2322}
2323
2324bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
2325  // Do not call this; no need to commit stack pages on AIX.
2326  ShouldNotReachHere();
2327  return true;
2328}
2329
2330bool os::remove_stack_guard_pages(char* addr, size_t size) {
2331  // Do not call this; no need to commit stack pages on AIX.
2332  ShouldNotReachHere();
2333  return true;
2334}
2335
2336void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2337}
2338
2339void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
2340}
2341
2342void os::numa_make_global(char *addr, size_t bytes) {
2343}
2344
2345void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2346}
2347
2348bool os::numa_topology_changed() {
2349  return false;
2350}
2351
2352size_t os::numa_get_groups_num() {
2353  return 1;
2354}
2355
2356int os::numa_get_group_id() {
2357  return 0;
2358}
2359
2360size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2361  if (size > 0) {
2362    ids[0] = 0;
2363    return 1;
2364  }
2365  return 0;
2366}
2367
2368bool os::get_page_info(char *start, page_info* info) {
2369  return false;
2370}
2371
2372char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2373  return end;
2374}
2375
2376// Reserves and attaches a shared memory segment.
2377// Will assert if a wish address is given and could not be obtained.
2378char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
2379
2380  // All other Unices do a mmap(MAP_FIXED) if the addr is given,
2381  // thereby clobbering old mappings at that place. That is probably
2382  // not intended, never used and almost certainly an error were it
2383  // ever be used this way (to try attaching at a specified address
2384  // without clobbering old mappings an alternate API exists,
2385  // os::attempt_reserve_memory_at()).
2386  // Instead of mimicking the dangerous coding of the other platforms, here I
2387  // just ignore the request address (release) or assert(debug).
2388  assert0(requested_addr == NULL);
2389
2390  // Always round to os::vm_page_size(), which may be larger than 4K.
2391  bytes = align_size_up(bytes, os::vm_page_size());
2392  const size_t alignment_hint0 =
2393    alignment_hint ? align_size_up(alignment_hint, os::vm_page_size()) : 0;
2394
2395  // In 4K mode always use mmap.
2396  // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted.
2397  if (os::vm_page_size() == SIZE_4K) {
2398    return reserve_mmaped_memory(bytes, requested_addr, alignment_hint);
2399  } else {
2400    if (bytes >= Use64KPagesThreshold) {
2401      return reserve_shmated_memory(bytes, requested_addr, alignment_hint);
2402    } else {
2403      return reserve_mmaped_memory(bytes, requested_addr, alignment_hint);
2404    }
2405  }
2406}
2407
2408bool os::pd_release_memory(char* addr, size_t size) {
2409
2410  // Dynamically do different things for mmap/shmat.
2411  vmembk_t* const vmi = vmembk_find(addr);
2412  assert0(vmi);
2413
2414  // Always round to os::vm_page_size(), which may be larger than 4K.
2415  size = align_size_up(size, os::vm_page_size());
2416  addr = (char *)align_ptr_up(addr, os::vm_page_size());
2417
2418  bool rc = false;
2419  bool remove_bookkeeping = false;
2420  if (vmi->type == VMEM_SHMATED) {
2421    // For shmatted memory, we do:
2422    // - If user wants to release the whole range, release the memory (shmdt).
2423    // - If user only wants to release a partial range, uncommit (disclaim) that
2424    //   range. That way, at least, we do not use memory anymore (bust still page
2425    //   table space).
2426    vmi->assert_is_valid_subrange(addr, size);
2427    if (addr == vmi->addr && size == vmi->size) {
2428      rc = release_shmated_memory(addr, size);
2429      remove_bookkeeping = true;
2430    } else {
2431      rc = uncommit_shmated_memory(addr, size);
2432    }
2433  } else {
2434    // User may unmap partial regions but region has to be fully contained.
2435#ifdef ASSERT
2436    vmi->assert_is_valid_subrange(addr, size);
2437#endif
2438    rc = release_mmaped_memory(addr, size);
2439    remove_bookkeeping = true;
2440  }
2441
2442  // update bookkeeping
2443  if (rc && remove_bookkeeping) {
2444    vmembk_remove(vmi);
2445  }
2446
2447  return rc;
2448}
2449
2450static bool checked_mprotect(char* addr, size_t size, int prot) {
2451
2452  // Little problem here: if SPEC1170 behaviour is off, mprotect() on AIX will
2453  // not tell me if protection failed when trying to protect an un-protectable range.
2454  //
2455  // This means if the memory was allocated using shmget/shmat, protection wont work
2456  // but mprotect will still return 0:
2457  //
2458  // See http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/mprotect.htm
2459
2460  bool rc = ::mprotect(addr, size, prot) == 0 ? true : false;
2461
2462  if (!rc) {
2463    const char* const s_errno = strerror(errno);
2464    warning("mprotect(" PTR_FORMAT "-" PTR_FORMAT ", 0x%X) failed (%s).", addr, addr + size, prot, s_errno);
2465    return false;
2466  }
2467
2468  // mprotect success check
2469  //
2470  // Mprotect said it changed the protection but can I believe it?
2471  //
2472  // To be sure I need to check the protection afterwards. Try to
2473  // read from protected memory and check whether that causes a segfault.
2474  //
2475  if (!os::Aix::xpg_sus_mode()) {
2476
2477    if (CanUseSafeFetch32()) {
2478
2479      const bool read_protected =
2480        (SafeFetch32((int*)addr, 0x12345678) == 0x12345678 &&
2481         SafeFetch32((int*)addr, 0x76543210) == 0x76543210) ? true : false;
2482
2483      if (prot & PROT_READ) {
2484        rc = !read_protected;
2485      } else {
2486        rc = read_protected;
2487      }
2488    }
2489  }
2490  if (!rc) {
2491    assert(false, "mprotect failed.");
2492  }
2493  return rc;
2494}
2495
2496// Set protections specified
2497bool os::protect_memory(char* addr, size_t size, ProtType prot, bool is_committed) {
2498  unsigned int p = 0;
2499  switch (prot) {
2500  case MEM_PROT_NONE: p = PROT_NONE; break;
2501  case MEM_PROT_READ: p = PROT_READ; break;
2502  case MEM_PROT_RW:   p = PROT_READ|PROT_WRITE; break;
2503  case MEM_PROT_RWX:  p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
2504  default:
2505    ShouldNotReachHere();
2506  }
2507  // is_committed is unused.
2508  return checked_mprotect(addr, size, p);
2509}
2510
2511bool os::guard_memory(char* addr, size_t size) {
2512  return checked_mprotect(addr, size, PROT_NONE);
2513}
2514
2515bool os::unguard_memory(char* addr, size_t size) {
2516  return checked_mprotect(addr, size, PROT_READ|PROT_WRITE|PROT_EXEC);
2517}
2518
2519// Large page support
2520
2521static size_t _large_page_size = 0;
2522
2523// Enable large page support if OS allows that.
2524void os::large_page_init() {
2525  return; // Nothing to do. See query_multipage_support and friends.
2526}
2527
2528char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
2529  // "exec" is passed in but not used. Creating the shared image for
2530  // the code cache doesn't have an SHM_X executable permission to check.
2531  Unimplemented();
2532  return 0;
2533}
2534
2535bool os::release_memory_special(char* base, size_t bytes) {
2536  // Detaching the SHM segment will also delete it, see reserve_memory_special().
2537  Unimplemented();
2538  return false;
2539}
2540
2541size_t os::large_page_size() {
2542  return _large_page_size;
2543}
2544
2545bool os::can_commit_large_page_memory() {
2546  // Does not matter, we do not support huge pages.
2547  return false;
2548}
2549
2550bool os::can_execute_large_page_memory() {
2551  // Does not matter, we do not support huge pages.
2552  return false;
2553}
2554
2555// Reserve memory at an arbitrary address, only if that area is
2556// available (and not reserved for something else).
2557char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
2558  char* addr = NULL;
2559
2560  // Always round to os::vm_page_size(), which may be larger than 4K.
2561  bytes = align_size_up(bytes, os::vm_page_size());
2562
2563  // In 4K mode always use mmap.
2564  // In 64K mode allocate small sizes with mmap, large ones with 64K shmatted.
2565  if (os::vm_page_size() == SIZE_4K) {
2566    return reserve_mmaped_memory(bytes, requested_addr, 0);
2567  } else {
2568    if (bytes >= Use64KPagesThreshold) {
2569      return reserve_shmated_memory(bytes, requested_addr, 0);
2570    } else {
2571      return reserve_mmaped_memory(bytes, requested_addr, 0);
2572    }
2573  }
2574
2575  return addr;
2576}
2577
2578size_t os::read(int fd, void *buf, unsigned int nBytes) {
2579  return ::read(fd, buf, nBytes);
2580}
2581
2582size_t os::read_at(int fd, void *buf, unsigned int nBytes, jlong offset) {
2583  return ::pread(fd, buf, nBytes, offset);
2584}
2585
2586void os::naked_short_sleep(jlong ms) {
2587  struct timespec req;
2588
2589  assert(ms < 1000, "Un-interruptable sleep, short time use only");
2590  req.tv_sec = 0;
2591  if (ms > 0) {
2592    req.tv_nsec = (ms % 1000) * 1000000;
2593  }
2594  else {
2595    req.tv_nsec = 1;
2596  }
2597
2598  nanosleep(&req, NULL);
2599
2600  return;
2601}
2602
2603// Sleep forever; naked call to OS-specific sleep; use with CAUTION
2604void os::infinite_sleep() {
2605  while (true) {    // sleep forever ...
2606    ::sleep(100);   // ... 100 seconds at a time
2607  }
2608}
2609
2610// Used to convert frequent JVM_Yield() to nops
2611bool os::dont_yield() {
2612  return DontYieldALot;
2613}
2614
2615void os::naked_yield() {
2616  sched_yield();
2617}
2618
2619////////////////////////////////////////////////////////////////////////////////
2620// thread priority support
2621
2622// From AIX manpage to pthread_setschedparam
2623// (see: http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?
2624//    topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_setschedparam.htm):
2625//
2626// "If schedpolicy is SCHED_OTHER, then sched_priority must be in the
2627// range from 40 to 80, where 40 is the least favored priority and 80
2628// is the most favored."
2629//
2630// (Actually, I doubt this even has an impact on AIX, as we do kernel
2631// scheduling there; however, this still leaves iSeries.)
2632//
2633// We use the same values for AIX and PASE.
2634int os::java_to_os_priority[CriticalPriority + 1] = {
2635  54,             // 0 Entry should never be used
2636
2637  55,             // 1 MinPriority
2638  55,             // 2
2639  56,             // 3
2640
2641  56,             // 4
2642  57,             // 5 NormPriority
2643  57,             // 6
2644
2645  58,             // 7
2646  58,             // 8
2647  59,             // 9 NearMaxPriority
2648
2649  60,             // 10 MaxPriority
2650
2651  60              // 11 CriticalPriority
2652};
2653
2654OSReturn os::set_native_priority(Thread* thread, int newpri) {
2655  if (!UseThreadPriorities) return OS_OK;
2656  pthread_t thr = thread->osthread()->pthread_id();
2657  int policy = SCHED_OTHER;
2658  struct sched_param param;
2659  param.sched_priority = newpri;
2660  int ret = pthread_setschedparam(thr, policy, &param);
2661
2662  if (ret != 0) {
2663    trcVerbose("Could not change priority for thread %d to %d (error %d, %s)",
2664        (int)thr, newpri, ret, strerror(ret));
2665  }
2666  return (ret == 0) ? OS_OK : OS_ERR;
2667}
2668
2669OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
2670  if (!UseThreadPriorities) {
2671    *priority_ptr = java_to_os_priority[NormPriority];
2672    return OS_OK;
2673  }
2674  pthread_t thr = thread->osthread()->pthread_id();
2675  int policy = SCHED_OTHER;
2676  struct sched_param param;
2677  int ret = pthread_getschedparam(thr, &policy, &param);
2678  *priority_ptr = param.sched_priority;
2679
2680  return (ret == 0) ? OS_OK : OS_ERR;
2681}
2682
2683// Hint to the underlying OS that a task switch would not be good.
2684// Void return because it's a hint and can fail.
2685void os::hint_no_preempt() {}
2686
2687////////////////////////////////////////////////////////////////////////////////
2688// suspend/resume support
2689
2690//  the low-level signal-based suspend/resume support is a remnant from the
2691//  old VM-suspension that used to be for java-suspension, safepoints etc,
2692//  within hotspot. Now there is a single use-case for this:
2693//    - calling get_thread_pc() on the VMThread by the flat-profiler task
2694//      that runs in the watcher thread.
2695//  The remaining code is greatly simplified from the more general suspension
2696//  code that used to be used.
2697//
2698//  The protocol is quite simple:
2699//  - suspend:
2700//      - sends a signal to the target thread
2701//      - polls the suspend state of the osthread using a yield loop
2702//      - target thread signal handler (SR_handler) sets suspend state
2703//        and blocks in sigsuspend until continued
2704//  - resume:
2705//      - sets target osthread state to continue
2706//      - sends signal to end the sigsuspend loop in the SR_handler
2707//
2708//  Note that the SR_lock plays no role in this suspend/resume protocol.
2709//
2710
2711static void resume_clear_context(OSThread *osthread) {
2712  osthread->set_ucontext(NULL);
2713  osthread->set_siginfo(NULL);
2714}
2715
2716static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) {
2717  osthread->set_ucontext(context);
2718  osthread->set_siginfo(siginfo);
2719}
2720
2721//
2722// Handler function invoked when a thread's execution is suspended or
2723// resumed. We have to be careful that only async-safe functions are
2724// called here (Note: most pthread functions are not async safe and
2725// should be avoided.)
2726//
2727// Note: sigwait() is a more natural fit than sigsuspend() from an
2728// interface point of view, but sigwait() prevents the signal hander
2729// from being run. libpthread would get very confused by not having
2730// its signal handlers run and prevents sigwait()'s use with the
2731// mutex granting granting signal.
2732//
2733// Currently only ever called on the VMThread and JavaThreads (PC sampling).
2734//
2735static void SR_handler(int sig, siginfo_t* siginfo, ucontext_t* context) {
2736  // Save and restore errno to avoid confusing native code with EINTR
2737  // after sigsuspend.
2738  int old_errno = errno;
2739
2740  Thread* thread = Thread::current();
2741  OSThread* osthread = thread->osthread();
2742  assert(thread->is_VM_thread() || thread->is_Java_thread(), "Must be VMThread or JavaThread");
2743
2744  os::SuspendResume::State current = osthread->sr.state();
2745  if (current == os::SuspendResume::SR_SUSPEND_REQUEST) {
2746    suspend_save_context(osthread, siginfo, context);
2747
2748    // attempt to switch the state, we assume we had a SUSPEND_REQUEST
2749    os::SuspendResume::State state = osthread->sr.suspended();
2750    if (state == os::SuspendResume::SR_SUSPENDED) {
2751      sigset_t suspend_set;  // signals for sigsuspend()
2752
2753      // get current set of blocked signals and unblock resume signal
2754      pthread_sigmask(SIG_BLOCK, NULL, &suspend_set);
2755      sigdelset(&suspend_set, SR_signum);
2756
2757      // wait here until we are resumed
2758      while (1) {
2759        sigsuspend(&suspend_set);
2760
2761        os::SuspendResume::State result = osthread->sr.running();
2762        if (result == os::SuspendResume::SR_RUNNING) {
2763          break;
2764        }
2765      }
2766
2767    } else if (state == os::SuspendResume::SR_RUNNING) {
2768      // request was cancelled, continue
2769    } else {
2770      ShouldNotReachHere();
2771    }
2772
2773    resume_clear_context(osthread);
2774  } else if (current == os::SuspendResume::SR_RUNNING) {
2775    // request was cancelled, continue
2776  } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) {
2777    // ignore
2778  } else {
2779    ShouldNotReachHere();
2780  }
2781
2782  errno = old_errno;
2783}
2784
2785static int SR_initialize() {
2786  struct sigaction act;
2787  char *s;
2788  // Get signal number to use for suspend/resume
2789  if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) {
2790    int sig = ::strtol(s, 0, 10);
2791    if (sig > 0 || sig < NSIG) {
2792      SR_signum = sig;
2793    }
2794  }
2795
2796  assert(SR_signum > SIGSEGV && SR_signum > SIGBUS,
2797        "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769");
2798
2799  sigemptyset(&SR_sigset);
2800  sigaddset(&SR_sigset, SR_signum);
2801
2802  // Set up signal handler for suspend/resume.
2803  act.sa_flags = SA_RESTART|SA_SIGINFO;
2804  act.sa_handler = (void (*)(int)) SR_handler;
2805
2806  // SR_signum is blocked by default.
2807  // 4528190 - We also need to block pthread restart signal (32 on all
2808  // supported Linux platforms). Note that LinuxThreads need to block
2809  // this signal for all threads to work properly. So we don't have
2810  // to use hard-coded signal number when setting up the mask.
2811  pthread_sigmask(SIG_BLOCK, NULL, &act.sa_mask);
2812
2813  if (sigaction(SR_signum, &act, 0) == -1) {
2814    return -1;
2815  }
2816
2817  // Save signal flag
2818  os::Aix::set_our_sigflags(SR_signum, act.sa_flags);
2819  return 0;
2820}
2821
2822static int SR_finalize() {
2823  return 0;
2824}
2825
2826static int sr_notify(OSThread* osthread) {
2827  int status = pthread_kill(osthread->pthread_id(), SR_signum);
2828  assert_status(status == 0, status, "pthread_kill");
2829  return status;
2830}
2831
2832// "Randomly" selected value for how long we want to spin
2833// before bailing out on suspending a thread, also how often
2834// we send a signal to a thread we want to resume
2835static const int RANDOMLY_LARGE_INTEGER = 1000000;
2836static const int RANDOMLY_LARGE_INTEGER2 = 100;
2837
2838// returns true on success and false on error - really an error is fatal
2839// but this seems the normal response to library errors
2840static bool do_suspend(OSThread* osthread) {
2841  assert(osthread->sr.is_running(), "thread should be running");
2842  // mark as suspended and send signal
2843
2844  if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) {
2845    // failed to switch, state wasn't running?
2846    ShouldNotReachHere();
2847    return false;
2848  }
2849
2850  if (sr_notify(osthread) != 0) {
2851    // try to cancel, switch to running
2852
2853    os::SuspendResume::State result = osthread->sr.cancel_suspend();
2854    if (result == os::SuspendResume::SR_RUNNING) {
2855      // cancelled
2856      return false;
2857    } else if (result == os::SuspendResume::SR_SUSPENDED) {
2858      // somehow managed to suspend
2859      return true;
2860    } else {
2861      ShouldNotReachHere();
2862      return false;
2863    }
2864  }
2865
2866  // managed to send the signal and switch to SUSPEND_REQUEST, now wait for SUSPENDED
2867
2868  for (int n = 0; !osthread->sr.is_suspended(); n++) {
2869    for (int i = 0; i < RANDOMLY_LARGE_INTEGER2 && !osthread->sr.is_suspended(); i++) {
2870      os::naked_yield();
2871    }
2872
2873    // timeout, try to cancel the request
2874    if (n >= RANDOMLY_LARGE_INTEGER) {
2875      os::SuspendResume::State cancelled = osthread->sr.cancel_suspend();
2876      if (cancelled == os::SuspendResume::SR_RUNNING) {
2877        return false;
2878      } else if (cancelled == os::SuspendResume::SR_SUSPENDED) {
2879        return true;
2880      } else {
2881        ShouldNotReachHere();
2882        return false;
2883      }
2884    }
2885  }
2886
2887  guarantee(osthread->sr.is_suspended(), "Must be suspended");
2888  return true;
2889}
2890
2891static void do_resume(OSThread* osthread) {
2892  //assert(osthread->sr.is_suspended(), "thread should be suspended");
2893
2894  if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) {
2895    // failed to switch to WAKEUP_REQUEST
2896    ShouldNotReachHere();
2897    return;
2898  }
2899
2900  while (!osthread->sr.is_running()) {
2901    if (sr_notify(osthread) == 0) {
2902      for (int n = 0; n < RANDOMLY_LARGE_INTEGER && !osthread->sr.is_running(); n++) {
2903        for (int i = 0; i < 100 && !osthread->sr.is_running(); i++) {
2904          os::naked_yield();
2905        }
2906      }
2907    } else {
2908      ShouldNotReachHere();
2909    }
2910  }
2911
2912  guarantee(osthread->sr.is_running(), "Must be running!");
2913}
2914
2915///////////////////////////////////////////////////////////////////////////////////
2916// signal handling (except suspend/resume)
2917
2918// This routine may be used by user applications as a "hook" to catch signals.
2919// The user-defined signal handler must pass unrecognized signals to this
2920// routine, and if it returns true (non-zero), then the signal handler must
2921// return immediately. If the flag "abort_if_unrecognized" is true, then this
2922// routine will never retun false (zero), but instead will execute a VM panic
2923// routine kill the process.
2924//
2925// If this routine returns false, it is OK to call it again. This allows
2926// the user-defined signal handler to perform checks either before or after
2927// the VM performs its own checks. Naturally, the user code would be making
2928// a serious error if it tried to handle an exception (such as a null check
2929// or breakpoint) that the VM was generating for its own correct operation.
2930//
2931// This routine may recognize any of the following kinds of signals:
2932//   SIGBUS, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGPIPE, SIGXFSZ, SIGUSR1.
2933// It should be consulted by handlers for any of those signals.
2934//
2935// The caller of this routine must pass in the three arguments supplied
2936// to the function referred to in the "sa_sigaction" (not the "sa_handler")
2937// field of the structure passed to sigaction(). This routine assumes that
2938// the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
2939//
2940// Note that the VM will print warnings if it detects conflicting signal
2941// handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
2942//
2943extern "C" JNIEXPORT int
2944JVM_handle_aix_signal(int signo, siginfo_t* siginfo, void* ucontext, int abort_if_unrecognized);
2945
2946// Set thread signal mask (for some reason on AIX sigthreadmask() seems
2947// to be the thing to call; documentation is not terribly clear about whether
2948// pthread_sigmask also works, and if it does, whether it does the same.
2949bool set_thread_signal_mask(int how, const sigset_t* set, sigset_t* oset) {
2950  const int rc = ::pthread_sigmask(how, set, oset);
2951  // return value semantics differ slightly for error case:
2952  // pthread_sigmask returns error number, sigthreadmask -1 and sets global errno
2953  // (so, pthread_sigmask is more theadsafe for error handling)
2954  // But success is always 0.
2955  return rc == 0 ? true : false;
2956}
2957
2958// Function to unblock all signals which are, according
2959// to POSIX, typical program error signals. If they happen while being blocked,
2960// they typically will bring down the process immediately.
2961bool unblock_program_error_signals() {
2962  sigset_t set;
2963  ::sigemptyset(&set);
2964  ::sigaddset(&set, SIGILL);
2965  ::sigaddset(&set, SIGBUS);
2966  ::sigaddset(&set, SIGFPE);
2967  ::sigaddset(&set, SIGSEGV);
2968  return set_thread_signal_mask(SIG_UNBLOCK, &set, NULL);
2969}
2970
2971// Renamed from 'signalHandler' to avoid collision with other shared libs.
2972void javaSignalHandler(int sig, siginfo_t* info, void* uc) {
2973  assert(info != NULL && uc != NULL, "it must be old kernel");
2974
2975  // Never leave program error signals blocked;
2976  // on all our platforms they would bring down the process immediately when
2977  // getting raised while being blocked.
2978  unblock_program_error_signals();
2979
2980  JVM_handle_aix_signal(sig, info, uc, true);
2981}
2982
2983// This boolean allows users to forward their own non-matching signals
2984// to JVM_handle_aix_signal, harmlessly.
2985bool os::Aix::signal_handlers_are_installed = false;
2986
2987// For signal-chaining
2988struct sigaction os::Aix::sigact[MAXSIGNUM];
2989unsigned int os::Aix::sigs = 0;
2990bool os::Aix::libjsig_is_loaded = false;
2991typedef struct sigaction *(*get_signal_t)(int);
2992get_signal_t os::Aix::get_signal_action = NULL;
2993
2994struct sigaction* os::Aix::get_chained_signal_action(int sig) {
2995  struct sigaction *actp = NULL;
2996
2997  if (libjsig_is_loaded) {
2998    // Retrieve the old signal handler from libjsig
2999    actp = (*get_signal_action)(sig);
3000  }
3001  if (actp == NULL) {
3002    // Retrieve the preinstalled signal handler from jvm
3003    actp = get_preinstalled_handler(sig);
3004  }
3005
3006  return actp;
3007}
3008
3009static bool call_chained_handler(struct sigaction *actp, int sig,
3010                                 siginfo_t *siginfo, void *context) {
3011  // Call the old signal handler
3012  if (actp->sa_handler == SIG_DFL) {
3013    // It's more reasonable to let jvm treat it as an unexpected exception
3014    // instead of taking the default action.
3015    return false;
3016  } else if (actp->sa_handler != SIG_IGN) {
3017    if ((actp->sa_flags & SA_NODEFER) == 0) {
3018      // automaticlly block the signal
3019      sigaddset(&(actp->sa_mask), sig);
3020    }
3021
3022    sa_handler_t hand = NULL;
3023    sa_sigaction_t sa = NULL;
3024    bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
3025    // retrieve the chained handler
3026    if (siginfo_flag_set) {
3027      sa = actp->sa_sigaction;
3028    } else {
3029      hand = actp->sa_handler;
3030    }
3031
3032    if ((actp->sa_flags & SA_RESETHAND) != 0) {
3033      actp->sa_handler = SIG_DFL;
3034    }
3035
3036    // try to honor the signal mask
3037    sigset_t oset;
3038    pthread_sigmask(SIG_SETMASK, &(actp->sa_mask), &oset);
3039
3040    // call into the chained handler
3041    if (siginfo_flag_set) {
3042      (*sa)(sig, siginfo, context);
3043    } else {
3044      (*hand)(sig);
3045    }
3046
3047    // restore the signal mask
3048    pthread_sigmask(SIG_SETMASK, &oset, 0);
3049  }
3050  // Tell jvm's signal handler the signal is taken care of.
3051  return true;
3052}
3053
3054bool os::Aix::chained_handler(int sig, siginfo_t* siginfo, void* context) {
3055  bool chained = false;
3056  // signal-chaining
3057  if (UseSignalChaining) {
3058    struct sigaction *actp = get_chained_signal_action(sig);
3059    if (actp != NULL) {
3060      chained = call_chained_handler(actp, sig, siginfo, context);
3061    }
3062  }
3063  return chained;
3064}
3065
3066struct sigaction* os::Aix::get_preinstalled_handler(int sig) {
3067  if ((((unsigned int)1 << sig) & sigs) != 0) {
3068    return &sigact[sig];
3069  }
3070  return NULL;
3071}
3072
3073void os::Aix::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
3074  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3075  sigact[sig] = oldAct;
3076  sigs |= (unsigned int)1 << sig;
3077}
3078
3079// for diagnostic
3080int os::Aix::sigflags[MAXSIGNUM];
3081
3082int os::Aix::get_our_sigflags(int sig) {
3083  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3084  return sigflags[sig];
3085}
3086
3087void os::Aix::set_our_sigflags(int sig, int flags) {
3088  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3089  sigflags[sig] = flags;
3090}
3091
3092void os::Aix::set_signal_handler(int sig, bool set_installed) {
3093  // Check for overwrite.
3094  struct sigaction oldAct;
3095  sigaction(sig, (struct sigaction*)NULL, &oldAct);
3096
3097  void* oldhand = oldAct.sa_sigaction
3098    ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3099    : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3100  // Renamed 'signalHandler' to avoid collision with other shared libs.
3101  if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
3102      oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
3103      oldhand != CAST_FROM_FN_PTR(void*, (sa_sigaction_t)javaSignalHandler)) {
3104    if (AllowUserSignalHandlers || !set_installed) {
3105      // Do not overwrite; user takes responsibility to forward to us.
3106      return;
3107    } else if (UseSignalChaining) {
3108      // save the old handler in jvm
3109      save_preinstalled_handler(sig, oldAct);
3110      // libjsig also interposes the sigaction() call below and saves the
3111      // old sigaction on it own.
3112    } else {
3113      fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
3114                    "%#lx for signal %d.", (long)oldhand, sig));
3115    }
3116  }
3117
3118  struct sigaction sigAct;
3119  sigfillset(&(sigAct.sa_mask));
3120  if (!set_installed) {
3121    sigAct.sa_handler = SIG_DFL;
3122    sigAct.sa_flags = SA_RESTART;
3123  } else {
3124    // Renamed 'signalHandler' to avoid collision with other shared libs.
3125    sigAct.sa_sigaction = javaSignalHandler;
3126    sigAct.sa_flags = SA_SIGINFO|SA_RESTART;
3127  }
3128  // Save flags, which are set by ours
3129  assert(sig > 0 && sig < MAXSIGNUM, "vm signal out of expected range");
3130  sigflags[sig] = sigAct.sa_flags;
3131
3132  int ret = sigaction(sig, &sigAct, &oldAct);
3133  assert(ret == 0, "check");
3134
3135  void* oldhand2 = oldAct.sa_sigaction
3136                 ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
3137                 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
3138  assert(oldhand2 == oldhand, "no concurrent signal handler installation");
3139}
3140
3141// install signal handlers for signals that HotSpot needs to
3142// handle in order to support Java-level exception handling.
3143void os::Aix::install_signal_handlers() {
3144  if (!signal_handlers_are_installed) {
3145    signal_handlers_are_installed = true;
3146
3147    // signal-chaining
3148    typedef void (*signal_setting_t)();
3149    signal_setting_t begin_signal_setting = NULL;
3150    signal_setting_t end_signal_setting = NULL;
3151    begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3152                             dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
3153    if (begin_signal_setting != NULL) {
3154      end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
3155                             dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
3156      get_signal_action = CAST_TO_FN_PTR(get_signal_t,
3157                            dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
3158      libjsig_is_loaded = true;
3159      assert(UseSignalChaining, "should enable signal-chaining");
3160    }
3161    if (libjsig_is_loaded) {
3162      // Tell libjsig jvm is setting signal handlers
3163      (*begin_signal_setting)();
3164    }
3165
3166    set_signal_handler(SIGSEGV, true);
3167    set_signal_handler(SIGPIPE, true);
3168    set_signal_handler(SIGBUS, true);
3169    set_signal_handler(SIGILL, true);
3170    set_signal_handler(SIGFPE, true);
3171    set_signal_handler(SIGTRAP, true);
3172    set_signal_handler(SIGXFSZ, true);
3173    set_signal_handler(SIGDANGER, true);
3174
3175    if (libjsig_is_loaded) {
3176      // Tell libjsig jvm finishes setting signal handlers.
3177      (*end_signal_setting)();
3178    }
3179
3180    // We don't activate signal checker if libjsig is in place, we trust ourselves
3181    // and if UserSignalHandler is installed all bets are off.
3182    // Log that signal checking is off only if -verbose:jni is specified.
3183    if (CheckJNICalls) {
3184      if (libjsig_is_loaded) {
3185        tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
3186        check_signals = false;
3187      }
3188      if (AllowUserSignalHandlers) {
3189        tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
3190        check_signals = false;
3191      }
3192      // Need to initialize check_signal_done.
3193      ::sigemptyset(&check_signal_done);
3194    }
3195  }
3196}
3197
3198static const char* get_signal_handler_name(address handler,
3199                                           char* buf, int buflen) {
3200  int offset;
3201  bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
3202  if (found) {
3203    // skip directory names
3204    const char *p1, *p2;
3205    p1 = buf;
3206    size_t len = strlen(os::file_separator());
3207    while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
3208    // The way os::dll_address_to_library_name is implemented on Aix
3209    // right now, it always returns -1 for the offset which is not
3210    // terribly informative.
3211    // Will fix that. For now, omit the offset.
3212    jio_snprintf(buf, buflen, "%s", p1);
3213  } else {
3214    jio_snprintf(buf, buflen, PTR_FORMAT, handler);
3215  }
3216  return buf;
3217}
3218
3219static void print_signal_handler(outputStream* st, int sig,
3220                                 char* buf, size_t buflen) {
3221  struct sigaction sa;
3222  sigaction(sig, NULL, &sa);
3223
3224  st->print("%s: ", os::exception_name(sig, buf, buflen));
3225
3226  address handler = (sa.sa_flags & SA_SIGINFO)
3227    ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
3228    : CAST_FROM_FN_PTR(address, sa.sa_handler);
3229
3230  if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
3231    st->print("SIG_DFL");
3232  } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
3233    st->print("SIG_IGN");
3234  } else {
3235    st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
3236  }
3237
3238  // Print readable mask.
3239  st->print(", sa_mask[0]=");
3240  os::Posix::print_signal_set_short(st, &sa.sa_mask);
3241
3242  address rh = VMError::get_resetted_sighandler(sig);
3243  // May be, handler was resetted by VMError?
3244  if (rh != NULL) {
3245    handler = rh;
3246    sa.sa_flags = VMError::get_resetted_sigflags(sig);
3247  }
3248
3249  // Print textual representation of sa_flags.
3250  st->print(", sa_flags=");
3251  os::Posix::print_sa_flags(st, sa.sa_flags);
3252
3253  // Check: is it our handler?
3254  if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler) ||
3255      handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
3256    // It is our signal handler.
3257    // Check for flags, reset system-used one!
3258    if ((int)sa.sa_flags != os::Aix::get_our_sigflags(sig)) {
3259      st->print(", flags was changed from " PTR32_FORMAT ", consider using jsig library",
3260                os::Aix::get_our_sigflags(sig));
3261    }
3262  }
3263  st->cr();
3264}
3265
3266#define DO_SIGNAL_CHECK(sig) \
3267  if (!sigismember(&check_signal_done, sig)) \
3268    os::Aix::check_signal_handler(sig)
3269
3270// This method is a periodic task to check for misbehaving JNI applications
3271// under CheckJNI, we can add any periodic checks here
3272
3273void os::run_periodic_checks() {
3274
3275  if (check_signals == false) return;
3276
3277  // SEGV and BUS if overridden could potentially prevent
3278  // generation of hs*.log in the event of a crash, debugging
3279  // such a case can be very challenging, so we absolutely
3280  // check the following for a good measure:
3281  DO_SIGNAL_CHECK(SIGSEGV);
3282  DO_SIGNAL_CHECK(SIGILL);
3283  DO_SIGNAL_CHECK(SIGFPE);
3284  DO_SIGNAL_CHECK(SIGBUS);
3285  DO_SIGNAL_CHECK(SIGPIPE);
3286  DO_SIGNAL_CHECK(SIGXFSZ);
3287  if (UseSIGTRAP) {
3288    DO_SIGNAL_CHECK(SIGTRAP);
3289  }
3290  DO_SIGNAL_CHECK(SIGDANGER);
3291
3292  // ReduceSignalUsage allows the user to override these handlers
3293  // see comments at the very top and jvm_solaris.h
3294  if (!ReduceSignalUsage) {
3295    DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
3296    DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
3297    DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
3298    DO_SIGNAL_CHECK(BREAK_SIGNAL);
3299  }
3300
3301  DO_SIGNAL_CHECK(SR_signum);
3302  DO_SIGNAL_CHECK(INTERRUPT_SIGNAL);
3303}
3304
3305typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
3306
3307static os_sigaction_t os_sigaction = NULL;
3308
3309void os::Aix::check_signal_handler(int sig) {
3310  char buf[O_BUFLEN];
3311  address jvmHandler = NULL;
3312
3313  struct sigaction act;
3314  if (os_sigaction == NULL) {
3315    // only trust the default sigaction, in case it has been interposed
3316    os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction");
3317    if (os_sigaction == NULL) return;
3318  }
3319
3320  os_sigaction(sig, (struct sigaction*)NULL, &act);
3321
3322  address thisHandler = (act.sa_flags & SA_SIGINFO)
3323    ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
3324    : CAST_FROM_FN_PTR(address, act.sa_handler);
3325
3326  switch(sig) {
3327  case SIGSEGV:
3328  case SIGBUS:
3329  case SIGFPE:
3330  case SIGPIPE:
3331  case SIGILL:
3332  case SIGXFSZ:
3333    // Renamed 'signalHandler' to avoid collision with other shared libs.
3334    jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)javaSignalHandler);
3335    break;
3336
3337  case SHUTDOWN1_SIGNAL:
3338  case SHUTDOWN2_SIGNAL:
3339  case SHUTDOWN3_SIGNAL:
3340  case BREAK_SIGNAL:
3341    jvmHandler = (address)user_handler();
3342    break;
3343
3344  case INTERRUPT_SIGNAL:
3345    jvmHandler = CAST_FROM_FN_PTR(address, SIG_DFL);
3346    break;
3347
3348  default:
3349    if (sig == SR_signum) {
3350      jvmHandler = CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler);
3351    } else {
3352      return;
3353    }
3354    break;
3355  }
3356
3357  if (thisHandler != jvmHandler) {
3358    tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
3359    tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
3360    tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
3361    // No need to check this sig any longer
3362    sigaddset(&check_signal_done, sig);
3363    // Running under non-interactive shell, SHUTDOWN2_SIGNAL will be reassigned SIG_IGN
3364    if (sig == SHUTDOWN2_SIGNAL && !isatty(fileno(stdin))) {
3365      tty->print_cr("Running in non-interactive shell, %s handler is replaced by shell",
3366                    exception_name(sig, buf, O_BUFLEN));
3367    }
3368  } else if (os::Aix::get_our_sigflags(sig) != 0 && (int)act.sa_flags != os::Aix::get_our_sigflags(sig)) {
3369    tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
3370    tty->print("expected:" PTR32_FORMAT, os::Aix::get_our_sigflags(sig));
3371    tty->print_cr("  found:" PTR32_FORMAT, act.sa_flags);
3372    // No need to check this sig any longer
3373    sigaddset(&check_signal_done, sig);
3374  }
3375
3376  // Dump all the signal
3377  if (sigismember(&check_signal_done, sig)) {
3378    print_signal_handlers(tty, buf, O_BUFLEN);
3379  }
3380}
3381
3382extern bool signal_name(int signo, char* buf, size_t len);
3383
3384const char* os::exception_name(int exception_code, char* buf, size_t size) {
3385  if (0 < exception_code && exception_code <= SIGRTMAX) {
3386    // signal
3387    if (!signal_name(exception_code, buf, size)) {
3388      jio_snprintf(buf, size, "SIG%d", exception_code);
3389    }
3390    return buf;
3391  } else {
3392    return NULL;
3393  }
3394}
3395
3396// To install functions for atexit system call
3397extern "C" {
3398  static void perfMemory_exit_helper() {
3399    perfMemory_exit();
3400  }
3401}
3402
3403// This is called _before_ the most of global arguments have been parsed.
3404void os::init(void) {
3405  // This is basic, we want to know if that ever changes.
3406  // (Shared memory boundary is supposed to be a 256M aligned.)
3407  assert(SHMLBA == ((uint64_t)0x10000000ULL)/*256M*/, "unexpected");
3408
3409  // First off, we need to know whether we run on AIX or PASE, and
3410  // the OS level we run on.
3411  os::Aix::initialize_os_info();
3412
3413  // Scan environment (SPEC1170 behaviour, etc).
3414  os::Aix::scan_environment();
3415
3416  // Check which pages are supported by AIX.
3417  query_multipage_support();
3418
3419  // Act like we only have one page size by eliminating corner cases which
3420  // we did not support very well anyway.
3421  // We have two input conditions:
3422  // 1) Data segment page size. This is controlled by linker setting (datapsize) on the
3423  //    launcher, and/or by LDR_CNTRL environment variable. The latter overrules the linker
3424  //    setting.
3425  //    Data segment page size is important for us because it defines the thread stack page
3426  //    size, which is needed for guard page handling, stack banging etc.
3427  // 2) The ability to allocate 64k pages dynamically. If this is a given, java heap can
3428  //    and should be allocated with 64k pages.
3429  //
3430  // So, we do the following:
3431  // LDR_CNTRL    can_use_64K_pages_dynamically       what we do                      remarks
3432  // 4K           no                                  4K                              old systems (aix 5.2, as/400 v5r4) or new systems with AME activated
3433  // 4k           yes                                 64k (treat 4k stacks as 64k)    different loader than java and standard settings
3434  // 64k          no              --- AIX 5.2 ? ---
3435  // 64k          yes                                 64k                             new systems and standard java loader (we set datapsize=64k when linking)
3436
3437  // We explicitly leave no option to change page size, because only upgrading would work,
3438  // not downgrading (if stack page size is 64k you cannot pretend its 4k).
3439
3440  if (g_multipage_support.datapsize == SIZE_4K) {
3441    // datapsize = 4K. Data segment, thread stacks are 4K paged.
3442    if (g_multipage_support.can_use_64K_pages) {
3443      // .. but we are able to use 64K pages dynamically.
3444      // This would be typical for java launchers which are not linked
3445      // with datapsize=64K (like, any other launcher but our own).
3446      //
3447      // In this case it would be smart to allocate the java heap with 64K
3448      // to get the performance benefit, and to fake 64k pages for the
3449      // data segment (when dealing with thread stacks).
3450      //
3451      // However, leave a possibility to downgrade to 4K, using
3452      // -XX:-Use64KPages.
3453      if (Use64KPages) {
3454        trcVerbose("64K page mode (faked for data segment)");
3455        Aix::_page_size = SIZE_64K;
3456      } else {
3457        trcVerbose("4K page mode (Use64KPages=off)");
3458        Aix::_page_size = SIZE_4K;
3459      }
3460    } else {
3461      // .. and not able to allocate 64k pages dynamically. Here, just
3462      // fall back to 4K paged mode and use mmap for everything.
3463      trcVerbose("4K page mode");
3464      Aix::_page_size = SIZE_4K;
3465      FLAG_SET_ERGO(bool, Use64KPages, false);
3466    }
3467  } else {
3468    // datapsize = 64k. Data segment, thread stacks are 64k paged.
3469    //   This normally means that we can allocate 64k pages dynamically.
3470    //   (There is one special case where this may be false: EXTSHM=on.
3471    //    but we decided to not support that mode).
3472    assert0(g_multipage_support.can_use_64K_pages);
3473    Aix::_page_size = SIZE_64K;
3474    trcVerbose("64K page mode");
3475    FLAG_SET_ERGO(bool, Use64KPages, true);
3476  }
3477
3478  // Short-wire stack page size to base page size; if that works, we just remove
3479  // that stack page size altogether.
3480  Aix::_stack_page_size = Aix::_page_size;
3481
3482  // For now UseLargePages is just ignored.
3483  FLAG_SET_ERGO(bool, UseLargePages, false);
3484  _page_sizes[0] = 0;
3485  _large_page_size = -1;
3486
3487  // debug trace
3488  trcVerbose("os::vm_page_size %s\n", describe_pagesize(os::vm_page_size()));
3489
3490  // Next, we need to initialize libo4 and libperfstat libraries.
3491  if (os::Aix::on_pase()) {
3492    os::Aix::initialize_libo4();
3493  } else {
3494    os::Aix::initialize_libperfstat();
3495  }
3496
3497  // Reset the perfstat information provided by ODM.
3498  if (os::Aix::on_aix()) {
3499    libperfstat::perfstat_reset();
3500  }
3501
3502  // Now initialze basic system properties. Note that for some of the values we
3503  // need libperfstat etc.
3504  os::Aix::initialize_system_info();
3505
3506  _initial_pid = getpid();
3507
3508  clock_tics_per_sec = sysconf(_SC_CLK_TCK);
3509
3510  init_random(1234567);
3511
3512  ThreadCritical::initialize();
3513
3514  // Main_thread points to the aboriginal thread.
3515  Aix::_main_thread = pthread_self();
3516
3517  initial_time_count = os::elapsed_counter();
3518
3519  // If the pagesize of the VM is greater than 8K determine the appropriate
3520  // number of initial guard pages. The user can change this with the
3521  // command line arguments, if needed.
3522  if (vm_page_size() > (int)Aix::vm_default_page_size()) {
3523    StackYellowPages = 1;
3524    StackRedPages = 1;
3525    StackShadowPages = round_to((StackShadowPages*Aix::vm_default_page_size()), vm_page_size()) / vm_page_size();
3526  }
3527}
3528
3529// This is called _after_ the global arguments have been parsed.
3530jint os::init_2(void) {
3531
3532  trcVerbose("processor count: %d", os::_processor_count);
3533  trcVerbose("physical memory: %lu", Aix::_physical_memory);
3534
3535  // Initially build up the loaded dll map.
3536  LoadedLibraries::reload();
3537
3538  const int page_size = Aix::page_size();
3539  const int map_size = page_size;
3540
3541  address map_address = (address) MAP_FAILED;
3542  const int prot  = PROT_READ;
3543  const int flags = MAP_PRIVATE|MAP_ANONYMOUS;
3544
3545  // Use optimized addresses for the polling page,
3546  // e.g. map it to a special 32-bit address.
3547  if (OptimizePollingPageLocation) {
3548    // architecture-specific list of address wishes:
3549    address address_wishes[] = {
3550      // AIX: addresses lower than 0x30000000 don't seem to work on AIX.
3551      // PPC64: all address wishes are non-negative 32 bit values where
3552      // the lower 16 bits are all zero. we can load these addresses
3553      // with a single ppc_lis instruction.
3554      (address) 0x30000000, (address) 0x31000000,
3555      (address) 0x32000000, (address) 0x33000000,
3556      (address) 0x40000000, (address) 0x41000000,
3557      (address) 0x42000000, (address) 0x43000000,
3558      (address) 0x50000000, (address) 0x51000000,
3559      (address) 0x52000000, (address) 0x53000000,
3560      (address) 0x60000000, (address) 0x61000000,
3561      (address) 0x62000000, (address) 0x63000000
3562    };
3563    int address_wishes_length = sizeof(address_wishes)/sizeof(address);
3564
3565    // iterate over the list of address wishes:
3566    for (int i=0; i<address_wishes_length; i++) {
3567      // Try to map with current address wish.
3568      // AIX: AIX needs MAP_FIXED if we provide an address and mmap will
3569      // fail if the address is already mapped.
3570      map_address = (address) ::mmap(address_wishes[i] - (ssize_t)page_size,
3571                                     map_size, prot,
3572                                     flags | MAP_FIXED,
3573                                     -1, 0);
3574      if (Verbose) {
3575        fprintf(stderr, "SafePoint Polling Page address: %p (wish) => %p\n",
3576                address_wishes[i], map_address + (ssize_t)page_size);
3577      }
3578
3579      if (map_address + (ssize_t)page_size == address_wishes[i]) {
3580        // Map succeeded and map_address is at wished address, exit loop.
3581        break;
3582      }
3583
3584      if (map_address != (address) MAP_FAILED) {
3585        // Map succeeded, but polling_page is not at wished address, unmap and continue.
3586        ::munmap(map_address, map_size);
3587        map_address = (address) MAP_FAILED;
3588      }
3589      // Map failed, continue loop.
3590    }
3591  } // end OptimizePollingPageLocation
3592
3593  if (map_address == (address) MAP_FAILED) {
3594    map_address = (address) ::mmap(NULL, map_size, prot, flags, -1, 0);
3595  }
3596  guarantee(map_address != MAP_FAILED, "os::init_2: failed to allocate polling page");
3597  os::set_polling_page(map_address);
3598
3599  if (!UseMembar) {
3600    address mem_serialize_page = (address) ::mmap(NULL, Aix::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
3601    guarantee(mem_serialize_page != NULL, "mmap Failed for memory serialize page");
3602    os::set_memory_serialize_page(mem_serialize_page);
3603
3604#ifndef PRODUCT
3605    if (Verbose && PrintMiscellaneous) {
3606      tty->print("[Memory Serialize Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
3607    }
3608#endif
3609  }
3610
3611  // initialize suspend/resume support - must do this before signal_sets_init()
3612  if (SR_initialize() != 0) {
3613    perror("SR_initialize failed");
3614    return JNI_ERR;
3615  }
3616
3617  Aix::signal_sets_init();
3618  Aix::install_signal_handlers();
3619
3620  // Check minimum allowable stack size for thread creation and to initialize
3621  // the java system classes, including StackOverflowError - depends on page
3622  // size. Add a page for compiler2 recursion in main thread.
3623  // Add in 2*BytesPerWord times page size to account for VM stack during
3624  // class initialization depending on 32 or 64 bit VM.
3625  os::Aix::min_stack_allowed = MAX2(os::Aix::min_stack_allowed,
3626            (size_t)(StackYellowPages+StackRedPages+StackShadowPages) * Aix::page_size() +
3627                     (2*BytesPerWord COMPILER2_PRESENT(+1)) * Aix::vm_default_page_size());
3628
3629  os::Aix::min_stack_allowed = align_size_up(os::Aix::min_stack_allowed, os::Aix::page_size());
3630
3631  size_t threadStackSizeInBytes = ThreadStackSize * K;
3632  if (threadStackSizeInBytes != 0 &&
3633      threadStackSizeInBytes < os::Aix::min_stack_allowed) {
3634    tty->print_cr("\nThe stack size specified is too small, "
3635                  "Specify at least %dk",
3636                  os::Aix::min_stack_allowed / K);
3637    return JNI_ERR;
3638  }
3639
3640  // Make the stack size a multiple of the page size so that
3641  // the yellow/red zones can be guarded.
3642  // Note that this can be 0, if no default stacksize was set.
3643  JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes, vm_page_size()));
3644
3645  Aix::libpthread_init();
3646
3647  if (MaxFDLimit) {
3648    // Set the number of file descriptors to max. print out error
3649    // if getrlimit/setrlimit fails but continue regardless.
3650    struct rlimit nbr_files;
3651    int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
3652    if (status != 0) {
3653      if (PrintMiscellaneous && (Verbose || WizardMode))
3654        perror("os::init_2 getrlimit failed");
3655    } else {
3656      nbr_files.rlim_cur = nbr_files.rlim_max;
3657      status = setrlimit(RLIMIT_NOFILE, &nbr_files);
3658      if (status != 0) {
3659        if (PrintMiscellaneous && (Verbose || WizardMode))
3660          perror("os::init_2 setrlimit failed");
3661      }
3662    }
3663  }
3664
3665  if (PerfAllowAtExitRegistration) {
3666    // Only register atexit functions if PerfAllowAtExitRegistration is set.
3667    // Atexit functions can be delayed until process exit time, which
3668    // can be problematic for embedded VM situations. Embedded VMs should
3669    // call DestroyJavaVM() to assure that VM resources are released.
3670
3671    // Note: perfMemory_exit_helper atexit function may be removed in
3672    // the future if the appropriate cleanup code can be added to the
3673    // VM_Exit VMOperation's doit method.
3674    if (atexit(perfMemory_exit_helper) != 0) {
3675      warning("os::init_2 atexit(perfMemory_exit_helper) failed");
3676    }
3677  }
3678
3679  return JNI_OK;
3680}
3681
3682// Mark the polling page as unreadable
3683void os::make_polling_page_unreadable(void) {
3684  if (!guard_memory((char*)_polling_page, Aix::page_size())) {
3685    fatal("Could not disable polling page");
3686  }
3687};
3688
3689// Mark the polling page as readable
3690void os::make_polling_page_readable(void) {
3691  // Changed according to os_linux.cpp.
3692  if (!checked_mprotect((char *)_polling_page, Aix::page_size(), PROT_READ)) {
3693    fatal(err_msg("Could not enable polling page at " PTR_FORMAT, _polling_page));
3694  }
3695};
3696
3697int os::active_processor_count() {
3698  int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
3699  assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check");
3700  return online_cpus;
3701}
3702
3703void os::set_native_thread_name(const char *name) {
3704  // Not yet implemented.
3705  return;
3706}
3707
3708bool os::distribute_processes(uint length, uint* distribution) {
3709  // Not yet implemented.
3710  return false;
3711}
3712
3713bool os::bind_to_processor(uint processor_id) {
3714  // Not yet implemented.
3715  return false;
3716}
3717
3718void os::SuspendedThreadTask::internal_do_task() {
3719  if (do_suspend(_thread->osthread())) {
3720    SuspendedThreadTaskContext context(_thread, _thread->osthread()->ucontext());
3721    do_task(context);
3722    do_resume(_thread->osthread());
3723  }
3724}
3725
3726class PcFetcher : public os::SuspendedThreadTask {
3727public:
3728  PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
3729  ExtendedPC result();
3730protected:
3731  void do_task(const os::SuspendedThreadTaskContext& context);
3732private:
3733  ExtendedPC _epc;
3734};
3735
3736ExtendedPC PcFetcher::result() {
3737  guarantee(is_done(), "task is not done yet.");
3738  return _epc;
3739}
3740
3741void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) {
3742  Thread* thread = context.thread();
3743  OSThread* osthread = thread->osthread();
3744  if (osthread->ucontext() != NULL) {
3745    _epc = os::Aix::ucontext_get_pc((ucontext_t *) context.ucontext());
3746  } else {
3747    // NULL context is unexpected, double-check this is the VMThread.
3748    guarantee(thread->is_VM_thread(), "can only be called for VMThread");
3749  }
3750}
3751
3752// Suspends the target using the signal mechanism and then grabs the PC before
3753// resuming the target. Used by the flat-profiler only
3754ExtendedPC os::get_thread_pc(Thread* thread) {
3755  // Make sure that it is called by the watcher for the VMThread.
3756  assert(Thread::current()->is_Watcher_thread(), "Must be watcher");
3757  assert(thread->is_VM_thread(), "Can only be called for VMThread");
3758
3759  PcFetcher fetcher(thread);
3760  fetcher.run();
3761  return fetcher.result();
3762}
3763
3764// Not neede on Aix.
3765// int os::Aix::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime) {
3766// }
3767
3768////////////////////////////////////////////////////////////////////////////////
3769// debug support
3770
3771static address same_page(address x, address y) {
3772  intptr_t page_bits = -os::vm_page_size();
3773  if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
3774    return x;
3775  else if (x > y)
3776    return (address)(intptr_t(y) | ~page_bits) + 1;
3777  else
3778    return (address)(intptr_t(y) & page_bits);
3779}
3780
3781bool os::find(address addr, outputStream* st) {
3782
3783  st->print(PTR_FORMAT ": ", addr);
3784
3785  const LoadedLibraryModule* lib = LoadedLibraries::find_for_text_address(addr);
3786  if (lib) {
3787    lib->print(st);
3788    return true;
3789  } else {
3790    lib = LoadedLibraries::find_for_data_address(addr);
3791    if (lib) {
3792      lib->print(st);
3793      return true;
3794    } else {
3795      st->print_cr("(outside any module)");
3796    }
3797  }
3798
3799  return false;
3800}
3801
3802////////////////////////////////////////////////////////////////////////////////
3803// misc
3804
3805// This does not do anything on Aix. This is basically a hook for being
3806// able to use structured exception handling (thread-local exception filters)
3807// on, e.g., Win32.
3808void
3809os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method,
3810                         JavaCallArguments* args, Thread* thread) {
3811  f(value, method, args, thread);
3812}
3813
3814void os::print_statistics() {
3815}
3816
3817int os::message_box(const char* title, const char* message) {
3818  int i;
3819  fdStream err(defaultStream::error_fd());
3820  for (i = 0; i < 78; i++) err.print_raw("=");
3821  err.cr();
3822  err.print_raw_cr(title);
3823  for (i = 0; i < 78; i++) err.print_raw("-");
3824  err.cr();
3825  err.print_raw_cr(message);
3826  for (i = 0; i < 78; i++) err.print_raw("=");
3827  err.cr();
3828
3829  char buf[16];
3830  // Prevent process from exiting upon "read error" without consuming all CPU
3831  while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
3832
3833  return buf[0] == 'y' || buf[0] == 'Y';
3834}
3835
3836int os::stat(const char *path, struct stat *sbuf) {
3837  char pathbuf[MAX_PATH];
3838  if (strlen(path) > MAX_PATH - 1) {
3839    errno = ENAMETOOLONG;
3840    return -1;
3841  }
3842  os::native_path(strcpy(pathbuf, path));
3843  return ::stat(pathbuf, sbuf);
3844}
3845
3846bool os::check_heap(bool force) {
3847  return true;
3848}
3849
3850// Is a (classpath) directory empty?
3851bool os::dir_is_empty(const char* path) {
3852  DIR *dir = NULL;
3853  struct dirent *ptr;
3854
3855  dir = opendir(path);
3856  if (dir == NULL) return true;
3857
3858  /* Scan the directory */
3859  bool result = true;
3860  char buf[sizeof(struct dirent) + MAX_PATH];
3861  while (result && (ptr = ::readdir(dir)) != NULL) {
3862    if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
3863      result = false;
3864    }
3865  }
3866  closedir(dir);
3867  return result;
3868}
3869
3870// This code originates from JDK's sysOpen and open64_w
3871// from src/solaris/hpi/src/system_md.c
3872
3873int os::open(const char *path, int oflag, int mode) {
3874
3875  if (strlen(path) > MAX_PATH - 1) {
3876    errno = ENAMETOOLONG;
3877    return -1;
3878  }
3879  int fd;
3880
3881  fd = ::open64(path, oflag, mode);
3882  if (fd == -1) return -1;
3883
3884  // If the open succeeded, the file might still be a directory.
3885  {
3886    struct stat64 buf64;
3887    int ret = ::fstat64(fd, &buf64);
3888    int st_mode = buf64.st_mode;
3889
3890    if (ret != -1) {
3891      if ((st_mode & S_IFMT) == S_IFDIR) {
3892        errno = EISDIR;
3893        ::close(fd);
3894        return -1;
3895      }
3896    } else {
3897      ::close(fd);
3898      return -1;
3899    }
3900  }
3901
3902  // All file descriptors that are opened in the JVM and not
3903  // specifically destined for a subprocess should have the
3904  // close-on-exec flag set. If we don't set it, then careless 3rd
3905  // party native code might fork and exec without closing all
3906  // appropriate file descriptors (e.g. as we do in closeDescriptors in
3907  // UNIXProcess.c), and this in turn might:
3908  //
3909  // - cause end-of-file to fail to be detected on some file
3910  //   descriptors, resulting in mysterious hangs, or
3911  //
3912  // - might cause an fopen in the subprocess to fail on a system
3913  //   suffering from bug 1085341.
3914  //
3915  // (Yes, the default setting of the close-on-exec flag is a Unix
3916  // design flaw.)
3917  //
3918  // See:
3919  // 1085341: 32-bit stdio routines should support file descriptors >255
3920  // 4843136: (process) pipe file descriptor from Runtime.exec not being closed
3921  // 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
3922#ifdef FD_CLOEXEC
3923  {
3924    int flags = ::fcntl(fd, F_GETFD);
3925    if (flags != -1)
3926      ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
3927  }
3928#endif
3929
3930  return fd;
3931}
3932
3933// create binary file, rewriting existing file if required
3934int os::create_binary_file(const char* path, bool rewrite_existing) {
3935  int oflags = O_WRONLY | O_CREAT;
3936  if (!rewrite_existing) {
3937    oflags |= O_EXCL;
3938  }
3939  return ::open64(path, oflags, S_IREAD | S_IWRITE);
3940}
3941
3942// return current position of file pointer
3943jlong os::current_file_offset(int fd) {
3944  return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
3945}
3946
3947// move file pointer to the specified offset
3948jlong os::seek_to_file_offset(int fd, jlong offset) {
3949  return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
3950}
3951
3952// This code originates from JDK's sysAvailable
3953// from src/solaris/hpi/src/native_threads/src/sys_api_td.c
3954
3955int os::available(int fd, jlong *bytes) {
3956  jlong cur, end;
3957  int mode;
3958  struct stat64 buf64;
3959
3960  if (::fstat64(fd, &buf64) >= 0) {
3961    mode = buf64.st_mode;
3962    if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
3963      // XXX: is the following call interruptible? If so, this might
3964      // need to go through the INTERRUPT_IO() wrapper as for other
3965      // blocking, interruptible calls in this file.
3966      int n;
3967      if (::ioctl(fd, FIONREAD, &n) >= 0) {
3968        *bytes = n;
3969        return 1;
3970      }
3971    }
3972  }
3973  if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
3974    return 0;
3975  } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
3976    return 0;
3977  } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
3978    return 0;
3979  }
3980  *bytes = end - cur;
3981  return 1;
3982}
3983
3984// Map a block of memory.
3985char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
3986                        char *addr, size_t bytes, bool read_only,
3987                        bool allow_exec) {
3988  int prot;
3989  int flags = MAP_PRIVATE;
3990
3991  if (read_only) {
3992    prot = PROT_READ;
3993    flags = MAP_SHARED;
3994  } else {
3995    prot = PROT_READ | PROT_WRITE;
3996    flags = MAP_PRIVATE;
3997  }
3998
3999  if (allow_exec) {
4000    prot |= PROT_EXEC;
4001  }
4002
4003  if (addr != NULL) {
4004    flags |= MAP_FIXED;
4005  }
4006
4007  // Allow anonymous mappings if 'fd' is -1.
4008  if (fd == -1) {
4009    flags |= MAP_ANONYMOUS;
4010  }
4011
4012  char* mapped_address = (char*)::mmap(addr, (size_t)bytes, prot, flags,
4013                                     fd, file_offset);
4014  if (mapped_address == MAP_FAILED) {
4015    return NULL;
4016  }
4017  return mapped_address;
4018}
4019
4020// Remap a block of memory.
4021char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
4022                          char *addr, size_t bytes, bool read_only,
4023                          bool allow_exec) {
4024  // same as map_memory() on this OS
4025  return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
4026                        allow_exec);
4027}
4028
4029// Unmap a block of memory.
4030bool os::pd_unmap_memory(char* addr, size_t bytes) {
4031  return munmap(addr, bytes) == 0;
4032}
4033
4034// current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
4035// are used by JVM M&M and JVMTI to get user+sys or user CPU time
4036// of a thread.
4037//
4038// current_thread_cpu_time() and thread_cpu_time(Thread*) returns
4039// the fast estimate available on the platform.
4040
4041jlong os::current_thread_cpu_time() {
4042  // return user + sys since the cost is the same
4043  const jlong n = os::thread_cpu_time(Thread::current(), true /* user + sys */);
4044  assert(n >= 0, "negative CPU time");
4045  return n;
4046}
4047
4048jlong os::thread_cpu_time(Thread* thread) {
4049  // consistent with what current_thread_cpu_time() returns
4050  const jlong n = os::thread_cpu_time(thread, true /* user + sys */);
4051  assert(n >= 0, "negative CPU time");
4052  return n;
4053}
4054
4055jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
4056  const jlong n = os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
4057  assert(n >= 0, "negative CPU time");
4058  return n;
4059}
4060
4061static bool thread_cpu_time_unchecked(Thread* thread, jlong* p_sys_time, jlong* p_user_time) {
4062  bool error = false;
4063
4064  jlong sys_time = 0;
4065  jlong user_time = 0;
4066
4067  // Reimplemented using getthrds64().
4068  //
4069  // Works like this:
4070  // For the thread in question, get the kernel thread id. Then get the
4071  // kernel thread statistics using that id.
4072  //
4073  // This only works of course when no pthread scheduling is used,
4074  // i.e. there is a 1:1 relationship to kernel threads.
4075  // On AIX, see AIXTHREAD_SCOPE variable.
4076
4077  pthread_t pthtid = thread->osthread()->pthread_id();
4078
4079  // retrieve kernel thread id for the pthread:
4080  tid64_t tid = 0;
4081  struct __pthrdsinfo pinfo;
4082  // I just love those otherworldly IBM APIs which force me to hand down
4083  // dummy buffers for stuff I dont care for...
4084  char dummy[1];
4085  int dummy_size = sizeof(dummy);
4086  if (pthread_getthrds_np(&pthtid, PTHRDSINFO_QUERY_TID, &pinfo, sizeof(pinfo),
4087                          dummy, &dummy_size) == 0) {
4088    tid = pinfo.__pi_tid;
4089  } else {
4090    tty->print_cr("pthread_getthrds_np failed.");
4091    error = true;
4092  }
4093
4094  // retrieve kernel timing info for that kernel thread
4095  if (!error) {
4096    struct thrdentry64 thrdentry;
4097    if (getthrds64(getpid(), &thrdentry, sizeof(thrdentry), &tid, 1) == 1) {
4098      sys_time = thrdentry.ti_ru.ru_stime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_stime.tv_usec * 1000LL;
4099      user_time = thrdentry.ti_ru.ru_utime.tv_sec * 1000000000LL + thrdentry.ti_ru.ru_utime.tv_usec * 1000LL;
4100    } else {
4101      tty->print_cr("pthread_getthrds_np failed.");
4102      error = true;
4103    }
4104  }
4105
4106  if (p_sys_time) {
4107    *p_sys_time = sys_time;
4108  }
4109
4110  if (p_user_time) {
4111    *p_user_time = user_time;
4112  }
4113
4114  if (error) {
4115    return false;
4116  }
4117
4118  return true;
4119}
4120
4121jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
4122  jlong sys_time;
4123  jlong user_time;
4124
4125  if (!thread_cpu_time_unchecked(thread, &sys_time, &user_time)) {
4126    return -1;
4127  }
4128
4129  return user_sys_cpu_time ? sys_time + user_time : user_time;
4130}
4131
4132void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4133  info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4134  info_ptr->may_skip_backward = false;     // elapsed time not wall time
4135  info_ptr->may_skip_forward = false;      // elapsed time not wall time
4136  info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4137}
4138
4139void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
4140  info_ptr->max_value = ALL_64_BITS;       // will not wrap in less than 64 bits
4141  info_ptr->may_skip_backward = false;     // elapsed time not wall time
4142  info_ptr->may_skip_forward = false;      // elapsed time not wall time
4143  info_ptr->kind = JVMTI_TIMER_TOTAL_CPU;  // user+system time is returned
4144}
4145
4146bool os::is_thread_cpu_time_supported() {
4147  return true;
4148}
4149
4150// System loadavg support. Returns -1 if load average cannot be obtained.
4151// For now just return the system wide load average (no processor sets).
4152int os::loadavg(double values[], int nelem) {
4153
4154  // Implemented using libperfstat on AIX.
4155
4156  guarantee(nelem >= 0 && nelem <= 3, "argument error");
4157  guarantee(values, "argument error");
4158
4159  if (os::Aix::on_pase()) {
4160    Unimplemented();
4161    return -1;
4162  } else {
4163    // AIX: use libperfstat
4164    //
4165    // See also:
4166    // http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/perfstat_cputot.htm
4167    // /usr/include/libperfstat.h:
4168
4169    // Use the already AIX version independent get_cpuinfo.
4170    os::Aix::cpuinfo_t ci;
4171    if (os::Aix::get_cpuinfo(&ci)) {
4172      for (int i = 0; i < nelem; i++) {
4173        values[i] = ci.loadavg[i];
4174      }
4175    } else {
4176      return -1;
4177    }
4178    return nelem;
4179  }
4180}
4181
4182void os::pause() {
4183  char filename[MAX_PATH];
4184  if (PauseAtStartupFile && PauseAtStartupFile[0]) {
4185    jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
4186  } else {
4187    jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
4188  }
4189
4190  int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
4191  if (fd != -1) {
4192    struct stat buf;
4193    ::close(fd);
4194    while (::stat(filename, &buf) == 0) {
4195      (void)::poll(NULL, 0, 100);
4196    }
4197  } else {
4198    jio_fprintf(stderr,
4199      "Could not open pause file '%s', continuing immediately.\n", filename);
4200  }
4201}
4202
4203bool os::Aix::is_primordial_thread() {
4204  if (pthread_self() == (pthread_t)1) {
4205    return true;
4206  } else {
4207    return false;
4208  }
4209}
4210
4211// OS recognitions (PASE/AIX, OS level) call this before calling any
4212// one of Aix::on_pase(), Aix::os_version() static
4213void os::Aix::initialize_os_info() {
4214
4215  assert(_on_pase == -1 && _os_version == -1, "already called.");
4216
4217  struct utsname uts;
4218  memset(&uts, 0, sizeof(uts));
4219  strcpy(uts.sysname, "?");
4220  if (::uname(&uts) == -1) {
4221    trc("uname failed (%d)", errno);
4222    guarantee(0, "Could not determine whether we run on AIX or PASE");
4223  } else {
4224    trcVerbose("uname says: sysname \"%s\" version \"%s\" release \"%s\" "
4225               "node \"%s\" machine \"%s\"\n",
4226               uts.sysname, uts.version, uts.release, uts.nodename, uts.machine);
4227    const int major = atoi(uts.version);
4228    assert(major > 0, "invalid OS version");
4229    const int minor = atoi(uts.release);
4230    assert(minor > 0, "invalid OS release");
4231    _os_version = (major << 8) | minor;
4232    if (strcmp(uts.sysname, "OS400") == 0) {
4233      Unimplemented();
4234    } else if (strcmp(uts.sysname, "AIX") == 0) {
4235      // We run on AIX. We do not support versions older than AIX 5.3.
4236      _on_pase = 0;
4237      if (_os_version < 0x0503) {
4238        trc("AIX release older than AIX 5.3 not supported.");
4239        assert(false, "AIX release too old.");
4240      } else {
4241        trcVerbose("We run on AIX %d.%d\n", major, minor);
4242      }
4243    } else {
4244      assert(false, "unknown OS");
4245    }
4246  }
4247
4248  guarantee(_on_pase != -1 && _os_version, "Could not determine AIX/OS400 release");
4249} // end: os::Aix::initialize_os_info()
4250
4251// Scan environment for important settings which might effect the VM.
4252// Trace out settings. Warn about invalid settings and/or correct them.
4253//
4254// Must run after os::Aix::initialue_os_info().
4255void os::Aix::scan_environment() {
4256
4257  char* p;
4258  int rc;
4259
4260  // Warn explicity if EXTSHM=ON is used. That switch changes how
4261  // System V shared memory behaves. One effect is that page size of
4262  // shared memory cannot be change dynamically, effectivly preventing
4263  // large pages from working.
4264  // This switch was needed on AIX 32bit, but on AIX 64bit the general
4265  // recommendation is (in OSS notes) to switch it off.
4266  p = ::getenv("EXTSHM");
4267  if (Verbose) {
4268    fprintf(stderr, "EXTSHM=%s.\n", p ? p : "<unset>");
4269  }
4270  if (p && strcasecmp(p, "ON") == 0) {
4271    fprintf(stderr, "Unsupported setting: EXTSHM=ON. Large Page support will be disabled.\n");
4272    _extshm = 1;
4273  } else {
4274    _extshm = 0;
4275  }
4276
4277  // SPEC1170 behaviour: will change the behaviour of a number of POSIX APIs.
4278  // Not tested, not supported.
4279  //
4280  // Note that it might be worth the trouble to test and to require it, if only to
4281  // get useful return codes for mprotect.
4282  //
4283  // Note: Setting XPG_SUS_ENV in the process is too late. Must be set earlier (before
4284  // exec() ? before loading the libjvm ? ....)
4285  p = ::getenv("XPG_SUS_ENV");
4286  trcVerbose("XPG_SUS_ENV=%s.", p ? p : "<unset>");
4287  if (p && strcmp(p, "ON") == 0) {
4288    _xpg_sus_mode = 1;
4289    trc("Unsupported setting: XPG_SUS_ENV=ON");
4290    // This is not supported. Worst of all, it changes behaviour of mmap MAP_FIXED to
4291    // clobber address ranges. If we ever want to support that, we have to do some
4292    // testing first.
4293    guarantee(false, "XPG_SUS_ENV=ON not supported");
4294  } else {
4295    _xpg_sus_mode = 0;
4296  }
4297
4298  // Switch off AIX internal (pthread) guard pages. This has
4299  // immediate effect for any pthread_create calls which follow.
4300  p = ::getenv("AIXTHREAD_GUARDPAGES");
4301  trcVerbose("AIXTHREAD_GUARDPAGES=%s.", p ? p : "<unset>");
4302  rc = ::putenv("AIXTHREAD_GUARDPAGES=0");
4303  guarantee(rc == 0, "");
4304
4305} // end: os::Aix::scan_environment()
4306
4307// PASE: initialize the libo4 library (AS400 PASE porting library).
4308void os::Aix::initialize_libo4() {
4309  Unimplemented();
4310}
4311
4312// AIX: initialize the libperfstat library (we load this dynamically
4313// because it is only available on AIX.
4314void os::Aix::initialize_libperfstat() {
4315
4316  assert(os::Aix::on_aix(), "AIX only");
4317
4318  if (!libperfstat::init()) {
4319    trc("libperfstat initialization failed.");
4320    assert(false, "libperfstat initialization failed");
4321  } else {
4322    if (Verbose) {
4323      fprintf(stderr, "libperfstat initialized.\n");
4324    }
4325  }
4326} // end: os::Aix::initialize_libperfstat
4327
4328/////////////////////////////////////////////////////////////////////////////
4329// thread stack
4330
4331// Function to query the current stack size using pthread_getthrds_np.
4332static bool query_stack_dimensions(address* p_stack_base, size_t* p_stack_size) {
4333  // This only works when invoked on a pthread. As we agreed not to use
4334  // primordial threads anyway, I assert here.
4335  guarantee(!os::Aix::is_primordial_thread(), "not allowed on the primordial thread");
4336
4337  // Information about this api can be found (a) in the pthread.h header and
4338  // (b) in http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.basetechref/doc/basetrf1/pthread_getthrds_np.htm
4339  //
4340  // The use of this API to find out the current stack is kind of undefined.
4341  // But after a lot of tries and asking IBM about it, I concluded that it is safe
4342  // enough for cases where I let the pthread library create its stacks. For cases
4343  // where I create an own stack and pass this to pthread_create, it seems not to
4344  // work (the returned stack size in that case is 0).
4345
4346  pthread_t tid = pthread_self();
4347  struct __pthrdsinfo pinfo;
4348  char dummy[1]; // We only need this to satisfy the api and to not get E.
4349  int dummy_size = sizeof(dummy);
4350
4351  memset(&pinfo, 0, sizeof(pinfo));
4352
4353  const int rc = pthread_getthrds_np(&tid, PTHRDSINFO_QUERY_ALL, &pinfo,
4354                                     sizeof(pinfo), dummy, &dummy_size);
4355
4356  if (rc != 0) {
4357    assert0(false);
4358    trcVerbose("pthread_getthrds_np failed (%d)", rc);
4359    return false;
4360  }
4361  guarantee0(pinfo.__pi_stackend);
4362
4363  // The following can happen when invoking pthread_getthrds_np on a pthread running
4364  // on a user provided stack (when handing down a stack to pthread create, see
4365  // pthread_attr_setstackaddr).
4366  // Not sure what to do here - I feel inclined to forbid this use case completely.
4367  guarantee0(pinfo.__pi_stacksize);
4368
4369  // Note: the pthread stack on AIX seems to look like this:
4370  //
4371  // ---------------------   real base ? at page border ?
4372  //
4373  //     pthread internal data, like ~2K, see also
4374  //     http://publib.boulder.ibm.com/infocenter/pseries/v5r3/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/thread_supp_tun_params.htm
4375  //
4376  // ---------------------   __pi_stackend - not page aligned, (xxxxF890)
4377  //
4378  //     stack
4379  //      ....
4380  //
4381  //     stack
4382  //
4383  // ---------------------   __pi_stackend  - __pi_stacksize
4384  //
4385  //     padding due to AIX guard pages (?) see AIXTHREAD_GUARDPAGES
4386  // ---------------------   __pi_stackaddr  (page aligned if AIXTHREAD_GUARDPAGES > 0)
4387  //
4388  //   AIX guard pages (?)
4389  //
4390
4391  // So, the safe thing to do is to use the area from __pi_stackend to __pi_stackaddr;
4392  // __pi_stackend however is almost never page aligned.
4393  //
4394
4395  if (p_stack_base) {
4396    (*p_stack_base) = (address) (pinfo.__pi_stackend);
4397  }
4398
4399  if (p_stack_size) {
4400    (*p_stack_size) = pinfo.__pi_stackend - pinfo.__pi_stackaddr;
4401  }
4402
4403  return true;
4404}
4405
4406// Get the current stack base from the OS (actually, the pthread library).
4407address os::current_stack_base() {
4408  address p;
4409  query_stack_dimensions(&p, 0);
4410  return p;
4411}
4412
4413// Get the current stack size from the OS (actually, the pthread library).
4414size_t os::current_stack_size() {
4415  size_t s;
4416  query_stack_dimensions(0, &s);
4417  return s;
4418}
4419
4420// Refer to the comments in os_solaris.cpp park-unpark.
4421//
4422// Beware -- Some versions of NPTL embody a flaw where pthread_cond_timedwait() can
4423// hang indefinitely. For instance NPTL 0.60 on 2.4.21-4ELsmp is vulnerable.
4424// For specifics regarding the bug see GLIBC BUGID 261237 :
4425//    http://www.mail-archive.com/debian-glibc@lists.debian.org/msg10837.html.
4426// Briefly, pthread_cond_timedwait() calls with an expiry time that's not in the future
4427// will either hang or corrupt the condvar, resulting in subsequent hangs if the condvar
4428// is used. (The simple C test-case provided in the GLIBC bug report manifests the
4429// hang). The JVM is vulernable via sleep(), Object.wait(timo), LockSupport.parkNanos()
4430// and monitorenter when we're using 1-0 locking. All those operations may result in
4431// calls to pthread_cond_timedwait(). Using LD_ASSUME_KERNEL to use an older version
4432// of libpthread avoids the problem, but isn't practical.
4433//
4434// Possible remedies:
4435//
4436// 1.   Establish a minimum relative wait time. 50 to 100 msecs seems to work.
4437//      This is palliative and probabilistic, however. If the thread is preempted
4438//      between the call to compute_abstime() and pthread_cond_timedwait(), more
4439//      than the minimum period may have passed, and the abstime may be stale (in the
4440//      past) resultin in a hang. Using this technique reduces the odds of a hang
4441//      but the JVM is still vulnerable, particularly on heavily loaded systems.
4442//
4443// 2.   Modify park-unpark to use per-thread (per ParkEvent) pipe-pairs instead
4444//      of the usual flag-condvar-mutex idiom. The write side of the pipe is set
4445//      NDELAY. unpark() reduces to write(), park() reduces to read() and park(timo)
4446//      reduces to poll()+read(). This works well, but consumes 2 FDs per extant
4447//      thread.
4448//
4449// 3.   Embargo pthread_cond_timedwait() and implement a native "chron" thread
4450//      that manages timeouts. We'd emulate pthread_cond_timedwait() by enqueuing
4451//      a timeout request to the chron thread and then blocking via pthread_cond_wait().
4452//      This also works well. In fact it avoids kernel-level scalability impediments
4453//      on certain platforms that don't handle lots of active pthread_cond_timedwait()
4454//      timers in a graceful fashion.
4455//
4456// 4.   When the abstime value is in the past it appears that control returns
4457//      correctly from pthread_cond_timedwait(), but the condvar is left corrupt.
4458//      Subsequent timedwait/wait calls may hang indefinitely. Given that, we
4459//      can avoid the problem by reinitializing the condvar -- by cond_destroy()
4460//      followed by cond_init() -- after all calls to pthread_cond_timedwait().
4461//      It may be possible to avoid reinitialization by checking the return
4462//      value from pthread_cond_timedwait(). In addition to reinitializing the
4463//      condvar we must establish the invariant that cond_signal() is only called
4464//      within critical sections protected by the adjunct mutex. This prevents
4465//      cond_signal() from "seeing" a condvar that's in the midst of being
4466//      reinitialized or that is corrupt. Sadly, this invariant obviates the
4467//      desirable signal-after-unlock optimization that avoids futile context switching.
4468//
4469//      I'm also concerned that some versions of NTPL might allocate an auxilliary
4470//      structure when a condvar is used or initialized. cond_destroy() would
4471//      release the helper structure. Our reinitialize-after-timedwait fix
4472//      put excessive stress on malloc/free and locks protecting the c-heap.
4473//
4474// We currently use (4). See the WorkAroundNTPLTimedWaitHang flag.
4475// It may be possible to refine (4) by checking the kernel and NTPL verisons
4476// and only enabling the work-around for vulnerable environments.
4477
4478// utility to compute the abstime argument to timedwait:
4479// millis is the relative timeout time
4480// abstime will be the absolute timeout time
4481// TODO: replace compute_abstime() with unpackTime()
4482
4483static struct timespec* compute_abstime(timespec* abstime, jlong millis) {
4484  if (millis < 0) millis = 0;
4485  struct timeval now;
4486  int status = gettimeofday(&now, NULL);
4487  assert(status == 0, "gettimeofday");
4488  jlong seconds = millis / 1000;
4489  millis %= 1000;
4490  if (seconds > 50000000) { // see man cond_timedwait(3T)
4491    seconds = 50000000;
4492  }
4493  abstime->tv_sec = now.tv_sec  + seconds;
4494  long       usec = now.tv_usec + millis * 1000;
4495  if (usec >= 1000000) {
4496    abstime->tv_sec += 1;
4497    usec -= 1000000;
4498  }
4499  abstime->tv_nsec = usec * 1000;
4500  return abstime;
4501}
4502
4503// Test-and-clear _Event, always leaves _Event set to 0, returns immediately.
4504// Conceptually TryPark() should be equivalent to park(0).
4505
4506int os::PlatformEvent::TryPark() {
4507  for (;;) {
4508    const int v = _Event;
4509    guarantee ((v == 0) || (v == 1), "invariant");
4510    if (Atomic::cmpxchg (0, &_Event, v) == v) return v;
4511  }
4512}
4513
4514void os::PlatformEvent::park() {       // AKA "down()"
4515  // Invariant: Only the thread associated with the Event/PlatformEvent
4516  // may call park().
4517  // TODO: assert that _Assoc != NULL or _Assoc == Self
4518  int v;
4519  for (;;) {
4520    v = _Event;
4521    if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4522  }
4523  guarantee (v >= 0, "invariant");
4524  if (v == 0) {
4525    // Do this the hard way by blocking ...
4526    int status = pthread_mutex_lock(_mutex);
4527    assert_status(status == 0, status, "mutex_lock");
4528    guarantee (_nParked == 0, "invariant");
4529    ++ _nParked;
4530    while (_Event < 0) {
4531      status = pthread_cond_wait(_cond, _mutex);
4532      assert_status(status == 0 || status == ETIMEDOUT, status, "cond_timedwait");
4533    }
4534    -- _nParked;
4535
4536    // In theory we could move the ST of 0 into _Event past the unlock(),
4537    // but then we'd need a MEMBAR after the ST.
4538    _Event = 0;
4539    status = pthread_mutex_unlock(_mutex);
4540    assert_status(status == 0, status, "mutex_unlock");
4541  }
4542  guarantee (_Event >= 0, "invariant");
4543}
4544
4545int os::PlatformEvent::park(jlong millis) {
4546  guarantee (_nParked == 0, "invariant");
4547
4548  int v;
4549  for (;;) {
4550    v = _Event;
4551    if (Atomic::cmpxchg (v-1, &_Event, v) == v) break;
4552  }
4553  guarantee (v >= 0, "invariant");
4554  if (v != 0) return OS_OK;
4555
4556  // We do this the hard way, by blocking the thread.
4557  // Consider enforcing a minimum timeout value.
4558  struct timespec abst;
4559  compute_abstime(&abst, millis);
4560
4561  int ret = OS_TIMEOUT;
4562  int status = pthread_mutex_lock(_mutex);
4563  assert_status(status == 0, status, "mutex_lock");
4564  guarantee (_nParked == 0, "invariant");
4565  ++_nParked;
4566
4567  // Object.wait(timo) will return because of
4568  // (a) notification
4569  // (b) timeout
4570  // (c) thread.interrupt
4571  //
4572  // Thread.interrupt and object.notify{All} both call Event::set.
4573  // That is, we treat thread.interrupt as a special case of notification.
4574  // We ignore spurious OS wakeups unless FilterSpuriousWakeups is false.
4575  // We assume all ETIME returns are valid.
4576  //
4577  // TODO: properly differentiate simultaneous notify+interrupt.
4578  // In that case, we should propagate the notify to another waiter.
4579
4580  while (_Event < 0) {
4581    status = pthread_cond_timedwait(_cond, _mutex, &abst);
4582    assert_status(status == 0 || status == ETIMEDOUT,
4583                  status, "cond_timedwait");
4584    if (!FilterSpuriousWakeups) break;         // previous semantics
4585    if (status == ETIMEDOUT) break;
4586    // We consume and ignore EINTR and spurious wakeups.
4587  }
4588  --_nParked;
4589  if (_Event >= 0) {
4590     ret = OS_OK;
4591  }
4592  _Event = 0;
4593  status = pthread_mutex_unlock(_mutex);
4594  assert_status(status == 0, status, "mutex_unlock");
4595  assert (_nParked == 0, "invariant");
4596  return ret;
4597}
4598
4599void os::PlatformEvent::unpark() {
4600  int v, AnyWaiters;
4601  for (;;) {
4602    v = _Event;
4603    if (v > 0) {
4604      // The LD of _Event could have reordered or be satisfied
4605      // by a read-aside from this processor's write buffer.
4606      // To avoid problems execute a barrier and then
4607      // ratify the value.
4608      OrderAccess::fence();
4609      if (_Event == v) return;
4610      continue;
4611    }
4612    if (Atomic::cmpxchg (v+1, &_Event, v) == v) break;
4613  }
4614  if (v < 0) {
4615    // Wait for the thread associated with the event to vacate
4616    int status = pthread_mutex_lock(_mutex);
4617    assert_status(status == 0, status, "mutex_lock");
4618    AnyWaiters = _nParked;
4619
4620    if (AnyWaiters != 0) {
4621      // We intentional signal *after* dropping the lock
4622      // to avoid a common class of futile wakeups.
4623      status = pthread_cond_signal(_cond);
4624      assert_status(status == 0, status, "cond_signal");
4625    }
4626    // Mutex should be locked for pthread_cond_signal(_cond).
4627    status = pthread_mutex_unlock(_mutex);
4628    assert_status(status == 0, status, "mutex_unlock");
4629  }
4630
4631  // Note that we signal() _after dropping the lock for "immortal" Events.
4632  // This is safe and avoids a common class of futile wakeups. In rare
4633  // circumstances this can cause a thread to return prematurely from
4634  // cond_{timed}wait() but the spurious wakeup is benign and the victim will
4635  // simply re-test the condition and re-park itself.
4636}
4637
4638
4639// JSR166
4640// -------------------------------------------------------
4641
4642//
4643// The solaris and linux implementations of park/unpark are fairly
4644// conservative for now, but can be improved. They currently use a
4645// mutex/condvar pair, plus a a count.
4646// Park decrements count if > 0, else does a condvar wait. Unpark
4647// sets count to 1 and signals condvar. Only one thread ever waits
4648// on the condvar. Contention seen when trying to park implies that someone
4649// is unparking you, so don't wait. And spurious returns are fine, so there
4650// is no need to track notifications.
4651//
4652
4653#define MAX_SECS 100000000
4654//
4655// This code is common to linux and solaris and will be moved to a
4656// common place in dolphin.
4657//
4658// The passed in time value is either a relative time in nanoseconds
4659// or an absolute time in milliseconds. Either way it has to be unpacked
4660// into suitable seconds and nanoseconds components and stored in the
4661// given timespec structure.
4662// Given time is a 64-bit value and the time_t used in the timespec is only
4663// a signed-32-bit value (except on 64-bit Linux) we have to watch for
4664// overflow if times way in the future are given. Further on Solaris versions
4665// prior to 10 there is a restriction (see cond_timedwait) that the specified
4666// number of seconds, in abstime, is less than current_time + 100,000,000.
4667// As it will be 28 years before "now + 100000000" will overflow we can
4668// ignore overflow and just impose a hard-limit on seconds using the value
4669// of "now + 100,000,000". This places a limit on the timeout of about 3.17
4670// years from "now".
4671//
4672
4673static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
4674  assert (time > 0, "convertTime");
4675
4676  struct timeval now;
4677  int status = gettimeofday(&now, NULL);
4678  assert(status == 0, "gettimeofday");
4679
4680  time_t max_secs = now.tv_sec + MAX_SECS;
4681
4682  if (isAbsolute) {
4683    jlong secs = time / 1000;
4684    if (secs > max_secs) {
4685      absTime->tv_sec = max_secs;
4686    }
4687    else {
4688      absTime->tv_sec = secs;
4689    }
4690    absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
4691  }
4692  else {
4693    jlong secs = time / NANOSECS_PER_SEC;
4694    if (secs >= MAX_SECS) {
4695      absTime->tv_sec = max_secs;
4696      absTime->tv_nsec = 0;
4697    }
4698    else {
4699      absTime->tv_sec = now.tv_sec + secs;
4700      absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
4701      if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
4702        absTime->tv_nsec -= NANOSECS_PER_SEC;
4703        ++absTime->tv_sec; // note: this must be <= max_secs
4704      }
4705    }
4706  }
4707  assert(absTime->tv_sec >= 0, "tv_sec < 0");
4708  assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
4709  assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
4710  assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
4711}
4712
4713void Parker::park(bool isAbsolute, jlong time) {
4714  // Optional fast-path check:
4715  // Return immediately if a permit is available.
4716  if (_counter > 0) {
4717    _counter = 0;
4718    OrderAccess::fence();
4719    return;
4720  }
4721
4722  Thread* thread = Thread::current();
4723  assert(thread->is_Java_thread(), "Must be JavaThread");
4724  JavaThread *jt = (JavaThread *)thread;
4725
4726  // Optional optimization -- avoid state transitions if there's an interrupt pending.
4727  // Check interrupt before trying to wait
4728  if (Thread::is_interrupted(thread, false)) {
4729    return;
4730  }
4731
4732  // Next, demultiplex/decode time arguments
4733  timespec absTime;
4734  if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all
4735    return;
4736  }
4737  if (time > 0) {
4738    unpackTime(&absTime, isAbsolute, time);
4739  }
4740
4741  // Enter safepoint region
4742  // Beware of deadlocks such as 6317397.
4743  // The per-thread Parker:: mutex is a classic leaf-lock.
4744  // In particular a thread must never block on the Threads_lock while
4745  // holding the Parker:: mutex. If safepoints are pending both the
4746  // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
4747  ThreadBlockInVM tbivm(jt);
4748
4749  // Don't wait if cannot get lock since interference arises from
4750  // unblocking. Also. check interrupt before trying wait
4751  if (Thread::is_interrupted(thread, false) || pthread_mutex_trylock(_mutex) != 0) {
4752    return;
4753  }
4754
4755  int status;
4756  if (_counter > 0) { // no wait needed
4757    _counter = 0;
4758    status = pthread_mutex_unlock(_mutex);
4759    assert (status == 0, "invariant");
4760    OrderAccess::fence();
4761    return;
4762  }
4763
4764#ifdef ASSERT
4765  // Don't catch signals while blocked; let the running threads have the signals.
4766  // (This allows a debugger to break into the running thread.)
4767  sigset_t oldsigs;
4768  sigset_t* allowdebug_blocked = os::Aix::allowdebug_blocked_signals();
4769  pthread_sigmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
4770#endif
4771
4772  OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
4773  jt->set_suspend_equivalent();
4774  // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
4775
4776  if (time == 0) {
4777    status = pthread_cond_wait (_cond, _mutex);
4778  } else {
4779    status = pthread_cond_timedwait (_cond, _mutex, &absTime);
4780    if (status != 0 && WorkAroundNPTLTimedWaitHang) {
4781      pthread_cond_destroy (_cond);
4782      pthread_cond_init    (_cond, NULL);
4783    }
4784  }
4785  assert_status(status == 0 || status == EINTR ||
4786                status == ETIME || status == ETIMEDOUT,
4787                status, "cond_timedwait");
4788
4789#ifdef ASSERT
4790  pthread_sigmask(SIG_SETMASK, &oldsigs, NULL);
4791#endif
4792
4793  _counter = 0;
4794  status = pthread_mutex_unlock(_mutex);
4795  assert_status(status == 0, status, "invariant");
4796  // If externally suspended while waiting, re-suspend
4797  if (jt->handle_special_suspend_equivalent_condition()) {
4798    jt->java_suspend_self();
4799  }
4800
4801  OrderAccess::fence();
4802}
4803
4804void Parker::unpark() {
4805  int s, status;
4806  status = pthread_mutex_lock(_mutex);
4807  assert (status == 0, "invariant");
4808  s = _counter;
4809  _counter = 1;
4810  if (s < 1) {
4811    if (WorkAroundNPTLTimedWaitHang) {
4812      status = pthread_cond_signal (_cond);
4813      assert (status == 0, "invariant");
4814      status = pthread_mutex_unlock(_mutex);
4815      assert (status == 0, "invariant");
4816    } else {
4817      status = pthread_mutex_unlock(_mutex);
4818      assert (status == 0, "invariant");
4819      status = pthread_cond_signal (_cond);
4820      assert (status == 0, "invariant");
4821    }
4822  } else {
4823    pthread_mutex_unlock(_mutex);
4824    assert (status == 0, "invariant");
4825  }
4826}
4827
4828extern char** environ;
4829
4830// Run the specified command in a separate process. Return its exit value,
4831// or -1 on failure (e.g. can't fork a new process).
4832// Unlike system(), this function can be called from signal handler. It
4833// doesn't block SIGINT et al.
4834int os::fork_and_exec(char* cmd) {
4835  char * argv[4] = {"sh", "-c", cmd, NULL};
4836
4837  pid_t pid = fork();
4838
4839  if (pid < 0) {
4840    // fork failed
4841    return -1;
4842
4843  } else if (pid == 0) {
4844    // child process
4845
4846    // Try to be consistent with system(), which uses "/usr/bin/sh" on AIX.
4847    execve("/usr/bin/sh", argv, environ);
4848
4849    // execve failed
4850    _exit(-1);
4851
4852  } else {
4853    // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
4854    // care about the actual exit code, for now.
4855
4856    int status;
4857
4858    // Wait for the child process to exit. This returns immediately if
4859    // the child has already exited. */
4860    while (waitpid(pid, &status, 0) < 0) {
4861      switch (errno) {
4862        case ECHILD: return 0;
4863        case EINTR: break;
4864        default: return -1;
4865      }
4866    }
4867
4868    if (WIFEXITED(status)) {
4869      // The child exited normally; get its exit code.
4870      return WEXITSTATUS(status);
4871    } else if (WIFSIGNALED(status)) {
4872      // The child exited because of a signal.
4873      // The best value to return is 0x80 + signal number,
4874      // because that is what all Unix shells do, and because
4875      // it allows callers to distinguish between process exit and
4876      // process death by signal.
4877      return 0x80 + WTERMSIG(status);
4878    } else {
4879      // Unknown exit code; pass it through.
4880      return status;
4881    }
4882  }
4883  return -1;
4884}
4885
4886// is_headless_jre()
4887//
4888// Test for the existence of xawt/libmawt.so or libawt_xawt.so
4889// in order to report if we are running in a headless jre.
4890//
4891// Since JDK8 xawt/libmawt.so is moved into the same directory
4892// as libawt.so, and renamed libawt_xawt.so
4893bool os::is_headless_jre() {
4894  struct stat statbuf;
4895  char buf[MAXPATHLEN];
4896  char libmawtpath[MAXPATHLEN];
4897  const char *xawtstr = "/xawt/libmawt.so";
4898  const char *new_xawtstr = "/libawt_xawt.so";
4899
4900  char *p;
4901
4902  // Get path to libjvm.so
4903  os::jvm_path(buf, sizeof(buf));
4904
4905  // Get rid of libjvm.so
4906  p = strrchr(buf, '/');
4907  if (p == NULL) return false;
4908  else *p = '\0';
4909
4910  // Get rid of client or server
4911  p = strrchr(buf, '/');
4912  if (p == NULL) return false;
4913  else *p = '\0';
4914
4915  // check xawt/libmawt.so
4916  strcpy(libmawtpath, buf);
4917  strcat(libmawtpath, xawtstr);
4918  if (::stat(libmawtpath, &statbuf) == 0) return false;
4919
4920  // check libawt_xawt.so
4921  strcpy(libmawtpath, buf);
4922  strcat(libmawtpath, new_xawtstr);
4923  if (::stat(libmawtpath, &statbuf) == 0) return false;
4924
4925  return true;
4926}
4927
4928// Get the default path to the core file
4929// Returns the length of the string
4930int os::get_core_path(char* buffer, size_t bufferSize) {
4931  const char* p = get_current_directory(buffer, bufferSize);
4932
4933  if (p == NULL) {
4934    assert(p != NULL, "failed to get current directory");
4935    return 0;
4936  }
4937
4938  jio_snprintf(buffer, bufferSize, "%s/core or core.%d",
4939                                               p, current_process_id());
4940
4941  return strlen(buffer);
4942}
4943
4944#ifndef PRODUCT
4945void TestReserveMemorySpecial_test() {
4946  // No tests available for this platform
4947}
4948#endif
4949