8385359: [CRaC] aarch64: c7g.medium <-> c8g.medium FAIL: vector length

src/hotspot/cpu/aarch64/vm_version_aarch64.cpp

@@ -63,6 +63,7 @@
   GLIBC_UNSUPPORTED(A53MAC    ); \
   GLIBC_UNSUPPORTED(ECV       ); \
   GLIBC_UNSUPPORTED(WFXT      ); \
+  GLIBC_UNSUPPORTED(SVE256    ); \
   GLIBC_UNSUPPORTED(NOTPACA   ); \
   /**/
 #include "runtime/abstract_vm_version.inline.hpp"
@@ -930,3 +931,56 @@ void VM_Version::CPUFeatures_apply_arch(VM_Features &parsed, VM_Features &missin
   missing.clear_feature(CPU_PACA);
   missing.clear_feature(CPU_NOTPACA);
 }
+
+bool VM_Version::process_image_cpu_features(const VM_Features *image_featuresp) {
+  int want;
+  if (image_featuresp == nullptr) {
+    // Cleanup after a failed restore.
+    want = supports_feature(CPU_SVE256) ? 32 : 16;
+  } else {
+    const VM_Features &image_features = *image_featuresp;
+    bool image_supports_sve256 = image_features.supports_feature(CPU_SVE256);
+    if (image_supports_sve256 && !_cpu_features.supports_feature(CPU_SVE256)) {
+      if (!Abstract_VM_Version::should_check_cpu_features()) {
+        return true;
+      }
+      ResourceMark rm;
+      VM_Features sve256;
+      sve256.set_feature(CPU_SVE256);
+      VM_Features use = image_features & _cpu_features;
+      log_error(crac)("The image has -XX:CPUFeatures=%s with CPU_SVE256=%s, this CPU has CPUFeatures=%s not supporting CPU_SVE256, try using -XX:CPUFeatures=%s on checkpoint.",
+                      image_features.print_numbers(), sve256.print_numbers(), _cpu_features.print_numbers(), use.print_numbers());
+      return false;
+    }
+    want = image_supports_sve256 ? 32 : 16;
+  }
+  if (set_maximum_sve_vector_length(want) == want) {
+    return true;
+  }
+  if (!_cpu_features.supports_feature(CPU_SVE)) {
+    guarantee(want == 16, "CPU_SVE256 cannot be present without CPU_SVE");
+    return true;
+  }
+  // Always call PR_SVE_SET_VL, we do not know who did execute this JVM.
+  errno = 0;
+  int got = set_and_get_current_sve_vector_length(want);
+  if (got != want) {
+    ResourceMark rm;
+    VM_Features sve256;
+    sve256.set_feature(CPU_SVE256);
+    if (image_featuresp != nullptr) {
+      const VM_Features &image_features = *image_featuresp;
+      log_error(crac)("The image has -XX:CPUFeatures=%s with CPU_SVE256=%s %s, this CPU has CPUFeatures=%s but PR_SVE_SET_VL reports %d: %s",
+                      image_features.print_numbers(), sve256.print_numbers(),
+                      want == 32 ? "set" : "unset",
+                      _cpu_features.print_numbers(), got, os::strerror(errno));
+    } else {
+      log_error(crac)("Cannot restore this JVM's CPUFeatures=%s with CPU_SVE256=%s %s, this CPU has CPUFeatures=%s but PR_SVE_SET_VL reports %d: %s",
+                      _features.print_numbers(), sve256.print_numbers(),
+                      want == 32 ? "set" : "unset",
+                      _cpu_features.print_numbers(), got, os::strerror(errno));
+    }
+    return false;
+  }
+  return true;
+}

src/hotspot/cpu/aarch64/vm_version_aarch64.hpp

@@ -59,6 +59,7 @@ class VM_Feature_Flag {
     decl(ECV,           ecv,        21) \
     decl(WFXT,          wfxt,       22) \
     /* These features are added for CRaC. */ \
+    decl(SVE256,        sve256,     62) \
     decl(NOTPACA,       notpaca,    63) \
     /**/
 
@@ -68,7 +69,7 @@ class VM_Feature_Flag {
   #undef DECLARE_CPU_FEATURE_FLAG
     MAX_CPU_FEATURES,
     LAST_CPU_FEATURE = CPU_WFXT,
-    FIRST_GLIBC_FEATURE = CPU_NOTPACA
+    FIRST_GLIBC_FEATURE = CPU_SVE256
   };
 };
 
