1 /*
   2  * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright 2013, 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 #ifndef OS_AIX_VM_OS_AIX_HPP
  27 #define OS_AIX_VM_OS_AIX_HPP
  28 
  29 // Information about the protection of the page at address '0' on this os.
  30 static bool zero_page_read_protected() { return false; }
  31 
  32 // Class Aix defines the interface to the Aix operating systems.
  33 
  34 class Aix {
  35   friend class os;
  36 
  37   // Length of strings included in the libperfstat structures.
  38 #define IDENTIFIER_LENGTH 64
  39 
  40   static bool libjsig_is_loaded;        // libjsig that interposes sigaction(),
  41                                         // __sigaction(), signal() is loaded
  42   static struct sigaction *(*get_signal_action)(int);
  43   static struct sigaction *get_preinstalled_handler(int);
  44   static void save_preinstalled_handler(int, struct sigaction&);
  45 
  46   static void check_signal_handler(int sig);
  47 
  48  protected:
  49 
  50   static julong _physical_memory;
  51   static pthread_t _main_thread;
  52   static Mutex* _createThread_lock;
  53   static int _page_size;
  54   static int _logical_cpus;
  55 
  56   // -1 = uninitialized, 0 = AIX, 1 = OS/400 (PASE)
  57   static int _on_pase;
  58 
  59   // -1 = uninitialized, otherwise 16 bit number:
  60   //  lower 8 bit - minor version
  61   //  higher 8 bit - major version
  62   //  For AIX, e.g. 0x0601 for AIX 6.1
  63   //  for OS/400 e.g. 0x0504 for OS/400 V5R4
  64   static int _os_version;
  65 
  66   // -1 = uninitialized,
  67   //  0 - SPEC1170 not requested (XPG_SUS_ENV is OFF or not set)
  68   //  1 - SPEC1170 requested (XPG_SUS_ENV is ON)
  69   static int _xpg_sus_mode;
  70 
  71   // -1 = uninitialized,
  72   //  0 - EXTSHM=OFF or not set
  73   //  1 - EXTSHM=ON
  74   static int _extshm;
  75 
  76   // page sizes on AIX.
  77   //
  78   //  AIX supports four different page sizes - 4K, 64K, 16MB, 16GB. The latter two
  79   //  (16M "large" resp. 16G "huge" pages) require special setup and are normally
  80   //  not available.
  81   //
  82   //  AIX supports multiple page sizes per process, for:
  83   //  - Stack (of the primordial thread, so not relevant for us)
  84   //  - Data - data, bss, heap, for us also pthread stacks
  85   //  - Text - text code
  86   //  - shared memory
  87   //
  88   //  Default page sizes can be set via linker options (-bdatapsize, -bstacksize, ...)
  89   //  and via environment variable LDR_CNTRL (DATAPSIZE, STACKPSIZE, ...)
  90   //
  91   //  For shared memory, page size can be set dynamically via shmctl(). Different shared memory
  92   //  regions can have different page sizes.
  93   //
  94   //  More information can be found at AIBM info center:
  95   //   http://publib.boulder.ibm.com/infocenter/aix/v6r1/index.jsp?topic=/com.ibm.aix.prftungd/doc/prftungd/multiple_page_size_app_support.htm
  96   //
  97   // -----
  98   //  We want to support 4K and 64K and, if the machine is set up correctly, 16MB pages.
  99   //
 100 
 101   // page size of the stack of newly created pthreads
 102   // (should be LDR_CNTRL DATAPSIZE because stack is allocated on heap by pthread lib)
 103   static int _stack_page_size;
 104 
 105   static julong available_memory();
 106   static julong physical_memory() { return _physical_memory; }
 107   static void initialize_system_info();
 108 
 109   // OS recognitions (PASE/AIX, OS level) call this before calling any
 110   // one of Aix::on_pase(), Aix::os_version().
 111   static void initialize_os_info();
 112 
 113   // Scan environment for important settings which might effect the
 114   // VM. Trace out settings. Warn about invalid settings and/or
 115   // correct them.
 116   //
 117   // Must run after os::Aix::initialue_os_info().
 118   static void scan_environment();
 119 
 120   // Initialize libo4 (on PASE) and libperfstat (on AIX). Call this
 121   // before relying on functions from either lib, e.g. Aix::get_meminfo().
 122   static void initialize_libo4();
 123   static void initialize_libperfstat();
 124 
 125  public:
 126   static void init_thread_fpu_state();
 127   static pthread_t main_thread(void)                                { return _main_thread; }
 128   // returns kernel thread id (similar to LWP id on Solaris), which can be
 129   // used to access /proc
 130   static pid_t gettid();
 131   static void set_createThread_lock(Mutex* lk)                      { _createThread_lock = lk; }
 132   static Mutex* createThread_lock(void)                             { return _createThread_lock; }
 133   static void hotspot_sigmask(Thread* thread);
 134 
 135   // Given an address, returns the size of the page backing that address
 136   static size_t query_pagesize(void* p);
 137 
 138   // Return `true' if the calling thread is the primordial thread. The
 139   // primordial thread is the thread which contains the main function,
 140   // *not* necessarily the thread which initialized the VM by calling
 141   // JNI_CreateJavaVM.
 142   static bool is_primordial_thread(void);
 143 
 144   static int page_size(void) {
 145     assert(_page_size != -1, "not initialized");
 146     return _page_size;
 147   }
 148 
 149   // Accessor methods for stack page size which may be different from usual page size.
 150   static int stack_page_size(void) {
 151     assert(_stack_page_size != -1, "not initialized");
 152     return _stack_page_size;
 153   }
 154 
 155   // This is used to scale stack space (guard pages etc.). The name is somehow misleading.
 156   static int vm_default_page_size(void ) { return 8*K; }
 157 
 158   static address   ucontext_get_pc(const ucontext_t* uc);
 159   static intptr_t* ucontext_get_sp(ucontext_t* uc);
 160   static intptr_t* ucontext_get_fp(ucontext_t* uc);
 161   // Set PC into context. Needed for continuation after signal.
 162   static void ucontext_set_pc(ucontext_t* uc, address pc);
 163 
 164   // This boolean allows users to forward their own non-matching signals
 165   // to JVM_handle_aix_signal, harmlessly.
 166   static bool signal_handlers_are_installed;
 167 
 168   static int get_our_sigflags(int);
 169   static void set_our_sigflags(int, int);
 170   static void signal_sets_init();
 171   static void install_signal_handlers();
 172   static void set_signal_handler(int, bool);
 173   static bool is_sig_ignored(int sig);
 174 
 175   static sigset_t* unblocked_signals();
 176   static sigset_t* vm_signals();
 177   static sigset_t* allowdebug_blocked_signals();
 178 
 179   // For signal-chaining
 180   static struct sigaction *get_chained_signal_action(int sig);
 181   static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
 182 
 183   // libpthread version string
 184   static void libpthread_init();
 185 
 186   // Minimum stack size a thread can be created with (allowing
 187   // the VM to completely create the thread and enter user code)
 188   static size_t min_stack_allowed;
 189 
 190   // Return default stack size or guard size for the specified thread type
 191   static size_t default_stack_size(os::ThreadType thr_type);
 192   static size_t default_guard_size(os::ThreadType thr_type);
 193 
 194   // Function returns true if we run on OS/400 (pase), false if we run
 195   // on AIX.
 196   static bool on_pase() {
 197     assert(_on_pase != -1, "not initialized");
 198     return _on_pase ? true : false;
 199   }
 200 
 201   // Function returns true if we run on AIX, false if we run on OS/400
 202   // (pase).
 203   static bool on_aix() {
 204     assert(_on_pase != -1, "not initialized");
 205     return _on_pase ? false : true;
 206   }
 207 
 208   // -1 = uninitialized, otherwise 16 bit number:
 209   // lower 8 bit - minor version
 210   // higher 8 bit - major version
 211   // For AIX, e.g. 0x0601 for AIX 6.1
 212   // for OS/400 e.g. 0x0504 for OS/400 V5R4
 213   static int os_version () {
 214     assert(_os_version != -1, "not initialized");
 215     return _os_version;
 216   }
 217 
 218   // Convenience method: returns true if running on PASE V5R4 or older.
 219   static bool on_pase_V5R4_or_older() {
 220     return on_pase() && os_version() <= 0x0504;
 221   }
 222 
 223   // Convenience method: returns true if running on AIX 5.3 or older.
 224   static bool on_aix_53_or_older() {
 225     return on_aix() && os_version() <= 0x0503;
 226   }
 227 
 228   // Returns true if we run in SPEC1170 compliant mode (XPG_SUS_ENV=ON).
 229   static bool xpg_sus_mode() {
 230     assert(_xpg_sus_mode != -1, "not initialized");
 231     return _xpg_sus_mode;
 232   }
 233 
 234   // Returns true if EXTSHM=ON.
 235   static bool extshm() {
 236     assert(_extshm != -1, "not initialized");
 237     return _extshm;
 238   }
 239 
 240   // result struct for get_meminfo()
 241   struct meminfo_t {
 242 
 243     // Amount of virtual memory (in units of 4 KB pages)
 244     unsigned long long virt_total;
 245 
 246     // Amount of real memory, in bytes
 247     unsigned long long real_total;
 248 
 249     // Amount of free real memory, in bytes
 250     unsigned long long real_free;
 251 
 252     // Total amount of paging space, in bytes
 253     unsigned long long pgsp_total;
 254 
 255     // Amount of free paging space, in bytes
 256     unsigned long long pgsp_free;
 257 
 258   };
 259 
 260   // Result struct for get_cpuinfo().
 261   struct cpuinfo_t {
 262     char description[IDENTIFIER_LENGTH];  // processor description (type/official name)
 263     u_longlong_t processorHZ;             // processor speed in Hz
 264     int ncpus;                            // number of active logical processors
 265     double loadavg[3];                    // (1<<SBITS) times the average number of runnables processes during the last 1, 5 and 15 minutes.
 266                                           // To calculate the load average, divide the numbers by (1<<SBITS). SBITS is defined in <sys/proc.h>.
 267     char version[20];                     // processor version from _system_configuration (sys/systemcfg.h)
 268   };
 269 
 270   // Functions to retrieve memory information on AIX, PASE.
 271   // (on AIX, using libperfstat, on PASE with libo4.so).
 272   // Returns true if ok, false if error.
 273   static bool get_meminfo(meminfo_t* pmi);
 274 
 275   // Function to retrieve cpu information on AIX
 276   // (on AIX, using libperfstat)
 277   // Returns true if ok, false if error.
 278   static bool get_cpuinfo(cpuinfo_t* pci);
 279 
 280 }; // os::Aix class
 281 
 282 
 283 class PlatformEvent : public CHeapObj<mtInternal> {
 284   private:
 285     double CachePad [4];   // increase odds that _mutex is sole occupant of cache line
 286     volatile int _Event;
 287     volatile int _nParked;
 288     pthread_mutex_t _mutex  [1];
 289     pthread_cond_t  _cond   [1];
 290     double PostPad  [2];
 291     Thread * _Assoc;
 292 
 293   public:       // TODO-FIXME: make dtor private
 294     ~PlatformEvent() { guarantee (0, "invariant"); }
 295 
 296   public:
 297     PlatformEvent() {
 298       int status;
 299       status = pthread_cond_init (_cond, NULL);
 300       assert_status(status == 0, status, "cond_init");
 301       status = pthread_mutex_init (_mutex, NULL);
 302       assert_status(status == 0, status, "mutex_init");
 303       _Event   = 0;
 304       _nParked = 0;
 305       _Assoc   = NULL;
 306     }
 307 
 308     // Use caution with reset() and fired() -- they may require MEMBARs
 309     void reset() { _Event = 0; }
 310     int  fired() { return _Event; }
 311     void park ();
 312     void unpark ();
 313     int  TryPark ();
 314     int  park (jlong millis);
 315     void SetAssociation (Thread * a) { _Assoc = a; }
 316 };
 317 
 318 class PlatformParker : public CHeapObj<mtInternal> {
 319   protected:
 320     pthread_mutex_t _mutex [1];
 321     pthread_cond_t  _cond  [1];
 322 
 323   public:       // TODO-FIXME: make dtor private
 324     ~PlatformParker() { guarantee (0, "invariant"); }
 325 
 326   public:
 327     PlatformParker() {
 328       int status;
 329       status = pthread_cond_init (_cond, NULL);
 330       assert_status(status == 0, status, "cond_init");
 331       status = pthread_mutex_init (_mutex, NULL);
 332       assert_status(status == 0, status, "mutex_init");
 333     }
 334 };
 335 
 336 #endif // OS_AIX_VM_OS_AIX_HPP