--- a/src/hotspot/os/linux/os_linux.cpp Tue Mar 13 11:33:57 2018 +0100
+++ b/src/hotspot/os/linux/os_linux.cpp Thu Mar 15 09:33:36 2018 +0100
@@ -177,20 +177,17 @@
if (OSContainer::is_containerized()) {
jlong mem_limit, mem_usage;
- if ((mem_limit = OSContainer::memory_limit_in_bytes()) > 0) {
- if ((mem_usage = OSContainer::memory_usage_in_bytes()) > 0) {
- if (mem_limit > mem_usage) {
- avail_mem = (julong)mem_limit - (julong)mem_usage;
- } else {
- avail_mem = 0;
- }
- log_trace(os)("available container memory: " JULONG_FORMAT, avail_mem);
- return avail_mem;
- } else {
- log_debug(os,container)("container memory usage call failed: " JLONG_FORMAT, mem_usage);
- }
- } else {
- log_debug(os,container)("container memory unlimited or failed: " JLONG_FORMAT, mem_limit);
+ if ((mem_limit = OSContainer::memory_limit_in_bytes()) < 1) {
+ log_debug(os, container)("container memory limit %s: " JLONG_FORMAT ", using host value",
+ mem_limit == OSCONTAINER_ERROR ? "failed" : "unlimited", mem_limit);
+ }
+ if (mem_limit > 0 && (mem_usage = OSContainer::memory_usage_in_bytes()) < 1) {
+ log_debug(os, container)("container memory usage failed: " JLONG_FORMAT ", using host value", mem_usage);
+ }
+ if (mem_limit > 0 && mem_usage > 0 ) {
+ avail_mem = mem_limit > mem_usage ? (julong)mem_limit - (julong)mem_usage : 0;
+ log_trace(os)("available container memory: " JULONG_FORMAT, avail_mem);
+ return avail_mem;
}
}
@@ -201,22 +198,18 @@
}
julong os::physical_memory() {
+ jlong phys_mem = 0;
if (OSContainer::is_containerized()) {
jlong mem_limit;
if ((mem_limit = OSContainer::memory_limit_in_bytes()) > 0) {
log_trace(os)("total container memory: " JLONG_FORMAT, mem_limit);
- return (julong)mem_limit;
- } else {
- if (mem_limit == OSCONTAINER_ERROR) {
- log_debug(os,container)("container memory limit call failed");
- }
- if (mem_limit == -1) {
- log_debug(os,container)("container memory unlimited, using host value");
- }
+ return mem_limit;
}
- }
-
- jlong phys_mem = Linux::physical_memory();
+ log_debug(os, container)("container memory limit %s: " JLONG_FORMAT ", using host value",
+ mem_limit == OSCONTAINER_ERROR ? "failed" : "unlimited", mem_limit);
+ }
+
+ phys_mem = Linux::physical_memory();
log_trace(os)("total system memory: " JLONG_FORMAT, phys_mem);
return phys_mem;
}
@@ -2135,63 +2128,54 @@
}
void os::Linux::print_container_info(outputStream* st) {
- if (OSContainer::is_containerized()) {
- st->print("container (cgroup) information:\n");
-
- char *p = OSContainer::container_type();
- if (p == NULL)
- st->print("container_type() failed\n");
- else {
- st->print("container_type: %s\n", p);
- }
-
- p = OSContainer::cpu_cpuset_cpus();
- if (p == NULL)
- st->print("cpu_cpuset_cpus() failed\n");
- else {
- st->print("cpu_cpuset_cpus: %s\n", p);
- free(p);
- }
-
- p = OSContainer::cpu_cpuset_memory_nodes();
- if (p == NULL)
- st->print("cpu_memory_nodes() failed\n");
- else {
- st->print("cpu_memory_nodes: %s\n", p);
- free(p);
- }
-
- int i = OSContainer::active_processor_count();
- if (i < 0)
- st->print("active_processor_count() failed\n");
- else
- st->print("active_processor_count: %d\n", i);
-
- i = OSContainer::cpu_quota();
- st->print("cpu_quota: %d\n", i);
-
- i = OSContainer::cpu_period();
- st->print("cpu_period: %d\n", i);
-
- i = OSContainer::cpu_shares();
- st->print("cpu_shares: %d\n", i);
-
- jlong j = OSContainer::memory_limit_in_bytes();
- st->print("memory_limit_in_bytes: " JLONG_FORMAT "\n", j);
-
- j = OSContainer::memory_and_swap_limit_in_bytes();
- st->print("memory_and_swap_limit_in_bytes: " JLONG_FORMAT "\n", j);
-
- j = OSContainer::memory_soft_limit_in_bytes();
- st->print("memory_soft_limit_in_bytes: " JLONG_FORMAT "\n", j);
-
- j = OSContainer::OSContainer::memory_usage_in_bytes();
- st->print("memory_usage_in_bytes: " JLONG_FORMAT "\n", j);
-
- j = OSContainer::OSContainer::memory_max_usage_in_bytes();
- st->print("memory_max_usage_in_bytes: " JLONG_FORMAT "\n", j);
- st->cr();
- }
+ if (!OSContainer::is_containerized()) {
+ return;
+ }
+
+ st->print("container (cgroup) information:\n");
+
+ const char *p_ct = OSContainer::container_type();
+ st->print("container_type: %s\n", p_ct != NULL ? p_ct : "failed");
+
+ char *p = OSContainer::cpu_cpuset_cpus();
+ st->print("cpu_cpuset_cpus: %s\n", p != NULL ? p : "failed");
+ free(p);
+
+ p = OSContainer::cpu_cpuset_memory_nodes();
+ st->print("cpu_memory_nodes: %s\n", p != NULL ? p : "failed");
+ free(p);
+
+ int i = OSContainer::active_processor_count();
+ if (i > 0) {
+ st->print("active_processor_count: %d\n", i);
+ } else {
+ st->print("active_processor_count: failed\n");
+ }
+
+ i = OSContainer::cpu_quota();
+ st->print("cpu_quota: %d\n", i);
+
+ i = OSContainer::cpu_period();
+ st->print("cpu_period: %d\n", i);
+
+ i = OSContainer::cpu_shares();
+ st->print("cpu_shares: %d\n", i);
+
+ jlong j = OSContainer::memory_limit_in_bytes();
+ st->print("memory_limit_in_bytes: " JLONG_FORMAT "\n", j);
+
+ j = OSContainer::memory_and_swap_limit_in_bytes();
+ st->print("memory_and_swap_limit_in_bytes: " JLONG_FORMAT "\n", j);
+
+ j = OSContainer::memory_soft_limit_in_bytes();
+ st->print("memory_soft_limit_in_bytes: " JLONG_FORMAT "\n", j);
+
+ j = OSContainer::OSContainer::memory_usage_in_bytes();
+ st->print("memory_usage_in_bytes: " JLONG_FORMAT "\n", j);
+
+ j = OSContainer::OSContainer::memory_max_usage_in_bytes();
+ st->print("memory_max_usage_in_bytes: " JLONG_FORMAT "\n", j);
+ st->cr();
}
void os::print_memory_info(outputStream* st) {
@@ -3069,10 +3053,12 @@
return res != (uintptr_t) MAP_FAILED;
}
-static address get_stack_commited_bottom(address bottom, size_t size) {
- address nbot = bottom;
- address ntop = bottom + size;
-
+// If there is no page mapped/committed, top (bottom + size) is returned
+static address get_stack_mapped_bottom(address bottom,
+ size_t size,
+ bool committed_only /* must have backing pages */) {
+ // address used to test if the page is mapped/committed
+ address test_addr = bottom + size;
size_t page_sz = os::vm_page_size();
unsigned pages = size / page_sz;
@@ -3084,38 +3070,39 @@
while (imin < imax) {
imid = (imax + imin) / 2;
- nbot = ntop - (imid * page_sz);
+ test_addr = bottom + (imid * page_sz);
// Use a trick with mincore to check whether the page is mapped or not.
// mincore sets vec to 1 if page resides in memory and to 0 if page
// is swapped output but if page we are asking for is unmapped
// it returns -1,ENOMEM
- mincore_return_value = mincore(nbot, page_sz, vec);
-
- if (mincore_return_value == -1) {
- // Page is not mapped go up
- // to find first mapped page
- if (errno != EAGAIN) {
- assert(errno == ENOMEM, "Unexpected mincore errno");
- imax = imid;
+ mincore_return_value = mincore(test_addr, page_sz, vec);
+
+ if (mincore_return_value == -1 || (committed_only && (vec[0] & 0x01) == 0)) {
+ // Page is not mapped/committed go up
+ // to find first mapped/committed page
+ if ((mincore_return_value == -1 && errno != EAGAIN)
+ || (committed_only && (vec[0] & 0x01) == 0)) {
+ assert(mincore_return_value != -1 || errno == ENOMEM, "Unexpected mincore errno");
+
+ imin = imid + 1;
}
} else {
- // Page is mapped go down
- // to find first not mapped page
- imin = imid + 1;
+ // mapped/committed, go down
+ imax= imid;
}
}
- nbot = nbot + page_sz;
-
- // Adjust stack bottom one page up if last checked page is not mapped
- if (mincore_return_value == -1) {
- nbot = nbot + page_sz;
- }
-
- return nbot;
-}
-
+ // Adjust stack bottom one page up if last checked page is not mapped/committed
+ if (mincore_return_value == -1 || (committed_only && (vec[0] & 0x01) == 0)) {
+ assert(mincore_return_value != -1 || (errno != EAGAIN && errno != ENOMEM),
+ "Should not get to here");
+
+ test_addr = test_addr + page_sz;
+ }
+
+ return test_addr;
+}
// Linux uses a growable mapping for the stack, and if the mapping for
// the stack guard pages is not removed when we detach a thread the
@@ -3153,9 +3140,9 @@
if (mincore((address)stack_extent, os::vm_page_size(), vec) == -1) {
// Fallback to slow path on all errors, including EAGAIN
- stack_extent = (uintptr_t) get_stack_commited_bottom(
- os::Linux::initial_thread_stack_bottom(),
- (size_t)addr - stack_extent);
+ stack_extent = (uintptr_t) get_stack_mapped_bottom(os::Linux::initial_thread_stack_bottom(),
+ (size_t)addr - stack_extent,
+ false /* committed_only */);
}
if (stack_extent < (uintptr_t)addr) {
@@ -3182,6 +3169,11 @@
return os::uncommit_memory(addr, size);
}
+size_t os::committed_stack_size(address bottom, size_t size) {
+ address bot = get_stack_mapped_bottom(bottom, size, true /* committed_only */);
+ return size_t(bottom + size - bot);
+}
+
// If 'fixed' is true, anon_mmap() will attempt to reserve anonymous memory
// at 'requested_addr'. If there are existing memory mappings at the same
// location, however, they will be overwritten. If 'fixed' is false,