+ * -basexml | -b
+ *
+ * This directory must contain one file with pattern *{openjdk}*.{res} which is considered as a container
+ * of reference scores and several *{jbsdk}*.{res}.
+ *
+ *
Names of these files have several mandatory fields separated by "_" and look like
+ * osName_jdkName_renderName_*.res
+ *
+ *
+ * If any of score is less than corresponding reference value by 5% then exit code 1 is returned otherwise
+ * exit code 0 is returned.
+ *
+ * Standard output will contain scores in format required for TeamCity charts.
+ *
+ * Created by vprovodin on 13/02/2017.
+ */
+public class TCChartReporter {
+
+ private static boolean printTCValues = false;
+ private static boolean printValues = false;
+
+ private static final DecimalFormat decimalFormat =
+ new DecimalFormat("0.00");
+
+ private static FileSystem defaultFileSystem = FileSystems.getDefault();
+
+ private static double getMeasurementError(String testCaseName, String osName) {
+ if (testCaseName.contains("text.Rendering.tests.drawString") && osName.toLowerCase().contains("lin") )
+ return 0.18;
+ return 0.1;
+ }
+
+ /**
+ * Level at which tests are grouped to be displayed in summary
+ */
+ private static final int LEVEL = 2;
+
+ /**
+ * Holds the groups and corresponding group-display-names
+ */
+ private static List groups = new ArrayList<>();
+ private static Map referenceValues = new HashMap<>();
+ private static boolean testFailed = false;
+
+ private static void printUsage() {
+ String usage =
+ "\njava TCChartReporter [options] " +
+ " \n\n" +
+ "where options include: " +
+ " \n" +
+ " -basexml | -b " +
+ "path to base-build result";
+ System.out.println(usage);
+ System.exit(0);
+ }
+
+ /**
+ * String = getTestResultsTableForSummary()
+ */
+ private static double generateTestCaseReport(
+ Object key,
+ Map testCaseResult,
+ Map testCaseResultCount) {
+
+ Integer curTestCountObj = testCaseResultCount.get(key.toString());
+ int curTestCount = 0;
+ if (curTestCountObj != null) {
+ curTestCount = curTestCountObj;
+ }
+
+ double totalScore = 0;
+
+ for (int i = 0; i < curTestCount; i++) {
+ J2DAnalyzer.ResultHolder resultTCR = testCaseResult.get(key.toString() + "_" + i);
+ totalScore = totalScore + resultTCR.getScore();
+ }
+
+ return totalScore;
+ }
+
+ /**
+ * Generate Testcase Summary Report for TC - *.out
+ */
+ private static void generateTestCaseSummaryReport(
+ String OJRname,
+ Map consoleResult,
+ Map testCaseResult,
+ Map testCaseResultCount,
+ boolean rememberReference) {
+
+ String curGroupName, curTestName;
+
+ Object[] groupNameArray = groups.toArray();
+
+ Object[] testCaseList = consoleResult.keySet().toArray();
+ Arrays.sort(testCaseList);
+
+ for (Object aGroupNameArray : groupNameArray) {
+
+ double value;
+ curGroupName = aGroupNameArray.toString();
+
+ for (Object aTestCaseList : testCaseList) {
+
+ curTestName = aTestCaseList.toString();
+
+ if (curTestName.contains(curGroupName)) {
+
+ value = generateTestCaseReport(curTestName, testCaseResult, testCaseResultCount);
+
+ if (printTCValues)
+ System.out.println("##teamcity[buildStatisticValue key='" + (OJRname.isEmpty() ? "" : OJRname + ".") + curTestName
+ + "' value='" + decimalFormat.format(value) + "']");
+ if (printValues)
+ System.out.println((OJRname.isEmpty() ? "" : OJRname + ".") + curTestName + "," + decimalFormat.format(value));
+ if (rememberReference) {
+ referenceValues.put(curTestName, value);
+ } else {
+ double refValue = referenceValues.getOrDefault(curTestName, 0.);
+ if (Math.abs(value/refValue - 1) >= getMeasurementError(curTestName, OJRname)) {
+ System.err.println(OJRname);
+ System.err.println(curTestName);
+ System.err.println("\treferenceValue=" + refValue);
+ System.err.println("\t actualValue=" + value);
+ System.err.println("\t diff:" + ((value / refValue - 1) * 100));
+ testFailed = (value < refValue);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * main
+ */
+ public static void main(String args[]) {
+
+ String baseXML = null;
+ int group = 2;
+
+ /* ---- Analysis Mode ----
+ BEST = 1;
+ WORST = 2;
+ AVERAGE = 3;
+ MIDAVG = 4;
+ ------------------------ */
+ int analyzerMode = 4;
+
+ try {
+
+ for (int i = 0; i < args.length; i++) {
+
+ if (args[i].startsWith("-basexml") ||
+ args[i].startsWith("-b")) {
+ i++;
+ baseXML = args[i];
+ } else if (args[i].startsWith("-tc")) {
+ printTCValues = true;
+ } else if (args[i].startsWith("-v"))
+ printValues = true;
+ }
+ } catch (Exception e) {
+ printUsage();
+ }
+
+ XMLHTMLReporter.setGroupLevel(group);
+ J2DAnalyzer.setMode(analyzerMode);
+ if (baseXML != null) {
+ generateComparisonReport(defaultFileSystem.getPath(baseXML));
+ } else {
+ printUsage();
+ }
+
+ if (testFailed)
+ System.exit(1);
+ }
+
+ /**
+ * Add Test Group to the list
+ */
+ private static void addGroup(String testName) {
+
+ String testNameSplit[] = testName.replace('.', '_').split("_");
+ StringBuilder group = new StringBuilder(testNameSplit[0]);
+ for (int i = 1; i < LEVEL; i++) {
+ group.append(".").append(testNameSplit[i]);
+ }
+
+ if (!groups.contains(group.toString()))
+ groups.add(group.toString());
+ }
+
+ private static List listResFiles(Path dir, String pattern) throws IOException {
+ List result = new ArrayList<>();
+ try (DirectoryStream stream = Files.newDirectoryStream(dir, pattern)) {
+ for (Path entry : stream) {
+ result.add(entry);
+ }
+ } catch (DirectoryIteratorException ex) {
+ throw ex.getCause();
+ }
+ return result;
+ }
+
+ /**
+ * Generate the reports from the base & target result XML
+ */
+ private static void generateComparisonReport(Path directoryToResFiles) {
+
+ if (directoryToResFiles.toFile().isDirectory()) {
+ List jbsdkFiles, openjdkFiles;
+
+ try {
+ jbsdkFiles = listResFiles(directoryToResFiles, "*{jbsdk,jbre}*.{res}");
+ openjdkFiles = listResFiles(directoryToResFiles, "*{openjdk}*.{res}");
+ } catch (IOException e) {
+ e.printStackTrace();
+ return;
+ }
+
+ readScores(openjdkFiles.get(0), true);
+
+ for (Path file : jbsdkFiles) {
+ readScores(file, false);
+ }
+ } else {
+ readScores(directoryToResFiles, true);
+ }
+ }
+
+ private static void readScores(Path file, boolean rememberReference) {
+ String fileName = file.getName(file.getNameCount() - 1).toString();
+ String osName="", jdkName="", renderName="";
+ if (fileName.contains("win") || fileName.contains("linux") || fileName.contains("osx")) {
+ String[] fileNameComponents = fileName.split("_");
+ if (fileNameComponents.length > 0)
+ osName = fileNameComponents[0];
+ if (fileNameComponents.length > 1)
+ jdkName = fileNameComponents[1];
+ if (fileNameComponents.length > 2)
+ renderName = fileNameComponents[2];
+ }
+
+ String resultXMLFileName = file.toString();
+
+ J2DAnalyzer.results = new Vector();
+ J2DAnalyzer.readResults(resultXMLFileName);
+ J2DAnalyzer.SingleResultSetHolder baseSRSH =
+ (J2DAnalyzer.SingleResultSetHolder) J2DAnalyzer.results.elementAt(0);
+ Enumeration baseEnum_ = baseSRSH.getKeyEnumeration();
+ Vector baseKeyvector = new Vector<>();
+ while (baseEnum_.hasMoreElements()) {
+ baseKeyvector.add((String) baseEnum_.nextElement());
+ }
+ String baseKeys[] = new String[baseKeyvector.size()];
+ baseKeyvector.copyInto(baseKeys);
+ J2DAnalyzer.sort(baseKeys);
+
+ Map consoleBaseRes = new HashMap<>();
+
+ Map testCaseBaseResult = new HashMap<>();
+ Map testCaseResultCount = new HashMap<>();
+
+ for (String baseKey : baseKeys) {
+
+ J2DAnalyzer.ResultHolder baseTCR =
+ baseSRSH.getResultByKey(baseKey);
+
+ Integer curTestCountObj = testCaseResultCount.get(baseTCR.getName());
+ int curTestCount = 0;
+ if (curTestCountObj != null) {
+ curTestCount = curTestCountObj;
+ }
+ curTestCount++;
+ testCaseBaseResult.put(baseTCR.getName() + "_" + (curTestCount - 1), baseTCR);
+ testCaseResultCount.put(baseTCR.getName(), curTestCount);
+
+ addGroup(baseTCR.getName());
+
+ Double curTotalScoreObj = consoleBaseRes.get(baseTCR.getName());
+ double curTotalScore = 0;
+ if (curTotalScoreObj != null) {
+ curTotalScore = curTotalScoreObj;
+ }
+ curTotalScore = curTotalScore + baseTCR.getScore();
+ consoleBaseRes.put(baseTCR.getName(), curTotalScore);
+ }
+
+ String OJRname = osName + "." + jdkName + "." + renderName;
+ generateTestCaseSummaryReport((OJRname.length() == 2? "": OJRname),
+ consoleBaseRes,
+ testCaseBaseResult,
+ testCaseResultCount,
+ rememberReference);
+
+ }
+}
diff --git a/src/hotspot/os/aix/os_aix.cpp b/src/hotspot/os/aix/os_aix.cpp
index 561ef77b18b4..9282b6dd2a55 100644
--- a/src/hotspot/os/aix/os_aix.cpp
+++ b/src/hotspot/os/aix/os_aix.cpp
@@ -1160,6 +1160,10 @@ void *os::dll_load(const char *filename, char *ebuf, int ebuflen) {
return nullptr;
}
+void * os::dll_load_utf8(const char *filename, char *ebuf, int ebuflen) {
+ return os::dll_load(filename, ebuf, ebuflen);
+}
+
void os::print_dll_info(outputStream *st) {
st->print_cr("Dynamic libraries:");
LoadedLibraries::print(st);
diff --git a/src/hotspot/os/bsd/os_bsd.cpp b/src/hotspot/os/bsd/os_bsd.cpp
index 1f2094fba1f6..d0ac030e70e5 100644
--- a/src/hotspot/os/bsd/os_bsd.cpp
+++ b/src/hotspot/os/bsd/os_bsd.cpp
@@ -1243,6 +1243,10 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
}
#endif // !__APPLE__
+void * os::dll_load_utf8(const char *filename, char *ebuf, int ebuflen) {
+ return os::dll_load(filename, ebuf, ebuflen);
+}
+
int _print_dll_info_cb(const char * name, address base_address, address top_address, void * param) {
outputStream * out = (outputStream *) param;
out->print_cr(INTPTR_FORMAT " \t%s", (intptr_t)base_address, name);
diff --git a/src/hotspot/os/linux/os_linux.cpp b/src/hotspot/os/linux/os_linux.cpp
index fb6701a50146..736f9eca4c0e 100644
--- a/src/hotspot/os/linux/os_linux.cpp
+++ b/src/hotspot/os/linux/os_linux.cpp
@@ -1807,6 +1807,10 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
return nullptr;
}
+void * os::dll_load_utf8(const char *filename, char *ebuf, int ebuflen) {
+ return os::dll_load(filename, ebuf, ebuflen);
+}
+
void * os::Linux::dlopen_helper(const char *filename, char *ebuf, int ebuflen) {
#ifndef IA32
bool ieee_handling = IEEE_subnormal_handling_OK();
diff --git a/src/hotspot/os/posix/signals_posix.cpp b/src/hotspot/os/posix/signals_posix.cpp
index eaadb3673151..199196086ff7 100644
--- a/src/hotspot/os/posix/signals_posix.cpp
+++ b/src/hotspot/os/posix/signals_posix.cpp
@@ -559,6 +559,12 @@ int JVM_HANDLE_XXX_SIGNAL(int sig, siginfo_t* info,
{
assert(info != nullptr && ucVoid != nullptr, "sanity");
+ if (sig == SIGABRT) {
+ // Re-set the handler so that we don't recurse if/when abort() is called
+ // from here.
+ PosixSignals::install_generic_signal_handler(SIGABRT, (void*)SIG_DFL);
+ }
+
// Note: it's not uncommon that JNI code uses signal/sigset to install,
// then restore certain signal handler (e.g. to temporarily block SIGPIPE,
// or have a SIGILL handler when detecting CPU type). When that happens,
@@ -1341,6 +1347,10 @@ void install_signal_handlers() {
assert(ret == 0, "check");
}
+ if (CatchSIGABRT) {
+ set_signal_handler(SIGABRT);
+ }
+
#if defined(__APPLE__)
// lldb (gdb) installs both standard BSD signal handlers, and mach exception
// handlers. By replacing the existing task exception handler, we disable lldb's mach
diff --git a/src/hotspot/os/windows/os_windows.cpp b/src/hotspot/os/windows/os_windows.cpp
index c08476df7c95..62ce2f8ad99e 100644
--- a/src/hotspot/os/windows/os_windows.cpp
+++ b/src/hotspot/os/windows/os_windows.cpp
@@ -1529,9 +1529,221 @@ static int _print_module(const char* fname, address base_address,
return 0;
}
+static errno_t convert_to_UTF16(char const* source_str, UINT source_encoding, LPWSTR* dest_utf16_str) {
+ const int len_estimated = MultiByteToWideChar(source_encoding,
+ MB_ERR_INVALID_CHARS,
+ source_str,
+ -1, // source is null-terminated
+ NULL,
+ 0); // estimate characters count
+ if (len_estimated == 0) {
+ // Probably source_str contains characters that cannot be represented in the source_encoding given.
+ *dest_utf16_str = NULL;
+ return EINVAL;
+ }
+
+ *dest_utf16_str = NEW_C_HEAP_ARRAY(WCHAR, len_estimated, mtInternal);
+
+ const int len_real = MultiByteToWideChar(source_encoding,
+ MB_ERR_INVALID_CHARS,
+ source_str,
+ -1, // source is null-terminated
+ *dest_utf16_str, len_estimated);
+ assert(len_real == len_estimated, "length already checked above");
+
+ return ERROR_SUCCESS;
+}
+
+// Converts a string in the "platform" encoding to UTF16.
+static errno_t convert_to_UTF16(char const* platform_str, LPWSTR* utf16_str) {
+ return convert_to_UTF16(platform_str, CP_ACP, utf16_str);
+}
+
+static errno_t convert_UTF8_to_UTF16(char const* utf8_str, LPWSTR* utf16_str) {
+ return convert_to_UTF16(utf8_str, CP_UTF8, utf16_str);
+}
+
+// Converts a wide-character string in UTF-16 encoding to the 8-bit "platform" encoding.
+// Unless the platform encoding is UTF-8, not all characters in the source string can be represented in the dest string.
+// The function succeeds in this case anyway and just replaces these with a certain character.
+static errno_t convert_UTF16_to_platform(LPWSTR source_utf16_str, char*& dest_str) {
+ const int len_estimated = WideCharToMultiByte(CP_ACP,
+ 0,
+ source_utf16_str,
+ -1, // source is null-terminated
+ NULL,
+ 0, // estimate characters count
+ NULL, NULL);
+ if (len_estimated == 0) {
+ dest_str = NULL;
+ return EINVAL;
+ }
+
+ dest_str = NEW_C_HEAP_ARRAY(CHAR, len_estimated, mtInternal);
+
+ const int len_real = WideCharToMultiByte(CP_ACP,
+ 0,
+ source_utf16_str,
+ -1, // source is null-terminated
+ dest_str, len_estimated, NULL, NULL);
+ assert(len_real == len_estimated, "length already checked above");
+
+ return ERROR_SUCCESS;
+}
+
+class MemoryReleaserW : public StackObj {
+private:
+ WCHAR* _object_ptr;
+
+public:
+ MemoryReleaserW(WCHAR * object_ptr) : _object_ptr(object_ptr) {}
+ ~MemoryReleaserW() { if (_object_ptr != NULL) FREE_C_HEAP_ARRAY(WCHAR, _object_ptr); }
+};
+
+class MemoryReleaser : public StackObj {
+private:
+ CHAR* _object_ptr;
+
+public:
+ MemoryReleaser(CHAR * object_ptr) : _object_ptr(object_ptr) {}
+ ~MemoryReleaser() { if (_object_ptr != NULL) FREE_C_HEAP_ARRAY(CHAR, _object_ptr); }
+};
+
// Loads .dll/.so and
// in case of error it checks if .dll/.so was built for the
// same architecture as Hotspot is running on
+void * os::dll_load_utf8(const char *utf8_name, char *ebuf, int ebuflen) {
+ LPWSTR utf16_name = NULL;
+ errno_t err = convert_UTF8_to_UTF16(utf8_name, &utf16_name);
+ MemoryReleaserW release_utf16_name(utf16_name);
+ if (err != ERROR_SUCCESS) {
+ errno = err;
+ return NULL;
+ }
+
+ char* platform_name = NULL; // name of the library converted to the "platform" encoding for use in log messages
+ errno_t ignored_err = convert_UTF16_to_platform(utf16_name, platform_name);
+ MemoryReleaser release_platform_name(platform_name);
+
+ log_info(os)("attempting shared library load of %s", platform_name);
+
+ void * result = LoadLibraryW(utf16_name);
+
+ if (result != NULL) {
+ Events::log(NULL, "Loaded shared library %s", platform_name);
+ // Recalculate pdb search path if a DLL was loaded successfully.
+ SymbolEngine::recalc_search_path();
+ log_info(os)("shared library load of %s was successful", platform_name);
+ return result;
+ }
+ DWORD errcode = GetLastError();
+ // Read system error message into ebuf
+ // It may or may not be overwritten below (in the for loop and just above)
+ lasterror(ebuf, (size_t) ebuflen);
+ ebuf[ebuflen - 1] = '\0';
+ Events::log(NULL, "Loading shared library %s failed, error code %lu", platform_name, errcode);
+ log_info(os)("shared library load of %s failed, error code %lu", platform_name, errcode);
+
+ if (errcode == ERROR_MOD_NOT_FOUND) {
+ strncpy(ebuf, "Can't find dependent libraries", ebuflen - 1);
+ ebuf[ebuflen - 1] = '\0';
+ return NULL;
+ }
+
+ // Parsing dll below
+ // If we can read dll-info and find that dll was built
+ // for an architecture other than Hotspot is running in
+ // - then print to buffer "DLL was built for a different architecture"
+ // else call os::lasterror to obtain system error message
+ int fd = ::wopen(utf16_name, O_RDONLY | O_BINARY, 0);
+ if (fd < 0) {
+ return NULL;
+ }
+
+ uint32_t signature_offset;
+ uint16_t lib_arch = 0;
+ bool failed_to_get_lib_arch =
+ ( // Go to position 3c in the dll
+ (os::seek_to_file_offset(fd, IMAGE_FILE_PTR_TO_SIGNATURE) < 0)
+ ||
+ // Read location of signature
+ (sizeof(signature_offset) !=
+ (::read(fd, (void*)&signature_offset, sizeof(signature_offset))))
+ ||
+ // Go to COFF File Header in dll
+ // that is located after "signature" (4 bytes long)
+ (os::seek_to_file_offset(fd,
+ signature_offset + IMAGE_FILE_SIGNATURE_LENGTH) < 0)
+ ||
+ // Read field that contains code of architecture
+ // that dll was built for
+ (sizeof(lib_arch) != (::read(fd, (void*)&lib_arch, sizeof(lib_arch))))
+ );
+
+ ::close(fd);
+ if (failed_to_get_lib_arch) {
+ // file i/o error - report os::lasterror(...) msg
+ return NULL;
+ }
+
+ typedef struct {
+ uint16_t arch_code;
+ char* arch_name;
+ } arch_t;
+
+ static const arch_t arch_array[] = {
+ {IMAGE_FILE_MACHINE_I386, (char*)"IA 32"},
+ {IMAGE_FILE_MACHINE_AMD64, (char*)"AMD 64"},
+ {IMAGE_FILE_MACHINE_ARM64, (char*)"ARM 64"}
+ };
+#if (defined _M_ARM64)
+ static const uint16_t running_arch = IMAGE_FILE_MACHINE_ARM64;
+#elif (defined _M_AMD64)
+ static const uint16_t running_arch = IMAGE_FILE_MACHINE_AMD64;
+#elif (defined _M_IX86)
+ static const uint16_t running_arch = IMAGE_FILE_MACHINE_I386;
+#else
+ #error Method os::dll_load requires that one of following \
+ is defined :_M_AMD64 or _M_IX86 or _M_ARM64
+#endif
+
+
+ // Obtain a string for printf operation
+ // lib_arch_str shall contain string what platform this .dll was built for
+ // running_arch_str shall string contain what platform Hotspot was built for
+ char *running_arch_str = NULL, *lib_arch_str = NULL;
+ for (unsigned int i = 0; i < ARRAY_SIZE(arch_array); i++) {
+ if (lib_arch == arch_array[i].arch_code) {
+ lib_arch_str = arch_array[i].arch_name;
+ }
+ if (running_arch == arch_array[i].arch_code) {
+ running_arch_str = arch_array[i].arch_name;
+ }
+ }
+
+ assert(running_arch_str,
+ "Didn't find running architecture code in arch_array");
+
+ // If the architecture is right
+ // but some other error took place - report os::lasterror(...) msg
+ if (lib_arch == running_arch) {
+ return NULL;
+ }
+
+ if (lib_arch_str != NULL) {
+ ::_snprintf(ebuf, ebuflen - 1,
+ "Can't load %s-bit .dll on a %s-bit platform",
+ lib_arch_str, running_arch_str);
+ } else {
+ // don't know what architecture this dll was build for
+ ::_snprintf(ebuf, ebuflen - 1,
+ "Can't load this .dll (machine code=0x%x) on a %s-bit platform",
+ lib_arch, running_arch_str);
+ }
+
+ return NULL;
+}
+
void * os::dll_load(const char *name, char *ebuf, int ebuflen) {
log_info(os)("attempting shared library load of %s", name);
void* result;
@@ -4548,7 +4760,7 @@ static wchar_t* wide_abs_unc_path(char const* path, errno_t & err, int additiona
set_path_prefix(buf, &prefix, &prefix_off, &needs_fullpath);
LPWSTR unicode_path = nullptr;
- err = convert_to_unicode(buf, &unicode_path);
+ err = convert_to_UTF16(buf, &unicode_path);
FREE_C_HEAP_ARRAY(char, buf);
if (err != ERROR_SUCCESS) {
return nullptr;
diff --git a/src/hotspot/share/c1/c1_Instruction.cpp b/src/hotspot/share/c1/c1_Instruction.cpp
index b2d31e3c1a83..cf3652c95190 100644
--- a/src/hotspot/share/c1/c1_Instruction.cpp
+++ b/src/hotspot/share/c1/c1_Instruction.cpp
@@ -808,6 +808,19 @@ bool BlockBegin::try_merge(ValueStack* new_state, bool has_irreducible_loops) {
}
}
+ for_each_stack_value(existing_state, index, existing_value) {
+ if ( !(existing_value->as_Phi() != NULL && existing_value->as_Phi()->block() == this)) {
+ TRACE_PHI(tty->print_cr("Re-entered loop head without existing phi for stack - bailout"));
+ return false;
+ }
+ }
+ for_each_local_value(existing_state, index, existing_value) {
+ if (!(existing_value == new_state->local_at(index) || (existing_value->as_Phi() != NULL && existing_value->as_Phi()->as_Phi()->block() == this))) {
+ TRACE_PHI(tty->print_cr("Re-entered loop head without existing phi for modified local - bailout"));
+ return false;
+ }
+ }
+
#ifdef ASSERT
// check that all necessary phi functions are present
for_each_stack_value(existing_state, index, existing_value) {
diff --git a/src/hotspot/share/classfile/classLoaderDataGraph.cpp b/src/hotspot/share/classfile/classLoaderDataGraph.cpp
index 2046286651ea..653586704b32 100644
--- a/src/hotspot/share/classfile/classLoaderDataGraph.cpp
+++ b/src/hotspot/share/classfile/classLoaderDataGraph.cpp
@@ -47,6 +47,7 @@
#include "utilities/growableArray.hpp"
#include "utilities/macros.hpp"
#include "utilities/ostream.hpp"
+#include "utilities/vmError.hpp"
volatile size_t ClassLoaderDataGraph::_num_array_classes = 0;
volatile size_t ClassLoaderDataGraph::_num_instance_classes = 0;
@@ -186,7 +187,8 @@ ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool has_class_mirror_
inline void assert_is_safepoint_or_gc() {
assert(SafepointSynchronize::is_at_safepoint() ||
Thread::current()->is_ConcurrentGC_thread() ||
- Thread::current()->is_Worker_thread(),
+ Thread::current()->is_Worker_thread() ||
+ VMError::is_error_reported(), // don't crash here again if we have already crashed
"Must be called by safepoint or GC");
}
diff --git a/src/hotspot/share/jfr/periodic/jfrNetworkUtilization.cpp b/src/hotspot/share/jfr/periodic/jfrNetworkUtilization.cpp
index 9d57cddb4480..cedf6b756982 100644
--- a/src/hotspot/share/jfr/periodic/jfrNetworkUtilization.cpp
+++ b/src/hotspot/share/jfr/periodic/jfrNetworkUtilization.cpp
@@ -113,10 +113,12 @@ class JfrNetworkInterfaceName : public JfrSerializer {
void serialize(JfrCheckpointWriter& writer) {} // we write each constant lazily
void on_rotation() {
- for (int i = 0; i < _interfaces->length(); ++i) {
- const InterfaceEntry& entry = _interfaces->at(i);
- if (entry.written) {
- entry.written = false;
+ if (_interfaces != NULL) {
+ for (int i = 0; i < _interfaces->length(); ++i) {
+ const InterfaceEntry &entry = _interfaces->at(i);
+ if (entry.written) {
+ entry.written = false;
+ }
}
}
}
diff --git a/src/hotspot/share/memory/metaspace/runningCounters.cpp b/src/hotspot/share/memory/metaspace/runningCounters.cpp
index 08dffc5c64c5..892f7ed5d27a 100644
--- a/src/hotspot/share/memory/metaspace/runningCounters.cpp
+++ b/src/hotspot/share/memory/metaspace/runningCounters.cpp
@@ -45,7 +45,8 @@ size_t RunningCounters::reserved_words_class() {
}
size_t RunningCounters::reserved_words_nonclass() {
- return VirtualSpaceList::vslist_nonclass()->reserved_words();
+ VirtualSpaceList* vs = VirtualSpaceList::vslist_nonclass();
+ return vs != NULL ? vs->reserved_words() : 0;
}
// Return total committed size, in words, for Metaspace
@@ -59,7 +60,8 @@ size_t RunningCounters::committed_words_class() {
}
size_t RunningCounters::committed_words_nonclass() {
- return VirtualSpaceList::vslist_nonclass()->committed_words();
+ VirtualSpaceList* vs = VirtualSpaceList::vslist_nonclass();
+ return vs != NULL ? vs->vslist_nonclass()->committed_words() : 0;
}
// ---- used chunks -----
diff --git a/src/hotspot/share/memory/universe.cpp b/src/hotspot/share/memory/universe.cpp
index dfeb6b11f6f2..56f51962e37f 100644
--- a/src/hotspot/share/memory/universe.cpp
+++ b/src/hotspot/share/memory/universe.cpp
@@ -86,6 +86,7 @@
#include "utilities/macros.hpp"
#include "utilities/ostream.hpp"
#include "utilities/preserveException.hpp"
+#include "utilities/vmError.hpp"
// Known objects
Klass* Universe::_typeArrayKlassObjs[T_LONG+1] = { nullptr /*, nullptr...*/ };
@@ -839,6 +840,8 @@ jint universe_init() {
ResolvedMethodTable::create_table();
+ VMError::init();
+
return JNI_OK;
}
diff --git a/src/hotspot/share/opto/loopPredicate.cpp b/src/hotspot/share/opto/loopPredicate.cpp
index fd0576832cf7..a74c1a183ba9 100644
--- a/src/hotspot/share/opto/loopPredicate.cpp
+++ b/src/hotspot/share/opto/loopPredicate.cpp
@@ -1223,7 +1223,7 @@ bool PhaseIdealLoop::loop_predication_impl_helper(IdealLoopTree* loop, IfProjNod
Node* idx = cmp->in(1);
assert(!invar.is_invariant(idx), "index is variant");
Node* rng = cmp->in(2);
- assert(rng->Opcode() == Op_LoadRange || iff->is_RangeCheck() || _igvn.type(rng)->is_int()->_lo >= 0, "must be");
+ // [tav: crash] assert(rng->Opcode() == Op_LoadRange || iff->is_RangeCheck() || _igvn.type(rng)->is_int()->_lo >= 0, "must be");
assert(invar.is_invariant(rng), "range must be invariant");
int scale = 1;
Node* offset = zero;
diff --git a/src/hotspot/share/prims/jni.cpp b/src/hotspot/share/prims/jni.cpp
index b6a4443a8c76..e1d07a2c5400 100644
--- a/src/hotspot/share/prims/jni.cpp
+++ b/src/hotspot/share/prims/jni.cpp
@@ -3519,6 +3519,19 @@ _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
return ret;
}
+#ifdef LINUX
+static void unsetLdPreload() {
+ // Workaround for: JBR-2253 Preload libjsig.so to fix JNA crashes
+ // NOTE: Probably it still can affect child processes, see
+ // https://stackoverflow.com/questions/3275015/ld-preload-affects-new-child-even-after-unsetenvld-preload
+ char * envUnset = ::getenv("UNSET_LD_PRELOAD");
+ if (envUnset != NULL && strlen(envUnset) > 3 && strncmp("true", envUnset, 4) == 0) {
+ unsetenv("LD_PRELOAD");
+ fprintf(stdout, "LD_PRELOAD was unset\n");
+ }
+}
+#endif //LINUX
+
DT_RETURN_MARK_DECL(CreateJavaVM, jint
, HOTSPOT_JNI_CREATEJAVAVM_RETURN(_ret_ref));
@@ -3625,6 +3638,10 @@ static jint JNI_CreateJavaVM_inner(JavaVM **vm, void **penv, void *args) {
// Since this is not a JVM_ENTRY we have to set the thread state manually before leaving.
ThreadStateTransition::transition_from_vm(thread, _thread_in_native);
MACOS_AARCH64_ONLY(thread->enable_wx(WXExec));
+
+#ifdef LINUX
+ unsetLdPreload();
+#endif //LINUX
} else {
// If create_vm exits because of a pending exception, exit with that
// exception. In the future when we figure out how to reclaim memory,
diff --git a/src/hotspot/share/prims/jvm.cpp b/src/hotspot/share/prims/jvm.cpp
index 4ec0dfa34cc7..25878d1dff5e 100644
--- a/src/hotspot/share/prims/jvm.cpp
+++ b/src/hotspot/share/prims/jvm.cpp
@@ -3417,34 +3417,30 @@ JVM_LEAF(void*, JVM_LoadZipLibrary())
return ZipLibrary::handle();
JVM_END
-JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* name, jboolean throwException))
+JVM_ENTRY_NO_ENV(void*, JVM_LoadLibrary(const char* utf8_name, jboolean throwException))
//%note jvm_ct
char ebuf[1024];
void *load_result;
{
ThreadToNativeFromVM ttnfvm(thread);
- load_result = os::dll_load(name, ebuf, sizeof ebuf);
+ load_result = os::dll_load_utf8(utf8_name, ebuf, sizeof ebuf);
}
if (load_result == nullptr) {
if (throwException) {
char msg[1024];
- jio_snprintf(msg, sizeof msg, "%s: %s", name, ebuf);
- // Since 'ebuf' may contain a string encoded using
- // platform encoding scheme, we need to pass
- // Exceptions::unsafe_to_utf8 to the new_exception method
- // as the last argument. See bug 6367357.
+ jio_snprintf(msg, sizeof msg, "%s: %s", utf8_name, ebuf);
Handle h_exception =
Exceptions::new_exception(thread,
vmSymbols::java_lang_UnsatisfiedLinkError(),
- msg, Exceptions::unsafe_to_utf8);
+ msg);
THROW_HANDLE_0(h_exception);
} else {
- log_info(library)("Failed to load library %s", name);
+ log_info(library)("Failed to load library %s", utf8_name);
return load_result;
}
}
- log_info(library)("Loaded library %s, handle " INTPTR_FORMAT, name, p2i(load_result));
+ log_info(library)("Loaded library %s, handle " INTPTR_FORMAT, utf8_name, p2i(load_result));
return load_result;
JVM_END
diff --git a/src/hotspot/share/runtime/abstract_vm_version.cpp b/src/hotspot/share/runtime/abstract_vm_version.cpp
index f1f8888653e4..59983b93c294 100644
--- a/src/hotspot/share/runtime/abstract_vm_version.cpp
+++ b/src/hotspot/share/runtime/abstract_vm_version.cpp
@@ -122,7 +122,7 @@ const char* Abstract_VM_Version::vm_name() {
# define VENDOR_PADDING 64
#endif
#ifndef VENDOR
-# define VENDOR "Oracle Corporation"
+# define VENDOR "JetBrains s.r.o."
#endif
static const char vm_vendor_string[sizeof(VENDOR) < VENDOR_PADDING ? VENDOR_PADDING : sizeof(VENDOR)] = VENDOR;
diff --git a/src/hotspot/share/runtime/arguments.cpp b/src/hotspot/share/runtime/arguments.cpp
index 76877db2903d..d1530d0e738d 100644
--- a/src/hotspot/share/runtime/arguments.cpp
+++ b/src/hotspot/share/runtime/arguments.cpp
@@ -37,6 +37,7 @@
#include "gc/shared/stringdedup/stringDedup.hpp"
#include "gc/shared/tlab_globals.hpp"
#include "jvm.h"
+#include "jfr/periodic/jfrOSInterface.hpp"
#include "logging/log.hpp"
#include "logging/logConfiguration.hpp"
#include "logging/logStream.hpp"
@@ -1291,6 +1292,8 @@ bool Arguments::add_property(const char* prop, PropertyWriteable writeable, Prop
if (old_java_vendor_url_bug != nullptr) {
os::free((void *)old_java_vendor_url_bug);
}
+ } else if (strcmp(key, "jbr.catch.SIGABRT") == 0) {
+ CatchSIGABRT = (strcmp(value, "true") == 0);
}
// Create new property and add at the end of the list
@@ -3918,3 +3921,10 @@ bool Arguments::copy_expand_pid(const char* src, size_t srclen,
*b = '\0';
return (p == src_end); // return false if not all of the source was copied
}
+
+void Arguments::add_virtualization_information_property()
+{
+ const char *virt_name = "undetected";
+ JFR_ONLY(virt_name = JfrOSInterface::virtualization_name();)
+ PropertyList_add(&_system_properties, new SystemProperty("jbr.virtualization.information", virt_name, false));
+}
diff --git a/src/hotspot/share/runtime/arguments.hpp b/src/hotspot/share/runtime/arguments.hpp
index 8251db3d0d59..8f3b8aa3f547 100644
--- a/src/hotspot/share/runtime/arguments.hpp
+++ b/src/hotspot/share/runtime/arguments.hpp
@@ -447,6 +447,8 @@ class Arguments : AllStatic {
_vm_info->set_value(vm_info);
}
+ static void add_virtualization_information_property();
+
// Property List manipulation
static void PropertyList_add(SystemProperty *element);
static void PropertyList_add(SystemProperty** plist, SystemProperty *element);
diff --git a/src/hotspot/share/runtime/globals.cpp b/src/hotspot/share/runtime/globals.cpp
index 66d1e3357086..f471cb4cb5ef 100644
--- a/src/hotspot/share/runtime/globals.cpp
+++ b/src/hotspot/share/runtime/globals.cpp
@@ -45,3 +45,5 @@ ALL_FLAGS(MATERIALIZE_DEVELOPER_FLAG,
MATERIALIZE_NOTPRODUCT_FLAG,
IGNORE_RANGE,
IGNORE_CONSTRAINT)
+
+MATERIALIZE_PRODUCT_FLAG(bool, CatchSIGABRT, false);
diff --git a/src/hotspot/share/runtime/globals.hpp b/src/hotspot/share/runtime/globals.hpp
index 16198aca5370..6a553f795c5e 100644
--- a/src/hotspot/share/runtime/globals.hpp
+++ b/src/hotspot/share/runtime/globals.hpp
@@ -2022,4 +2022,6 @@ DECLARE_ARCH_FLAGS(ARCH_FLAGS)
DECLARE_FLAGS(RUNTIME_FLAGS)
DECLARE_FLAGS(RUNTIME_OS_FLAGS)
+DECLARE_PRODUCT_FLAG(bool, CatchSIGABRT, false);
+
#endif // SHARE_RUNTIME_GLOBALS_HPP
diff --git a/src/hotspot/share/runtime/jniHandles.cpp b/src/hotspot/share/runtime/jniHandles.cpp
index 25c8aa8b10b6..f50b491854eb 100644
--- a/src/hotspot/share/runtime/jniHandles.cpp
+++ b/src/hotspot/share/runtime/jniHandles.cpp
@@ -258,6 +258,23 @@ void JNIHandles::print_on(outputStream* st) {
st->flush();
}
+// Called while generating crash log, possibly not at safepoint
+void JNIHandles::print_on_unsafe(outputStream* st) {
+ st->print_cr("JNI global refs: " SIZE_FORMAT ", weak refs: " SIZE_FORMAT,
+ global_handles() != NULL ? global_handles()->allocation_count() : 0,
+ weak_global_handles() != NULL ? weak_global_handles()->allocation_count() : 0);
+ st->cr();
+ st->flush();
+}
+
+void JNIHandles::print_memory_usage_on(outputStream *st) {
+ st->print_cr("JNI global refs memory usage: " SIZE_FORMAT ", weak refs: " SIZE_FORMAT,
+ global_handles() != NULL ? global_handles()->total_memory_usage() : 0,
+ global_handles() != NULL ? weak_global_handles()->total_memory_usage() : 0);
+ st->cr();
+ st->flush();
+}
+
void JNIHandles::print() { print_on(tty); }
class VerifyJNIHandles: public OopClosure {
diff --git a/src/hotspot/share/runtime/jniHandles.hpp b/src/hotspot/share/runtime/jniHandles.hpp
index 230a3f5ca428..66e440cb8f19 100644
--- a/src/hotspot/share/runtime/jniHandles.hpp
+++ b/src/hotspot/share/runtime/jniHandles.hpp
@@ -110,6 +110,8 @@ class JNIHandles : AllStatic {
// Debugging
static void print_on(outputStream* st);
+ static void print_on_unsafe(outputStream* st);
+ static void print_memory_usage_on(outputStream* st);
static void print();
static void verify();
// The category predicates all require handle != nullptr.
diff --git a/src/hotspot/share/runtime/mutexLocker.cpp b/src/hotspot/share/runtime/mutexLocker.cpp
index efd8490cd80e..6948bb745945 100644
--- a/src/hotspot/share/runtime/mutexLocker.cpp
+++ b/src/hotspot/share/runtime/mutexLocker.cpp
@@ -156,6 +156,7 @@ Monitor* JVMCI_lock = nullptr;
Monitor* JVMCIRuntime_lock = nullptr;
#endif
+Mutex* OOMEStacks_lock = nullptr;
#define MAX_NUM_MUTEX 128
static Mutex* _mutex_array[MAX_NUM_MUTEX];
@@ -357,6 +358,8 @@ void mutex_init() {
// JVMCIRuntime_lock must be acquired before JVMCI_lock to avoid deadlock
MUTEX_DEFL(JVMCI_lock , PaddedMonitor, JVMCIRuntime_lock);
#endif
+
+ MUTEX_DEFN(OOMEStacks_lock , PaddedMutex , safepoint-1);
}
#undef MUTEX_DEFL
diff --git a/src/hotspot/share/runtime/mutexLocker.hpp b/src/hotspot/share/runtime/mutexLocker.hpp
index 840d01e62fa0..df6bde0eb265 100644
--- a/src/hotspot/share/runtime/mutexLocker.hpp
+++ b/src/hotspot/share/runtime/mutexLocker.hpp
@@ -155,6 +155,8 @@ extern Mutex* Bootclasspath_lock;
extern Mutex* tty_lock; // lock to synchronize output.
+extern Mutex* OOMEStacks_lock;
+
// A MutexLocker provides mutual exclusion with respect to a given mutex
// for the scope which contains the locker. The lock is an OS lock, not
// an object lock, and the two do not interoperate. Do not use Mutex-based
diff --git a/src/hotspot/share/runtime/os.cpp b/src/hotspot/share/runtime/os.cpp
index f9bd773e370e..dd9d27e853d6 100644
--- a/src/hotspot/share/runtime/os.cpp
+++ b/src/hotspot/share/runtime/os.cpp
@@ -991,6 +991,7 @@ static void print_hex_location(outputStream* st, address p, int unitsize) {
}
}
+ATTRIBUTE_NO_SANITIZE_ADDRESS("Memory is read raw here without any regard for objects' boundaries")
void os::print_hex_dump(outputStream* st, address start, address end, int unitsize,
int bytes_per_line, address logical_start) {
assert(unitsize == 1 || unitsize == 2 || unitsize == 4 || unitsize == 8, "just checking");
diff --git a/src/hotspot/share/runtime/os.hpp b/src/hotspot/share/runtime/os.hpp
index 67e1ef7dcf7b..48ce50b40993 100644
--- a/src/hotspot/share/runtime/os.hpp
+++ b/src/hotspot/share/runtime/os.hpp
@@ -733,6 +733,7 @@ class os: AllStatic {
// same architecture as HotSpot is running on
// in case of an error null is returned and an error message is stored in ebuf
static void* dll_load(const char *name, char *ebuf, int ebuflen);
+ static void* dll_load_utf8(const char *name, char *ebuf, int ebuflen);
// lookup symbol in a shared library
static void* dll_lookup(void* handle, const char* name);
diff --git a/src/hotspot/share/runtime/threads.cpp b/src/hotspot/share/runtime/threads.cpp
index 237e3a22451d..eeac4c9c5e9c 100644
--- a/src/hotspot/share/runtime/threads.cpp
+++ b/src/hotspot/share/runtime/threads.cpp
@@ -583,6 +583,8 @@ jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
JFR_ONLY(Jfr::on_create_vm_1();)
+ Arguments::add_virtualization_information_property();
+
// Should be done after the heap is fully created
main_thread->cache_global_variables();
diff --git a/src/hotspot/share/runtime/vmOperations.cpp b/src/hotspot/share/runtime/vmOperations.cpp
index 3469e3f2cc0b..674ecdf97e79 100644
--- a/src/hotspot/share/runtime/vmOperations.cpp
+++ b/src/hotspot/share/runtime/vmOperations.cpp
@@ -25,6 +25,7 @@
#include "precompiled.hpp"
#include "classfile/classLoaderDataGraph.hpp"
#include "classfile/vmSymbols.hpp"
+#include "classfile/symbolTable.hpp"
#include "code/codeCache.hpp"
#include "compiler/compileBroker.hpp"
#include "gc/shared/collectedHeap.hpp"
@@ -37,6 +38,7 @@
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
#include "oops/symbol.hpp"
+#include "oops/symbolHandle.hpp"
#include "runtime/arguments.hpp"
#include "runtime/deoptimization.hpp"
#include "runtime/frame.inline.hpp"
@@ -50,7 +52,7 @@
#include "runtime/threadSMR.inline.hpp"
#include "runtime/vmOperations.hpp"
#include "services/threadService.hpp"
-#include "utilities/ticks.hpp"
+#include "javaCalls.hpp"
#define VM_OP_NAME_INITIALIZE(name) #name,
@@ -160,6 +162,37 @@ void VM_ZombieAll::doit() {
#endif // !PRODUCT
+
+// Prints out additional information supplied by the application
+// through the use of JBR API. The data in the form of a String
+// are obtained from Throwable.$$jb$getAdditionalInfoForJstack()
+// and, not not null, are included into the output.
+void VM_PrintThreads::print_additional_info() {
+ JavaThread *THREAD = JavaThread::current();
+ HandleMark hm(THREAD);
+ ResourceMark rm;
+
+ InstanceKlass *klass = vmClasses::Throwable_klass();
+ if (klass != NULL) {
+ TempNewSymbol method_name = SymbolTable::new_symbol("$$jb$getAdditionalInfoForJstack");
+ Symbol *signature = vmSymbols::void_string_signature();
+ Method *method = klass->find_method(method_name, signature);
+ if (method != NULL) {
+ JavaValue result(T_OBJECT);
+ JavaCalls::call_static(&result, klass,
+ method_name, signature, THREAD);
+ oop dump_oop = result.get_oop();
+ if (dump_oop != NULL) {
+ // convert Java String to utf8 string
+ char *s = java_lang_String::as_utf8_string(dump_oop);
+ _out->cr();
+ _out->print_raw_cr(s);
+ _out->cr();
+ }
+ }
+ }
+}
+
bool VM_PrintThreads::doit_prologue() {
// Get Heap_lock if concurrent locks will be dumped
if (_print_concurrent_locks) {
@@ -172,6 +205,7 @@ void VM_PrintThreads::doit() {
Threads::print_on(_out, true, false, _print_concurrent_locks, _print_extended_info);
if (_print_jni_handle_info) {
JNIHandles::print_on(_out);
+ JNIHandles::print_memory_usage_on(_out);
}
}
@@ -180,6 +214,13 @@ void VM_PrintThreads::doit_epilogue() {
// Release Heap_lock
Heap_lock->unlock();
}
+
+ // We should be on the "signal handler" thread, which is a JavaThread
+ if (Thread::current()->is_Java_thread()) {
+ // .. but best play it safe as we're going to need to make
+ // Java calls on the current thread.
+ print_additional_info();
+ }
}
void VM_PrintMetadata::doit() {
diff --git a/src/hotspot/share/runtime/vmOperations.hpp b/src/hotspot/share/runtime/vmOperations.hpp
index 8778fe29adea..620b97933581 100644
--- a/src/hotspot/share/runtime/vmOperations.hpp
+++ b/src/hotspot/share/runtime/vmOperations.hpp
@@ -154,6 +154,9 @@ class VM_PrintThreads: public VM_Operation {
void doit();
bool doit_prologue();
void doit_epilogue();
+
+private:
+ void print_additional_info();
};
class VM_PrintMetadata : public VM_Operation {
diff --git a/src/hotspot/share/utilities/compilerWarnings.hpp b/src/hotspot/share/utilities/compilerWarnings.hpp
index 28954843dc32..a0ca28ae117b 100644
--- a/src/hotspot/share/utilities/compilerWarnings.hpp
+++ b/src/hotspot/share/utilities/compilerWarnings.hpp
@@ -103,4 +103,10 @@
#define ALLOW_C_FUNCTION(name, ...) __VA_ARGS__
#endif
+#if defined(__clang__) || defined (__GNUC__)
+# define ATTRIBUTE_NO_SANITIZE_ADDRESS(reason_for_exclusion) __attribute__((no_sanitize_address))
+#else
+# define ATTRIBUTE_NO_SANITIZE_ADDRESS(reason_for_exclusion)
+#endif
+
#endif // SHARE_UTILITIES_COMPILERWARNINGS_HPP
diff --git a/src/hotspot/share/utilities/debug.cpp b/src/hotspot/share/utilities/debug.cpp
index d39335c6307f..3991de53bce8 100644
--- a/src/hotspot/share/utilities/debug.cpp
+++ b/src/hotspot/share/utilities/debug.cpp
@@ -251,6 +251,8 @@ void report_untested(const char* file, int line, const char* message) {
void report_java_out_of_memory(const char* message) {
static int out_of_memory_reported = 0;
+ VMError::record_oome_stack(message);
+
// A number of threads may attempt to report OutOfMemoryError at around the
// same time. To avoid dumping the heap or executing the data collection
// commands multiple times we just do it once when the first threads reports
diff --git a/src/hotspot/share/utilities/globalDefinitions_visCPP.hpp b/src/hotspot/share/utilities/globalDefinitions_visCPP.hpp
index 3b28328d7dd4..538acd028929 100644
--- a/src/hotspot/share/utilities/globalDefinitions_visCPP.hpp
+++ b/src/hotspot/share/utilities/globalDefinitions_visCPP.hpp
@@ -101,6 +101,11 @@ inline int g_isnan(jdouble f) { return _isnan(f); }
inline int g_isfinite(jfloat f) { return _finite(f); }
inline int g_isfinite(jdouble f) { return _finite(f); }
+// Miscellaneous
+
+// Visual Studio 2005 deprecates POSIX names - use ISO C++ names instead
+#define wopen _wopen
+
// Formatting.
#define FORMAT64_MODIFIER "ll"
diff --git a/src/hotspot/share/utilities/vmError.cpp b/src/hotspot/share/utilities/vmError.cpp
index d40504d6d200..48feef76a7f3 100644
--- a/src/hotspot/share/utilities/vmError.cpp
+++ b/src/hotspot/share/utilities/vmError.cpp
@@ -26,6 +26,7 @@
#include "precompiled.hpp"
#include "cds/metaspaceShared.hpp"
+#include "classfile/classLoaderDataGraph.hpp"
#include "code/codeCache.hpp"
#include "compiler/compilationFailureInfo.hpp"
#include "compiler/compileBroker.hpp"
@@ -48,6 +49,7 @@
#include "runtime/frame.inline.hpp"
#include "runtime/init.hpp"
#include "runtime/javaThread.inline.hpp"
+#include "runtime/jniHandles.hpp"
#include "runtime/os.inline.hpp"
#include "runtime/osThread.hpp"
#include "runtime/safefetch.hpp"
@@ -656,6 +658,7 @@ void VMError::clear_step_start_time() {
// could be nested report_and_die() calls on stack (see above). Only one
// thread can report error, so large buffers are statically allocated in data
// segment.
+ATTRIBUTE_NO_SANITIZE_ADDRESS("Memory is read raw here without any regard for objects' boundaries")
void VMError::report(outputStream* st, bool _verbose) {
// Used by reattempt step logic
static int continuation = 0;
@@ -1316,6 +1319,22 @@ void VMError::report(outputStream* st, bool _verbose) {
NativeHeapTrimmer::print_state(st);
st->cr();
+ STEP("JNI global references")
+ st->print_cr("JNI global refs:");
+ JNIHandles::print_on_unsafe(st);
+ JNIHandles::print_memory_usage_on(st);
+
+ STEP("OOME stack traces")
+ st->print_cr("OOME stack traces (most recent first):");
+ print_oome_stacks(st);
+
+ STEP("Classloader stats")
+ st->print_cr("Classloader memory used:");
+ FREE_C_HEAP_ARRAY(void*, _ballast_memory);
+ _ballast_memory = nullptr;
+ print_classloaders_stats(st);
+ print_dup_classes(st); // do it separately in case we're low on memory
+
STEP_IF("printing system", _verbose)
st->print_cr("--------------- S Y S T E M ---------------");
st->cr();
@@ -2161,3 +2180,176 @@ VMErrorCallbackMark::~VMErrorCallbackMark() {
assert(_thread->_vm_error_callbacks != nullptr, "Popped too far");
_thread->_vm_error_callbacks = _thread->_vm_error_callbacks->_next;
}
+
+char VMError::_oome_stacktrace[OOME_STACKTRACE_COUNT][OOME_STACKTRACE_BUFSIZE];
+int VMError::_oome_free_index;
+void * VMError::_ballast_memory;
+
+void VMError::init() {
+ _oome_free_index = 0;
+ // This will be released before dumping classes statistics as the latter
+ // may need to allocate some memory in an OOME situation.
+ _ballast_memory = NEW_C_HEAP_ARRAY(void*, 36000*4, mtStatistics);
+}
+
+void VMError::record_oome_stack(const char *message) {
+ Thread * thread = Thread::current();
+ if (!thread->is_Java_thread()) {
+ // The following code can't work in non-Java thread.
+ // Besides, it's not a true OOM *exception* if there's no Java on the stack.
+ return;
+ }
+
+ {
+ MutexLocker ml(OOMEStacks_lock);
+ ResourceMark rm;
+
+ stringStream st(_oome_stacktrace[_oome_free_index], OOME_STACKTRACE_BUFSIZE);
+ st.print_cr("OutOfMemoryError(\"%s\") on the thread \"%s\"", message, thread->name());
+ JavaThread::cast(thread)->print_stack_on(&st);
+
+ st.cr();
+
+ _oome_free_index = (_oome_free_index + 1) % OOME_STACKTRACE_COUNT;
+ }
+}
+
+void VMError::print_oome_stacks(outputStream *st) {
+ int index = _oome_free_index == 0 ? OOME_STACKTRACE_COUNT - 1 : _oome_free_index - 1;
+
+ for (int i = 0; i < OOME_STACKTRACE_COUNT; i++) {
+ const char * const trace = _oome_stacktrace[index];
+ if (strcmp(trace, "") != 0) st->print_raw_cr(trace);
+ index = index == 0 ? OOME_STACKTRACE_COUNT - 1 : index - 1;
+ }
+}
+
+class CLDCounterClosure : public CLDClosure {
+public:
+ // Loader Klass -> memory used in words
+ using TABLE = ResizeableResourceHashtable;
+
+private:
+ TABLE& _loaded_size;
+
+public:
+ explicit CLDCounterClosure(TABLE& loaded_size) : _loaded_size(loaded_size) {}
+
+ void do_cld(ClassLoaderData* cld) override {
+ Klass * const loader = cld->class_loader_klass();
+ ClassLoaderMetaspace * const ms = cld->metaspace_or_null();
+ if (ms != nullptr) {
+ size_t used_words = 0;
+ ms->usage_numbers(&used_words, nullptr, nullptr);
+
+ const size_t * const new_size_ptr = _loaded_size.get(loader);
+ size_t new_size = new_size_ptr == nullptr
+ ? used_words
+ : *new_size_ptr + used_words;
+ _loaded_size.put(loader, new_size);
+ }
+ }
+};
+
+static int compare_by_size(Pair* p1, Pair* p2) {
+ return p2->second == p1->second
+ ? 0
+ : p2->second > p1->second ? 1 : -1;
+}
+
+void VMError::print_classloaders_stats(outputStream *st) {
+ if (_thread) {
+ ResourceMark rm(_thread);
+ MutexLocker ml(_thread, ClassLoaderDataGraph_lock);
+
+ CLDCounterClosure::TABLE sizes(10, 100);
+ CLDCounterClosure counter(sizes);
+ ClassLoaderDataGraph::cld_do(&counter);
+ GrowableArray> loaders_stats;
+ sizes.iterate_all([&] (Klass* loader_klass, size_t total_words) {
+ loaders_stats.push(Pair(loader_klass, total_words));
+ });
+
+ loaders_stats.sort(compare_by_size);
+
+ for (const auto loaders_stat : loaders_stats) {
+ Klass * const loader_klass = loaders_stat.first;
+ const size_t total_words = loaders_stat.second;
+ const char *name = loader_klass != nullptr
+ ? loader_klass->external_name()
+ : BOOTSTRAP_LOADER_NAME;
+ const size_t total_bytes = total_words * BytesPerWord;
+ st->print_cr("Loader %-80s: " SIZE_FORMAT "%s",
+ name,
+ byte_size_in_proper_unit(total_bytes),
+ proper_unit_for_byte_size(total_bytes));
+ }
+
+ st->cr();
+ } else {
+ st->print_cr("Not available (crashed in non-Java thread)");
+ }
+}
+
+class DuplicateKlassClosure : public KlassClosure {
+ static bool klass_equals(Klass* const & klass1, Klass* const & klass2) {
+ return strcmp(klass1->external_name(), klass2->external_name()) == 0;
+ }
+
+ static unsigned klass_hash(Klass* const & k) {
+ int h = 0;
+ const char* p = k->external_name();
+ while (*p != '\0') {
+ h = 31 * h + *p;
+ p++;
+ }
+ return h;
+ }
+
+public:
+ // Klass -> number times loaded
+ using TABLE = ResizeableResourceHashtable;
+
+private:
+ TABLE& _classes_count;
+
+public:
+ explicit DuplicateKlassClosure(TABLE& classes_count) : _classes_count(classes_count) {}
+
+ void do_klass(Klass* klass) override {
+ const size_t * const new_count_ptr = _classes_count.get(klass);
+ const size_t new_count = new_count_ptr != nullptr ? *new_count_ptr + 1 : 1;
+ _classes_count.put(klass, new_count);
+ }
+};
+
+void VMError::print_dup_classes(outputStream *st) {
+ if (_thread) {
+ ResourceMark rm(_thread);
+ MutexLocker ma(_thread, MultiArray_lock);
+ MutexLocker mcld(_thread, ClassLoaderDataGraph_lock);
+
+ DuplicateKlassClosure::TABLE classes_count(100, 200);
+ DuplicateKlassClosure counter(classes_count);
+ ClassLoaderDataGraph::loaded_classes_do(&counter);
+
+ GrowableArray> dup_classes;
+ classes_count.iterate_all([&] (Klass* const name, size_t count) {
+ if (count > 1) dup_classes.push(Pair(name, count));
+ });
+
+ if (dup_classes.length() > 0) {
+ st->print_cr("Classes loaded by more than one classloader:");
+ dup_classes.sort(compare_by_size);
+ for (const auto dup : dup_classes) {
+ const char * const name = dup.first->external_name();
+ const size_t size = dup.first->size();
+ const size_t count = dup.second;
+ st->print_cr("Class %-80s: loaded " SIZE_FORMAT " times (x " SIZE_FORMAT "B)",
+ name, count, size);
+ }
+ st->cr();
+ }
+ }
+}
diff --git a/src/hotspot/share/utilities/vmError.hpp b/src/hotspot/share/utilities/vmError.hpp
index a2a098e2cda5..1228ed51f166 100644
--- a/src/hotspot/share/utilities/vmError.hpp
+++ b/src/hotspot/share/utilities/vmError.hpp
@@ -69,6 +69,12 @@ class VMError : public AllStatic {
// used for reattempt step logic
static const size_t _reattempt_required_stack_headroom;
+ static const int OOME_STACKTRACE_BUFSIZE = 16*K;
+ static const int OOME_STACKTRACE_COUNT = 4;
+ static char _oome_stacktrace[OOME_STACKTRACE_COUNT][OOME_STACKTRACE_BUFSIZE];
+ static int _oome_free_index;
+ static void * _ballast_memory;
+
// Thread id of the first error. We must be able to handle native thread,
// so use thread id instead of Thread* to identify thread.
static volatile intptr_t _first_error_tid;
@@ -225,6 +231,11 @@ class VMError : public AllStatic {
// permissions.
static int prepare_log_file(const char* pattern, const char* default_pattern, bool overwrite_existing, char* buf, size_t buflen);
+ static void init();
+ static void record_oome_stack(const char *message);
+ static void print_oome_stacks(outputStream *st);
+ static void print_classloaders_stats(outputStream *st);
+ static void print_dup_classes(outputStream *st);
};
class VMErrorCallback {
diff --git a/src/java.base/macosx/classes/sun/nio/fs/BsdFileSystem.java b/src/java.base/macosx/classes/sun/nio/fs/BsdFileSystem.java
index 3b99a456288c..92889ba62cdf 100644
--- a/src/java.base/macosx/classes/sun/nio/fs/BsdFileSystem.java
+++ b/src/java.base/macosx/classes/sun/nio/fs/BsdFileSystem.java
@@ -54,8 +54,8 @@ class BsdFileSystem extends UnixFileSystem {
public WatchService newWatchService()
throws IOException
{
- // use polling implementation until we implement a BSD/kqueue one
- return new PollingWatchService();
+ final boolean usePollingWatchService = Boolean.getBoolean("watch.service.polling");
+ return usePollingWatchService ? new PollingWatchService() : new MacOSXWatchService();
}
// lazy initialization of the list of supported attribute views
diff --git a/src/java.base/macosx/classes/sun/nio/fs/MacOSXWatchService.java b/src/java.base/macosx/classes/sun/nio/fs/MacOSXWatchService.java
new file mode 100644
index 000000000000..1b00d07c3885
--- /dev/null
+++ b/src/java.base/macosx/classes/sun/nio/fs/MacOSXWatchService.java
@@ -0,0 +1,827 @@
+/*
+ * Copyright (c) 2021, 2022, JetBrains s.r.o.. 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.
+ */
+
+package sun.nio.fs;
+
+import sun.util.logging.PlatformLogger;
+
+import jdk.internal.misc.Unsafe;
+
+import java.io.IOException;
+import java.nio.file.ClosedWatchServiceException;
+import java.nio.file.DirectoryIteratorException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.LinkOption;
+import java.nio.file.NotDirectoryException;
+import java.nio.file.Path;
+import java.nio.file.StandardWatchEventKinds;
+import java.nio.file.WatchEvent;
+import java.nio.file.WatchKey;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayDeque;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.function.Consumer;
+
+class MacOSXWatchService extends AbstractWatchService {
+ // Controls tracing in the native part of the watcher.
+ private static boolean tracingEnabled = false;
+ private static final PlatformLogger logger = PlatformLogger.getLogger("sun.nio.fs.MacOSXWatchService");
+
+ private final HashMap dirKeyToWatchKey = new HashMap<>();
+ private final HashMap eventStreamToWatchKey = new HashMap<>();
+ private final Object watchKeysLock = new Object();
+
+ private final CFRunLoopThread runLoopThread;
+
+ MacOSXWatchService() throws IOException {
+ runLoopThread = new CFRunLoopThread();
+ runLoopThread.setDaemon(true);
+ runLoopThread.start();
+
+ try {
+ // In order to be able to schedule any FSEventStream's, a reference to a run loop is required.
+ runLoopThread.waitForRunLoopRef();
+ } catch (InterruptedException e) {
+ throw new IOException(e);
+ }
+ }
+
+ @Override
+ WatchKey register(Path dir, WatchEvent.Kind[] events, WatchEvent.Modifier... modifiers) throws IOException {
+ checkIsOpen();
+
+ final UnixPath unixDir = (UnixPath)dir;
+ final Object dirKey = checkPath(unixDir);
+ final EnumSet eventSet = FSEventKind.setOf(events);
+ final EnumSet modifierSet = WatchModifier.setOf(modifiers);
+ synchronized (closeLock()) {
+ checkIsOpen();
+
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("register for " + dir);
+
+ synchronized (watchKeysLock) {
+ MacOSXWatchKey watchKey = dirKeyToWatchKey.get(dirKey);
+ final boolean keyForDirAlreadyExists = (watchKey != null);
+ if (keyForDirAlreadyExists) {
+ eventStreamToWatchKey.remove(watchKey.getEventStreamRef());
+ watchKey.disable();
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("re-used existing watch key");
+ } else {
+ watchKey = new MacOSXWatchKey(this, unixDir, dirKey);
+ dirKeyToWatchKey.put(dirKey, watchKey);
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("created a new watch key");
+ }
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("starting to [re-]populate directory cache with data");
+ watchKey.enable(runLoopThread, eventSet, modifierSet);
+ eventStreamToWatchKey.put(watchKey.getEventStreamRef(), watchKey);
+ watchKeysLock.notify(); // So that run loop gets running again if stopped due to lack of event streams
+ return watchKey;
+ }
+ }
+ }
+
+ /**
+ * Invoked on the CFRunLoopThread by the native code to report directories that need to be re-scanned.
+ */
+ private void callback(final long eventStreamRef, final String[] paths, final long eventFlagsPtr) {
+ synchronized (watchKeysLock) {
+ final MacOSXWatchKey watchKey = eventStreamToWatchKey.get(eventStreamRef);
+ if (watchKey != null) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("Callback fired for '" + watchKey.getRealRootPath() + "'");
+ watchKey.handleEvents(paths, eventFlagsPtr);
+ } else {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("Callback fired for watch key that is no longer there");
+ }
+ }
+ }
+
+ void cancel(final MacOSXWatchKey watchKey) {
+ synchronized (watchKeysLock) {
+ dirKeyToWatchKey.remove(watchKey.getRootPathKey());
+ eventStreamToWatchKey.remove(watchKey.getEventStreamRef());
+ }
+ }
+
+ void waitForEventSource() {
+ synchronized (watchKeysLock) {
+ if (isOpen() && eventStreamToWatchKey.isEmpty()) {
+ try {
+ watchKeysLock.wait();
+ } catch (InterruptedException ignore) {}
+ }
+ }
+ }
+
+ @Override
+ void implClose() {
+ synchronized (watchKeysLock) {
+ eventStreamToWatchKey.clear();
+ dirKeyToWatchKey.forEach((key, watchKey) -> watchKey.invalidate());
+ dirKeyToWatchKey.clear();
+ watchKeysLock.notify(); // Let waitForEventSource() go if it was waiting
+ runLoopThread.runLoopStop(); // Force exit from CFRunLoopRun()
+ }
+ }
+
+ private static void traceLine(final String text) {
+ logger.finest("NATIVE trace: " + text);
+ }
+
+ private class CFRunLoopThread extends Thread {
+ // Native reference to the CFRunLoop object of the watch service run loop.
+ private long runLoopRef;
+
+ public CFRunLoopThread() {
+ super("FileSystemWatcher");
+ }
+
+ synchronized void waitForRunLoopRef() throws InterruptedException {
+ if (runLoopRef == 0)
+ runLoopThread.wait(); // ...for CFRunLoopRef to become available
+ }
+
+ long getRunLoopRef() {
+ return runLoopRef;
+ }
+
+ synchronized void runLoopStop() {
+ if (runLoopRef != 0) {
+ // The run loop may have stuck in CFRunLoopRun() even though all of its input sources
+ // have been removed. Need to terminate it explicitly so that it can run to completion.
+ MacOSXWatchService.CFRunLoopStop(runLoopRef);
+ }
+ }
+
+ @Override
+ public void run() {
+ synchronized (this) {
+ runLoopRef = CFRunLoopGetCurrent();
+ notify();
+ }
+
+ while (isOpen()) {
+ CFRunLoopRun(MacOSXWatchService.this);
+ waitForEventSource();
+ }
+
+ synchronized (this) {
+ runLoopRef = 0; // CFRunLoopRef is no longer usable when the loop has been terminated
+ }
+ }
+ }
+
+ private void checkIsOpen() {
+ if (!isOpen())
+ throw new ClosedWatchServiceException();
+ }
+
+ private Object checkPath(UnixPath dir) throws IOException {
+ if (dir == null)
+ throw new NullPointerException("No path to watch");
+
+ UnixFileAttributes attrs;
+ try {
+ attrs = UnixFileAttributes.get(dir, true);
+ } catch (UnixException x) {
+ throw x.asIOException(dir);
+ }
+
+ if (!attrs.isDirectory())
+ throw new NotDirectoryException(dir.getPathForExceptionMessage());
+
+ final Object fileKey = attrs.fileKey();
+ if (fileKey == null)
+ throw new AssertionError("File keys must be supported");
+
+ return fileKey;
+ }
+
+ private enum FSEventKind {
+ CREATE, MODIFY, DELETE, OVERFLOW;
+
+ public static FSEventKind of(final WatchEvent.Kind watchEventKind) {
+ if (StandardWatchEventKinds.ENTRY_CREATE == watchEventKind) {
+ return CREATE;
+ } else if (StandardWatchEventKinds.ENTRY_MODIFY == watchEventKind) {
+ return MODIFY;
+ } else if (StandardWatchEventKinds.ENTRY_DELETE == watchEventKind) {
+ return DELETE;
+ } else if (StandardWatchEventKinds.OVERFLOW == watchEventKind) {
+ return OVERFLOW;
+ } else {
+ throw new UnsupportedOperationException(watchEventKind.name());
+ }
+ }
+
+ public static EnumSet setOf(final WatchEvent.Kind[] events) {
+ final EnumSet eventSet = EnumSet.noneOf(FSEventKind.class);
+ for (final WatchEvent.Kind event: events) {
+ if (event == null) {
+ throw new NullPointerException("An element in event set is 'null'");
+ } else if (event == StandardWatchEventKinds.OVERFLOW) {
+ continue;
+ }
+
+ eventSet.add(FSEventKind.of(event));
+ }
+
+ if (eventSet.isEmpty())
+ throw new IllegalArgumentException("No events to register");
+
+ return eventSet;
+ }
+
+ }
+
+ private enum WatchModifier {
+ FILE_TREE, SENSITIVITY_HIGH, SENSITIVITY_MEDIUM, SENSITIVITY_LOW;
+
+ public static WatchModifier of(final WatchEvent.Modifier watchEventModifier) {
+ if (ExtendedOptions.FILE_TREE.matches(watchEventModifier)) {
+ return FILE_TREE;
+ } if (ExtendedOptions.SENSITIVITY_HIGH.matches(watchEventModifier)) {
+ return SENSITIVITY_HIGH;
+ } if (ExtendedOptions.SENSITIVITY_MEDIUM.matches(watchEventModifier)) {
+ return SENSITIVITY_MEDIUM;
+ } if (ExtendedOptions.SENSITIVITY_LOW.matches(watchEventModifier)) {
+ return SENSITIVITY_LOW;
+ } else {
+ throw new UnsupportedOperationException(watchEventModifier.name());
+ }
+ }
+
+ public static EnumSet setOf(final WatchEvent.Modifier[] modifiers) {
+ final EnumSet modifierSet = EnumSet.noneOf(WatchModifier.class);
+ for (final WatchEvent.Modifier modifier : modifiers) {
+ if (modifier == null)
+ throw new NullPointerException("An element in modifier set is 'null'");
+
+ modifierSet.add(WatchModifier.of(modifier));
+ }
+
+ return modifierSet;
+ }
+
+ public static double sensitivityOf(final EnumSet modifiers) {
+ if (modifiers.contains(SENSITIVITY_HIGH)) {
+ return 0.1;
+ } else if (modifiers.contains(SENSITIVITY_LOW)) {
+ return 1;
+ } else {
+ return 0.5; // aka SENSITIVITY_MEDIUM
+ }
+ }
+ }
+
+ private static class MacOSXWatchKey extends AbstractWatchKey {
+ private static final Unsafe unsafe = Unsafe.getUnsafe();
+
+ private static final long kFSEventStreamEventFlagMustScanSubDirs = 0x00000001;
+ private static final long kFSEventStreamEventFlagRootChanged = 0x00000020;
+
+ private final Path relativeRootPath;
+
+ // Full path to this key's watch root directory.
+ private final Path realRootPath;
+ private final int realRootPathLength;
+ private final Object rootPathKey;
+
+ // Kinds of events to be reported.
+ private EnumSet eventsToWatch;
+
+ // Should events in directories below realRootPath reported?
+ private boolean watchFileTree;
+
+ // Native FSEventStreamRef as returned by FSEventStreamCreate().
+ private long eventStreamRef;
+ private final Object eventStreamRefLock = new Object();
+
+ private final DirectoryTreeSnapshot directoryTreeSnapshot = new DirectoryTreeSnapshot();
+
+ MacOSXWatchKey(final MacOSXWatchService watchService, final UnixPath dir, final Object rootPathKey) throws IOException {
+ super(dir, watchService);
+ this.relativeRootPath = dir.getFileSystem().getPath("");
+ this.realRootPath = dir.toRealPath().normalize();
+ this.realRootPathLength = realRootPath.toString().length() + 1;
+ this.rootPathKey = rootPathKey;
+ }
+
+ synchronized void enable(final CFRunLoopThread runLoopThread,
+ final EnumSet eventsToWatch,
+ final EnumSet modifierSet) throws IOException {
+ assert(!isValid());
+
+ this.eventsToWatch = eventsToWatch;
+ this.watchFileTree = modifierSet.contains(WatchModifier.FILE_TREE);
+
+ directoryTreeSnapshot.build();
+
+ synchronized (eventStreamRefLock) {
+ final int kFSEventStreamCreateFlagWatchRoot = 0x00000004;
+ eventStreamRef = MacOSXWatchService.eventStreamCreate(
+ realRootPath.toString(),
+ WatchModifier.sensitivityOf(modifierSet),
+ kFSEventStreamCreateFlagWatchRoot);
+
+ if (eventStreamRef == 0)
+ throw new IOException("Unable to create FSEventStream");
+
+ MacOSXWatchService.eventStreamSchedule(eventStreamRef, runLoopThread.getRunLoopRef());
+ }
+ }
+
+ synchronized void disable() {
+ invalidate();
+ directoryTreeSnapshot.reset();
+ }
+
+ synchronized void handleEvents(final String[] paths, long eventFlagsPtr) {
+ if (paths == null) {
+ reportOverflow(null);
+ return;
+ }
+
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("handleEvents(): will handle " + paths.length + " events");
+
+ final Set dirsToScan = new LinkedHashSet<>(paths.length);
+ final Set dirsToScanRecursively = new LinkedHashSet<>();
+ collectDirsToScan(paths, eventFlagsPtr, dirsToScan, dirsToScanRecursively);
+
+ for (final Path recurseDir : dirsToScanRecursively) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("handleEvents(): scanning directory recursively " + recurseDir);
+ dirsToScan.removeIf(dir -> dir.startsWith(recurseDir));
+ assert(watchFileTree);
+ directoryTreeSnapshot.update(recurseDir, true);
+ }
+
+ for (final Path dir : dirsToScan) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("handleEvents(): scanning directory " + dir);
+ directoryTreeSnapshot.update(dir, false);
+ }
+ }
+
+ private Path toRelativePath(final String absPath) {
+ return (absPath.length() > realRootPathLength)
+ ? relativeRootPath.getFileSystem().getPath(absPath.substring(realRootPathLength))
+ : relativeRootPath;
+ }
+
+ private void collectDirsToScan(final String[] paths, long eventFlagsPtr,
+ final Set dirsToScan,
+ final Set dirsToScanRecursively) {
+ for (final String absPath : paths) {
+ if (absPath == null) {
+ reportOverflow(null);
+ continue;
+ }
+
+ Path path = toRelativePath(absPath);
+
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("handleEvents(): event path name " + path);
+
+ if (!watchFileTree && !relativeRootPath.equals(path)) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("handleEvents(): skipping event for a nested directory");
+ continue;
+ }
+
+ final int flags = unsafe.getInt(eventFlagsPtr);
+ if ((flags & kFSEventStreamEventFlagRootChanged) != 0) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("handleEvents(): watch root changed, path=" + path);
+ cancel();
+ signal();
+ break;
+ } else if ((flags & kFSEventStreamEventFlagMustScanSubDirs) != 0 && watchFileTree) {
+ dirsToScanRecursively.add(path);
+ } else {
+ dirsToScan.add(path);
+ }
+
+ final long SIZEOF_FS_EVENT_STREAM_EVENT_FLAGS = 4L; // FSEventStreamEventFlags is UInt32
+ eventFlagsPtr += SIZEOF_FS_EVENT_STREAM_EVENT_FLAGS;
+ }
+ }
+
+ /**
+ * Represents a snapshot of a directory tree.
+ * The snapshot includes subdirectories iff watchFileTree is true.
+ */
+ private class DirectoryTreeSnapshot {
+ private final HashMap snapshots;
+
+ DirectoryTreeSnapshot() {
+ this.snapshots = new HashMap<>(watchFileTree ? 256 : 1);
+ }
+
+ void build() throws IOException {
+ final Queue pathToDo = new ArrayDeque<>();
+ pathToDo.offer(relativeRootPath);
+
+ while (!pathToDo.isEmpty()) {
+ final Path path = pathToDo.poll();
+ try {
+ createForOneDirectory(path, watchFileTree ? pathToDo : null);
+ } catch (IOException e) {
+ final boolean exceptionForRootPath = relativeRootPath.equals(path);
+ if (exceptionForRootPath)
+ throw e; // report to the user as the watch root may have disappeared
+
+ // Ignore for sub-directories as some may have been removed during the scan.
+ // That's OK, those kinds of changes in the directory hierarchy is what
+ // WatchService is used for. However, it's impossible to catch all changes
+ // at this point, so we may fail to report some events that had occurred before
+ // FSEventStream has been created to watch for those changes.
+ }
+ }
+ }
+
+ private DirectorySnapshot createForOneDirectory(
+ final Path directory,
+ final Queue newDirectoriesFound) throws IOException {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("Creating snapshot for one directory " + directory);
+
+ final DirectorySnapshot snapshot = DirectorySnapshot.create(getRealRootPath(), directory);
+ snapshots.put(directory, snapshot);
+ if (newDirectoriesFound != null)
+ snapshot.forEachDirectory(newDirectoriesFound::offer);
+
+ return snapshot;
+ }
+
+ void reset() {
+ snapshots.clear();
+ }
+
+ void update(final Path directory, final boolean recurse) {
+ if (!recurse) {
+ directoryTreeSnapshot.update(directory, null);
+ } else {
+ final Queue pathToDo = new ArrayDeque<>();
+ pathToDo.offer(directory);
+ while (!pathToDo.isEmpty()) {
+ final Path dir = pathToDo.poll();
+ directoryTreeSnapshot.update(dir, pathToDo);
+ }
+ }
+ }
+
+ private void update(final Path directory, final Queue modifiedDirs) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("update for " + directory);
+ final DirectorySnapshot snapshot = snapshots.get(directory);
+ if (snapshot == null) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("no snapshot for directory " + directory);
+ // This means that we missed a notification about an update of our parent.
+ // Report overflow (who knows what else we weren't notified about?) and
+ // do our best to recover from this mess by queueing our parent for an update.
+ reportOverflow(directory);
+ if (modifiedDirs != null)
+ modifiedDirs.offer(getParentOf(directory));
+
+ return;
+ }
+
+ // FSEvents API does not generate events for directories that got moved from/to the directory
+ // being watched, so we have to watch for new/deleted directories ourselves. If we still
+ // receive an event for, say, one of the new directories, it won't be reported again as this
+ // will count as refresh with no modifications detected.
+ final Queue createdDirs = new ArrayDeque<>();
+ final Queue deletedDirs = new ArrayDeque<>();
+ snapshot.update(MacOSXWatchKey.this, createdDirs, deletedDirs, modifiedDirs);
+
+ handleNewDirectories(createdDirs);
+ handleDeletedDirectories(deletedDirs);
+ }
+
+ private Path getParentOf(final Path directory) {
+ Path parent = directory.getParent();
+ if (parent == null)
+ parent = relativeRootPath;
+ return parent;
+ }
+
+ private void handleDeletedDirectories(final Queue deletedDirs) {
+ // We don't know the exact sequence in which these were deleted,
+ // so at least maintain a sensible order, i.e. children are deleted before the parent.
+ final LinkedList dirsToReportDeleted = new LinkedList<>();
+ while (!deletedDirs.isEmpty()) {
+ final Path path = deletedDirs.poll();
+ dirsToReportDeleted.addFirst(path);
+ final DirectorySnapshot directorySnapshot = snapshots.get(path);
+ if (directorySnapshot != null) // May be null if we're not watching the whole file tree.
+ directorySnapshot.forEachDirectory(deletedDirs::offer);
+ }
+
+ for(final Path path : dirsToReportDeleted) {
+ final DirectorySnapshot directorySnapshot = snapshots.remove(path);
+ if (directorySnapshot != null) {
+ // This is needed in case a directory tree was moved (mv -f) out of this directory.
+ directorySnapshot.forEachFile(MacOSXWatchKey.this::reportDeleted);
+ }
+ reportDeleted(path);
+ }
+ }
+
+ private void handleNewDirectories(final Queue createdDirs) {
+ // We don't know the exact sequence in which these were created,
+ // so at least maintain a sensible order, i.e. the parent created before its children.
+ while (!createdDirs.isEmpty()) {
+ final Path path = createdDirs.poll();
+ reportCreated(path);
+ if (watchFileTree) {
+ if (!snapshots.containsKey(path)) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("Just noticed yet another directory: " + path);
+ // Happens when a directory tree gets moved (mv -f) into this directory.
+ DirectorySnapshot newSnapshot = null;
+ try {
+ newSnapshot = createForOneDirectory(path, createdDirs);
+ } catch(IOException ignore) { }
+
+ if (newSnapshot != null)
+ newSnapshot.forEachFile(MacOSXWatchKey.this::reportCreated);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Represents a snapshot of a directory with a millisecond precision timestamp of the last modification.
+ */
+ private static class DirectorySnapshot {
+ // Path to this directory relative to the watch root.
+ private final Path directory;
+
+ // Maps file names to their attributes.
+ private final Map files;
+
+ // A counter to keep track of files that have disappeared since the last run.
+ private long currentTick;
+
+ private DirectorySnapshot(final Path directory) {
+ this.directory = directory;
+ this.files = new HashMap<>();
+ }
+
+ static DirectorySnapshot create(final Path realRootPath, final Path directory) throws IOException {
+ final DirectorySnapshot snapshot = new DirectorySnapshot(directory);
+ try (final DirectoryStream directoryStream = Files.newDirectoryStream(realRootPath.resolve(directory))) {
+ for (final Path file : directoryStream) {
+ try {
+ final BasicFileAttributes attrs = Files.readAttributes(file, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
+ final Entry entry = new Entry(attrs.isDirectory(), attrs.lastModifiedTime().toMillis(), 0);
+ snapshot.files.put(file.getFileName(), entry);
+ } catch (IOException ignore) {}
+ }
+ } catch (DirectoryIteratorException e) {
+ throw e.getCause();
+ }
+
+ return snapshot;
+ }
+
+ void forEachDirectory(final Consumer consumer) {
+ files.forEach((path, entry) -> { if (entry.isDirectory) consumer.accept(directory.resolve(path)); } );
+ }
+
+ void forEachFile(final Consumer consumer) {
+ files.forEach((path, entry) -> { if (!entry.isDirectory) consumer.accept(directory.resolve(path)); } );
+ }
+
+ void update(final MacOSXWatchKey watchKey,
+ final Queue createdDirs,
+ final Queue deletedDirs,
+ final Queue modifiedDirs) {
+ currentTick++;
+
+ try (final DirectoryStream directoryStream = Files.newDirectoryStream(watchKey.getRealRootPath().resolve(directory))) {
+ for (final Path file : directoryStream) {
+ try {
+ final BasicFileAttributes attrs
+ = Files.readAttributes(file, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
+ final Path fileName = file.getFileName();
+ final Entry entry = files.get(fileName);
+ final boolean isNew = (entry == null);
+ final long lastModified = attrs.lastModifiedTime().toMillis();
+ final Path relativePath = directory.resolve(fileName);
+
+ if (attrs.isDirectory()) {
+ if (isNew) {
+ files.put(fileName, new Entry(true, lastModified, currentTick));
+ if (createdDirs != null) createdDirs.offer(relativePath);
+ } else {
+ if (!entry.isDirectory) { // Used to be a file, now a directory
+ if (createdDirs != null) createdDirs.offer(relativePath);
+
+ files.put(fileName, new Entry(true, lastModified, currentTick));
+ watchKey.reportDeleted(relativePath);
+ } else if (entry.isModified(lastModified)) {
+ if (modifiedDirs != null) modifiedDirs.offer(relativePath);
+ watchKey.reportModified(relativePath);
+ }
+ entry.update(lastModified, currentTick);
+ }
+ } else {
+ if (isNew) {
+ files.put(fileName, new Entry(false, lastModified, currentTick));
+ watchKey.reportCreated(relativePath);
+ } else {
+ if (entry.isDirectory) { // Used to be a directory, now a file.
+ if (deletedDirs != null) deletedDirs.offer(relativePath);
+
+ files.put(fileName, new Entry(false, lastModified, currentTick));
+ watchKey.reportCreated(directory.resolve(fileName));
+ } else if (entry.isModified(lastModified)) {
+ watchKey.reportModified(relativePath);
+ }
+ entry.update(lastModified, currentTick);
+ }
+ }
+ } catch (IOException ignore) {
+ // Simply skip the file we couldn't read; it'll get marked as deleted later.
+ }
+ }
+ } catch (IOException | DirectoryIteratorException ignore) {
+ // Most probably this directory has just been deleted; our parent will notice that.
+ }
+
+ checkDeleted(watchKey, deletedDirs);
+ }
+
+ private void checkDeleted(final MacOSXWatchKey watchKey, final Queue deletedDirs) {
+ final Iterator> it = files.entrySet().iterator();
+ while (it.hasNext()) {
+ final Map.Entry mapEntry = it.next();
+ final Entry entry = mapEntry.getValue();
+ if (entry.lastTickCount != currentTick) {
+ final Path file = mapEntry.getKey();
+ it.remove();
+
+ if (entry.isDirectory) {
+ if (deletedDirs != null) deletedDirs.offer(directory.resolve(file));
+ } else {
+ watchKey.reportDeleted(directory.resolve(file));
+ }
+ }
+ }
+ }
+
+ /**
+ * Information about an entry in a directory.
+ */
+ private static class Entry {
+ private long lastModified;
+ private long lastTickCount;
+ private final boolean isDirectory;
+
+ Entry(final boolean isDirectory, final long lastModified, final long lastTickCount) {
+ this.lastModified = lastModified;
+ this.lastTickCount = lastTickCount;
+ this.isDirectory = isDirectory;
+ }
+
+ boolean isModified(final long lastModified) {
+ return (this.lastModified != lastModified);
+ }
+
+ void update(final long lastModified, final long lastTickCount) {
+ this.lastModified = lastModified;
+ this.lastTickCount = lastTickCount;
+ }
+ }
+ }
+
+ private void reportCreated(final Path path) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("About to report CREATE for path " + path);
+
+ if (eventsToWatch.contains(FSEventKind.CREATE))
+ signalEvent(StandardWatchEventKinds.ENTRY_CREATE, path);
+ }
+
+ private void reportDeleted(final Path path) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("About to report DELETE for path " + path);
+
+ if (eventsToWatch.contains(FSEventKind.DELETE))
+ signalEvent(StandardWatchEventKinds.ENTRY_DELETE, path);
+ }
+
+ private void reportModified(final Path path) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("About to report MODIFIED for path " + path);
+
+ if (eventsToWatch.contains(FSEventKind.MODIFY))
+ signalEvent(StandardWatchEventKinds.ENTRY_MODIFY, path);
+ }
+
+ private void reportOverflow(final Path path) {
+ if (logger.isLoggable(PlatformLogger.Level.FINEST))
+ logger.finest("About to report OVERFLOW for path " + path);
+
+ if (eventsToWatch.contains(FSEventKind.OVERFLOW))
+ signalEvent(StandardWatchEventKinds.OVERFLOW, path);
+ }
+
+ public Object getRootPathKey() {
+ return rootPathKey;
+ }
+
+ public Path getRealRootPath() {
+ return realRootPath;
+ }
+
+ @Override
+ public boolean isValid() {
+ synchronized (eventStreamRefLock) {
+ return eventStreamRef != 0;
+ }
+ }
+
+ @Override
+ public void cancel() {
+ if (!isValid()) return;
+
+ // First, must stop the corresponding run loop:
+ ((MacOSXWatchService) watcher()).cancel(this);
+
+ // Next, invalidate the corresponding native FSEventStream.
+ invalidate();
+ }
+
+ void invalidate() {
+ synchronized (eventStreamRefLock) {
+ if (isValid()) {
+ eventStreamStop(eventStreamRef);
+ eventStreamRef = 0;
+ }
+ }
+ }
+
+ long getEventStreamRef() {
+ synchronized (eventStreamRefLock) {
+ assert (isValid());
+ return eventStreamRef;
+ }
+ }
+ }
+
+ /* native methods */
+
+ private static native long eventStreamCreate(String dir, double latencyInSeconds, int flags);
+ private static native void eventStreamSchedule(long eventStreamRef, long runLoopRef);
+ private static native void eventStreamStop(long eventStreamRef);
+ private static native long CFRunLoopGetCurrent();
+ private static native void CFRunLoopRun(final MacOSXWatchService watchService);
+ private static native void CFRunLoopStop(long runLoopRef);
+
+ private static native void initIDs();
+
+ static {
+ tracingEnabled = logger.isLoggable(PlatformLogger.Level.FINEST);
+ System.loadLibrary("nio");
+ initIDs();
+ }
+}
diff --git a/src/java.base/macosx/native/libnio/fs/MacOSXWatchService.c b/src/java.base/macosx/native/libnio/fs/MacOSXWatchService.c
new file mode 100644
index 000000000000..72c08c9608b2
--- /dev/null
+++ b/src/java.base/macosx/native/libnio/fs/MacOSXWatchService.c
@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2021, 2022, JetBrains s.r.o.. 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 "jni.h"
+#include "jni_util.h"
+#include "nio_util.h"
+
+#include
+
+#include
+#include
+
+#if defined(__GNUC__) || defined(__clang__)
+# ifndef ATTRIBUTE_PRINTF
+# define ATTRIBUTE_PRINTF(fmt,vargs) __attribute__((format(printf, fmt, vargs)))
+# endif
+#endif
+
+static void
+traceLine(JNIEnv* env, const char* fmt, ...) ATTRIBUTE_PRINTF(2, 3);
+
+// Controls exception stack trace output and debug trace.
+// Set by raising the logging level of sun.nio.fs.MacOSXWatchService to or above FINEST.
+static jboolean tracingEnabled;
+
+static jmethodID callbackMID; // MacOSXWatchService.callback()
+static __thread jobject watchService; // The instance of MacOSXWatchService that is associated with this thread
+
+
+JNIEXPORT void JNICALL
+Java_sun_nio_fs_MacOSXWatchService_initIDs(JNIEnv* env, __unused jclass clazz)
+{
+ jfieldID tracingEnabledFieldID = (*env)->GetStaticFieldID(env, clazz, "tracingEnabled", "Z");
+ CHECK_NULL(tracingEnabledFieldID);
+ tracingEnabled = (*env)->GetStaticBooleanField(env, clazz, tracingEnabledFieldID);
+ if ((*env)->ExceptionCheck(env)) {
+ (*env)->ExceptionDescribe(env);
+ }
+
+ callbackMID = (*env)->GetMethodID(env, clazz, "callback", "(J[Ljava/lang/String;J)V");
+}
+
+extern CFStringRef toCFString(JNIEnv *env, jstring javaString);
+
+static void
+traceLine(JNIEnv* env, const char* fmt, ...)
+{
+ if (tracingEnabled) {
+ va_list vargs;
+ va_start(vargs, fmt);
+ char* buf = (char*)malloc(1024);
+ vsnprintf(buf, 1024, fmt, vargs);
+ const jstring text = JNU_NewStringPlatform(env, buf);
+ free(buf);
+ va_end(vargs);
+
+ jboolean ignoreException;
+ JNU_CallStaticMethodByName(env, &ignoreException, "sun/nio/fs/MacOSXWatchService", "traceLine", "(Ljava/lang/String;)V", text);
+ }
+}
+
+static jboolean
+convertToJavaStringArray(JNIEnv* env, char **eventPaths,
+ const jsize numEventsToReport, jobjectArray javaEventPathsArray)
+{
+ for (jsize i = 0; i < numEventsToReport; i++) {
+ const jstring path = JNU_NewStringPlatform(env, eventPaths[i]);
+ CHECK_NULL_RETURN(path, FALSE);
+ (*env)->SetObjectArrayElement(env, javaEventPathsArray, i, path);
+ }
+
+ return JNI_TRUE;
+}
+
+static void
+callJavaCallback(JNIEnv* env, jlong streamRef, jobjectArray javaEventPathsArray, jlong eventFlags)
+{
+ if (callbackMID != NULL && watchService != NULL) {
+ // We are called on the run loop thread, so it's OK to use the thread-local reference
+ // to the watch service.
+ (*env)->CallVoidMethod(env, watchService, callbackMID, streamRef, javaEventPathsArray, eventFlags);
+ }
+}
+
+/**
+ * Callback that is invoked on the run loop thread and informs of new file-system events from an FSEventStream.
+ */
+static void
+callback(__unused ConstFSEventStreamRef streamRef,
+ __unused void *clientCallBackInfo,
+ size_t numEventsTotal,
+ void *eventPaths,
+ const FSEventStreamEventFlags eventFlags[],
+ __unused const FSEventStreamEventId eventIds[])
+{
+ JNIEnv *env = (JNIEnv *) JNU_GetEnv(jvm, JNI_VERSION_1_2);
+ if (!env) { // Shouldn't happen as run loop starts from Java code
+ return;
+ }
+
+ // We can get more events at once than the number of Java array elements,
+ // so report them in chunks.
+ const size_t MAX_EVENTS_TO_REPORT_AT_ONCE = (INT_MAX - 2);
+
+ jboolean success = JNI_TRUE;
+ for(size_t eventIndex = 0; success && (eventIndex < numEventsTotal); ) {
+ const size_t numEventsRemaining = (numEventsTotal - eventIndex);
+ const jsize numEventsToReport = (numEventsRemaining > MAX_EVENTS_TO_REPORT_AT_ONCE)
+ ? MAX_EVENTS_TO_REPORT_AT_ONCE
+ : numEventsRemaining;
+
+ const jboolean localFramePushed = ((*env)->PushLocalFrame(env, numEventsToReport + 5) == JNI_OK);
+ success = localFramePushed;
+
+ jobjectArray javaEventPathsArray = NULL;
+ if (success) {
+ javaEventPathsArray = (*env)->NewObjectArray(env, (jsize)numEventsToReport, JNU_ClassString(env), NULL);
+ success = (javaEventPathsArray != NULL);
+ }
+
+ if (success) {
+ success = convertToJavaStringArray(env, &((char**)eventPaths)[eventIndex], numEventsToReport, javaEventPathsArray);
+ }
+
+ callJavaCallback(env, (jlong)streamRef, javaEventPathsArray, (jlong)&eventFlags[eventIndex]);
+
+ if ((*env)->ExceptionCheck(env)) {
+ if (tracingEnabled) (*env)->ExceptionDescribe(env);
+ }
+
+ if (localFramePushed) {
+ (*env)->PopLocalFrame(env, NULL);
+ }
+
+ eventIndex += numEventsToReport;
+ }
+}
+
+/**
+ * Creates a new FSEventStream and returns FSEventStreamRef for it.
+ */
+JNIEXPORT jlong JNICALL
+Java_sun_nio_fs_MacOSXWatchService_eventStreamCreate(JNIEnv* env, __unused jclass clazz,
+ jstring dir, jdouble latencyInSeconds, jint flags)
+{
+ const CFStringRef path = toCFString(env, dir);
+ CHECK_NULL_RETURN(path, 0);
+ const CFArrayRef pathsToWatch = CFArrayCreate(NULL, (const void **) &path, 1, NULL);
+ CHECK_NULL_RETURN(pathsToWatch, 0);
+
+ const FSEventStreamRef stream = FSEventStreamCreate(
+ NULL,
+ &callback,
+ NULL,
+ pathsToWatch,
+ kFSEventStreamEventIdSinceNow,
+ (CFAbsoluteTime) latencyInSeconds,
+ flags
+ );
+
+ traceLine(env, "created event stream 0x%p", stream);
+
+ return (jlong)stream;
+}
+
+
+/**
+ * Schedules the given FSEventStream on the run loop of the current thread. Starts the stream
+ * so that the run loop can receive events from the stream.
+ */
+JNIEXPORT void JNICALL
+Java_sun_nio_fs_MacOSXWatchService_eventStreamSchedule(__unused JNIEnv* env, __unused jclass clazz,
+ jlong eventStreamRef, jlong runLoopRef)
+{
+ const FSEventStreamRef stream = (FSEventStreamRef)eventStreamRef;
+ const CFRunLoopRef runLoop = (CFRunLoopRef)runLoopRef;
+
+ FSEventStreamScheduleWithRunLoop(stream, runLoop, kCFRunLoopDefaultMode);
+ FSEventStreamStart(stream);
+
+ traceLine(env, "scheduled stream 0x%p on thread 0x%p", stream, CFRunLoopGetCurrent());
+}
+
+/**
+ * Performs the steps necessary to dispose of the given FSEventStreamRef.
+ * The stream must have been started and scheduled with a run loop.
+ */
+JNIEXPORT void JNICALL
+Java_sun_nio_fs_MacOSXWatchService_eventStreamStop(__unused JNIEnv* env, __unused jclass clazz, jlong eventStreamRef)
+{
+ const FSEventStreamRef streamRef = (FSEventStreamRef)eventStreamRef;
+
+ FSEventStreamStop(streamRef); // Unregister with the FS Events service. No more callbacks from this stream
+ FSEventStreamInvalidate(streamRef); // Unschedule from any runloops
+ FSEventStreamRelease(streamRef); // Decrement the stream's refcount
+}
+
+/**
+ * Returns the CFRunLoop object for the current thread.
+ */
+JNIEXPORT jlong JNICALL
+Java_sun_nio_fs_MacOSXWatchService_CFRunLoopGetCurrent(__unused JNIEnv* env, __unused jclass clazz)
+{
+ const CFRunLoopRef currentRunLoop = CFRunLoopGetCurrent();
+ traceLine(env, "get current run loop: 0x%p", currentRunLoop);
+ return (jlong)currentRunLoop;
+}
+
+/**
+ * Simply calls CFRunLoopRun() to run current thread's run loop for as long as there are event sources
+ * attached to it.
+ */
+JNIEXPORT void JNICALL
+Java_sun_nio_fs_MacOSXWatchService_CFRunLoopRun(__unused JNIEnv* env, __unused jclass clazz, jlong watchServiceObject)
+{
+ traceLine(env, "running run loop on 0x%p", CFRunLoopGetCurrent());
+
+ // Thread-local pointer to the WatchService instance will be used by the callback
+ // on this thread.
+ watchService = (*env)->NewGlobalRef(env, (jobject)watchServiceObject);
+ CFRunLoopRun();
+ (*env)->DeleteGlobalRef(env, (jobject)watchService);
+ watchService = NULL;
+
+ traceLine(env, "run loop done on 0x%p", CFRunLoopGetCurrent());
+}
+
+JNIEXPORT void JNICALL
+Java_sun_nio_fs_MacOSXWatchService_CFRunLoopStop(__unused JNIEnv* env, __unused jclass clazz, jlong runLoopRef)
+{
+ traceLine(env, "stopping run loop 0x%p", (void*)runLoopRef);
+ CFRunLoopStop((CFRunLoopRef)runLoopRef);
+}
diff --git a/src/java.base/macosx/native/libnio/fs/UTIFileTypeDetector.c b/src/java.base/macosx/native/libnio/fs/UTIFileTypeDetector.c
index 5e9451e850c1..2820bafbce9a 100644
--- a/src/java.base/macosx/native/libnio/fs/UTIFileTypeDetector.c
+++ b/src/java.base/macosx/native/libnio/fs/UTIFileTypeDetector.c
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2015, 2022, 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
@@ -35,7 +35,7 @@
* If a memory error occurs, and OutOfMemoryError is thrown and
* NULL is returned.
*/
-static CFStringRef toCFString(JNIEnv *env, jstring javaString)
+CFStringRef toCFString(JNIEnv *env, jstring javaString)
{
if (javaString == NULL) {
return NULL;
diff --git a/src/java.base/share/classes/com/jetbrains/base/JBRApiModule.java b/src/java.base/share/classes/com/jetbrains/base/JBRApiModule.java
new file mode 100644
index 000000000000..49fca1b8c81f
--- /dev/null
+++ b/src/java.base/share/classes/com/jetbrains/base/JBRApiModule.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2000-2023 JetBrains s.r.o.
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package com.jetbrains.base;
+
+import com.jetbrains.internal.JBRApi;
+
+import java.lang.invoke.MethodHandles;
+
+/**
+ * This class contains mapping between JBR API interfaces and implementation in {@code java.base} module.
+ */
+public class JBRApiModule {
+ static {
+ JBRApi.registerModule(MethodHandles.lookup(), JBRApiModule.class.getModule()::addExports)
+ .service("com.jetbrains.JBR$ServiceApi")
+ .withStatic("getService", "getService", "com.jetbrains.internal.JBRApi")
+ .service("com.jetbrains.Jstack")
+ .withStatic("includeInfoFrom", "$$jb$additionalInfoForJstack", "java.lang.Throwable");
+ }
+}
diff --git a/src/java.base/share/classes/com/jetbrains/bootstrap/JBRApiBootstrap.java b/src/java.base/share/classes/com/jetbrains/bootstrap/JBRApiBootstrap.java
new file mode 100644
index 000000000000..53f893c2e31b
--- /dev/null
+++ b/src/java.base/share/classes/com/jetbrains/bootstrap/JBRApiBootstrap.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright 2000-2023 JetBrains s.r.o.
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package com.jetbrains.bootstrap;
+
+import com.jetbrains.internal.JBRApi;
+import jdk.internal.loader.ClassLoaders;
+
+import java.lang.invoke.MethodHandles;
+
+/**
+ * Bootstrap class, used to initialize {@linkplain JBRApi JBR API}.
+ */
+public class JBRApiBootstrap {
+ private JBRApiBootstrap() {}
+
+ /**
+ * Classes that register JBR API implementation for their modules.
+ */
+ private static final String[] MODULES = {
+ "com.jetbrains.base.JBRApiModule",
+ "com.jetbrains.desktop.JBRApiModule"
+ };
+
+ /**
+ * Called from static initializer of {@link com.jetbrains.JBR}.
+ * @param outerLookup lookup context inside {@code jetbrains.api} module
+ * @return implementation for {@link com.jetbrains.JBR.ServiceApi} interface
+ */
+ public static synchronized Object bootstrap(MethodHandles.Lookup outerLookup) {
+ if (!System.getProperty("jetbrains.api.enabled", "true").equalsIgnoreCase("true")) return null;
+ try {
+ Class apiInterface = outerLookup.findClass("com.jetbrains.JBR$ServiceApi");
+ if (!outerLookup.hasFullPrivilegeAccess() ||
+ outerLookup.lookupClass().getPackage() != apiInterface.getPackage()) {
+ throw new IllegalArgumentException("Lookup must be full-privileged from the com.jetbrains package: " +
+ outerLookup.lookupClass().getName());
+ }
+ JBRApi.init(outerLookup);
+ ClassLoader classLoader = ClassLoaders.platformClassLoader();
+ for (String m : MODULES) Class.forName(m, true, classLoader);
+ return JBRApi.getService(apiInterface);
+ } catch(ClassNotFoundException | IllegalAccessException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+}
diff --git a/src/java.base/share/classes/com/jetbrains/internal/ASMUtils.java b/src/java.base/share/classes/com/jetbrains/internal/ASMUtils.java
new file mode 100644
index 000000000000..af28b5c0ac86
--- /dev/null
+++ b/src/java.base/share/classes/com/jetbrains/internal/ASMUtils.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2000-2023 JetBrains s.r.o.
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package com.jetbrains.internal;
+
+import jdk.internal.org.objectweb.asm.ClassVisitor;
+import jdk.internal.org.objectweb.asm.MethodVisitor;
+import jdk.internal.org.objectweb.asm.Type;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.reflect.ClassFileFormatVersion;
+import java.lang.reflect.Method;
+
+import static jdk.internal.org.objectweb.asm.Opcodes.*;
+
+/**
+ * Utility class that helps with bytecode generation
+ */
+class ASMUtils {
+
+ private static final MethodHandle genericSignatureGetter;
+ static {
+ try {
+ genericSignatureGetter = MethodHandles.privateLookupIn(Method.class, MethodHandles.lookup())
+ .findVirtual(Method.class, "getGenericSignature", MethodType.methodType(String.class));
+ } catch (NoSuchMethodException | IllegalAccessException e) {
+ throw new Error(e);
+ }
+ }
+
+ public static final int CLASSFILE_VERSION = ClassFileFormatVersion.latest().major();
+
+ public static void generateUnsupportedMethod(ClassVisitor writer, Method interfaceMethod) {
+ InternalMethodInfo methodInfo = getInternalMethodInfo(interfaceMethod);
+ MethodVisitor p = writer.visitMethod(ACC_PUBLIC | ACC_FINAL, methodInfo.name(),
+ methodInfo.descriptor(), methodInfo.genericSignature(), methodInfo.exceptionNames());
+ p.visitTypeInsn(NEW, "java/lang/UnsupportedOperationException");
+ p.visitInsn(DUP);
+ p.visitLdcInsn("No implementation found for this method");
+ p.visitMethodInsn(INVOKESPECIAL, "java/lang/UnsupportedOperationException", "", "(Ljava/lang/String;)V", false);
+ p.visitInsn(ATHROW);
+ p.visitMaxs(-1, -1);
+ }
+
+ public static void logDeprecated(MethodVisitor writer, String message) {
+ writer.visitTypeInsn(NEW, "java/lang/Exception");
+ writer.visitInsn(DUP);
+ writer.visitLdcInsn(message);
+ writer.visitMethodInsn(INVOKESPECIAL, "java/lang/Exception", "", "(Ljava/lang/String;)V", false);
+ writer.visitMethodInsn(INVOKEVIRTUAL, "java/lang/Exception", "printStackTrace", "()V", false);
+ }
+
+ protected record InternalMethodInfo(String name, String descriptor, String genericSignature,
+ String[] exceptionNames) {}
+
+ public static InternalMethodInfo getInternalMethodInfo(Method method) {
+ try {
+ return new InternalMethodInfo(
+ method.getName(),
+ Type.getMethodDescriptor(method),
+ (String) genericSignatureGetter.invoke(method),
+ getExceptionNames(method));
+ } catch (Throwable e) {
+ throw new Error(e);
+ }
+ }
+
+ private static String[] getExceptionNames(Method method) {
+ Class[] exceptionTypes = method.getExceptionTypes();
+ String[] exceptionNames = new String[exceptionTypes.length];
+ for (int i = 0; i < exceptionTypes.length; i++) {
+ exceptionNames[i] = Type.getInternalName(exceptionTypes[i]);
+ }
+ return exceptionNames;
+ }
+
+ public static int getParameterSize(Class c) {
+ if (c == Void.TYPE) {
+ return 0;
+ } else if (c == Long.TYPE || c == Double.TYPE) {
+ return 2;
+ }
+ return 1;
+ }
+
+ public static int getLoadOpcode(Class c) {
+ if (c == Void.TYPE) {
+ throw new InternalError("Unexpected void type of load opcode");
+ }
+ return ILOAD + getOpcodeOffset(c);
+ }
+
+ public static int getReturnOpcode(Class c) {
+ if (c == Void.TYPE) {
+ return RETURN;
+ }
+ return IRETURN + getOpcodeOffset(c);
+ }
+
+ public static int getOpcodeOffset(Class c) {
+ if (c.isPrimitive()) {
+ if (c == Long.TYPE) {
+ return 1;
+ } else if (c == Float.TYPE) {
+ return 2;
+ } else if (c == Double.TYPE) {
+ return 3;
+ }
+ return 0;
+ } else {
+ return 4;
+ }
+ }
+}
diff --git a/src/java.base/share/classes/com/jetbrains/internal/JBRApi.java b/src/java.base/share/classes/com/jetbrains/internal/JBRApi.java
new file mode 100644
index 000000000000..dd45238c5f1d
--- /dev/null
+++ b/src/java.base/share/classes/com/jetbrains/internal/JBRApi.java
@@ -0,0 +1,352 @@
+/*
+ * Copyright 2000-2023 JetBrains s.r.o.
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+package com.jetbrains.internal;
+
+import sun.security.action.GetBooleanAction;
+
+import java.io.Serial;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.function.BiFunction;
+
+import static java.lang.invoke.MethodHandles.Lookup;
+
+/**
+ * JBR API is a collection of JBR-specific features that are accessed by client though
+ * {@link com.jetbrains.JBR jetbrains.api} module. Actual implementation is linked by
+ * JBR at runtime by generating {@linkplain Proxy proxy objects}.
+ * Mapping between interfaces and implementation code is defined in
+ * {@linkplain com.jetbrains.bootstrap.JBRApiBootstrap#MODULES registry classes}.
+ *
+ * This class has most basic methods for working with JBR API and cache of generated proxies.
+ *
+ *
How to add a new service
+ *
+ * - Create your service interface in module {@link com.jetbrains.JBR jetbrains.api}:
+ *
{@code
+ * package com.jetbrains;
+ *
+ * interface StringOptimizer {
+ * void optimize(String string);
+ * }
+ * }
+ *
+ * - Create an implementation inside JBR:
+ *
{@link java.lang.String java.lang.String}:{@code
+ * private static void optimizeInternal(String string) {
+ * string.hash = 0;
+ * string.hashIsZero = true;
+ * }
+ * }
+ *
+ * - Register your service in corresponding
+ * {@linkplain com.jetbrains.bootstrap.JBRApiBootstrap#MODULES module registry class}:
+ *
{@link com.jetbrains.base.JBRApiModule}:{@code
+ * .service("com.jetbrains.StringOptimizer", null)
+ * .withStatic("optimize", "java.lang.String", "optimizeInternal")
+ * }
+ *
+ * - You can also bind the interface to implementation class
+ * (without actually implementing the interface):
+ *
{@link java.lang.String java.lang.String}:{@code
+ * private static class StringOptimizerImpl {
+ *
+ * private void optimize(String string) {
+ * string.hash = 0;
+ * string.hashIsZero = true;
+ * }
+ * }
+ * }
+ * {@link com.jetbrains.base.JBRApiModule}:{@code
+ * .service("com.jetbrains.StringOptimizer", "java.lang.String$StringOptimizerImpl")
+ * }
+ *
+ *
+ * How to add a new proxy
+ * Registering a proxy is similar to registering a service:
+ * {@code
+ * .proxy("com.jetbrains.SomeProxy", "a.b.c.SomeProxyImpl")
+ * }
+ * Note that unlike service, proxy must have a target type.
+ * Also, proxy expects target object as a single constructor argument
+ * and can only be instantiated by JBR, there's no API that would allow
+ * user to directly create proxy object.
+ */
+public class JBRApi {
+ @SuppressWarnings("removal")
+ static final boolean VERBOSE = AccessController.doPrivileged(new GetBooleanAction("jetbrains.api.verbose"));
+
+ private static final Map registeredProxyInfoByInterfaceName = new HashMap<>();
+ private static final Map registeredProxyInfoByTargetName = new HashMap<>();
+ private static final ConcurrentMap, Proxy> proxyByInterface = new ConcurrentHashMap<>();
+
+ /**
+ * lookup context inside {@code jetbrains.api} module
+ */
+ static Lookup outerLookup;
+ /**
+ * Known service and proxy interfaces extracted from {@link com.jetbrains.JBR.Metadata}
+ */
+ static Set knownServices, knownProxies;
+
+ public static void init(Lookup outerLookup) {
+ JBRApi.outerLookup = outerLookup;
+ try {
+ Class metadataClass = outerLookup.findClass("com.jetbrains.JBR$Metadata");
+ Lookup lookup = MethodHandles.privateLookupIn(metadataClass, outerLookup);
+ knownServices = Set.of((String[]) lookup.findStaticVarHandle(metadataClass,
+ "KNOWN_SERVICES", String[].class).get());
+ knownProxies = Set.of((String[]) lookup.findStaticVarHandle(metadataClass,
+ "KNOWN_PROXIES", String[].class).get());
+ } catch (ClassNotFoundException | NoSuchFieldException | IllegalAccessException e) {
+ e.printStackTrace();
+ knownServices = Set.of();
+ knownProxies = Set.of();
+ }
+ if (VERBOSE) {
+ System.out.println("JBR API init\nKNOWN_SERVICES = " + knownServices + "\nKNOWN_PROXIES = " + knownProxies);
+ }
+ }
+
+ /**
+ * @return fully supported service implementation for the given interface, or null
+ * @apiNote this method is a part of internal {@link com.jetbrains.JBR.ServiceApi}
+ * service, but is not directly exposed to user.
+ */
+ public static T getService(Class interFace) {
+ Proxy p = getProxy(interFace);
+ return p != null && p.isSupported() ? p.getInstance() : null;
+ }
+
+ /**
+ * @return proxy for the given interface, or {@code null}
+ */
+ @SuppressWarnings("unchecked")
+ static Proxy getProxy(Class interFace) {
+ return (Proxy) proxyByInterface.computeIfAbsent(interFace, i -> {
+ RegisteredProxyInfo info = registeredProxyInfoByInterfaceName.get(i.getName());
+ if (info == null) return null;
+ ProxyInfo resolved = ProxyInfo.resolve(info);
+ if (resolved == null) {
+ if (VERBOSE) {
+ System.err.println("Couldn't resolve proxy info: " + i.getName());
+ }
+ return null;
+ } else return new Proxy<>(resolved);
+ });
+ }
+
+ /**
+ * @return true if given class represents a proxy interface. Even if {@code jetbrains.api}
+ * introduces new interfaces JBR is not aware of, these interfaces would still be detected
+ * by this method.
+ */
+ static boolean isKnownProxyInterface(Class clazz) {
+ String name = clazz.getName();
+ return registeredProxyInfoByInterfaceName.containsKey(name) ||
+ knownServices.contains(name) || knownProxies.contains(name);
+ }
+
+ /**
+ * Reverse lookup by proxy target type name.
+ * @return user-side interface for given implementation target type name.
+ */
+ static Class getProxyInterfaceByTargetName(String targetName) {
+ RegisteredProxyInfo info = registeredProxyInfoByTargetName.get(targetName);
+ if (info == null) return null;
+ try {
+ return Class.forName(info.interfaceName(), true,
+ (info.type().isPublicApi() ? outerLookup : info.apiModule()).lookupClass().getClassLoader());
+ } catch (ClassNotFoundException e) {
+ if (VERBOSE) e.printStackTrace();
+ return null;
+ }
+ }
+
+ public static InternalServiceBuilder internalServiceBuilder(Lookup interFace, String... targets) {
+ return new InternalServiceBuilder(new RegisteredProxyInfo(
+ interFace, interFace.lookupClass().getName(), targets, ProxyInfo.Type.INTERNAL_SERVICE, new ArrayList<>()));
+ }
+
+ public static class InternalServiceBuilder {
+
+ private final RegisteredProxyInfo info;
+
+ private InternalServiceBuilder(RegisteredProxyInfo info) {
+ this.info = info;
+ }
+
+ public InternalServiceBuilder withStatic(String interfaceMethodName, String methodName, String... classes) {
+ info.staticMethods().add(
+ new RegisteredProxyInfo.StaticMethodMapping(interfaceMethodName, methodName, classes));
+ return this;
+ }
+
+ @SuppressWarnings("removal")
+ public Object build() {
+ return AccessController.doPrivileged((PrivilegedAction