--- /dev/null 2019-01-28 17:46:31.000000000 +0800 +++ new/src/share/vm/jfr/periodic/jfrOSInterface.cpp 2019-01-28 17:46:31.000000000 +0800 @@ -0,0 +1,248 @@ +/* + * Copyright (c) 2012, 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. + * + */ + +#include "precompiled.hpp" +#include "jfr/periodic/jfrOSInterface.hpp" +#include "memory/allocation.inline.hpp" +#include "memory/resourceArea.hpp" +#include "runtime/os.hpp" +#include "runtime/os_perf.hpp" +#include "utilities/ostream.hpp" +#include "trace/tracing.hpp" + +#include // for environment variables +#ifdef __APPLE__ +#include +#define environ (*_NSGetEnviron()) +#endif + +#ifndef environ +extern char** environ; +#endif + +static JfrOSInterface* _instance = NULL; + +JfrOSInterface& JfrOSInterface::instance() { + return *_instance; +} + +JfrOSInterface* JfrOSInterface::create() { + assert(_instance == NULL, "invariant"); + _instance = new JfrOSInterface(); + return _instance; +} + +void JfrOSInterface::destroy() { + if (_instance != NULL) { + delete _instance; + _instance = NULL; + } +} + +class JfrOSInterface::JfrOSInterfaceImpl : public JfrCHeapObj { + friend class JfrOSInterface; + private: + CPUInformationInterface* _cpu_info_interface; + CPUPerformanceInterface* _cpu_perf_interface; + SystemProcessInterface* _system_process_interface; + + // stub helper + void functionality_not_implemented(char** str) const; + + JfrOSInterfaceImpl(); + bool initialize(); + ~JfrOSInterfaceImpl(); + + // cpu info + int cpu_information(CPUInformation& cpu_info); + int cpu_load(int which_logical_cpu, double* cpu_load); + int context_switch_rate(double* rate); + int cpu_load_total_process(double* cpu_load); + int cpu_loads_process(double* pjvmUserLoad, double* pjvmKernelLoad, double* psystemTotal); + + // os information + int os_version(char** os_version) const; + + // environment information + void generate_environment_variables_events(); + + // system processes information + int system_processes(SystemProcess** system_processes, int* no_of_sys_processes); +}; + +JfrOSInterface::JfrOSInterfaceImpl::JfrOSInterfaceImpl() : _cpu_info_interface(NULL), + _cpu_perf_interface(NULL), + _system_process_interface(NULL) {} + +bool JfrOSInterface::JfrOSInterfaceImpl::initialize() { + _cpu_info_interface = new CPUInformationInterface(); + bool success = _cpu_info_interface != NULL && _cpu_info_interface->initialize(); + if (!success) { + return false; + } + _cpu_perf_interface = new CPUPerformanceInterface(); + success = _cpu_perf_interface != NULL && _cpu_perf_interface->initialize(); + if (!success) { + return false; + } + _system_process_interface = new SystemProcessInterface(); + success = _system_process_interface != NULL && _system_process_interface->initialize(); + return success; +} + +JfrOSInterface::JfrOSInterfaceImpl::~JfrOSInterfaceImpl(void) { + if (_cpu_info_interface != NULL) { + delete _cpu_info_interface; + _cpu_info_interface = NULL; + } + if (_cpu_perf_interface != NULL) { + delete _cpu_perf_interface; + _cpu_perf_interface = NULL; + } + if (_system_process_interface != NULL) { + delete _system_process_interface; + _system_process_interface = NULL; + } +} + +int JfrOSInterface::JfrOSInterfaceImpl::cpu_load(int which_logical_cpu, double* cpu_load) { + return _cpu_perf_interface->cpu_load(which_logical_cpu, cpu_load); +} + +int JfrOSInterface::JfrOSInterfaceImpl::context_switch_rate(double* rate) { + return _cpu_perf_interface->context_switch_rate(rate); +} + +int JfrOSInterface::JfrOSInterfaceImpl::cpu_load_total_process(double* cpu_load) { + return _cpu_perf_interface->cpu_load_total_process(cpu_load); +} + +int JfrOSInterface::JfrOSInterfaceImpl::cpu_loads_process(double* pjvmUserLoad, + double* pjvmKernelLoad, + double* psystemTotal) { + return _cpu_perf_interface->cpu_loads_process(pjvmUserLoad, pjvmKernelLoad, psystemTotal); +} + +int JfrOSInterface::JfrOSInterfaceImpl::cpu_information(CPUInformation& cpu_info) { + return _cpu_info_interface->cpu_information(cpu_info); +} + +int JfrOSInterface::JfrOSInterfaceImpl::system_processes(SystemProcess** system_processes, int* no_of_sys_processes) { + assert(system_processes != NULL, "system_processes pointer is NULL!"); + assert(no_of_sys_processes != NULL, "no_of_sys_processes pointer is NULL!"); + return _system_process_interface->system_processes(system_processes, no_of_sys_processes); +} + +// assigned char* is RESOURCE_HEAP_ALLOCATED +// caller need to ensure proper ResourceMark placement. +int JfrOSInterface::JfrOSInterfaceImpl::os_version(char** os_version) const { + assert(os_version != NULL, "os_version pointer is NULL!"); + stringStream os_ver_info; + os::print_os_info_brief(&os_ver_info); + *os_version = os_ver_info.as_string(); + return OS_OK; +} + +void JfrOSInterface::JfrOSInterfaceImpl::functionality_not_implemented(char** str) const { + assert(str != NULL, "address to string is NULL!"); + const char* not_impl = "Functionality_not_implemented"; + const size_t not_impl_len = strlen(not_impl); + *str = NEW_C_HEAP_ARRAY(char, not_impl_len+1, mtTracing); + strncpy(*str, not_impl, not_impl_len); + (*str)[not_impl_len] = '\0'; +} + +JfrOSInterface::JfrOSInterface() { + _impl = NULL; +} + +bool JfrOSInterface::initialize() { + _impl = new JfrOSInterface::JfrOSInterfaceImpl(); + return _impl != NULL && _impl->initialize(); +} + +JfrOSInterface::~JfrOSInterface() { + if (_impl != NULL) { + delete _impl; + _impl = NULL; + } +} + +int JfrOSInterface::cpu_information(CPUInformation& cpu_info) { + return instance()._impl->cpu_information(cpu_info); +} + +int JfrOSInterface::cpu_load(int which_logical_cpu, double* cpu_load) { + return instance()._impl->cpu_load(which_logical_cpu, cpu_load); +} + +int JfrOSInterface::context_switch_rate(double* rate) { + return instance()._impl->context_switch_rate(rate); +} + +int JfrOSInterface::cpu_load_total_process(double* cpu_load) { + return instance()._impl->cpu_load_total_process(cpu_load); +} + +int JfrOSInterface::cpu_loads_process(double* jvm_user_load, double* jvm_kernel_load, double* system_total_load){ + return instance()._impl->cpu_loads_process(jvm_user_load, jvm_kernel_load, system_total_load); +} + +int JfrOSInterface::os_version(char** os_version) { + return instance()._impl->os_version(os_version); +} + +int JfrOSInterface::generate_initial_environment_variable_events() { + if (environ == NULL) { + return OS_ERR; + } + + if (EventInitialEnvironmentVariable::is_enabled()) { + // One time stamp for all events, so they can be grouped together + JfrTraceTime time_stamp(Tracing::time()); + for (char** p = environ; *p != NULL; p++) { + char* variable = *p; + char* equal_sign = strchr(variable, '='); + if (equal_sign != NULL) { + // Extract key/value + ResourceMark rm; + ptrdiff_t key_length = equal_sign - variable; + char* key = NEW_RESOURCE_ARRAY(char, key_length + 1); + char* value = equal_sign + 1; + strncpy(key, variable, key_length); + key[key_length] = '\0'; + EventInitialEnvironmentVariable event(UNTIMED); + event.set_endtime(time_stamp); + event.set_key(key); + event.set_value(value); + event.commit(); + } + } + } + return OS_OK; +} + +int JfrOSInterface::system_processes(SystemProcess** sys_processes, int* no_of_sys_processes) { + return instance()._impl->system_processes(sys_processes, no_of_sys_processes); +}