Lines Matching refs:os
131 julong os::Linux::_physical_memory = 0;
133 address os::Linux::_initial_thread_stack_bottom = NULL;
134 uintptr_t os::Linux::_initial_thread_stack_size = 0;
136 int (*os::Linux::_clock_gettime)(clockid_t, struct timespec *) = NULL;
137 int (*os::Linux::_pthread_getcpuclockid)(pthread_t, clockid_t *) = NULL;
138 Mutex* os::Linux::_createThread_lock = NULL;
139 pthread_t os::Linux::_main_thread;
140 int os::Linux::_page_size = -1;
141 const int os::Linux::_vm_default_page_size = (8 * K);
142 bool os::Linux::_is_floating_stack = false;
143 bool os::Linux::_is_NPTL = false;
144 bool os::Linux::_supports_fast_thread_cpu_time = false;
145 const char * os::Linux::_glibc_version = NULL;
146 const char * os::Linux::_libpthread_version = NULL;
204 julong os::available_memory() {
208 julong os::Linux::available_memory() {
216 julong os::physical_memory() {
220 julong os::allocatable_physical_memory(julong size) {
227 julong reasonable_size = (julong)2*G - 2 * os::vm_page_size();
237 bool os::getenv(const char* name, char* buf, int len) {
250 bool os::have_special_privileges() {
308 pid_t os::Linux::gettid() {
327 void os::Linux::initialize_system_info() {
330 pid_t pid = os::Linux::gettid();
344 void os::init_system_properties_values() {
403 os::jvm_path(buf, sizeof(buf));
513 void os::breakpoint() {
527 bool os::Linux::is_sig_ignored(int sig) {
538 void os::Linux::signal_sets_init() {
563 if (!os::Linux::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
567 if (!os::Linux::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
571 if (!os::Linux::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
586 sigset_t* os::Linux::unblocked_signals() {
593 sigset_t* os::Linux::vm_signals() {
599 sigset_t* os::Linux::allowdebug_blocked_signals() {
604 void os::Linux::hotspot_sigmask(Thread* thread) {
613 pthread_sigmask(SIG_UNBLOCK, os::Linux::unblocked_signals(), NULL);
629 void os::Linux::libpthread_init() {
645 os::Linux::set_glibc_version(str);
651 os::Linux::set_glibc_version(_gnu_libc_version);
664 if (strcmp(os::Linux::glibc_version(), "glibc 2.3.2") == 0 &&
668 os::Linux::set_libpthread_version("linuxthreads");
670 os::Linux::set_libpthread_version(str);
674 os::Linux::set_libpthread_version("linuxthreads");
678 os::Linux::set_is_NPTL();
680 os::Linux::set_is_LinuxThreads();
685 if (os::Linux::is_NPTL() || os::Linux::supports_variable_stack_size()) {
686 os::Linux::set_is_floating_stack();
757 bottom = (address)align_size_down((uintptr_t)bottom, os::Linux::page_size());
758 bottom += os::Linux::page_size() - 1;
762 // os::current_stack_pointer(), as its result can be slightly below current
774 bool os::Linux::manually_expand_stack(JavaThread * t, address addr) {
797 if (os::Linux::is_LinuxThreads() && !os::Linux::is_floating_stack()) {
816 address stack_bottom = os::current_stack_base() - os::current_stack_size();
840 int pid = os::current_process_id();
858 osthread->set_thread_id(os::Linux::gettid());
861 int lgrp_id = os::numa_get_group_id();
867 os::Linux::hotspot_sigmask(thread);
870 os::Linux::init_thread_fpu_state();
880 // wait until os::start_thread()
892 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
915 if (os::Linux::supports_variable_stack_size()) {
918 stack_size = os::Linux::default_stack_size(thr_type);
921 case os::java_thread:
927 case os::compiler_thread:
933 case os::vm_thread:
934 case os::pgc_thread:
935 case os::cgc_thread:
936 case os::watcher_thread:
942 stack_size = MAX2(stack_size, os::Linux::min_stack_allowed);
949 pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));
955 bool lock = os::Linux::is_LinuxThreads() && !os::Linux::is_floating_stack();
957 os::Linux::createThread_lock()->lock_without_safepoint_check();
972 if (lock) os::Linux::createThread_lock()->unlock();
989 os::Linux::createThread_lock()->unlock();
1010 bool os::create_main_thread(JavaThread* thread) {
1011 assert(os::Linux::_main_thread == pthread_self(), "should be called inside main thread");
1015 bool os::create_attached_thread(JavaThread* thread) {
1028 osthread->set_thread_id(os::Linux::gettid());
1032 os::Linux::init_thread_fpu_state();
1040 int lgrp_id = os::numa_get_group_id();
1046 if (os::Linux::is_initial_thread()) {
1062 os::Linux::manually_expand_stack(jt, addr);
1068 os::Linux::hotspot_sigmask(thread);
1073 void os::pd_start_thread(Thread* thread) {
1082 void os::free_thread(OSThread* osthread) {
1097 int os::allocate_thread_local_storage() {
1106 void os::free_thread_local_storage(int index) {
1111 void os::thread_local_storage_at_put(int index, void* value) {
1124 bool os::Linux::is_initial_thread(void) {
1131 "os::init did not locate initial thread's stack region");
1165 void os::Linux::capture_initial_stack(size_t max_size) {
1365 double os::elapsedTime() {
1367 return (double)(os::elapsed_counter()) * 0.000001;
1370 jlong os::elapsed_counter() {
1376 jlong os::elapsed_frequency() {
1383 bool os::supports_vtime() { return false; }
1384 bool os::enable_vtime() { return false; }
1385 bool os::vtime_enabled() { return false; }
1386 double os::elapsedVTime() {
1391 jlong os::javaTimeMillis() {
1402 void os::Linux::clock_init() {
1452 void os::Linux::fast_thread_clock_init() {
1479 jlong os::javaTimeNanos() {
1495 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1516 bool os::getTimesSecs(double* process_real_time,
1535 char * os::local_time_string(char *buf, size_t buflen) {
1546 struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
1553 // Note: os::shutdown() might be called very early during initialization, or
1554 // called from signal handler. Before adding something to os::shutdown(), make
1556 void os::shutdown() {
1575 // Note: os::abort() might be called very early during initialization, or
1576 // called from signal handler. Before adding something to os::abort(), make
1578 void os::abort(bool dump_core) {
1579 os::shutdown();
1585 jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1596 void os::die() {
1602 void os::set_error_file(const char *logfile) {}
1608 size_t os::lasterror(char *buf, size_t len) {
1622 intx os::current_thread_id() { return (intx)pthread_self(); }
1623 int os::current_process_id() {
1646 const char* os::dll_file_extension() { return ".so"; }
1650 const char* os::get_temp_directory() { return "/tmp"; }
1657 return os::stat(filename, &statbuf) == 0;
1660 void os::dll_build_name(char* buffer, size_t buflen,
1673 } else if (strchr(pname, *os::path_separator()) != NULL) {
1700 const char* os::get_current_directory(char *buf, int buflen) {
1705 bool os::address_is_in_vm(address addr) {
1710 dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo);
1722 bool os::dll_address_to_function_name(address addr, char *buf,
1790 bool os::dll_address_to_library_name(address addr, char* buf,
1828 bool os::Linux::_stack_is_executable = false;
1845 _lib = os::Linux::dll_load_in_vmthread(_filename, _ebuf, _ebuflen);
1846 os::Linux::_stack_is_executable = true;
1851 void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
1861 if (os::uses_stack_guard_pages() && !os::Linux::_stack_is_executable) {
1865 os::Linux::_stack_is_executable = true;
1893 result = os::Linux::dlopen_helper(filename, ebuf, ebuflen);
1911 result = os::Linux::dlopen_helper(filename, ebuf, ebuflen);
2006 #error Method os::dll_load requires that one of following is defined:\
2062 void * os::Linux::dlopen_helper(const char *filename, char *ebuf, int ebuflen) {
2071 void * os::Linux::dll_load_in_vmthread(const char *filename, char *ebuf, int ebuflen) {
2091 if (!os::guard_memory((char *) jt->stack_red_zone_base() - jt->stack_red_zone_size(),
2108 void* os::dll_lookup(void* handle, const char* name) {
2133 void os::print_dll_info(outputStream *st) {
2137 pid_t pid = os::Linux::gettid();
2146 void os::print_os_info_brief(outputStream* st) {
2147 os::Linux::print_distro_info(st);
2149 os::Posix::print_uname_info(st);
2151 os::Linux::print_libversion_info(st);
2155 void os::print_os_info(outputStream* st) {
2158 os::Linux::print_distro_info(st);
2160 os::Posix::print_uname_info(st);
2168 os::Linux::print_libversion_info(st);
2170 os::Posix::print_rlimit_info(st);
2172 os::Posix::print_load_average(st);
2174 os::Linux::print_full_memory_info(st);
2182 void os::Linux::print_distro_info(outputStream* st) {
2197 void os::Linux::print_libversion_info(outputStream* st) {
2200 st->print(os::Linux::glibc_version()); st->print(" ");
2201 st->print(os::Linux::libpthread_version()); st->print(" ");
2202 if (os::Linux::is_LinuxThreads()) {
2203 st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed");
2208 void os::Linux::print_full_memory_info(outputStream* st) {
2214 void os::print_memory_info(outputStream* st) {
2217 st->print(" %dk page", os::vm_page_size()>>10);
2224 os::physical_memory() >> 10);
2226 os::available_memory() >> 10);
2234 void os::pd_print_cpu_info(outputStream* st) {
2257 void os::print_siginfo(outputStream* st, void* siginfo) {
2263 st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));
2309 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
2328 void os::jvm_path(char *buf, jint buflen) {
2343 CAST_FROM_FN_PTR(address, os::jvm_path),
2407 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
2411 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
2431 os::die();
2434 os::signal_notify(sig);
2437 void* os::user_handler() {
2497 void* os::signal(int signal_number, void* handler) {
2512 void os::signal_raise(int signal_number) {
2517 * The following code is moved from os.cpp for making this
2522 int os::sigexitnum_pd() {
2533 void os::signal_init_pd() {
2541 void os::signal_notify(int sig) {
2584 int os::signal_lookup() {
2588 int os::signal_wait() {
2595 int os::vm_page_size() {
2597 assert(os::Linux::page_size() != -1, "must call os::init");
2598 return os::Linux::page_size();
2602 int os::vm_allocation_granularity() {
2603 assert(os::Linux::page_size() != -1, "must call os::init");
2604 return os::Linux::page_size();
2624 os::get_temp_directory(), os::current_process_id(), num);
2668 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2676 warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT
2685 int os::Linux::commit_memory_impl(char* addr, size_t size, bool exec) {
2706 bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
2707 return os::Linux::commit_memory_impl(addr, size, exec) == 0;
2710 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
2713 int err = os::Linux::commit_memory_impl(addr, size, exec);
2731 int os::Linux::commit_memory_impl(char* addr, size_t size,
2761 err = os::Linux::commit_memory_impl(addr, size, exec);
2768 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
2770 return os::Linux::commit_memory_impl(addr, size, alignment_hint, exec) == 0;
2773 void os::pd_commit_memory_or_exit(char* addr, size_t size,
2777 int err = os::Linux::commit_memory_impl(addr, size, alignment_hint, exec);
2785 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2793 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
2799 if (alignment_hint <= (size_t)os::vm_page_size() || !UseSHM) {
2804 void os::numa_make_global(char *addr, size_t bytes) {
2808 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2812 bool os::numa_topology_changed() { return false; }
2814 size_t os::numa_get_groups_num() {
2819 int os::numa_get_group_id() {
2830 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2837 bool os::get_page_info(char *start, page_info* info) {
2841 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2846 int os::Linux::sched_getcpu_syscall(void) {
2880 void* os::Linux::libnuma_dlsym(void* handle, const char *name) {
2888 bool os::Linux::libnuma_init() {
2926 void os::Linux::rebuild_cpu_to_node_map() {
2936 size_t cpu_num = os::active_processor_count();
2962 int os::Linux::get_node_by_cpu(int cpu_id) {
2969 GrowableArray<int>* os::Linux::_cpu_to_node;
2970 os::Linux::sched_getcpu_func_t os::Linux::_sched_getcpu;
2971 os::Linux::numa_node_to_cpus_func_t os::Linux::_numa_node_to_cpus;
2972 os::Linux::numa_max_node_func_t os::Linux::_numa_max_node;
2973 os::Linux::numa_available_func_t os::Linux::_numa_available;
2974 os::Linux::numa_tonode_memory_func_t os::Linux::_numa_tonode_memory;
2975 os::Linux::numa_interleave_memory_func_t os::Linux::_numa_interleave_memory;
2976 unsigned long* os::Linux::_numa_all_nodes;
2978 bool os::pd_uncommit_memory(char* addr, size_t size) {
3019 while ((sz = os::get_line_chars(fd, buf, sizeof(buf))) > 0) {
3043 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
3045 bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
3047 assert(os::Linux::is_initial_thread(),
3053 return os::commit_memory(addr, size, !ExecMem);
3059 bool os::remove_stack_guard_pages(char* addr, size_t size) {
3061 bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
3063 assert(os::Linux::is_initial_thread(),
3069 return os::uncommit_memory(addr, size);
3086 assert((uintptr_t)requested_addr % os::Linux::page_size() == 0, "unaligned address");
3116 char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
3121 bool os::pd_release_memory(char* addr, size_t size) {
3131 char* bottom = (char*)align_size_down((intptr_t)addr, os::Linux::page_size());
3140 size = align_size_up(pointer_delta(addr, bottom, 1) + size, os::Linux::page_size());
3145 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3160 bool os::guard_memory(char* addr, size_t size) {
3164 bool os::unguard_memory(char* addr, size_t size) {
3168 bool os::Linux::hugetlbfs_sanity_check(bool warn, size_t page_size) {
3246 void os::large_page_init() {
3330 char* os::reserve_memory_special(size_t bytes, char* req_addr, bool exec) {
3397 bool os::release_memory_special(char* base, size_t bytes) {
3410 size_t os::large_page_size() {
3417 bool os::can_commit_large_page_memory() {
3421 bool os::can_execute_large_page_memory() {
3428 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3439 assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");
3512 size_t os::read(int fd, void *buf, unsigned int nBytes) {
3516 // TODO-FIXME: reconcile Solaris' os::sleep with the linux variation.
3522 int os::sleep(Thread* thread, jlong millis, bool interruptible) {
3533 if (os::is_interrupted(thread, true)) {
3595 int os::naked_sleep() {
3597 return os::sleep(Thread::current(), 1, false);
3601 void os::infinite_sleep() {
3608 bool os::dont_yield() {
3612 void os::yield() {
3616 os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN ;}
3618 void os::yield_all(int attempts) {
3621 // os::yield_all() with nanosleep(1ms) is not necessary.
3626 void os::loop_breaker(int attempts) {
3627 os::yield_all(attempts);
3647 int os::java_to_os_priority[CriticalPriority + 1] = {
3680 os::java_to_os_priority[MaxPriority] = os::java_to_os_priority[CriticalPriority];
3685 OSReturn os::set_native_priority(Thread* thread, int newpri) {
3692 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
3705 void os::hint_no_preempt() {}
3764 os::SuspendResume::State current = osthread->sr.state();
3765 if (current == os::SuspendResume::SR_SUSPEND_REQUEST) {
3769 os::SuspendResume::State state = osthread->sr.suspended();
3770 if (state == os::SuspendResume::SR_SUSPENDED) {
3782 os::SuspendResume::State result = osthread->sr.running();
3783 if (result == os::SuspendResume::SR_RUNNING) {
3789 } else if (state == os::SuspendResume::SR_RUNNING) {
3796 } else if (current == os::SuspendResume::SR_RUNNING) {
3798 } else if (current == os::SuspendResume::SR_WAKEUP_REQUEST) {
3841 os::Linux::set_our_sigflags(SR_signum, act.sa_flags);
3868 if (osthread->sr.request_suspend() != os::SuspendResume::SR_SUSPEND_REQUEST) {
3884 os::SuspendResume::State cancelled = osthread->sr.cancel_suspend();
3885 if (cancelled == os::SuspendResume::SR_RUNNING) {
3887 } else if (cancelled == os::SuspendResume::SR_SUSPENDED) {
3906 if (osthread->sr.request_wakeup() != os::SuspendResume::SR_WAKEUP_REQUEST) {
3930 void os::interrupt(Thread* thread) {
3955 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
4011 bool os::Linux::signal_handlers_are_installed = false;
4014 struct sigaction os::Linux::sigact[MAXSIGNUM];
4015 unsigned int os::Linux::sigs = 0;
4016 bool os::Linux::libjsig_is_loaded = false;
4018 get_signal_t os::Linux::get_signal_action = NULL;
4020 struct sigaction* os::Linux::get_chained_signal_action(int sig) {
4080 bool os::Linux::chained_handler(int sig, siginfo_t* siginfo, void* context) {
4092 struct sigaction* os::Linux::get_preinstalled_handler(int sig) {
4099 void os::Linux::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
4106 int os::Linux::sigflags[MAXSIGNUM];
4108 int os::Linux::get_our_sigflags(int sig) {
4113 void os::Linux::set_our_sigflags(int sig, int flags) {
4118 void os::Linux::set_signal_handler(int sig, bool set_installed) {
4168 void os::Linux::install_signal_handlers() {
4230 jlong os::Linux::fast_thread_cpu_time(clockid_t clockid) {
4232 int rc = os::Linux::clock_gettime(clockid, &tp);
4252 bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
4257 size_t len = strlen(os::file_separator());
4258 while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
4275 st->print("%s: ", os::exception_name(sig, buf, buflen));
4305 if((int)sa.sa_flags != os::Linux::get_our_sigflags(sig)) {
4308 os::Linux::get_our_sigflags(sig));
4317 os::Linux::check_signal_handler(sig)
4322 void os::run_periodic_checks() {
4355 void os::Linux::check_signal_handler(int sig) {
4413 } else if(os::Linux::get_our_sigflags(sig) != 0 && (int)act.sa_flags != os::Linux::get_our_sigflags(sig)) {
4415 tty->print("expected:" PTR32_FORMAT, os::Linux::get_our_sigflags(sig));
4431 const char* os::exception_name(int exception_code, char* buf, size_t size) {
4444 void os::init(void) {
4466 fatal(err_msg("os_linux.cpp: os::init: sysconf failed (%s)",
4477 initial_time_count = os::elapsed_counter();
4498 jint os::init_2(void)
4504 guarantee( polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page" );
4506 os::set_polling_page( polling_page );
4516 os::set_memory_serialize_page( mem_serialize_page );
4524 os::large_page_init();
4540 os::Linux::min_stack_allowed = MAX2(os::Linux::min_stack_allowed,
4546 threadStackSizeInBytes < os::Linux::min_stack_allowed) {
4549 os::Linux::min_stack_allowed/ K);
4605 perror("os::init_2 getrlimit failed");
4611 perror("os::init_2 setrlimit failed");
4616 // Initialize lock used to serialize thread creation (see os::create_thread)
4634 warning("os::init2 atexit(perfMemory_exit_helper) failed");
4645 void os::init_3(void)
4657 void os::make_polling_page_unreadable(void) {
4663 void os::make_polling_page_readable(void) {
4669 int os::active_processor_count() {
4677 void os::set_native_thread_name(const char *name) {
4682 bool os::distribute_processes(uint length, uint* distribution) {
4687 bool os::bind_to_processor(uint processor_id) {
4694 void os::SuspendedThreadTask::internal_do_task() {
4702 class PcFetcher : public os::SuspendedThreadTask {
4704 PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
4707 void do_task(const os::SuspendedThreadTaskContext& context);
4717 void PcFetcher::do_task(const os::SuspendedThreadTaskContext& context) {
4721 _epc = os::Linux::ucontext_get_pc((ucontext_t *) context.ucontext());
4730 ExtendedPC os::get_thread_pc(Thread* thread) {
4740 int os::Linux::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime)
4763 int page_bits = -os::vm_page_size();
4772 bool os::find(address addr, outputStream* st) {
4818 os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method,
4823 void os::print_statistics() {
4826 int os::message_box(const char* title, const char* message) {
4845 int os::stat(const char *path, struct stat *sbuf) {
4851 os::native_path(strcpy(pathbuf, path));
4855 bool os::check_heap(bool force) {
4864 bool os::dir_is_empty(const char* path) {
4894 int os::open(const char *path, int oflag, int mode) {
4963 int os::create_binary_file(const char* path, bool rewrite_existing) {
4972 jlong os::current_file_offset(int fd) {
4977 jlong os::seek_to_file_offset(int fd, jlong offset) {
4984 int os::available(int fd, jlong *bytes) {
5015 int os::socket_available(int fd, jint *pbytes) {
5025 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
5055 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
5059 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
5065 bool os::pd_unmap_memory(char* addr, size_t bytes) {
5076 int rc = os::Linux::pthread_getcpuclockid(tid, &clockid);
5088 jlong os::current_thread_cpu_time() {
5089 if (os::Linux::supports_fast_thread_cpu_time()) {
5090 return os::Linux::fast_thread_cpu_time(CLOCK_THREAD_CPUTIME_ID);
5097 jlong os::thread_cpu_time(Thread* thread) {
5099 if (os::Linux::supports_fast_thread_cpu_time()) {
5100 return os::Linux::fast_thread_cpu_time(thread_cpu_clockid(thread));
5106 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
5107 if (user_sys_cpu_time && os::Linux::supports_fast_thread_cpu_time()) {
5108 return os::Linux::fast_thread_cpu_time(CLOCK_THREAD_CPUTIME_ID);
5114 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
5115 if (user_sys_cpu_time && os::Linux::supports_fast_thread_cpu_time()) {
5116 return os::Linux::fast_thread_cpu_time(thread_cpu_clockid(thread));
5170 if (proc_task_unchecked && os::Linux::is_NPTL()) {
5212 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5219 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5226 bool os::is_thread_cpu_time_supported() {
5233 int os::loadavg(double loadavg[], int nelem) {
5237 void os::pause() {
5346 int os::PlatformEvent::TryPark() {
5354 void os::PlatformEvent::park() { // AKA "down()"
5389 int os::PlatformEvent::park(jlong millis) {
5427 status = os::Linux::safe_cond_timedwait(_cond, _mutex, &abst);
5453 void os::PlatformEvent::unpark() {
5628 sigset_t* allowdebug_blocked = os::Linux::allowdebug_blocked_signals();
5639 status = os::Linux::safe_cond_timedwait (_cond, _mutex, &absTime) ;
5705 int os::fork_and_exec(char* cmd) {
5777 bool os::is_headless_jre() {
5786 os::jvm_path(buf, sizeof(buf));
5813 int os::get_core_path(char* buffer, size_t bufferSize) {
5836 if (os::create_thread(this, os::os_thread)) {
5838 os::set_priority(this, NearMaxPriority);
5839 os::start_thread(this);
5863 //ssize_t free_before = os::available_memory();
5864 //tty->print ("Notified: Free: %dK \n",os::available_memory()/1024);
5873 //ssize_t free_after = os::available_memory();