Backport 824af4cc8d7810d337098c05d748ec6b41caa802

RadekCap · RadekCap · commit 1a01a9ab95a7 · 2025-05-07T14:31:16.000+02:00
diff --git a/src/hotspot/os/linux/cgroupV1Subsystem_linux.cpp b/src/hotspot/os/linux/cgroupV1Subsystem_linux.cpp
@@ -76,7 +76,7 @@ void CgroupV1Controller::set_subsystem_path(char *cgroup_path) {
  */
 jlong CgroupV1MemoryController::uses_mem_hierarchy() {
   GET_CONTAINER_INFO(jlong, this, "/memory.use_hierarchy",
-                    "Use Hierarchy is: " JLONG_FORMAT, JLONG_FORMAT, use_hierarchy);
+                    "Use Hierarchy is: ", JLONG_FORMAT, JLONG_FORMAT, use_hierarchy);
   return use_hierarchy;
 }
 
@@ -90,16 +90,14 @@ void CgroupV1MemoryController::set_subsystem_path(char *cgroup_path) {
 
 jlong CgroupV1Subsystem::read_memory_limit_in_bytes() {
   GET_CONTAINER_INFO(julong, _memory->controller(), "/memory.limit_in_bytes",
-                     "Memory Limit is: " JULONG_FORMAT, JULONG_FORMAT, memlimit);
+                     "Memory Limit is: ", JULONG_FORMAT, JULONG_FORMAT, memlimit);
 
   if (memlimit >= os::Linux::physical_memory()) {
     log_trace(os, container)("Non-Hierarchical Memory Limit is: Unlimited");
     CgroupV1MemoryController* mem_controller = reinterpret_cast<CgroupV1MemoryController*>(_memory->controller());
     if (mem_controller->is_hierarchical()) {
-      const char* matchline = "hierarchical_memory_limit";
-      const char* format = "%s " JULONG_FORMAT;
-      GET_CONTAINER_INFO_LINE(julong, _memory->controller(), "/memory.stat", matchline,
-                             "Hierarchical Memory Limit is: " JULONG_FORMAT, format, hier_memlimit)
+      GET_CONTAINER_INFO_LINE(julong, _memory->controller(), "/memory.stat", "hierarchical_memory_limit",
+                             "Hierarchical Memory Limit is: " JULONG_FORMAT, JULONG_FORMAT, hier_memlimit)
       if (hier_memlimit >= os::Linux::physical_memory()) {
         log_trace(os, container)("Hierarchical Memory Limit is: Unlimited");
       } else {
@@ -113,54 +111,72 @@ jlong CgroupV1Subsystem::read_memory_limit_in_bytes() {
   }
 }
 
-jlong CgroupV1Subsystem::memory_and_swap_limit_in_bytes() {
+/* read_mem_swap
+ *
+ * Determine the memory and swap limit metric. Returns a positive limit value strictly
+ * lower than the physical memory and swap limit iff there is a limit. Otherwise a
+ * negative value is returned indicating the determined status.
+ *
+ * returns:
+ *    * A number > 0 if the limit is available and lower than a physical upper bound.
+ *    * OSCONTAINER_ERROR if the limit cannot be retrieved (i.e. not supported) or
+ *    * -1 if there isn't any limit in place (note: includes values which exceed a physical
+ *      upper bound)
+ */
+jlong CgroupV1Subsystem::read_mem_swap() {
   julong host_total_memsw;
   GET_CONTAINER_INFO(julong, _memory->controller(), "/memory.memsw.limit_in_bytes",
-                     "Memory and Swap Limit is: " JULONG_FORMAT, JULONG_FORMAT, memswlimit);
+                     "Memory and Swap Limit is: ", JULONG_FORMAT, JULONG_FORMAT, memswlimit);
   host_total_memsw = os::Linux::host_swap() + os::Linux::physical_memory();
   if (memswlimit >= host_total_memsw) {
     log_trace(os, container)("Non-Hierarchical Memory and Swap Limit is: Unlimited");
     CgroupV1MemoryController* mem_controller = reinterpret_cast<CgroupV1MemoryController*>(_memory->controller());
     if (mem_controller->is_hierarchical()) {
       const char* matchline = "hierarchical_memsw_limit";
-      const char* format = "%s " JULONG_FORMAT;
       GET_CONTAINER_INFO_LINE(julong, _memory->controller(), "/memory.stat", matchline,
-                             "Hierarchical Memory and Swap Limit is : " JULONG_FORMAT, format, hier_memswlimit)
+                             "Hierarchical Memory and Swap Limit is : " JULONG_FORMAT, JULONG_FORMAT, hier_memswlimit)
       if (hier_memswlimit >= host_total_memsw) {
         log_trace(os, container)("Hierarchical Memory and Swap Limit is: Unlimited");
       } else {
-        jlong swappiness = read_mem_swappiness();
-        if (swappiness == 0) {
-            const char* matchmemline = "hierarchical_memory_limit";
-            GET_CONTAINER_INFO_LINE(julong, _memory->controller(), "/memory.stat", matchmemline,
-                             "Hierarchical Memory Limit is : " JULONG_FORMAT, format, hier_memlimit)
-            log_trace(os, container)("Memory and Swap Limit has been reset to " JULONG_FORMAT " because swappiness is 0", hier_memlimit);
-            return (jlong)hier_memlimit;
-        }
         return (jlong)hier_memswlimit;
       }
     }
     return (jlong)-1;
   } else {
-    jlong swappiness = read_mem_swappiness();
-    if (swappiness == 0) {
-      jlong memlimit = read_memory_limit_in_bytes();
-      log_trace(os, container)("Memory and Swap Limit has been reset to " JULONG_FORMAT " because swappiness is 0", memlimit);
-      return memlimit;
-    }
     return (jlong)memswlimit;
   }
 }
 
+jlong CgroupV1Subsystem::memory_and_swap_limit_in_bytes() {
+  jlong memory_swap = read_mem_swap();
+  if (memory_swap == -1) {
+    return memory_swap;
+  }
+  // If there is a swap limit, but swappiness == 0, reset the limit
+  // to the memory limit. Do the same for cases where swap isn't
+  // supported.
+  jlong swappiness = read_mem_swappiness();
+  if (swappiness == 0 || memory_swap == OSCONTAINER_ERROR) {
+    jlong memlimit = read_memory_limit_in_bytes();
+    if (memory_swap == OSCONTAINER_ERROR) {
+      log_trace(os, container)("Memory and Swap Limit has been reset to " JLONG_FORMAT " because swap is not supported", memlimit);
+    } else {
+      log_trace(os, container)("Memory and Swap Limit has been reset to " JLONG_FORMAT " because swappiness is 0", memlimit);
+    }
+    return memlimit;
+  }
+  return memory_swap;
+}
+
 jlong CgroupV1Subsystem::read_mem_swappiness() {
   GET_CONTAINER_INFO(julong, _memory->controller(), "/memory.swappiness",
-                     "Swappiness is: " JULONG_FORMAT, JULONG_FORMAT, swappiness);
+                     "Swappiness is: ", JULONG_FORMAT, JULONG_FORMAT, swappiness);
   return swappiness;
 }
 
 jlong CgroupV1Subsystem::memory_soft_limit_in_bytes() {
   GET_CONTAINER_INFO(julong, _memory->controller(), "/memory.soft_limit_in_bytes",
-                     "Memory Soft Limit is: " JULONG_FORMAT, JULONG_FORMAT, memsoftlimit);
+                     "Memory Soft Limit is: ", JULONG_FORMAT, JULONG_FORMAT, memsoftlimit);
   if (memsoftlimit >= os::Linux::physical_memory()) {
     log_trace(os, container)("Memory Soft Limit is: Unlimited");
     return (jlong)-1;
@@ -180,7 +196,7 @@ jlong CgroupV1Subsystem::memory_soft_limit_in_bytes() {
  */
 jlong CgroupV1Subsystem::memory_usage_in_bytes() {
   GET_CONTAINER_INFO(jlong, _memory->controller(), "/memory.usage_in_bytes",
-                     "Memory Usage is: " JLONG_FORMAT, JLONG_FORMAT, memusage);
+                     "Memory Usage is: ", JLONG_FORMAT, JLONG_FORMAT, memusage);
   return memusage;
 }
 
@@ -194,20 +210,20 @@ jlong CgroupV1Subsystem::memory_usage_in_bytes() {
  */
 jlong CgroupV1Subsystem::memory_max_usage_in_bytes() {
   GET_CONTAINER_INFO(jlong, _memory->controller(), "/memory.max_usage_in_bytes",
-                     "Maximum Memory Usage is: " JLONG_FORMAT, JLONG_FORMAT, memmaxusage);
+                     "Maximum Memory Usage is: ", JLONG_FORMAT, JLONG_FORMAT, memmaxusage);
   return memmaxusage;
 }
 
 
 jlong CgroupV1Subsystem::kernel_memory_usage_in_bytes() {
   GET_CONTAINER_INFO(jlong, _memory->controller(), "/memory.kmem.usage_in_bytes",
-                     "Kernel Memory Usage is: " JLONG_FORMAT, JLONG_FORMAT, kmem_usage);
+                     "Kernel Memory Usage is: ", JLONG_FORMAT, JLONG_FORMAT, kmem_usage);
   return kmem_usage;
 }
 
 jlong CgroupV1Subsystem::kernel_memory_limit_in_bytes() {
   GET_CONTAINER_INFO(julong, _memory->controller(), "/memory.kmem.limit_in_bytes",
-                     "Kernel Memory Limit is: " JULONG_FORMAT, JULONG_FORMAT, kmem_limit);
+                     "Kernel Memory Limit is: ", JULONG_FORMAT, JULONG_FORMAT, kmem_limit);
   if (kmem_limit >= os::Linux::physical_memory()) {
     return (jlong)-1;
   }
@@ -216,7 +232,7 @@ jlong CgroupV1Subsystem::kernel_memory_limit_in_bytes() {
 
 jlong CgroupV1Subsystem::kernel_memory_max_usage_in_bytes() {
   GET_CONTAINER_INFO(jlong, _memory->controller(), "/memory.kmem.max_usage_in_bytes",
-                     "Maximum Kernel Memory Usage is: " JLONG_FORMAT, JLONG_FORMAT, kmem_max_usage);
+                     "Maximum Kernel Memory Usage is: ", JLONG_FORMAT, JLONG_FORMAT, kmem_max_usage);
   return kmem_max_usage;
 }
 
@@ -254,13 +270,13 @@ char * CgroupV1Subsystem::cpu_cpuset_memory_nodes() {
  */
 int CgroupV1Subsystem::cpu_quota() {
   GET_CONTAINER_INFO(int, _cpu->controller(), "/cpu.cfs_quota_us",
-                     "CPU Quota is: %d", "%d", quota);
+                     "CPU Quota is: ", "%d", "%d", quota);
   return quota;
 }
 
 int CgroupV1Subsystem::cpu_period() {
   GET_CONTAINER_INFO(int, _cpu->controller(), "/cpu.cfs_period_us",
-                     "CPU Period is: %d", "%d", period);
+                     "CPU Period is: ", "%d", "%d", period);
   return period;
 }
 