@@ -113,14 +114,17 @@ class VM_Version : public Abstract_VM_Version, public VM_Feature_Flag {
   // Return the length that will be used, or -ve if an error occurred.
   static int set_and_get_current_sve_vector_length(int len);
   static int get_current_sve_vector_length();
+  // Limit what set_and_get_current_sve_vector_length is willing to set.
+  static int set_maximum_sve_vector_length(int length);
 
 public:
   // Initialization
   typedef ::VM_Features VM_Features;
   static void initialize();
   static bool cpu_features_binary(VM_Features *data);
-  static bool check_cpu_features_skip() {
-    return _ignore_glibc_not_using;
+  static bool _cpu_features_ignore;
+  static bool can_use_cpu_features() {
+    return !_cpu_features_ignore;
   }
   static void check_virtualizations();
 
@@ -137,11 +141,12 @@ class VM_Version : public Abstract_VM_Version, public VM_Feature_Flag {
   static constexpr char glibc_prefix[] = ":glibc.cpu.hwcaps=";
   static constexpr size_t glibc_prefix_len = sizeof(glibc_prefix) - 1;
 #endif //LINUX
-  static bool _ignore_glibc_not_using;
   static void print_using_features_cr();
   static void insert_features_names(VM_Version::VM_Features features, outputStream& os);
   // The returned string needs a ResourceMark.
   static const char *restore_failed_check(const VM_Features *image_features, const VM_Features *current_features);
+  static bool process_image_cpu_features(const VM_Features *image_featuresp);
+  static constexpr bool process_image_cpu_features_needed = true;
 
   static void print_platform_virtualization_info(outputStream*);
 

src/hotspot/cpu/arm/vm_version_arm.hpp

@@ -41,10 +41,14 @@ class VM_Version: public Abstract_VM_Version {
   static bool is_initialized()      { return _is_initialized; }
   struct VM_Features: public Zero_Features {};
   static bool cpu_features_binary(VM_Features *data) { return false; }
-  static bool check_cpu_features_skip() { return true; }
+  static bool can_use_cpu_features() { return false; }
   static const char *restore_failed_check(const VM_Features *image_features, const VM_Features *current_features) {
     return nullptr;
   }
+  static bool process_image_cpu_features(const VM_Features *image_featuresp) {
+    return false;
+  }
+  static constexpr bool process_image_cpu_features_needed = false;
 
 
  protected:

src/hotspot/cpu/ppc/vm_version_ppc.hpp

@@ -57,7 +57,7 @@ class VM_Version: public Abstract_VM_Version {
   static void check_virtualizations();
   struct VM_Features: public Zero_Features {};
   static bool cpu_features_binary(VM_Features *data) { return false; }
-  static bool check_cpu_features_skip() { return true; }
+  static bool can_use_cpu_features() { return false; }
 
   // Override Abstract_VM_Version implementation
   static void print_platform_virtualization_info(outputStream*);

src/hotspot/cpu/riscv/vm_version_riscv.hpp

@@ -502,7 +502,7 @@ class VM_Version : public Abstract_VM_Version {
   static void initialize_cpu_information();
   struct VM_Features: public Zero_Features {};
   static bool cpu_features_binary(VM_Features *data) { return false; }
-  static bool check_cpu_features_skip() { return true; }
+  static bool can_use_cpu_features() { return false; }
 
   constexpr static bool supports_stack_watermark_barrier() { return true; }
 

src/hotspot/cpu/s390/vm_version_s390.hpp

@@ -31,7 +31,6 @@
 #include "runtime/globals_extension.hpp"
 
 class VM_Version: public Abstract_VM_Version {
-
  protected:
 // z/Architecture is the name of the 64-bit extension of the 31-bit s390
 // architecture.
@@ -418,7 +417,7 @@ class VM_Version: public Abstract_VM_Version {
   static bool is_determine_features_test_running() { return _is_determine_features_test_running; }
   struct VM_Features: public Zero_Features {};
   static bool cpu_features_binary(VM_Features *data) { return false; }
-  static bool check_cpu_features_skip() { return true; }
+  static bool can_use_cpu_features() { return false; }
 
   // Override Abstract_VM_Version implementation
   static void print_platform_virtualization_info(outputStream*);

src/hotspot/cpu/x86/vm_version_x86.hpp

@@ -726,12 +726,15 @@ class VM_Version : public Abstract_VM_Version, protected VM_Feature_Flag {
   static constexpr char glibc_prefix[] = ":glibc.cpu.hwcaps=";
   static constexpr size_t glibc_prefix_len = sizeof(glibc_prefix) - 1;
 #endif //LINUX
-  static bool _ignore_glibc_not_using;
   static void print_using_features_cr();
   static void insert_features_names(VM_Version::VM_Features features, outputStream& os);
   static const char *restore_failed_check(const VM_Features *image_features, const VM_Features *current_features) {
     return nullptr;
   }
+  static bool process_image_cpu_features(const VM_Features *image_featuresp) {
+    return false;
+  }
+  static constexpr bool process_image_cpu_features_needed = false;
 
   static bool os_supports_avx_vectors();
   static bool os_supports_apx_egprs();
@@ -813,8 +816,9 @@ class VM_Version : public Abstract_VM_Version, protected VM_Feature_Flag {
   // Initialization
   static void initialize();
   static bool cpu_features_binary(VM_Features *data);
-  static bool check_cpu_features_skip() {
-    return _ignore_glibc_not_using;
+  static bool _cpu_features_ignore;
+  static bool can_use_cpu_features() {
+    return !_cpu_features_ignore;
   }
 
   // Override Abstract_VM_Version implementation

src/hotspot/cpu/zero/vm_version_zero.hpp

@@ -34,10 +34,14 @@ class VM_Version : public Abstract_VM_Version {
   static void initialize();
   struct VM_Features: public Zero_Features {};
   static bool cpu_features_binary(VM_Features *data) { return false; }
-  static bool check_cpu_features_skip() { return true; }
+  static bool can_use_cpu_features() { return false; }
   static const char *restore_failed_check(const VM_Features *image_features, const VM_Features *current_features) {
     return nullptr;
   }
+  static bool process_image_cpu_features(const VM_Features *image_featuresp) {
+    return false;
+  }
+  static constexpr bool process_image_cpu_features_needed = false;
 
   constexpr static bool supports_stack_watermark_barrier() { return true; }
 

src/hotspot/os_cpu/bsd_aarch64/vm_version_bsd_aarch64.cpp

@@ -35,6 +35,11 @@ int VM_Version::get_current_sve_vector_length() {
   return -1;
 }
 
+int VM_Version::set_maximum_sve_vector_length(int length) {
+  ShouldNotCallThis();
+  return length;
+}
+
 int VM_Version::set_and_get_current_sve_vector_length(int length) {
   ShouldNotCallThis();
   return -1;

src/hotspot/os_cpu/linux_aarch64/vm_version_linux_aarch64.cpp

@@ -24,6 +24,7 @@
  */
 
 #include "memory/resourceArea.hpp"
+#include "runtime/globals_extension.hpp"
 #include "runtime/java.hpp"
 #include "runtime/os.hpp"
 #include "runtime/os.inline.hpp"
@@ -120,9 +121,17 @@ int VM_Version::get_current_sve_vector_length() {
   return prctl(PR_SVE_GET_VL);
 }
 
+static int maximum_sve_vector_length = INT_MAX;
+
+int VM_Version::set_maximum_sve_vector_length(int length) {
+  int retval = maximum_sve_vector_length;
+  maximum_sve_vector_length = length;
+  return retval;
+}
+
 int VM_Version::set_and_get_current_sve_vector_length(int length) {
-  assert(VM_Version::supports_sve(), "should not call this");
-  int new_length = prctl(PR_SVE_SET_VL, length);
+  assert(_cpu_features.supports_feature(CPU_SVE), "should not call this");
+  int new_length = prctl(PR_SVE_SET_VL, MIN2(length, maximum_sve_vector_length));
   return new_length;
 }
 
@@ -163,6 +172,10 @@ void VM_Version::get_os_cpu_info() {
   update_feature(auxv2, CPU_WFXT,       HWCAP2_WFXT      );
   update_feature(~auxv, CPU_NOTPACA,    HWCAP_PACA       );
 
+  if (supports_sve() && get_current_sve_vector_length() == 32) {
+    set_feature(CPU_SVE256);
+  }
+
   uint64_t ctr_el0;
   uint64_t dczid_el0;
   __asm__ (
@@ -226,6 +239,20 @@ void VM_Version::check_os_cpu_info() {
     // GLIBC_TUNABLES=glibc.cpu.hwcaps is unsupported on aarch64
     vm_exit_during_initialization(err_msg("LSE (%s) cannot be disabled via -XX:CPUFeatures on aarch64.", lse.print_numbers()));
   }
+  if (FLAG_IS_DEFAULT(CPUFeatures)) {
+    assert(_cpu_features.supports_feature(CPU_SVE256) == _features.supports_feature(CPU_SVE256), "CPU_SVE256 is not changed");
+  } else if (_cpu_features.supports_feature(CPU_SVE256) && !_features.supports_feature(CPU_SVE256)) {
+    maximum_sve_vector_length = 16;
+    int got = set_and_get_current_sve_vector_length(maximum_sve_vector_length);
+    if (got != maximum_sve_vector_length) {
+      stringStream ss;
+      VM_Features sve256;
+      sve256.set_feature(VM_Feature_Flag::CPU_SVE256);
+      ss.print("Specified -XX:CPUFeatures=%s have unset CPU_SVE256=%s, this CPU has CPUFeatures=%s but it cannot be disabled as PR_SVE_SET_VL reports %d: %m",
+               _features.print_numbers(), sve256.print_numbers(), _cpu_features.print_numbers(), got);
+      vm_exit_during_initialization(ss.base());
+    }
+  }
 }
 
 static bool read_fully(const char *fname, char *buf, size_t buflen) {

src/hotspot/os_cpu/windows_aarch64/vm_version_windows_aarch64.cpp

@@ -61,6 +61,12 @@ int VM_Version::get_current_sve_vector_length() {
   return VM_Version::supports_sve() ? get_sve_vector_length() : 0;
 }
 
+int VM_Version::set_maximum_sve_vector_length(int length) {
+  // CPU_SVE256 cannot be set on Windows.
+  ShouldNotCallThis();
+  return length;
+}
+
 int VM_Version::set_and_get_current_sve_vector_length(int length) {
   assert(VM_Version::supports_sve(), "should not call this");
 

src/hotspot/share/include/crlib/crlib_image_constraints.h

@@ -69,6 +69,13 @@ typedef const struct crlib_image_constraints {
   // Returns the size of the data, in bytes — it can be more, equal to or less than
   // 'value_size'. Returned value of 0 represents an error.
   size_t (*get_failed_bitmap)(crlib_conf_t *, const char *name, unsigned char *value_return, size_t value_size);
+
+  // Register callbacks before restore. Callbacks are called only during restore.
+  // If the callback returns false the restore is aborted.
+  // name is not copied, its content must remain valid.
+  // user_data is an arbitrary pointer value which is passed along.
+  bool (*register_label_hook)(crlib_conf_t *, const char *name, bool (*hook)(const char *value, void *user_data), void *user_data);
+  bool (*register_bitmap_hook)(crlib_conf_t *, const char *name, bool (*hook)(const unsigned char *value, size_t value_size, void *user_data), void *user_data);
 } crlib_image_constraints_t;
 
 #ifdef __cplusplus

src/hotspot/share/runtime/abstract_vm_version.cpp

@@ -401,3 +401,7 @@ void Abstract_VM_Version::check_cpufeatures_vmoptions() {
     tty->print_cr("Do not use -XX:ShowCPUFeatures: this architecture does not support any arch-specific strings.");
   }
 }
+
+bool Abstract_VM_Version::should_check_cpu_features() {
+  return VM_Version::can_use_cpu_features() && (CheckCPUFeatures == nullptr || strcmp(CheckCPUFeatures, "skip") != 0);
+}

src/hotspot/share/runtime/abstract_vm_version.hpp

@@ -268,6 +268,8 @@ class Abstract_VM_Version: AllStatic {
 
   // features_buffer is an opaque object that stores arch specific representation of cpu features
   static bool verify_aot_code_cache_features(void* features_buffer) { return false; };
+
+  static bool should_check_cpu_features();
 };
 
 #endif // SHARE_RUNTIME_ABSTRACT_VM_VERSION_HPP

src/hotspot/share/runtime/abstract_vm_version.inline.hpp

@@ -35,7 +35,7 @@ VM_Features VM_Version::CPUFeatures_parse(const char *str) {
   if (str == nullptr || strcmp(str, "native") == 0) {
     return _features;
   } else if (strcmp(str, "ignore") == 0) {
-    _ignore_glibc_not_using = true;
+    _cpu_features_ignore = true;
     return _features;
   } else if (strcmp(str, "generic") == 0) {
     return CPUFeatures_generic();
@@ -80,7 +80,7 @@ VM_Features VM_Version::CPUFeatures_parse_numeric(const char *str) {
 #endif // LINUX
 }
 
-bool VM_Version::_ignore_glibc_not_using = LINUX_ONLY(false) NOT_LINUX(true);
+bool VM_Version::_cpu_features_ignore = LINUX_ONLY(false) NOT_LINUX(true);
 #ifdef LINUX
 bool VM_Version::glibc_env_set(char *disable_str) {
 #define TUNABLES_NAME "GLIBC_TUNABLES"
@@ -196,7 +196,7 @@ void VM_Version::glibc_reexec() {
 
 // Returns whether we should have got set a GLIBC_TUNABLES environment variables but did not get any.
 bool VM_Version::glibc_not_using() {
-  if (_ignore_glibc_not_using)
+  if (_cpu_features_ignore)
     return true;
 
   VM_Features features_expected;
@@ -290,7 +290,7 @@ bool VM_Version::glibc_not_using() {
 #endif // LINUX
 
 void VM_Version::print_using_features_cr() {
-  if (_ignore_glibc_not_using) {
+  if (_cpu_features_ignore) {
     tty->print_raw_cr("CPU features are being kept intact as requested by -XX:CPUFeatures=ignore");
   } else {
     tty->print_raw("CPU features being used are: -XX:CPUFeatures=");