/*

 * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#ifndef SHARE_RUNTIME_OS_HPP

#define SHARE_RUNTIME_OS_HPP

#include "jvm.h"

#include "jvmtifiles/jvmti.h"

#include "metaprogramming/isRegisteredEnum.hpp"

#include "metaprogramming/integralConstant.hpp"

#include "runtime/extendedPC.hpp"

#include "utilities/exceptions.hpp"

#include "utilities/ostream.hpp"

#include "utilities/macros.hpp"

#ifndef _WINDOWS

# include <setjmp.h>

#endif

#ifdef __APPLE__

# include <mach/mach_time.h>

#endif

class AgentLibrary;

class frame;

// os defines the interface to operating system; this includes traditional

// OS services (time, I/O) as well as other functionality with system-

// dependent code.

typedef void (*dll_func)(...);

class Thread;

class JavaThread;

class NativeCallStack;

class methodHandle;

class OSThread;

class Mutex;

template<class E> class GrowableArray;

// %%%%% Moved ThreadState, START_FN, OSThread to new osThread.hpp. -- Rose

// Platform-independent error return values from OS functions

enum OSReturn {

  OS_OK         =  0,        // Operation was successful

  OS_ERR        = -1,        // Operation failed

  OS_INTRPT     = -2,        // Operation was interrupted

  OS_TIMEOUT    = -3,        // Operation timed out

  OS_NOMEM      = -5,        // Operation failed for lack of memory

  OS_NORESOURCE = -6         // Operation failed for lack of nonmemory resource

};

enum ThreadPriority {        // JLS 20.20.1-3

  NoPriority       = -1,     // Initial non-priority value

  MinPriority      =  1,     // Minimum priority

  NormPriority     =  5,     // Normal (non-daemon) priority

  NearMaxPriority  =  9,     // High priority, used for VMThread

  MaxPriority      = 10,     // Highest priority, used for WatcherThread

                             // ensures that VMThread doesn't starve profiler

  CriticalPriority = 11      // Critical thread priority

};

// Executable parameter flag for os::commit_memory() and

// os::commit_memory_or_exit().

const bool ExecMem = true;

// Typedef for structured exception handling support

typedef void (*java_call_t)(JavaValue* value, const methodHandle& method, JavaCallArguments* args, Thread* thread);

class MallocTracker;

class os: AllStatic {

  friend class VMStructs;

  friend class JVMCIVMStructs;

  friend class MallocTracker;

#ifdef ASSERT

 private:

  static bool _mutex_init_done;

 public:

  static void set_mutex_init_done() { _mutex_init_done = true; }

  static bool mutex_init_done() { return _mutex_init_done; }

#endif

 public:

  enum { page_sizes_max = 9 }; // Size of _page_sizes array (8 plus a sentinel)

 private:

  static OSThread*          _starting_thread;

  static address            _polling_page;

 public:

  static size_t             _page_sizes[page_sizes_max];

 private:

  static void init_page_sizes(size_t default_page_size) {

    _page_sizes[0] = default_page_size;

    _page_sizes[1] = 0; // sentinel

  }

  static char*  pd_reserve_memory(size_t bytes, char* addr = 0,

                                  size_t alignment_hint = 0);

  static char*  pd_attempt_reserve_memory_at(size_t bytes, char* addr);

  static char*  pd_attempt_reserve_memory_at(size_t bytes, char* addr, int file_desc);

  static void   pd_split_reserved_memory(char *base, size_t size,

                                      size_t split, bool realloc);

  static bool   pd_commit_memory(char* addr, size_t bytes, bool executable);

  static bool   pd_commit_memory(char* addr, size_t size, size_t alignment_hint,

                                 bool executable);

  // Same as pd_commit_memory() that either succeeds or calls

  // vm_exit_out_of_memory() with the specified mesg.

  static void   pd_commit_memory_or_exit(char* addr, size_t bytes,

                                         bool executable, const char* mesg);

  static void   pd_commit_memory_or_exit(char* addr, size_t size,

                                         size_t alignment_hint,

                                         bool executable, const char* mesg);

  static bool   pd_uncommit_memory(char* addr, size_t bytes);

  static bool   pd_release_memory(char* addr, size_t bytes);

  static char*  pd_map_memory(int fd, const char* file_name, size_t file_offset,

                           char *addr, size_t bytes, bool read_only = false,

                           bool allow_exec = false);

  static char*  pd_remap_memory(int fd, const char* file_name, size_t file_offset,

                             char *addr, size_t bytes, bool read_only,

                             bool allow_exec);

  static bool   pd_unmap_memory(char *addr, size_t bytes);

  static void   pd_free_memory(char *addr, size_t bytes, size_t alignment_hint);

  static void   pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint);

  static size_t page_size_for_region(size_t region_size, size_t min_pages, bool must_be_aligned);

  // Get summary strings for system information in buffer provided

  static void  get_summary_cpu_info(char* buf, size_t buflen);

  static void  get_summary_os_info(char* buf, size_t buflen);

  static void initialize_initial_active_processor_count();

  LINUX_ONLY(static void pd_init_container_support();)

 public:

  static void init(void);                      // Called before command line parsing

  static void init_container_support() {       // Called during command line parsing.

     LINUX_ONLY(pd_init_container_support();)

  }

  static void init_before_ergo(void);          // Called after command line parsing

                                               // before VM ergonomics processing.

  static jint init_2(void);                    // Called after command line parsing

                                               // and VM ergonomics processing

  // unset environment variable

  static bool unsetenv(const char* name);

  static bool have_special_privileges();

  static jlong  javaTimeMillis();

  static jlong  javaTimeNanos();

  static void   javaTimeNanos_info(jvmtiTimerInfo *info_ptr);

  static void   javaTimeSystemUTC(jlong &seconds, jlong &nanos);

  static void   run_periodic_checks();

  static bool   supports_monotonic_clock();

  // Returns the elapsed time in seconds since the vm started.

  static double elapsedTime();

  // Returns real time in seconds since an arbitrary point

  // in the past.

  static bool getTimesSecs(double* process_real_time,

                           double* process_user_time,

                           double* process_system_time);

  // Interface to the performance counter

  static jlong elapsed_counter();

  static jlong elapsed_frequency();

  // The "virtual time" of a thread is the amount of time a thread has

  // actually run.  The first function indicates whether the OS supports

  // this functionality for the current thread, and if so:

  //   * the second enables vtime tracking (if that is required).

  //   * the third tells whether vtime is enabled.

  //   * the fourth returns the elapsed virtual time for the current

  //     thread.

  static bool supports_vtime();

  static bool enable_vtime();

  static bool vtime_enabled();

  static double elapsedVTime();

  // Return current local time in a string (YYYY-MM-DD HH:MM:SS).

  // It is MT safe, but not async-safe, as reading time zone

  // information may require a lock on some platforms.

  static char*      local_time_string(char *buf, size_t buflen);

  static struct tm* localtime_pd     (const time_t* clock, struct tm*  res);

  static struct tm* gmtime_pd        (const time_t* clock, struct tm*  res);

  // Fill in buffer with current local time as an ISO-8601 string.

  // E.g., YYYY-MM-DDThh:mm:ss.mmm+zzzz.

  // Returns buffer, or NULL if it failed.

  static char* iso8601_time(char* buffer, size_t buffer_length, bool utc = false);

  // Interface for detecting multiprocessor system

  static inline bool is_MP() {

    // During bootstrap if _processor_count is not yet initialized

    // we claim to be MP as that is safest. If any platform has a

    // stub generator that might be triggered in this phase and for

    // which being declared MP when in fact not, is a problem - then

    // the bootstrap routine for the stub generator needs to check

    // the processor count directly and leave the bootstrap routine

    // in place until called after initialization has ocurred.

    return (_processor_count != 1);

  }

  static julong available_memory();

  static julong physical_memory();

  static bool has_allocatable_memory_limit(julong* limit);

  static bool is_server_class_machine();

  // Returns the id of the processor on which the calling thread is currently executing.

  // The returned value is guaranteed to be between 0 and (os::processor_count() - 1).

  static uint processor_id();

  // number of CPUs

  static int processor_count() {

    return _processor_count;

  }

  static void set_processor_count(int count) { _processor_count = count; }

  // Returns the number of CPUs this process is currently allowed to run on.

  // Note that on some OSes this can change dynamically.

  static int active_processor_count();

  // At startup the number of active CPUs this process is allowed to run on.

  // This value does not change dynamically. May be different from active_processor_count().

  static int initial_active_processor_count() {

    assert(_initial_active_processor_count > 0, "Initial active processor count not set yet.");

    return _initial_active_processor_count;

  }

  // Bind processes to processors.

  //     This is a two step procedure:

  //     first you generate a distribution of processes to processors,

  //     then you bind processes according to that distribution.

  // Compute a distribution for number of processes to processors.

  //    Stores the processor id's into the distribution array argument.

  //    Returns true if it worked, false if it didn't.

  static bool distribute_processes(uint length, uint* distribution);

  // Binds the current process to a processor.

  //    Returns true if it worked, false if it didn't.

  static bool bind_to_processor(uint processor_id);

  // Give a name to the current thread.

  static void set_native_thread_name(const char *name);

  // Interface for stack banging (predetect possible stack overflow for

  // exception processing)  There are guard pages, and above that shadow

  // pages for stack overflow checking.

  static bool uses_stack_guard_pages();

  static bool must_commit_stack_guard_pages();

  static void map_stack_shadow_pages(address sp);

  static bool stack_shadow_pages_available(Thread *thread, const methodHandle& method, address sp);

  // Find committed memory region within specified range (start, start + size),

  // return true if found any

  static bool committed_in_range(address start, size_t size, address& committed_start, size_t& committed_size);

  // OS interface to Virtual Memory

  // Return the default page size.

  static int    vm_page_size();

  // Returns the page size to use for a region of memory.

  // region_size / min_pages will always be greater than or equal to the

  // returned value. The returned value will divide region_size.

  static size_t page_size_for_region_aligned(size_t region_size, size_t min_pages);

  // Returns the page size to use for a region of memory.

  // region_size / min_pages will always be greater than or equal to the

  // returned value. The returned value might not divide region_size.

  static size_t page_size_for_region_unaligned(size_t region_size, size_t min_pages);

  // Return the largest page size that can be used

  static size_t max_page_size() {

    // The _page_sizes array is sorted in descending order.

    return _page_sizes[0];

  }

  // Return a lower bound for page sizes. Also works before os::init completed.

  static size_t min_page_size() { return 4 * K; }

  // Methods for tracing page sizes returned by the above method.

  // The region_{min,max}_size parameters should be the values

  // passed to page_size_for_region() and page_size should be the result of that

  // call.  The (optional) base and size parameters should come from the

  // ReservedSpace base() and size() methods.

  static void trace_page_sizes(const char* str, const size_t* page_sizes, int count);

  static void trace_page_sizes(const char* str,

                               const size_t region_min_size,

                               const size_t region_max_size,

                               const size_t page_size,

                               const char* base,

                               const size_t size);

  static void trace_page_sizes_for_requested_size(const char* str,

                                                  const size_t requested_size,

                                                  const size_t page_size,

                                                  const size_t alignment,

                                                  const char* base,

                                                  const size_t size);

  static int    vm_allocation_granularity();

  static char*  reserve_memory(size_t bytes, char* addr = 0,

                               size_t alignment_hint = 0, int file_desc = -1);

  static char*  reserve_memory(size_t bytes, char* addr,

                               size_t alignment_hint, MEMFLAGS flags);

  static char*  reserve_memory_aligned(size_t size, size_t alignment, int file_desc = -1);

  static char*  attempt_reserve_memory_at(size_t bytes, char* addr, int file_desc = -1);

  static void   split_reserved_memory(char *base, size_t size,

                                      size_t split, bool realloc);

  static bool   commit_memory(char* addr, size_t bytes, bool executable);

  static bool   commit_memory(char* addr, size_t size, size_t alignment_hint,

                              bool executable);

  // Same as commit_memory() that either succeeds or calls

  // vm_exit_out_of_memory() with the specified mesg.

  static void   commit_memory_or_exit(char* addr, size_t bytes,

                                      bool executable, const char* mesg);

  static void   commit_memory_or_exit(char* addr, size_t size,

                                      size_t alignment_hint,

                                      bool executable, const char* mesg);

  static bool   uncommit_memory(char* addr, size_t bytes);

  static bool   release_memory(char* addr, size_t bytes);

  // Touch memory pages that cover the memory range from start to end (exclusive)

  // to make the OS back the memory range with actual memory.

  // Current implementation may not touch the last page if unaligned addresses

  // are passed.

  static void   pretouch_memory(void* start, void* end, size_t page_size = vm_page_size());

  enum ProtType { MEM_PROT_NONE, MEM_PROT_READ, MEM_PROT_RW, MEM_PROT_RWX };

  static bool   protect_memory(char* addr, size_t bytes, ProtType prot,

                               bool is_committed = true);

  static bool   guard_memory(char* addr, size_t bytes);

  static bool   unguard_memory(char* addr, size_t bytes);

  static bool   create_stack_guard_pages(char* addr, size_t bytes);

  static bool   pd_create_stack_guard_pages(char* addr, size_t bytes);

  static bool   remove_stack_guard_pages(char* addr, size_t bytes);

  // Helper function to create a new file with template jvmheap.XXXXXX.

  // Returns a valid fd on success or else returns -1

  static int create_file_for_heap(const char* dir);

  // Map memory to the file referred by fd. This function is slightly different from map_memory()

  // and is added to be used for implementation of -XX:AllocateHeapAt

  static char* map_memory_to_file(char* base, size_t size, int fd);

  // Replace existing reserved memory with file mapping

  static char* replace_existing_mapping_with_file_mapping(char* base, size_t size, int fd);

  static char*  map_memory(int fd, const char* file_name, size_t file_offset,

                           char *addr, size_t bytes, bool read_only = false,

                           bool allow_exec = false);

  static char*  remap_memory(int fd, const char* file_name, size_t file_offset,

                             char *addr, size_t bytes, bool read_only,

                             bool allow_exec);

  static bool   unmap_memory(char *addr, size_t bytes);

  static void   free_memory(char *addr, size_t bytes, size_t alignment_hint);

  static void   realign_memory(char *addr, size_t bytes, size_t alignment_hint);

  // NUMA-specific interface

  static bool   numa_has_static_binding();

  static bool   numa_has_group_homing();

  static void   numa_make_local(char *addr, size_t bytes, int lgrp_hint);

  static void   numa_make_global(char *addr, size_t bytes);

  static size_t numa_get_groups_num();

  static size_t numa_get_leaf_groups(int *ids, size_t size);

  static bool   numa_topology_changed();

  static int    numa_get_group_id();

  // Page manipulation

  struct page_info {

    size_t size;

    int lgrp_id;

  };

  static bool   get_page_info(char *start, page_info* info);

  static char*  scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found);

  static char*  non_memory_address_word();

  // reserve, commit and pin the entire memory region

  static char*  reserve_memory_special(size_t size, size_t alignment,

                                       char* addr, bool executable);

  static bool   release_memory_special(char* addr, size_t bytes);

  static void   large_page_init();

  static size_t large_page_size();

  static bool   can_commit_large_page_memory();

  static bool   can_execute_large_page_memory();

  // OS interface to polling page

  static address get_polling_page()             { return _polling_page; }

  static void    set_polling_page(address page) { _polling_page = page; }

  static bool    is_poll_address(address addr)  { return addr >= _polling_page && addr < (_polling_page + os::vm_page_size()); }

  static void    make_polling_page_unreadable();

  static void    make_polling_page_readable();

  // Check if pointer points to readable memory (by 4-byte read access)

  static bool    is_readable_pointer(const void* p);

  static bool    is_readable_range(const void* from, const void* to);

  // threads

  enum ThreadType {

    vm_thread,

    cgc_thread,        // Concurrent GC thread

    pgc_thread,        // Parallel GC thread

    java_thread,       // Java, CodeCacheSweeper, JVMTIAgent and Service threads.

    compiler_thread,

    watcher_thread,

    os_thread

  };

  static bool create_thread(Thread* thread,

                            ThreadType thr_type,

                            size_t req_stack_size = 0);

  // The "main thread", also known as "starting thread", is the thread

  // that loads/creates the JVM via JNI_CreateJavaVM.

  static bool create_main_thread(JavaThread* thread);

  // The primordial thread is the initial process thread. The java

  // launcher never uses the primordial thread as the main thread, but

  // applications that host the JVM directly may do so. Some platforms

  // need special-case handling of the primordial thread if it attaches

  // to the VM.

  static bool is_primordial_thread(void)

#if defined(_WINDOWS) || defined(BSD)

    // No way to identify the primordial thread.

    { return false; }

#else

  ;

#endif

  static bool create_attached_thread(JavaThread* thread);

  static void pd_start_thread(Thread* thread);

  static void start_thread(Thread* thread);

  // Returns true if successful.

  static bool signal_thread(Thread* thread, int sig, const char* reason);

  static void free_thread(OSThread* osthread);

  // thread id on Linux/64bit is 64bit, on Windows and Solaris, it's 32bit

  static intx current_thread_id();

  static int current_process_id();

  // Implementation of java.lang.Thread.sleep for JavaThreads

  static int sleep(JavaThread* thread, jlong ms);

  // Short standalone OS sleep routines suitable for slow path spin loop.

  // Ignores safepoints/suspension/Thread.interrupt() (so keep it short).

  // ms/ns = 0, will sleep for the least amount of time allowed by the OS.

  // Maximum sleep time is just under 1 second.

  static void naked_short_sleep(jlong ms);

  static void naked_short_nanosleep(jlong ns);

  // Longer standalone OS sleep routine - a convenience wrapper around

  // multiple calls to naked_short_sleep. Only for use by non-JavaThreads.

  static void naked_sleep(jlong millis);

  // Never returns, use with CAUTION

  static void infinite_sleep();

  static void naked_yield () ;

  static OSReturn set_priority(Thread* thread, ThreadPriority priority);

  static OSReturn get_priority(const Thread* const thread, ThreadPriority& priority);

  static void interrupt(Thread* thread);

  static bool is_interrupted(Thread* thread, bool clear_interrupted);

  static int pd_self_suspend_thread(Thread* thread);

  static ExtendedPC fetch_frame_from_context(const void* ucVoid, intptr_t** sp, intptr_t** fp);

  static frame      fetch_frame_from_context(const void* ucVoid);

  static frame      fetch_frame_from_ucontext(Thread* thread, void* ucVoid);

  static void breakpoint();

  static bool start_debugging(char *buf, int buflen);

  static address current_stack_pointer();

  static address current_stack_base();

  static size_t current_stack_size();