@@ -276,7 +292,7 @@ int CgroupV1Subsystem::cpu_period() {
  */
 int CgroupV1Subsystem::cpu_shares() {
   GET_CONTAINER_INFO(int, _cpu->controller(), "/cpu.shares",
-                     "CPU Shares is: %d", "%d", shares);
+                     "CPU Shares is: ", "%d", "%d", shares);
   // Convert 1024 to no shares setup
   if (shares == 1024) return -1;
 
@@ -286,10 +302,7 @@ int CgroupV1Subsystem::cpu_shares() {
 
 char* CgroupV1Subsystem::pids_max_val() {
   GET_CONTAINER_INFO_CPTR(cptr, _pids, "/pids.max",
-                     "Maximum number of tasks is: %s", "%s %*d", pidsmax, 1024);
-  if (pidsmax == NULL) {
-    return NULL;
-  }
+                     "Maximum number of tasks is: %s", "%1023s", pidsmax, 1024);
   return os::strdup(pidsmax);
 }
 
@@ -319,6 +332,6 @@ jlong CgroupV1Subsystem::pids_max() {
 jlong CgroupV1Subsystem::pids_current() {
   if (_pids == NULL) return OSCONTAINER_ERROR;
   GET_CONTAINER_INFO(jlong, _pids, "/pids.current",
-                     "Current number of tasks is: " JLONG_FORMAT, JLONG_FORMAT, pids_current);
+                     "Current number of tasks is: ", JLONG_FORMAT, JLONG_FORMAT, pids_current);
   return pids_current;
 }
diff --git a/src/hotspot/os/linux/cgroupV1Subsystem_linux.hpp b/src/hotspot/os/linux/cgroupV1Subsystem_linux.hpp
@@ -114,6 +114,7 @@ class CgroupV1Subsystem: public CgroupSubsystem {
     char * pids_max_val();
 
     jlong read_mem_swappiness();
+    jlong read_mem_swap();
 
   public:
     CgroupV1Subsystem(CgroupV1Controller* cpuset,
diff --git a/src/hotspot/os/linux/cgroupV2Subsystem_linux.cpp b/src/hotspot/os/linux/cgroupV2Subsystem_linux.cpp
@@ -164,6 +164,12 @@ char* CgroupV2Subsystem::mem_soft_limit_val() {
 // without also setting a memory limit is not allowed.
 jlong CgroupV2Subsystem::memory_and_swap_limit_in_bytes() {
   char* mem_swp_limit_str = mem_swp_limit_val();
+  if (mem_swp_limit_str == nullptr) {
+    // Some container tests rely on this trace logging to happen.
+    log_trace(os, container)("Memory and Swap Limit is: %d", OSCONTAINER_ERROR);
+    // swap disabled at kernel level, treat it as no swap
+    return read_memory_limit_in_bytes();
+  }
   jlong swap_limit = limit_from_str(mem_swp_limit_str);
   if (swap_limit >= 0) {
     jlong memory_limit = read_memory_limit_in_bytes();
diff --git a/test/hotspot/jtreg/containers/docker/TestMemoryAwareness.java b/test/hotspot/jtreg/containers/docker/TestMemoryAwareness.java
@@ -33,15 +33,15 @@
  *          java.base/jdk.internal.platform
  *          java.management
  *          jdk.jartool/sun.tools.jar
- * @build AttemptOOM sun.hotspot.WhiteBox PrintContainerInfo CheckOperatingSystemMXBean
- * @run driver ClassFileInstaller -jar whitebox.jar sun.hotspot.WhiteBox sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @build AttemptOOM jdk.test.whitebox.WhiteBox PrintContainerInfo CheckOperatingSystemMXBean
+ * @run driver jdk.test.lib.helpers.ClassFileInstaller -jar whitebox.jar jdk.test.whitebox.WhiteBox
  * @run main/othervm -Xbootclasspath/a:whitebox.jar -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI TestMemoryAwareness
  */
 import java.util.function.Consumer;
 import jdk.test.lib.containers.docker.Common;
 import jdk.test.lib.containers.docker.DockerRunOptions;
 import jdk.test.lib.containers.docker.DockerTestUtils;
-import sun.hotspot.WhiteBox;
+import jdk.test.whitebox.WhiteBox;
 import jdk.test.lib.process.OutputAnalyzer;
 
 import static jdk.test.lib.Asserts.assertNotNull;
@@ -75,6 +75,9 @@ public static void main(String[] args) throws Exception {
 
             testMemorySoftLimit("500m", "524288000");
             testMemorySoftLimit("1g", "1073741824");
+            testMemorySwapLimitSanity();
+
+            testMemorySwapNotSupported("500m", "520m", "512000 k", "532480 k");
 
             // Add extra 10 Mb to allocator limit, to be sure to cause OOM
             testOOM("256m", 256 + 10);
@@ -153,6 +156,54 @@ private static void testMemorySoftLimit(String valueToSet, String expectedTraceV
             .shouldMatch("Memory Soft Limit.*" + expectedTraceValue);
     }
 
+    /*
+     * Verifies that PrintContainerInfo prints the memory
+     * limit - without swap - iff swap is disabled (e.g. via swapaccount=0). It must
+     * not print 'not supported' for that value in that case. It'll always pass
+     * on systems with swap accounting enabled.
+     */
+    private static void testMemorySwapNotSupported(String valueToSet, String swapToSet, String expectedMem, String expectedSwap)
+            throws Exception {
+        Common.logNewTestCase("memory swap not supported: " + valueToSet);
+
+        DockerRunOptions opts = Common.newOpts(imageName, "PrintContainerInfo");
+        Common.addWhiteBoxOpts(opts);
+        opts.addDockerOpts("--memory=" + valueToSet);
+        opts.addDockerOpts("--memory-swap=" + swapToSet);
+
+        Common.run(opts)
+            .shouldMatch("memory_limit_in_bytes:.*" + expectedMem)
+            .shouldNotMatch("memory_and_swap_limit_in_bytes:.*not supported")
+            // On systems with swapaccount=0 this returns the memory limit.
+            // On systems with swapaccount=1 this returns the set memory+swap value.
+            .shouldMatch("memory_and_swap_limit_in_bytes:.*(" + expectedMem + "|" + expectedSwap + ")");
+    }
+
+    /*
+     * This test verifies that no confusingly large positive numbers get printed on
+     * systems with swapaccount=0 kernel option. On some systems -2 were converted
+     * to unsigned long and printed that way. Ensure this oddity doesn't occur.
+     */
+    private static void testMemorySwapLimitSanity() throws Exception {
+        String valueToSet = "500m";
+        String expectedTraceValue = "524288000";
+        Common.logNewTestCase("memory swap sanity: " + valueToSet);
+
+        DockerRunOptions opts = Common.newOpts(imageName, "PrintContainerInfo");
+        Common.addWhiteBoxOpts(opts);
+        opts.addDockerOpts("--memory=" + valueToSet);
+        opts.addDockerOpts("--memory-swap=" + valueToSet);
+
+        String neg2InUnsignedLong = "18446744073709551614";
+
+        Common.run(opts)
+            .shouldMatch("Memory Limit is:.*" + expectedTraceValue)
+            // Either for cgroup v1: a_1) same as memory limit, or b_1) -2 on systems with swapaccount=0
+            // Either for cgroup v2: a_2) 0, or b_2) -2 on systems with swapaccount=0
+            .shouldMatch("Memory and Swap Limit is:.*(" + expectedTraceValue + "|-2|0)")
+            .shouldNotMatch("Memory and Swap Limit is:.*" + neg2InUnsignedLong);
+    }
+
 
     // provoke OOM inside the container, see how VM reacts
     private static void testOOM(String dockerMemLimit, int sizeToAllocInMb) throws Exception {
@@ -215,7 +266,10 @@ private static void testOperatingSystemMXBeanAwareness(String memoryAllocation,
         out.shouldHaveExitValue(0)
            .shouldContain("Checking OperatingSystemMXBean")
            .shouldContain("OperatingSystemMXBean.getTotalPhysicalMemorySize: " + expectedMemory)
+           .shouldContain("OperatingSystemMXBean.getTotalMemorySize: " + expectedMemory)
+           .shouldMatch("OperatingSystemMXBean\\.getFreeMemorySize: [1-9][0-9]+")
            .shouldMatch("OperatingSystemMXBean\\.getFreePhysicalMemorySize: [1-9][0-9]+");
+
         // in case of warnings like : "Your kernel does not support swap limit capabilities
         // or the cgroup is not mounted. Memory limited without swap."
         // the getTotalSwapSpaceSize either returns the system (or host) values, or 0
@@ -230,6 +284,7 @@ private static void testOperatingSystemMXBeanAwareness(String memoryAllocation,
             String hostSwap = getHostSwap();
             out.shouldMatch("OperatingSystemMXBean.getTotalSwapSpaceSize: (0|" + hostSwap + ")");
         }
+
         try {
             out.shouldMatch("OperatingSystemMXBean\\.getFreeSwapSpaceSize: [1-9][0-9]+");
         } catch(RuntimeException ex) {
diff --git a/test/hotspot/jtreg/containers/docker/TestMemoryWithCgroupV1.java b/test/hotspot/jtreg/containers/docker/TestMemoryWithCgroupV1.java
@@ -85,8 +85,8 @@ private static void testMemoryLimitWithSwappiness(String dockerMemLimit, String
         // capabilities or the cgroup is not mounted. Memory limited without swap."
         // we only have Memory and Swap Limit is: <huge integer> in the output
         try {
-            if (out.getOutput().contains("memory_and_swap_limit_in_bytes: not supported")) {
-                System.out.println("memory_and_swap_limit_in_bytes not supported, avoiding Memory and Swap Limit check");
+            if (out.getOutput().contains("Memory and Swap Limit is: -2")) {
+                System.out.println("System doesn't seem to allow swap, avoiding Memory and Swap Limit check");
             } else {
                 out.shouldContain("Memory and Swap Limit is: " + expectedReadLimit)
                     .shouldContain(
