diff --git a/.gitignore b/.gitignore index a1f0faf..2006cc1 100644 --- a/.gitignore +++ b/.gitignore @@ -112,3 +112,5 @@ /aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u171-b10.tar.xz /aarch64-port-jdk8u-aarch64-jdk8u172-b11.tar.xz /aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u172-b11--shenandoah-merge-2018-05-15.tar.xz +/aarch64-port-jdk8u-aarch64-jdk8u181-b13.tar.xz +/aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u181-b13.tar.xz diff --git a/8075942-pr3602-rh1582032.patch b/8075942-pr3602-rh1582032.patch new file mode 100644 index 0000000..bd2a40e --- /dev/null +++ b/8075942-pr3602-rh1582032.patch @@ -0,0 +1,95 @@ +# HG changeset patch +# User prr +# Date 1429299166 25200 +# Fri Apr 17 12:32:46 2015 -0700 +# Node ID 1f4b038b9550afaf88a70cee4cf9c1422ecd86d6 +# Parent 533117ae5b7587c8d9c0612581682ab984475430 +8075942, PR3602: ArrayIndexOutOfBoundsException in sun.java2d.pisces.Dasher.goTo +Reviewed-by: flar, lbourges + +diff --git openjdk.orig/jdk/src/share/classes/sun/java2d/pisces/Dasher.java openjdk/jdk/src/share/classes/sun/java2d/pisces/Dasher.java +--- openjdk.orig/jdk/src/share/classes/sun/java2d/pisces/Dasher.java ++++ openjdk/jdk/src/share/classes/sun/java2d/pisces/Dasher.java +@@ -146,7 +146,7 @@ + if (dashOn) { + if (starting) { + firstSegmentsBuffer = Helpers.widenArray(firstSegmentsBuffer, +- firstSegidx, type - 2); ++ firstSegidx, type - 2 + 1); + firstSegmentsBuffer[firstSegidx++] = type; + System.arraycopy(pts, off, firstSegmentsBuffer, firstSegidx, type - 2); + firstSegidx += type - 2; +diff --git a/test/javopenjdk.orig/jdk/awt/BasicStroke/DashStrokeTest.java openjdk/jdk/test/java/awt/BasicStroke/DashStrokeTest.java +new file mode 100644 +--- /dev/null ++++ openjdk/jdk/test/java/awt/BasicStroke/DashStrokeTest.java +@@ -0,0 +1,69 @@ ++/* ++ * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ * @test ++ * @bug 8075942 ++ * @summary test there is no exception rendering a dashed stroke ++ * @run DashStrokeTest ++ * @run -Dsun.java2d.renderer=sun.java2d.pisces.PiscesRenderingEngine ++ */ ++ ++import java.awt.BasicStroke; ++import java.awt.Color; ++import java.awt.Graphics2D; ++import java.awt.Stroke; ++import java.awt.geom.GeneralPath; ++import java.awt.image.BufferedImage; ++ ++ ++public class DashStrokeTest { ++ ++ public static void main(String[] args) { ++ ++ GeneralPath shape = new GeneralPath(); ++ int[] pointTypes = {0, 0, 1, 1, 0, 1, 1, 0}; ++ double[] xpoints = {428, 420, 400, 400, 400, 400, 420, 733}; ++ double[] ypoints = {180, 180, 180, 160, 30, 10, 10, 10}; ++ shape.moveTo(xpoints[0], ypoints[0]); ++ for (int i = 1; i < pointTypes.length; i++) { ++ if (pointTypes[i] == 1 && i < pointTypes.length - 1) { ++ shape.quadTo(xpoints[i], ypoints[i], ++ xpoints[i + 1], ypoints[i + 1]); ++ } else { ++ shape.lineTo(xpoints[i], ypoints[i]); ++ } ++ } ++ ++ BufferedImage image = new ++ BufferedImage(1000, 1000, BufferedImage.TYPE_INT_ARGB); ++ Graphics2D g2 = image.createGraphics(); ++ ++ Color color = new Color(124, 0, 124, 255); ++ g2.setColor(color); ++ Stroke stroke = new BasicStroke(1.0f, ++ BasicStroke.CAP_BUTT, ++ BasicStroke.JOIN_BEVEL, ++ 10.0f, new float[] {9, 6}, 0.0f); ++ g2.setStroke(stroke); ++ g2.draw(shape); ++ } ++} diff --git a/8146115-pr3508-rh1463098.patch b/8146115-pr3508-rh1463098.patch new file mode 100644 index 0000000..a04728b --- /dev/null +++ b/8146115-pr3508-rh1463098.patch @@ -0,0 +1,1494 @@ +# HG changeset patch +# User poonam +# Date 1530903013 0 +# Fri Jul 06 18:50:13 2018 +0000 +# Node ID 2f2d2af6fa5c44e67e0a9987f56392315a1e4b64 +# Parent 95b72537801cc9946c27ad27f07e3f0790a21b08 +8146115, PR3508, RH1463098: Improve docker container detection and resource configuration usage +Reviewed-by: bobv, dbuck + +diff --git openjdk.orig/hotspot/src/os/aix/vm/os_aix.cpp openjdk/hotspot/src/os/aix/vm/os_aix.cpp +--- openjdk.orig/hotspot/src/os/aix/vm/os_aix.cpp ++++ openjdk/hotspot/src/os/aix/vm/os_aix.cpp +@@ -4008,6 +4008,16 @@ + }; + + int os::active_processor_count() { ++ // User has overridden the number of active processors ++ if (ActiveProcessorCount > 0) { ++ if (PrintActiveCpus) { ++ tty->print_cr("active_processor_count: " ++ "active processor count set by user : %d", ++ ActiveProcessorCount); ++ } ++ return ActiveProcessorCount; ++ } ++ + int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN); + assert(online_cpus > 0 && online_cpus <= processor_count(), "sanity check"); + return online_cpus; +diff --git openjdk.orig/hotspot/src/os/bsd/vm/os_bsd.cpp openjdk/hotspot/src/os/bsd/vm/os_bsd.cpp +--- openjdk.orig/hotspot/src/os/bsd/vm/os_bsd.cpp ++++ openjdk/hotspot/src/os/bsd/vm/os_bsd.cpp +@@ -3770,6 +3770,16 @@ + }; + + int os::active_processor_count() { ++ // User has overridden the number of active processors ++ if (ActiveProcessorCount > 0) { ++ if (PrintActiveCpus) { ++ tty->print_cr("active_processor_count: " ++ "active processor count set by user : %d", ++ ActiveProcessorCount); ++ } ++ return ActiveProcessorCount; ++ } ++ + return _processor_count; + } + +diff --git openjdk.orig/hotspot/src/os/linux/vm/globals_linux.hpp openjdk/hotspot/src/os/linux/vm/globals_linux.hpp +--- openjdk.orig/hotspot/src/os/linux/vm/globals_linux.hpp ++++ openjdk/hotspot/src/os/linux/vm/globals_linux.hpp +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 2005, 2016, Oracle and/or its affiliates. All rights reserved. ++ * Copyright (c) 2005, 2018, 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 +@@ -49,8 +49,13 @@ + product(bool, UseSHM, false, \ + "Use SYSV shared memory for large pages") \ + \ +- diagnostic(bool, PrintActiveCpus, false, \ +- "Print the number of CPUs detected in os::active_processor_count") ++ product(bool, UseContainerSupport, true, \ ++ "Enable detection and runtime container configuration support") \ ++ \ ++ product(bool, PreferContainerQuotaForCPUCount, true, \ ++ "Calculate the container CPU availability based on the value" \ ++ " of quotas (if set), when true. Otherwise, use the CPU" \ ++ " shares value, provided it is less than quota.") + + // + // Defines Linux-specific default values. The flags are available on all +diff --git openjdk.orig/hotspot/src/os/linux/vm/osContainer_linux.cpp openjdk/hotspot/src/os/linux/vm/osContainer_linux.cpp +new file mode 100644 +--- /dev/null ++++ openjdk/hotspot/src/os/linux/vm/osContainer_linux.cpp +@@ -0,0 +1,680 @@ ++/* ++ * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++#include ++#include ++#include ++#include "utilities/globalDefinitions.hpp" ++#include "memory/allocation.hpp" ++#include "runtime/os.hpp" ++#include "osContainer_linux.hpp" ++ ++#define PER_CPU_SHARES 1024 ++ ++bool OSContainer::_is_initialized = false; ++bool OSContainer::_is_containerized = false; ++julong _unlimited_memory; ++ ++class CgroupSubsystem: CHeapObj { ++ friend class OSContainer; ++ ++ private: ++ /* mountinfo contents */ ++ char *_root; ++ char *_mount_point; ++ ++ /* Constructed subsystem directory */ ++ char *_path; ++ ++ public: ++ CgroupSubsystem(char *root, char *mountpoint) { ++ _root = os::strdup(root); ++ _mount_point = os::strdup(mountpoint); ++ _path = NULL; ++ } ++ ++ /* ++ * Set directory to subsystem specific files based ++ * on the contents of the mountinfo and cgroup files. ++ */ ++ void set_subsystem_path(char *cgroup_path) { ++ char buf[MAXPATHLEN+1]; ++ if (_root != NULL && cgroup_path != NULL) { ++ if (strcmp(_root, "/") == 0) { ++ int buflen; ++ strncpy(buf, _mount_point, MAXPATHLEN); ++ buf[MAXPATHLEN-1] = '\0'; ++ if (strcmp(cgroup_path,"/") != 0) { ++ buflen = strlen(buf); ++ if ((buflen + strlen(cgroup_path)) > (MAXPATHLEN-1)) { ++ return; ++ } ++ strncat(buf, cgroup_path, MAXPATHLEN-buflen); ++ buf[MAXPATHLEN-1] = '\0'; ++ } ++ _path = os::strdup(buf); ++ } else { ++ if (strcmp(_root, cgroup_path) == 0) { ++ strncpy(buf, _mount_point, MAXPATHLEN); ++ buf[MAXPATHLEN-1] = '\0'; ++ _path = os::strdup(buf); ++ } else { ++ char *p = strstr(_root, cgroup_path); ++ if (p != NULL && p == _root) { ++ if (strlen(cgroup_path) > strlen(_root)) { ++ int buflen; ++ strncpy(buf, _mount_point, MAXPATHLEN); ++ buf[MAXPATHLEN-1] = '\0'; ++ buflen = strlen(buf); ++ if ((buflen + strlen(cgroup_path)) > (MAXPATHLEN-1)) { ++ return; ++ } ++ strncat(buf, cgroup_path + strlen(_root), MAXPATHLEN-buflen); ++ buf[MAXPATHLEN-1] = '\0'; ++ _path = os::strdup(buf); ++ } ++ } ++ } ++ } ++ } ++ } ++ ++ char *subsystem_path() { return _path; } ++}; ++ ++CgroupSubsystem* memory = NULL; ++CgroupSubsystem* cpuset = NULL; ++CgroupSubsystem* cpu = NULL; ++CgroupSubsystem* cpuacct = NULL; ++ ++typedef char * cptr; ++ ++PRAGMA_DIAG_PUSH ++PRAGMA_FORMAT_NONLITERAL_IGNORED ++template int subsystem_file_contents(CgroupSubsystem* c, ++ const char *filename, ++ const char *scan_fmt, ++ T returnval) { ++ FILE *fp = NULL; ++ char *p; ++ char file[MAXPATHLEN+1]; ++ char buf[MAXPATHLEN+1]; ++ ++ if (c == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("subsystem_file_contents: CgroupSubsytem* is NULL"); ++ } ++ return OSCONTAINER_ERROR; ++ } ++ if (c->subsystem_path() == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("subsystem_file_contents: subsystem path is NULL"); ++ } ++ return OSCONTAINER_ERROR; ++ } ++ ++ strncpy(file, c->subsystem_path(), MAXPATHLEN); ++ file[MAXPATHLEN-1] = '\0'; ++ int filelen = strlen(file); ++ if ((filelen + strlen(filename)) > (MAXPATHLEN-1)) { ++ if (PrintContainerInfo) { ++ tty->print_cr("File path too long %s, %s", file, filename); ++ } ++ return OSCONTAINER_ERROR; ++ } ++ strncat(file, filename, MAXPATHLEN-filelen); ++ if (PrintContainerInfo) { ++ tty->print_cr("Path to %s is %s", filename, file); ++ } ++ fp = fopen(file, "r"); ++ if (fp != NULL) { ++ p = fgets(buf, MAXPATHLEN, fp); ++ if (p != NULL) { ++ int matched = sscanf(p, scan_fmt, returnval); ++ if (matched == 1) { ++ fclose(fp); ++ return 0; ++ } else { ++ if (PrintContainerInfo) { ++ tty->print_cr("Type %s not found in file %s", scan_fmt, file); ++ } ++ } ++ } else { ++ if (PrintContainerInfo) { ++ tty->print_cr("Empty file %s", file); ++ } ++ } ++ } else { ++ if (PrintContainerInfo) { ++ tty->print_cr("Open of file %s failed, %s", file, strerror(errno)); ++ } ++ } ++ if (fp != NULL) ++ fclose(fp); ++ return OSCONTAINER_ERROR; ++} ++PRAGMA_DIAG_POP ++ ++#define GET_CONTAINER_INFO(return_type, subsystem, filename, \ ++ logstring, scan_fmt, variable) \ ++ return_type variable; \ ++{ \ ++ int err; \ ++ err = subsystem_file_contents(subsystem, \ ++ filename, \ ++ scan_fmt, \ ++ &variable); \ ++ if (err != 0) \ ++ return (return_type) OSCONTAINER_ERROR; \ ++ \ ++ if (PrintContainerInfo) \ ++ tty->print_cr(logstring, variable); \ ++} ++ ++#define GET_CONTAINER_INFO_CPTR(return_type, subsystem, filename, \ ++ logstring, scan_fmt, variable, bufsize) \ ++ char variable[bufsize]; \ ++{ \ ++ int err; \ ++ err = subsystem_file_contents(subsystem, \ ++ filename, \ ++ scan_fmt, \ ++ variable); \ ++ if (err != 0) \ ++ return (return_type) NULL; \ ++ \ ++ if (PrintContainerInfo) \ ++ tty->print_cr(logstring, variable); \ ++} ++ ++/* init ++ * ++ * Initialize the container support and determine if ++ * we are running under cgroup control. ++ */ ++void OSContainer::init() { ++ int mountid; ++ int parentid; ++ int major; ++ int minor; ++ FILE *mntinfo = NULL; ++ FILE *cgroup = NULL; ++ char buf[MAXPATHLEN+1]; ++ char tmproot[MAXPATHLEN+1]; ++ char tmpmount[MAXPATHLEN+1]; ++ char tmpbase[MAXPATHLEN+1]; ++ char *p; ++ jlong mem_limit; ++ ++ assert(!_is_initialized, "Initializing OSContainer more than once"); ++ ++ _is_initialized = true; ++ _is_containerized = false; ++ ++ _unlimited_memory = (LONG_MAX / os::vm_page_size()) * os::vm_page_size(); ++ ++ if (PrintContainerInfo) { ++ tty->print_cr("OSContainer::init: Initializing Container Support"); ++ } ++ if (!UseContainerSupport) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Container Support not enabled"); ++ } ++ return; ++ } ++ ++ /* ++ * Find the cgroup mount point for memory and cpuset ++ * by reading /proc/self/mountinfo ++ * ++ * Example for docker: ++ * 219 214 0:29 /docker/7208cebd00fa5f2e342b1094f7bed87fa25661471a4637118e65f1c995be8a34 /sys/fs/cgroup/memory ro,nosuid,nodev,noexec,relatime - cgroup cgroup rw,memory ++ * ++ * Example for host: ++ * 34 28 0:29 / /sys/fs/cgroup/memory rw,nosuid,nodev,noexec,relatime shared:16 - cgroup cgroup rw,memory ++ */ ++ mntinfo = fopen("/proc/self/mountinfo", "r"); ++ if (mntinfo == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Can't open /proc/self/mountinfo, %s", ++ strerror(errno)); ++ } ++ return; ++ } ++ ++ while ( (p = fgets(buf, MAXPATHLEN, mntinfo)) != NULL) { ++ // Look for the filesystem type and see if it's cgroup ++ char fstype[MAXPATHLEN+1]; ++ fstype[0] = '\0'; ++ char *s = strstr(p, " - "); ++ if (s != NULL && ++ sscanf(s, " - %s", fstype) == 1 && ++ strcmp(fstype, "cgroup") == 0) { ++ ++ if (strstr(p, "memory") != NULL) { ++ int matched = sscanf(p, "%d %d %d:%d %s %s", ++ &mountid, ++ &parentid, ++ &major, ++ &minor, ++ tmproot, ++ tmpmount); ++ if (matched == 6) { ++ memory = new CgroupSubsystem(tmproot, tmpmount); ++ } ++ else ++ if (PrintContainerInfo) { ++ tty->print_cr("Incompatible str containing cgroup and memory: %s", p); ++ } ++ } else if (strstr(p, "cpuset") != NULL) { ++ int matched = sscanf(p, "%d %d %d:%d %s %s", ++ &mountid, ++ &parentid, ++ &major, ++ &minor, ++ tmproot, ++ tmpmount); ++ if (matched == 6) { ++ cpuset = new CgroupSubsystem(tmproot, tmpmount); ++ } ++ else { ++ if (PrintContainerInfo) { ++ tty->print_cr("Incompatible str containing cgroup and cpuset: %s", p); ++ } ++ } ++ } else if (strstr(p, "cpu,cpuacct") != NULL || strstr(p, "cpuacct,cpu") != NULL) { ++ int matched = sscanf(p, "%d %d %d:%d %s %s", ++ &mountid, ++ &parentid, ++ &major, ++ &minor, ++ tmproot, ++ tmpmount); ++ if (matched == 6) { ++ cpu = new CgroupSubsystem(tmproot, tmpmount); ++ cpuacct = new CgroupSubsystem(tmproot, tmpmount); ++ } ++ else { ++ if (PrintContainerInfo) { ++ tty->print_cr("Incompatible str containing cgroup and cpu,cpuacct: %s", p); ++ } ++ } ++ } else if (strstr(p, "cpuacct") != NULL) { ++ int matched = sscanf(p, "%d %d %d:%d %s %s", ++ &mountid, ++ &parentid, ++ &major, ++ &minor, ++ tmproot, ++ tmpmount); ++ if (matched == 6) { ++ cpuacct = new CgroupSubsystem(tmproot, tmpmount); ++ } ++ else { ++ if (PrintContainerInfo) { ++ tty->print_cr("Incompatible str containing cgroup and cpuacct: %s", p); ++ } ++ } ++ } else if (strstr(p, "cpu") != NULL) { ++ int matched = sscanf(p, "%d %d %d:%d %s %s", ++ &mountid, ++ &parentid, ++ &major, ++ &minor, ++ tmproot, ++ tmpmount); ++ if (matched == 6) { ++ cpu = new CgroupSubsystem(tmproot, tmpmount); ++ } ++ else { ++ if (PrintContainerInfo) { ++ tty->print_cr("Incompatible str containing cgroup and cpu: %s", p); ++ } ++ } ++ } ++ } ++ } ++ ++ fclose(mntinfo); ++ ++ if (memory == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Required cgroup memory subsystem not found"); ++ } ++ return; ++ } ++ if (cpuset == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Required cgroup cpuset subsystem not found"); ++ } ++ return; ++ } ++ if (cpu == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Required cgroup cpu subsystem not found"); ++ } ++ return; ++ } ++ if (cpuacct == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Required cgroup cpuacct subsystem not found"); ++ } ++ return; ++ } ++ ++ /* ++ * Read /proc/self/cgroup and map host mount point to ++ * local one via /proc/self/mountinfo content above ++ * ++ * Docker example: ++ * 5:memory:/docker/6558aed8fc662b194323ceab5b964f69cf36b3e8af877a14b80256e93aecb044 ++ * ++ * Host example: ++ * 5:memory:/user.slice ++ * ++ * Construct a path to the process specific memory and cpuset ++ * cgroup directory. ++ * ++ * For a container running under Docker from memory example above ++ * the paths would be: ++ * ++ * /sys/fs/cgroup/memory ++ * ++ * For a Host from memory example above the path would be: ++ * ++ * /sys/fs/cgroup/memory/user.slice ++ * ++ */ ++ cgroup = fopen("/proc/self/cgroup", "r"); ++ if (cgroup == NULL) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Can't open /proc/self/cgroup, %s", ++ strerror(errno)); ++ } ++ return; ++ } ++ ++ while ( (p = fgets(buf, MAXPATHLEN, cgroup)) != NULL) { ++ int cgno; ++ int matched; ++ char *controller; ++ char *base; ++ ++ /* Skip cgroup number */ ++ strsep(&p, ":"); ++ /* Get controller and base */ ++ controller = strsep(&p, ":"); ++ base = strsep(&p, "\n"); ++ ++ if (controller != NULL) { ++ if (strstr(controller, "memory") != NULL) { ++ memory->set_subsystem_path(base); ++ } else if (strstr(controller, "cpuset") != NULL) { ++ cpuset->set_subsystem_path(base); ++ } else if (strstr(controller, "cpu,cpuacct") != NULL || strstr(controller, "cpuacct,cpu") != NULL) { ++ cpu->set_subsystem_path(base); ++ cpuacct->set_subsystem_path(base); ++ } else if (strstr(controller, "cpuacct") != NULL) { ++ cpuacct->set_subsystem_path(base); ++ } else if (strstr(controller, "cpu") != NULL) { ++ cpu->set_subsystem_path(base); ++ } ++ } ++ } ++ ++ fclose(cgroup); ++ ++ // We need to update the amount of physical memory now that ++ // command line arguments have been processed. ++ if ((mem_limit = memory_limit_in_bytes()) > 0) { ++ os::Linux::set_physical_memory(mem_limit); ++ } ++ ++ _is_containerized = true; ++ ++} ++ ++const char * OSContainer::container_type() { ++ if (is_containerized()) { ++ return "cgroupv1"; ++ } else { ++ return NULL; ++ } ++} ++ ++ ++/* memory_limit_in_bytes ++ * ++ * Return the limit of available memory for this process. ++ * ++ * return: ++ * memory limit in bytes or ++ * -1 for unlimited ++ * OSCONTAINER_ERROR for not supported ++ */ ++jlong OSContainer::memory_limit_in_bytes() { ++ GET_CONTAINER_INFO(julong, memory, "/memory.limit_in_bytes", ++ "Memory Limit is: " JULONG_FORMAT, JULONG_FORMAT, memlimit); ++ ++ if (memlimit >= _unlimited_memory) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Memory Limit is: Unlimited"); ++ } ++ return (jlong)-1; ++ } ++ else { ++ return (jlong)memlimit; ++ } ++} ++ ++jlong OSContainer::memory_and_swap_limit_in_bytes() { ++ GET_CONTAINER_INFO(julong, memory, "/memory.memsw.limit_in_bytes", ++ "Memory and Swap Limit is: " JULONG_FORMAT, JULONG_FORMAT, memswlimit); ++ if (memswlimit >= _unlimited_memory) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Memory and Swap Limit is: Unlimited"); ++ } ++ return (jlong)-1; ++ } else { ++ return (jlong)memswlimit; ++ } ++} ++ ++jlong OSContainer::memory_soft_limit_in_bytes() { ++ GET_CONTAINER_INFO(julong, memory, "/memory.soft_limit_in_bytes", ++ "Memory Soft Limit is: " JULONG_FORMAT, JULONG_FORMAT, memsoftlimit); ++ if (memsoftlimit >= _unlimited_memory) { ++ if (PrintContainerInfo) { ++ tty->print_cr("Memory Soft Limit is: Unlimited"); ++ } ++ return (jlong)-1; ++ } else { ++ return (jlong)memsoftlimit; ++ } ++} ++ ++/* memory_usage_in_bytes ++ * ++ * Return the amount of used memory for this process. ++ * ++ * return: ++ * memory usage in bytes or ++ * -1 for unlimited ++ * OSCONTAINER_ERROR for not supported ++ */ ++jlong OSContainer::memory_usage_in_bytes() { ++ GET_CONTAINER_INFO(jlong, memory, "/memory.usage_in_bytes", ++ "Memory Usage is: " JLONG_FORMAT, JLONG_FORMAT, memusage); ++ return memusage; ++} ++ ++/* memory_max_usage_in_bytes ++ * ++ * Return the maximum amount of used memory for this process. ++ * ++ * return: ++ * max memory usage in bytes or ++ * OSCONTAINER_ERROR for not supported ++ */ ++jlong OSContainer::memory_max_usage_in_bytes() { ++ GET_CONTAINER_INFO(jlong, memory, "/memory.max_usage_in_bytes", ++ "Maximum Memory Usage is: " JLONG_FORMAT, JLONG_FORMAT, memmaxusage); ++ return memmaxusage; ++} ++ ++/* active_processor_count ++ * ++ * Calculate an appropriate number of active processors for the ++ * VM to use based on these three inputs. ++ * ++ * cpu affinity ++ * cgroup cpu quota & cpu period ++ * cgroup cpu shares ++ * ++ * Algorithm: ++ * ++ * Determine the number of available CPUs from sched_getaffinity ++ * ++ * If user specified a quota (quota != -1), calculate the number of ++ * required CPUs by dividing quota by period. ++ * ++ * If shares are in effect (shares != -1), calculate the number ++ * of CPUs required for the shares by dividing the share value ++ * by PER_CPU_SHARES. ++ * ++ * All results of division are rounded up to the next whole number. ++ * ++ * If neither shares or quotas have been specified, return the ++ * number of active processors in the system. ++ * ++ * If both shares and quotas have been specified, the results are ++ * based on the flag PreferContainerQuotaForCPUCount. If true, ++ * return the quota value. If false return the smallest value ++ * between shares or quotas. ++ * ++ * If shares and/or quotas have been specified, the resulting number ++ * returned will never exceed the number of active processors. ++ * ++ * return: ++ * number of CPUs ++ */ ++int OSContainer::active_processor_count() { ++ int quota_count = 0, share_count = 0; ++ int cpu_count, limit_count; ++ int result; ++ ++ cpu_count = limit_count = os::Linux::active_processor_count(); ++ int quota = cpu_quota(); ++ int period = cpu_period(); ++ int share = cpu_shares(); ++ ++ if (quota > -1 && period > 0) { ++ quota_count = ceilf((float)quota / (float)period); ++ if (PrintContainerInfo) { ++ tty->print_cr("CPU Quota count based on quota/period: %d", quota_count); ++ } ++ } ++ if (share > -1) { ++ share_count = ceilf((float)share / (float)PER_CPU_SHARES); ++ if (PrintContainerInfo) { ++ tty->print_cr("CPU Share count based on shares: %d", share_count); ++ } ++ } ++ ++ // If both shares and quotas are setup results depend ++ // on flag PreferContainerQuotaForCPUCount. ++ // If true, limit CPU count to quota ++ // If false, use minimum of shares and quotas ++ if (quota_count !=0 && share_count != 0) { ++ if (PreferContainerQuotaForCPUCount) { ++ limit_count = quota_count; ++ } else { ++ limit_count = MIN2(quota_count, share_count); ++ } ++ } else if (quota_count != 0) { ++ limit_count = quota_count; ++ } else if (share_count != 0) { ++ limit_count = share_count; ++ } ++ ++ result = MIN2(cpu_count, limit_count); ++ if (PrintContainerInfo) { ++ tty->print_cr("OSContainer::active_processor_count: %d", result); ++ } ++ return result; ++} ++ ++char * OSContainer::cpu_cpuset_cpus() { ++ GET_CONTAINER_INFO_CPTR(cptr, cpuset, "/cpuset.cpus", ++ "cpuset.cpus is: %s", "%1023s", cpus, 1024); ++ return os::strdup(cpus); ++} ++ ++char * OSContainer::cpu_cpuset_memory_nodes() { ++ GET_CONTAINER_INFO_CPTR(cptr, cpuset, "/cpuset.mems", ++ "cpuset.mems is: %s", "%1023s", mems, 1024); ++ return os::strdup(mems); ++} ++ ++/* cpu_quota ++ * ++ * Return the number of milliseconds per period ++ * process is guaranteed to run. ++ * ++ * return: ++ * quota time in milliseconds ++ * -1 for no quota ++ * OSCONTAINER_ERROR for not supported ++ */ ++int OSContainer::cpu_quota() { ++ GET_CONTAINER_INFO(int, cpu, "/cpu.cfs_quota_us", ++ "CPU Quota is: %d", "%d", quota); ++ return quota; ++} ++ ++int OSContainer::cpu_period() { ++ GET_CONTAINER_INFO(int, cpu, "/cpu.cfs_period_us", ++ "CPU Period is: %d", "%d", period); ++ return period; ++} ++ ++/* cpu_shares ++ * ++ * Return the amount of cpu shares available to the process ++ * ++ * return: ++ * Share number (typically a number relative to 1024) ++ * (2048 typically expresses 2 CPUs worth of processing) ++ * -1 for no share setup ++ * OSCONTAINER_ERROR for not supported ++ */ ++int OSContainer::cpu_shares() { ++ GET_CONTAINER_INFO(int, cpu, "/cpu.shares", ++ "CPU Shares is: %d", "%d", shares); ++ // Convert 1024 to no shares setup ++ if (shares == 1024) return -1; ++ ++ return shares; ++} ++ +diff --git openjdk.orig/hotspot/src/os/linux/vm/osContainer_linux.hpp openjdk/hotspot/src/os/linux/vm/osContainer_linux.hpp +new file mode 100644 +--- /dev/null ++++ openjdk/hotspot/src/os/linux/vm/osContainer_linux.hpp +@@ -0,0 +1,68 @@ ++/* ++ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. ++ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. ++ * ++ * This code is free software; you can redistribute it and/or modify it ++ * under the terms of the GNU General Public License version 2 only, as ++ * published by the Free Software Foundation. ++ * ++ * This code is distributed in the hope that it will be useful, but WITHOUT ++ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or ++ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ++ * version 2 for more details (a copy is included in the LICENSE file that ++ * accompanied this code). ++ * ++ * You should have received a copy of the GNU General Public License version ++ * 2 along with this work; if not, write to the Free Software Foundation, ++ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. ++ * ++ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA ++ * or visit www.oracle.com if you need additional information or have any ++ * questions. ++ * ++ */ ++ ++#ifndef OS_LINUX_VM_OSCONTAINER_LINUX_HPP ++#define OS_LINUX_VM_OSCONTAINER_LINUX_HPP ++ ++#include "utilities/globalDefinitions.hpp" ++#include "utilities/macros.hpp" ++#include "memory/allocation.hpp" ++ ++#define OSCONTAINER_ERROR (-2) ++ ++class OSContainer: AllStatic { ++ ++ private: ++ static bool _is_initialized; ++ static bool _is_containerized; ++ ++ public: ++ static void init(); ++ static inline bool is_containerized(); ++ static const char * container_type(); ++ ++ static jlong memory_limit_in_bytes(); ++ static jlong memory_and_swap_limit_in_bytes(); ++ static jlong memory_soft_limit_in_bytes(); ++ static jlong memory_usage_in_bytes(); ++ static jlong memory_max_usage_in_bytes(); ++ ++ static int active_processor_count(); ++ ++ static char * cpu_cpuset_cpus(); ++ static char * cpu_cpuset_memory_nodes(); ++ ++ static int cpu_quota(); ++ static int cpu_period(); ++ ++ static int cpu_shares(); ++ ++}; ++ ++inline bool OSContainer::is_containerized() { ++ assert(_is_initialized, "OSContainer not initialized"); ++ return _is_containerized; ++} ++ ++#endif // OS_LINUX_VM_OSCONTAINER_LINUX_HPP +diff --git openjdk.orig/hotspot/src/os/linux/vm/os_linux.cpp openjdk/hotspot/src/os/linux/vm/os_linux.cpp +--- openjdk.orig/hotspot/src/os/linux/vm/os_linux.cpp ++++ openjdk/hotspot/src/os/linux/vm/os_linux.cpp +@@ -37,6 +37,7 @@ + #include "mutex_linux.inline.hpp" + #include "oops/oop.inline.hpp" + #include "os_share_linux.hpp" ++#include "osContainer_linux.hpp" + #include "prims/jniFastGetField.hpp" + #include "prims/jvm.h" + #include "prims/jvm_misc.hpp" +@@ -179,13 +180,62 @@ + julong os::Linux::available_memory() { + // values in struct sysinfo are "unsigned long" + struct sysinfo si; ++ julong avail_mem; ++ ++ if (OSContainer::is_containerized()) { ++ jlong mem_limit, mem_usage; ++ if ((mem_limit = OSContainer::memory_limit_in_bytes()) < 1) { ++ if (PrintContainerInfo) { ++ tty->print_cr("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) { ++ if (PrintContainerInfo) { ++ tty->print_cr("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; ++ if (PrintContainerInfo) { ++ tty->print_cr("available container memory: " JULONG_FORMAT, avail_mem); ++ } ++ return avail_mem; ++ } ++ } ++ + sysinfo(&si); +- +- return (julong)si.freeram * si.mem_unit; ++ avail_mem = (julong)si.freeram * si.mem_unit; ++ if (Verbose) { ++ tty->print_cr("available memory: " JULONG_FORMAT, avail_mem); ++ } ++ return avail_mem; + } + + julong os::physical_memory() { +- return Linux::physical_memory(); ++ jlong phys_mem = 0; ++ if (OSContainer::is_containerized()) { ++ jlong mem_limit; ++ if ((mem_limit = OSContainer::memory_limit_in_bytes()) > 0) { ++ if (PrintContainerInfo) { ++ tty->print_cr("total container memory: " JLONG_FORMAT, mem_limit); ++ } ++ return mem_limit; ++ } ++ ++ if (PrintContainerInfo) { ++ tty->print_cr("container memory limit %s: " JLONG_FORMAT ", using host value", ++ mem_limit == OSCONTAINER_ERROR ? "failed" : "unlimited", mem_limit); ++ } ++ } ++ ++ phys_mem = Linux::physical_memory(); ++ if (Verbose) { ++ tty->print_cr("total system memory: " JLONG_FORMAT, phys_mem); ++ } ++ return phys_mem; + } + + //////////////////////////////////////////////////////////////////////////////// +@@ -2129,6 +2179,8 @@ + os::Posix::print_load_average(st); + + os::Linux::print_full_memory_info(st); ++ ++ os::Linux::print_container_info(st); + } + + // Try to identify popular distros. +@@ -2194,6 +2246,57 @@ + st->cr(); + } + ++void os::Linux::print_container_info(outputStream* st) { ++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) { + + st->print("Memory:"); +@@ -4966,6 +5069,10 @@ + } + } + ++void os::pd_init_container_support() { ++ OSContainer::init(); ++} ++ + // this is called _after_ the global arguments have been parsed + jint os::init_2(void) + { +@@ -5146,7 +5253,7 @@ + // sched_getaffinity gives an accurate answer as it accounts for cpusets. + // If anything goes wrong we fallback to returning the number of online + // processors - which can be greater than the number available to the process. +-int os::active_processor_count() { ++int os::Linux::active_processor_count() { + cpu_set_t cpus; // can represent at most 1024 (CPU_SETSIZE) processors + int cpus_size = sizeof(cpu_set_t); + int cpu_count = 0; +@@ -5164,10 +5271,48 @@ + "which may exceed available processors", strerror(errno), cpu_count); + } + +- assert(cpu_count > 0 && cpu_count <= processor_count(), "sanity check"); ++ assert(cpu_count > 0 && cpu_count <= os::processor_count(), "sanity check"); + return cpu_count; + } + ++// Determine the active processor count from one of ++// three different sources: ++// ++// 1. User option -XX:ActiveProcessorCount ++// 2. kernel os calls (sched_getaffinity or sysconf(_SC_NPROCESSORS_ONLN) ++// 3. extracted from cgroup cpu subsystem (shares and quotas) ++// ++// Option 1, if specified, will always override. ++// If the cgroup subsystem is active and configured, we ++// will return the min of the cgroup and option 2 results. ++// This is required since tools, such as numactl, that ++// alter cpu affinity do not update cgroup subsystem ++// cpuset configuration files. ++int os::active_processor_count() { ++ // User has overridden the number of active processors ++ if (ActiveProcessorCount > 0) { ++ if (PrintActiveCpus) { ++ tty->print_cr("active_processor_count: " ++ "active processor count set by user : %d", ++ ActiveProcessorCount); ++ } ++ return ActiveProcessorCount; ++ } ++ ++ int active_cpus; ++ if (OSContainer::is_containerized()) { ++ active_cpus = OSContainer::active_processor_count(); ++ if (PrintActiveCpus) { ++ tty->print_cr("active_processor_count: determined by OSContainer: %d", ++ active_cpus); ++ } ++ } else { ++ active_cpus = os::Linux::active_processor_count(); ++ } ++ ++ return active_cpus; ++} ++ + void os::set_native_thread_name(const char *name) { + // Not yet implemented. + return; +diff --git openjdk.orig/hotspot/src/os/linux/vm/os_linux.hpp openjdk/hotspot/src/os/linux/vm/os_linux.hpp +--- openjdk.orig/hotspot/src/os/linux/vm/os_linux.hpp ++++ openjdk/hotspot/src/os/linux/vm/os_linux.hpp +@@ -35,6 +35,7 @@ + + class Linux { + friend class os; ++ friend class OSContainer; + friend class TestReserveMemorySpecial; + + // For signal-chaining +@@ -79,6 +80,9 @@ + + static julong available_memory(); + static julong physical_memory() { return _physical_memory; } ++ static void set_physical_memory(julong phys_mem) { _physical_memory = phys_mem; } ++ static int active_processor_count(); ++ + static void initialize_system_info(); + + static int commit_memory_impl(char* addr, size_t bytes, bool exec); +@@ -116,6 +120,7 @@ + static bool release_memory_special_huge_tlbfs(char* base, size_t bytes); + + static void print_full_memory_info(outputStream* st); ++ static void print_container_info(outputStream* st); + static void print_distro_info(outputStream* st); + static void print_libversion_info(outputStream* st); + +diff --git openjdk.orig/hotspot/src/os/solaris/vm/os_solaris.cpp openjdk/hotspot/src/os/solaris/vm/os_solaris.cpp +--- openjdk.orig/hotspot/src/os/solaris/vm/os_solaris.cpp ++++ openjdk/hotspot/src/os/solaris/vm/os_solaris.cpp +@@ -357,6 +357,16 @@ + } + + int os::active_processor_count() { ++ // User has overridden the number of active processors ++ if (ActiveProcessorCount > 0) { ++ if (Verbose) { ++ tty->print_cr("active_processor_count: " ++ "active processor count set by user : %d", ++ ActiveProcessorCount); ++ } ++ return ActiveProcessorCount; ++ } ++ + int online_cpus = sysconf(_SC_NPROCESSORS_ONLN); + pid_t pid = getpid(); + psetid_t pset = PS_NONE; +diff --git openjdk.orig/hotspot/src/os/windows/vm/os_windows.cpp openjdk/hotspot/src/os/windows/vm/os_windows.cpp +--- openjdk.orig/hotspot/src/os/windows/vm/os_windows.cpp ++++ openjdk/hotspot/src/os/windows/vm/os_windows.cpp +@@ -716,6 +716,16 @@ + #endif + + int os::active_processor_count() { ++ // User has overridden the number of active processors ++ if (ActiveProcessorCount > 0) { ++ if (PrintActiveCpus) { ++ tty->print_cr("active_processor_count: " ++ "active processor count set by user : %d", ++ ActiveProcessorCount); ++ } ++ return ActiveProcessorCount; ++ } ++ + DWORD_PTR lpProcessAffinityMask = 0; + DWORD_PTR lpSystemAffinityMask = 0; + int proc_count = processor_count(); +diff --git openjdk.orig/hotspot/src/share/vm/runtime/arguments.cpp openjdk/hotspot/src/share/vm/runtime/arguments.cpp +--- openjdk.orig/hotspot/src/share/vm/runtime/arguments.cpp ++++ openjdk/hotspot/src/share/vm/runtime/arguments.cpp +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. ++ * Copyright (c) 1997, 2018, 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 +@@ -1801,20 +1801,34 @@ + } + } + ++ // Convert Fraction to Precentage values ++ if (FLAG_IS_DEFAULT(MaxRAMPercentage) && ++ !FLAG_IS_DEFAULT(MaxRAMFraction)) ++ MaxRAMPercentage = 100.0 / MaxRAMFraction; ++ ++ if (FLAG_IS_DEFAULT(MinRAMPercentage) && ++ !FLAG_IS_DEFAULT(MinRAMFraction)) ++ MinRAMPercentage = 100.0 / MinRAMFraction; ++ ++ if (FLAG_IS_DEFAULT(InitialRAMPercentage) && ++ !FLAG_IS_DEFAULT(InitialRAMFraction)) ++ InitialRAMPercentage = 100.0 / InitialRAMFraction; ++ + // If the maximum heap size has not been set with -Xmx, + // then set it as fraction of the size of physical memory, + // respecting the maximum and minimum sizes of the heap. + if (FLAG_IS_DEFAULT(MaxHeapSize)) { +- julong reasonable_max = phys_mem / MaxRAMFraction; +- +- if (phys_mem <= MaxHeapSize * MinRAMFraction) { ++ julong reasonable_max = (julong)((phys_mem * MaxRAMPercentage) / 100); ++ const julong reasonable_min = (julong)((phys_mem * MinRAMPercentage) / 100); ++ if (reasonable_min < MaxHeapSize) { + // Small physical memory, so use a minimum fraction of it for the heap +- reasonable_max = phys_mem / MinRAMFraction; ++ reasonable_max = reasonable_min; + } else { + // Not-small physical memory, so require a heap at least + // as large as MaxHeapSize + reasonable_max = MAX2(reasonable_max, (julong)MaxHeapSize); + } ++ + if (!FLAG_IS_DEFAULT(ErgoHeapSizeLimit) && ErgoHeapSizeLimit != 0) { + // Limit the heap size to ErgoHeapSizeLimit + reasonable_max = MIN2(reasonable_max, (julong)ErgoHeapSizeLimit); +@@ -1856,7 +1870,7 @@ + reasonable_minimum = limit_by_allocatable_memory(reasonable_minimum); + + if (InitialHeapSize == 0) { +- julong reasonable_initial = phys_mem / InitialRAMFraction; ++ julong reasonable_initial = (julong)((phys_mem * InitialRAMPercentage) / 100); + + reasonable_initial = MAX3(reasonable_initial, reasonable_minimum, (julong)min_heap_size()); + reasonable_initial = MIN2(reasonable_initial, (julong)MaxHeapSize); +@@ -1881,6 +1895,94 @@ + } + } + ++// This option inspects the machine and attempts to set various ++// parameters to be optimal for long-running, memory allocation ++// intensive jobs. It is intended for machines with large ++// amounts of cpu and memory. ++jint Arguments::set_aggressive_heap_flags() { ++ // initHeapSize is needed since _initial_heap_size is 4 bytes on a 32 bit ++ // VM, but we may not be able to represent the total physical memory ++ // available (like having 8gb of memory on a box but using a 32bit VM). ++ // Thus, we need to make sure we're using a julong for intermediate ++ // calculations. ++ julong initHeapSize; ++ julong total_memory = os::physical_memory(); ++ ++ if (total_memory < (julong) 256 * M) { ++ jio_fprintf(defaultStream::error_stream(), ++ "You need at least 256mb of memory to use -XX:+AggressiveHeap\n"); ++ vm_exit(1); ++ } ++ ++ // The heap size is half of available memory, or (at most) ++ // all of possible memory less 160mb (leaving room for the OS ++ // when using ISM). This is the maximum; because adaptive sizing ++ // is turned on below, the actual space used may be smaller. ++ ++ initHeapSize = MIN2(total_memory / (julong) 2, ++ total_memory - (julong) 160 * M); ++ ++ initHeapSize = limit_by_allocatable_memory(initHeapSize); ++ ++ if (FLAG_IS_DEFAULT(MaxHeapSize)) { ++ FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize); ++ FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize); ++ // Currently the minimum size and the initial heap sizes are the same. ++ set_min_heap_size(initHeapSize); ++ } ++ if (FLAG_IS_DEFAULT(NewSize)) { ++ // Make the young generation 3/8ths of the total heap. ++ FLAG_SET_CMDLINE(uintx, NewSize, ++ ((julong) MaxHeapSize / (julong) 8) * (julong) 3); ++ FLAG_SET_CMDLINE(uintx, MaxNewSize, NewSize); ++ } ++ ++#ifndef _ALLBSD_SOURCE // UseLargePages is not yet supported on BSD. ++ FLAG_SET_DEFAULT(UseLargePages, true); ++#endif ++ ++ // Increase some data structure sizes for efficiency ++ FLAG_SET_CMDLINE(uintx, BaseFootPrintEstimate, MaxHeapSize); ++ FLAG_SET_CMDLINE(bool, ResizeTLAB, false); ++ FLAG_SET_CMDLINE(uintx, TLABSize, 256 * K); ++ ++ // See the OldPLABSize comment below, but replace 'after promotion' ++ // with 'after copying'. YoungPLABSize is the size of the survivor ++ // space per-gc-thread buffers. The default is 4kw. ++ FLAG_SET_CMDLINE(uintx, YoungPLABSize, 256 * K); // Note: this is in words ++ ++ // OldPLABSize is the size of the buffers in the old gen that ++ // UseParallelGC uses to promote live data that doesn't fit in the ++ // survivor spaces. At any given time, there's one for each gc thread. ++ // The default size is 1kw. These buffers are rarely used, since the ++ // survivor spaces are usually big enough. For specjbb, however, there ++ // are occasions when there's lots of live data in the young gen ++ // and we end up promoting some of it. We don't have a definite ++ // explanation for why bumping OldPLABSize helps, but the theory ++ // is that a bigger PLAB results in retaining something like the ++ // original allocation order after promotion, which improves mutator ++ // locality. A minor effect may be that larger PLABs reduce the ++ // number of PLAB allocation events during gc. The value of 8kw ++ // was arrived at by experimenting with specjbb. ++ FLAG_SET_CMDLINE(uintx, OldPLABSize, 8 * K); // Note: this is in words ++ ++ // Enable parallel GC and adaptive generation sizing ++ FLAG_SET_CMDLINE(bool, UseParallelGC, true); ++ ++ // Encourage steady state memory management ++ FLAG_SET_CMDLINE(uintx, ThresholdTolerance, 100); ++ ++ // This appears to improve mutator locality ++ FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); ++ ++ // Get around early Solaris scheduling bug ++ // (affinity vs other jobs on system) ++ // but disallow DR and offlining (5008695). ++ FLAG_SET_CMDLINE(bool, BindGCTaskThreadsToCPUs, true); ++ ++ return JNI_OK; ++} ++ + // This must be called after ergonomics because we want bytecode rewriting + // if the server compiler is used, or if UseSharedSpaces is disabled. + void Arguments::set_bytecode_flags() { +@@ -2644,6 +2746,14 @@ + return result; + } + ++ // We need to ensure processor and memory resources have been properly ++ // configured - which may rely on arguments we just processed - before ++ // doing the final argument processing. Any argument processing that ++ // needs to know about processor and memory resources must occur after ++ // this point. ++ ++ os::init_container_support(); ++ + // Do final processing now that all arguments have been parsed + result = finalize_vm_init_args(&scp, scp_assembly_required); + if (result != JNI_OK) { +@@ -3117,94 +3227,6 @@ + _exit_hook = CAST_TO_FN_PTR(exit_hook_t, option->extraInfo); + } else if (match_option(option, "abort", &tail)) { + _abort_hook = CAST_TO_FN_PTR(abort_hook_t, option->extraInfo); +- // -XX:+AggressiveHeap +- } else if (match_option(option, "-XX:+AggressiveHeap", &tail)) { +- +- // This option inspects the machine and attempts to set various +- // parameters to be optimal for long-running, memory allocation +- // intensive jobs. It is intended for machines with large +- // amounts of cpu and memory. +- +- // initHeapSize is needed since _initial_heap_size is 4 bytes on a 32 bit +- // VM, but we may not be able to represent the total physical memory +- // available (like having 8gb of memory on a box but using a 32bit VM). +- // Thus, we need to make sure we're using a julong for intermediate +- // calculations. +- julong initHeapSize; +- julong total_memory = os::physical_memory(); +- +- if (total_memory < (julong)256*M) { +- jio_fprintf(defaultStream::error_stream(), +- "You need at least 256mb of memory to use -XX:+AggressiveHeap\n"); +- vm_exit(1); +- } +- +- // The heap size is half of available memory, or (at most) +- // all of possible memory less 160mb (leaving room for the OS +- // when using ISM). This is the maximum; because adaptive sizing +- // is turned on below, the actual space used may be smaller. +- +- initHeapSize = MIN2(total_memory / (julong)2, +- total_memory - (julong)160*M); +- +- initHeapSize = limit_by_allocatable_memory(initHeapSize); +- +- if (FLAG_IS_DEFAULT(MaxHeapSize)) { +- FLAG_SET_CMDLINE(uintx, MaxHeapSize, initHeapSize); +- FLAG_SET_CMDLINE(uintx, InitialHeapSize, initHeapSize); +- // Currently the minimum size and the initial heap sizes are the same. +- set_min_heap_size(initHeapSize); +- } +- if (FLAG_IS_DEFAULT(NewSize)) { +- // Make the young generation 3/8ths of the total heap. +- FLAG_SET_CMDLINE(uintx, NewSize, +- ((julong)MaxHeapSize / (julong)8) * (julong)3); +- FLAG_SET_CMDLINE(uintx, MaxNewSize, NewSize); +- } +- +-#ifndef _ALLBSD_SOURCE // UseLargePages is not yet supported on BSD. +- FLAG_SET_DEFAULT(UseLargePages, true); +-#endif +- +- // Increase some data structure sizes for efficiency +- FLAG_SET_CMDLINE(uintx, BaseFootPrintEstimate, MaxHeapSize); +- FLAG_SET_CMDLINE(bool, ResizeTLAB, false); +- FLAG_SET_CMDLINE(uintx, TLABSize, 256*K); +- +- // See the OldPLABSize comment below, but replace 'after promotion' +- // with 'after copying'. YoungPLABSize is the size of the survivor +- // space per-gc-thread buffers. The default is 4kw. +- FLAG_SET_CMDLINE(uintx, YoungPLABSize, 256*K); // Note: this is in words +- +- // OldPLABSize is the size of the buffers in the old gen that +- // UseParallelGC uses to promote live data that doesn't fit in the +- // survivor spaces. At any given time, there's one for each gc thread. +- // The default size is 1kw. These buffers are rarely used, since the +- // survivor spaces are usually big enough. For specjbb, however, there +- // are occasions when there's lots of live data in the young gen +- // and we end up promoting some of it. We don't have a definite +- // explanation for why bumping OldPLABSize helps, but the theory +- // is that a bigger PLAB results in retaining something like the +- // original allocation order after promotion, which improves mutator +- // locality. A minor effect may be that larger PLABs reduce the +- // number of PLAB allocation events during gc. The value of 8kw +- // was arrived at by experimenting with specjbb. +- FLAG_SET_CMDLINE(uintx, OldPLABSize, 8*K); // Note: this is in words +- +- // Enable parallel GC and adaptive generation sizing +- FLAG_SET_CMDLINE(bool, UseParallelGC, true); +- +- // Encourage steady state memory management +- FLAG_SET_CMDLINE(uintx, ThresholdTolerance, 100); +- +- // This appears to improve mutator locality +- FLAG_SET_CMDLINE(bool, ScavengeBeforeFullGC, false); +- +- // Get around early Solaris scheduling bug +- // (affinity vs other jobs on system) +- // but disallow DR and offlining (5008695). +- FLAG_SET_CMDLINE(bool, BindGCTaskThreadsToCPUs, true); +- + } else if (match_option(option, "-XX:+NeverTenure", &tail)) { + // The last option must always win. + FLAG_SET_CMDLINE(bool, AlwaysTenure, false); +@@ -3605,6 +3627,15 @@ + return JNI_ERR; + } + ++ // This must be done after all arguments have been processed ++ // and the container support has been initialized since AggressiveHeap ++ // relies on the amount of total memory available. ++ if (AggressiveHeap) { ++ jint result = set_aggressive_heap_flags(); ++ if (result != JNI_OK) { ++ return result; ++ } ++ } + // This must be done after all arguments have been processed. + // java_compiler() true means set to "NONE" or empty. + if (java_compiler() && !xdebug_mode()) { +diff --git openjdk.orig/hotspot/src/share/vm/runtime/arguments.hpp openjdk/hotspot/src/share/vm/runtime/arguments.hpp +--- openjdk.orig/hotspot/src/share/vm/runtime/arguments.hpp ++++ openjdk/hotspot/src/share/vm/runtime/arguments.hpp +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved. ++ * Copyright (c) 1997, 2018, 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 +@@ -365,6 +365,8 @@ + // Aggressive optimization flags. + static void set_aggressive_opts_flags(); + ++ static jint set_aggressive_heap_flags(); ++ + // Argument parsing + static void do_pd_flag_adjustments(); + static bool parse_argument(const char* arg, Flag::Flags origin); +diff --git openjdk.orig/hotspot/src/share/vm/runtime/globals.hpp openjdk/hotspot/src/share/vm/runtime/globals.hpp +--- openjdk.orig/hotspot/src/share/vm/runtime/globals.hpp ++++ openjdk/hotspot/src/share/vm/runtime/globals.hpp +@@ -2076,13 +2076,23 @@ + product_pd(uint64_t, MaxRAM, \ + "Real memory size (in bytes) used to set maximum heap size") \ + \ ++ product(bool, AggressiveHeap, false, \ ++ "Optimize heap options for long-running memory intensive apps") \ ++ \ + product(uintx, ErgoHeapSizeLimit, 0, \ + "Maximum ergonomically set heap size (in bytes); zero means use " \ +- "MaxRAM / MaxRAMFraction") \ ++ "MaxRAM * MaxRAMPercentage / 100") \ + \ + experimental(bool, UseCGroupMemoryLimitForHeap, false, \ + "Use CGroup memory limit as physical memory limit for heap " \ +- "sizing") \ ++ "sizing" \ ++ "Deprecated, replaced by container support") \ ++ \ ++ diagnostic(bool, PrintContainerInfo, false, \ ++ "Print container related information") \ ++ \ ++ diagnostic(bool, PrintActiveCpus, false, \ ++ "Print the number of CPUs detected in os::active_processor_count") \ + \ + product(uintx, MaxRAMFraction, 4, \ + "Maximum fraction (1/n) of real memory used for maximum heap " \ +@@ -2099,6 +2109,19 @@ + product(uintx, InitialRAMFraction, 64, \ + "Fraction (1/n) of real memory used for initial heap size") \ + \ ++ product(double, MaxRAMPercentage, 25.0, \ ++ "Maximum percentage of real memory used for maximum heap size") \ ++ \ ++ product(double, MinRAMPercentage, 50.0, \ ++ "Minimum percentage of real memory used for maximum heap" \ ++ "size on systems with small physical memory size") \ ++ \ ++ product(double, InitialRAMPercentage, 1.5625, \ ++ "Percentage of real memory used for initial heap size") \ ++ \ ++ product(intx, ActiveProcessorCount, -1, \ ++ "Specify the CPU count the VM should use and report as active") \ ++ \ + develop(uintx, MaxVirtMemFraction, 2, \ + "Maximum fraction (1/n) of virtual memory used for ergonomically "\ + "determining maximum heap size") \ +diff --git openjdk.orig/hotspot/src/share/vm/runtime/os.hpp openjdk/hotspot/src/share/vm/runtime/os.hpp +--- openjdk.orig/hotspot/src/share/vm/runtime/os.hpp ++++ openjdk/hotspot/src/share/vm/runtime/os.hpp +@@ -152,8 +152,16 @@ + static size_t page_size_for_region(size_t region_size, size_t min_pages, bool must_be_aligned); + + static void initialize_initial_active_processor_count(); ++ ++ LINUX_ONLY(static void pd_init_container_support();) ++ + public: + static void init(void); // Called before command line parsing ++ ++ static void init_container_support() { // Called during command line parsing. ++ LINUX_ONLY(pd_init_container_support();) ++ } ++ + static void init_before_ergo(void); // Called after command line parsing + // before VM ergonomics processing. + static jint init_2(void); // Called after command line parsing +diff --git openjdk.orig/hotspot/src/share/vm/runtime/thread.cpp openjdk/hotspot/src/share/vm/runtime/thread.cpp +--- openjdk.orig/hotspot/src/share/vm/runtime/thread.cpp ++++ openjdk/hotspot/src/share/vm/runtime/thread.cpp +@@ -3332,6 +3332,7 @@ + Arguments::init_version_specific_system_properties(); + + // Parse arguments ++ // Note: this internally calls os::init_container_support() + jint parse_result = Arguments::parse(args); + if (parse_result != JNI_OK) return parse_result; + diff --git a/8203182-pr3603-rh1568033.patch b/8203182-pr3603-rh1568033.patch new file mode 100644 index 0000000..031a60c --- /dev/null +++ b/8203182-pr3603-rh1568033.patch @@ -0,0 +1,131 @@ +# HG changeset patch +# User igerasim +# Date 1528992969 25200 +# Thu Jun 14 09:16:09 2018 -0700 +# Node ID d9b0b4bd2526818afa73b60da77403245554caa8 +# Parent 1f4b038b9550afaf88a70cee4cf9c1422ecd86d6 +8203182, PR3603: Release session if initialization of SunPKCS11 Signature fails +Summary: Ensure session is properly released in P11Signature class +Reviewed-by: valeriep +Contributed-by: Martin Balao + +diff --git openjdk.orig/jdk/src/share/classes/sun/security/pkcs11/P11Signature.java openjdk/jdk/src/share/classes/sun/security/pkcs11/P11Signature.java +--- openjdk.orig/jdk/src/share/classes/sun/security/pkcs11/P11Signature.java ++++ openjdk/jdk/src/share/classes/sun/security/pkcs11/P11Signature.java +@@ -309,47 +309,51 @@ + session = token.killSession(session); + return; + } +- // "cancel" operation by finishing it +- // XXX make sure all this always works correctly +- if (mode == M_SIGN) { +- try { +- if (type == T_UPDATE) { +- token.p11.C_SignFinal(session.id(), 0); +- } else { +- byte[] digest; +- if (type == T_DIGEST) { +- digest = md.digest(); +- } else { // T_RAW +- digest = buffer; ++ try { ++ // "cancel" operation by finishing it ++ // XXX make sure all this always works correctly ++ if (mode == M_SIGN) { ++ try { ++ if (type == T_UPDATE) { ++ token.p11.C_SignFinal(session.id(), 0); ++ } else { ++ byte[] digest; ++ if (type == T_DIGEST) { ++ digest = md.digest(); ++ } else { // T_RAW ++ digest = buffer; ++ } ++ token.p11.C_Sign(session.id(), digest); + } +- token.p11.C_Sign(session.id(), digest); ++ } catch (PKCS11Exception e) { ++ throw new ProviderException("cancel failed", e); + } +- } catch (PKCS11Exception e) { +- throw new ProviderException("cancel failed", e); ++ } else { // M_VERIFY ++ try { ++ byte[] signature; ++ if (keyAlgorithm.equals("DSA")) { ++ signature = new byte[40]; ++ } else { ++ signature = new byte[(p11Key.length() + 7) >> 3]; ++ } ++ if (type == T_UPDATE) { ++ token.p11.C_VerifyFinal(session.id(), signature); ++ } else { ++ byte[] digest; ++ if (type == T_DIGEST) { ++ digest = md.digest(); ++ } else { // T_RAW ++ digest = buffer; ++ } ++ token.p11.C_Verify(session.id(), digest, signature); ++ } ++ } catch (PKCS11Exception e) { ++ // will fail since the signature is incorrect ++ // XXX check error code ++ } + } +- } else { // M_VERIFY +- try { +- byte[] signature; +- if (keyAlgorithm.equals("DSA")) { +- signature = new byte[40]; +- } else { +- signature = new byte[(p11Key.length() + 7) >> 3]; +- } +- if (type == T_UPDATE) { +- token.p11.C_VerifyFinal(session.id(), signature); +- } else { +- byte[] digest; +- if (type == T_DIGEST) { +- digest = md.digest(); +- } else { // T_RAW +- digest = buffer; +- } +- token.p11.C_Verify(session.id(), digest, signature); +- } +- } catch (PKCS11Exception e) { +- // will fail since the signature is incorrect +- // XXX check error code +- } ++ } finally { ++ session = token.releaseSession(session); + } + } + +@@ -368,6 +372,8 @@ + } + initialized = true; + } catch (PKCS11Exception e) { ++ // release session when initialization failed ++ session = token.releaseSession(session); + throw new ProviderException("Initialization failed", e); + } + if (bytesProcessed != 0) { +@@ -529,6 +535,8 @@ + } + bytesProcessed += len; + } catch (PKCS11Exception e) { ++ initialized = false; ++ session = token.releaseSession(session); + throw new ProviderException(e); + } + break; +@@ -576,6 +584,8 @@ + bytesProcessed += len; + byteBuffer.position(ofs + len); + } catch (PKCS11Exception e) { ++ initialized = false; ++ session = token.releaseSession(session); + throw new ProviderException("Update failed", e); + } + break; diff --git a/8206406-pr3610-rh1597825.patch b/8206406-pr3610-rh1597825.patch new file mode 100644 index 0000000..0f38126 --- /dev/null +++ b/8206406-pr3610-rh1597825.patch @@ -0,0 +1,65 @@ +# HG changeset patch +# User aph +# Date 1531146945 -3600 +# Mon Jul 09 15:35:45 2018 +0100 +# Node ID 95b72537801cc9946c27ad27f07e3f0790a21b08 +# Parent f6341f4635dacb56678264d29a88cd052b74036b +8206406, PR3610, RH1597825: StubCodeDesc constructor publishes partially-constructed objects on StubCodeDesc::_list +Reviewed-by: dholmes + +diff --git openjdk.orig/hotspot/src/share/vm/runtime/stubCodeGenerator.cpp openjdk/hotspot/src/share/vm/runtime/stubCodeGenerator.cpp +--- openjdk.orig/hotspot/src/share/vm/runtime/stubCodeGenerator.cpp ++++ openjdk/hotspot/src/share/vm/runtime/stubCodeGenerator.cpp +@@ -34,12 +34,12 @@ + + // Implementation of StubCodeDesc + +-StubCodeDesc* StubCodeDesc::_list = NULL; +-int StubCodeDesc::_count = 0; ++StubCodeDesc* volatile StubCodeDesc::_list = NULL; ++int StubCodeDesc::_count = 0; + + + StubCodeDesc* StubCodeDesc::desc_for(address pc) { +- StubCodeDesc* p = _list; ++ StubCodeDesc* p = (StubCodeDesc*)OrderAccess::load_ptr_acquire(&_list); + while (p != NULL && !p->contains(pc)) p = p->_next; + // p == NULL || p->contains(pc) + return p; +@@ -47,7 +47,7 @@ + + + StubCodeDesc* StubCodeDesc::desc_for_index(int index) { +- StubCodeDesc* p = _list; ++ StubCodeDesc* p = (StubCodeDesc*)OrderAccess::load_ptr_acquire(&_list); + while (p != NULL && p->index() != index) p = p->_next; + return p; + } +diff --git openjdk.orig/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp openjdk/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp +--- openjdk.orig/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp ++++ openjdk/hotspot/src/share/vm/runtime/stubCodeGenerator.hpp +@@ -38,7 +38,7 @@ + + class StubCodeDesc: public CHeapObj { + protected: +- static StubCodeDesc* _list; // the list of all descriptors ++ static StubCodeDesc* volatile _list; // the list of all descriptors + static int _count; // length of list + + StubCodeDesc* _next; // the next element in the linked list +@@ -69,13 +69,13 @@ + + StubCodeDesc(const char* group, const char* name, address begin) { + assert(name != NULL, "no name specified"); +- _next = _list; ++ _next = (StubCodeDesc*)OrderAccess::load_ptr_acquire(&_list); + _group = group; + _name = name; + _index = ++_count; // (never zero) + _begin = begin; + _end = NULL; +- _list = this; ++ OrderAccess::release_store_ptr(&_list, this); + }; + + const char* group() const { return _group; } diff --git a/hotspot-remove-debuglink.patch b/8206425-hotspot-remove-debuglink.patch similarity index 64% rename from hotspot-remove-debuglink.patch rename to 8206425-hotspot-remove-debuglink.patch index 3b3070d..adbf1f0 100644 --- a/hotspot-remove-debuglink.patch +++ b/8206425-hotspot-remove-debuglink.patch @@ -1,15 +1,15 @@ -Remove unnecessary .gnu_debuglink sections from libjvm +# HG changeset patch +# User sgehwolf +# Date 1530808022 -7200 +# Thu Jul 05 18:27:02 2018 +0200 +# Node ID 5ba59d58d976db456c4455640111e8107b8d80e8 +# Parent ad057f2e3211cd18bc56550d8a2c400d92ec35b1 +8206425: .gnu_debuglink sections added unconditionally when no debuginfo is stripped +Summary: Only add .gnu_debuglink sections when there is some stripping done. +Reviewed-by: erikj, dholmes -The .gnu_debuglink section indicates which file contains the debuginfo. This -is not needed if we not stripping the shared object. - -RPM's debuginfo extraction code will add the right file links automatically. As -it is, RPM copies over the .gnu_debuglink link to the debug info file. Without -this patch, the debug info file also ends up containing the .gnu_debuglink -section pointing to a missing (and not needed) file. - -diff --git a/make/linux/makefiles/jsig.make b/make/linux/makefiles/jsig.make ---- openjdk/hotspot/make/linux/makefiles/jsig.make +diff --git openjdk.orig/hotspot/make/linux/makefiles/jsig.make openjdk/hotspot/make/linux/makefiles/jsig.make +--- openjdk.orig/hotspot/make/linux/makefiles/jsig.make +++ openjdk/hotspot/make/linux/makefiles/jsig.make @@ -57,14 +57,15 @@ $(LFLAGS_JSIG) $(JSIG_DEBUG_CFLAGS) $(EXTRA_CFLAGS) -o $@ $< -ldl @@ -29,10 +29,10 @@ diff --git a/make/linux/makefiles/jsig.make b/make/linux/makefiles/jsig.make endif ifeq ($(ZIP_DEBUGINFO_FILES),1) $(ZIPEXE) -q -y $(LIBJSIG_DIZ) $(LIBJSIG_DEBUGINFO) -diff --git a/make/linux/makefiles/saproc.make b/make/linux/makefiles/saproc.make ---- openjdk/hotspot/make/linux/makefiles/saproc.make +diff --git openjdk.orig/hotspot/make/linux/makefiles/saproc.make openjdk/hotspot/make/linux/makefiles/saproc.make +--- openjdk.orig/hotspot/make/linux/makefiles/saproc.make +++ openjdk/hotspot/make/linux/makefiles/saproc.make -@@ -99,14 +99,15 @@ +@@ -100,14 +100,15 @@ -lthread_db ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) $(QUIETLY) $(OBJCOPY) --only-keep-debug $@ $(LIBSAPROC_DEBUGINFO) @@ -50,21 +50,21 @@ diff --git a/make/linux/makefiles/saproc.make b/make/linux/makefiles/saproc.make endif ifeq ($(ZIP_DEBUGINFO_FILES),1) $(ZIPEXE) -q -y $(LIBSAPROC_DIZ) $(LIBSAPROC_DEBUGINFO) -diff --git a/make/linux/makefiles/vm.make b/make/linux/makefiles/vm.make ---- openjdk/hotspot/make/linux/makefiles/vm.make +diff --git openjdk.orig/hotspot/make/linux/makefiles/vm.make openjdk/hotspot/make/linux/makefiles/vm.make +--- openjdk.orig/hotspot/make/linux/makefiles/vm.make +++ openjdk/hotspot/make/linux/makefiles/vm.make @@ -358,14 +358,15 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1) $(QUIETLY) $(OBJCOPY) --only-keep-debug $@ $(LIBJVM_DEBUGINFO) -- $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DEBUGINFO) $@ - ifeq ($(STRIP_POLICY),all_strip) ++ ifeq ($(STRIP_POLICY),all_strip) + $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DEBUGINFO) $@ +- ifeq ($(STRIP_POLICY),all_strip) $(QUIETLY) $(STRIP) $@ -+ $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DEBUGINFO) $@ else ifeq ($(STRIP_POLICY),min_strip) - $(QUIETLY) $(STRIP) -g $@ + $(QUIETLY) $(OBJCOPY) --add-gnu-debuglink=$(LIBJVM_DEBUGINFO) $@ + $(QUIETLY) $(STRIP) -g $@ + endif # implied else here is no stripping at all - endif diff --git a/hotspot-assembler-debuginfo.patch b/8207057-pr3613-hotspot-assembler-debuginfo.patch similarity index 100% rename from hotspot-assembler-debuginfo.patch rename to 8207057-pr3613-hotspot-assembler-debuginfo.patch diff --git a/dont-add-unnecessary-debug-links.patch b/8207234-dont-add-unnecessary-debug-links.patch similarity index 100% rename from dont-add-unnecessary-debug-links.patch rename to 8207234-dont-add-unnecessary-debug-links.patch diff --git a/java-1.8.0-openjdk.spec b/java-1.8.0-openjdk.spec index f89ec64..8ba0d79 100644 --- a/java-1.8.0-openjdk.spec +++ b/java-1.8.0-openjdk.spec @@ -221,7 +221,11 @@ # note, following three variables are sedded from update_sources if used correctly. Hardcode them rather there. %global project aarch64-port %global repo jdk8u -%global revision aarch64-jdk8u172-b11 +%global revision aarch64-jdk8u181-b13 +%global shenandoah_project aarch64-port +%global shenandoah_repo jdk8u-shenandoah +%global shenandoah_revision aarch64-shenandoah-jdk8u181-b13 + # eg # jdk8u60-b27 -> jdk8u60 or # aarch64-jdk8u60-b27 -> aarch64-jdk8u60 (dont forget spec escape % by %%) %global whole_update %(VERSION=%{revision}; echo ${VERSION%%-*}) # eg jdk8u60 -> 60 or aarch64-jdk8u60 -> 60 @@ -957,7 +961,7 @@ Provides: java-%{javaver}-%{origin}-accessibility = %{epoch}:%{version}-%{releas Name: java-%{javaver}-%{origin} Version: %{javaver}.%{updatever} -Release: 16.%{buildver}%{?dist} +Release: 7.%{buildver}%{?dist} # java-1.5.0-ibm from jpackage.org set Epoch to 1 for unknown reasons # and this change was brought into RHEL-4. java-1.5.0-ibm packages # also included the epoch in their virtual provides. This created a @@ -993,13 +997,20 @@ URL: http://openjdk.java.net/ Source0: %{project}-%{repo}-%{revision}.tar.xz # Shenandoah HotSpot -Source1: aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u172-b11--shenandoah-merge-2018-05-15.tar.xz +# aarch64-port/jdk8u-shenandoah contains an integration forest of +# OpenJDK 8u, the aarch64 port and Shenandoah +# To regenerate, use: +# VERSION=%%{shenandoah_revision} +# FILE_NAME_ROOT=%%{shenandoah_project}-%%{shenandoah_repo}-${VERSION} +# REPO_ROOT= REPOS=hotspot generate_source_tarball.sh +# where the source is obtained from http://hg.openjdk.java.net/%%{project}/%%{repo} +Source1: %{shenandoah_project}-%{shenandoah_repo}-%{shenandoah_revision}.tar.xz # Custom README for -src subpackage Source2: README.md # Use 'generate_tarballs.sh' to generate the following tarballs -# They are based on code contained in the IcedTea7 project +# They are based on code contained in the IcedTea project (3.x) # Systemtap tapsets. Zipped up to keep it small Source8: systemtap-tapset-3.6.0pre02.tar.xz @@ -1087,10 +1098,8 @@ Patch531: rhbz_1538767_fix_linking.patch # ############################################# # Patches 204 and 205 stop the build adding .gnu_debuglink sections to unstripped files -Patch204: hotspot-remove-debuglink.patch -Patch205: dont-add-unnecessary-debug-links.patch -# Enable debug information for assembly code files -Patch206: hotspot-assembler-debuginfo.patch +# 8207234: More libraries with .gnu_debuglink sections added unconditionally +Patch205: 8207234-dont-add-unnecessary-debug-links.patch # Arch-specific upstreamable patches # s390: PR2415: JVM -Xmx requirement is too high on s390 @@ -1121,40 +1130,21 @@ Patch7: include-all-srcs.patch Patch202: system-libpng.patch # 8042159: Allow using a system-installed lcms2 Patch203: system-lcms.patch -# PR2462: Backport "8074839: Resolve disabled warnings for libunpack and the unpack200 binary" +# S8074839, PR2462: Resolve disabled warnings for libunpack and the unpack200 binary # This fixes printf warnings that lead to build failure with -Werror=format-security from optflags Patch502: pr2462.patch -# S8148351, PR2842: Only display resolved symlink for compiler, do not change path -Patch506: pr2842-01.patch -Patch507: pr2842-02.patch # S8154313: Generated javadoc scattered all over the place Patch400: 8154313.patch -# S6260348, PR3066: GTK+ L&F JTextComponent not respecting desktop caret blink rate -Patch526: 6260348-pr3066.patch -# 8061305, PR3335, RH1423421: Javadoc crashes when method name ends with "Property" -Patch538: 8061305-pr3335-rh1423421.patch -# 8188030, PR3459, RH1484079: AWT java apps fail to start when some minimal fonts are present -Patch560: 8188030-pr3459-rh1484079.patch # 8197429, PR3546, RH153662{2,3}: 32 bit java app started via JNI crashes with larger stack sizes Patch561: 8197429-pr3546-rh1536622.patch -# PR3539, RH1548475: Pass EXTRA_LDFLAGS to HotSpot build -Patch562: pr3539-rh1548475.patch # 8171000, PR3542, RH1402819: Robot.createScreenCapture() crashes in wayland mode Patch563: 8171000-pr3542-rh1402819.patch # 8197546, PR3542, RH1402819: Fix for 8171000 breaks Solaris + Linux builds Patch564: 8197546-pr3542-rh1402819.patch -# 8185723, PR3553: Zero: segfaults on Power PC 32-bit -Patch565: 8185723-pr3553.patch -# 8186461, PR3557: Zero's atomic_copy64() should use SPE instructions on linux-powerpcspe -Patch566: 8186461-pr3557.patch # PR3559: Use ldrexd for atomic reads on ARMv7. Patch567: pr3559.patch # 8187577, PR3578: JVM crash during gc doing concurrent marking Patch568: 8187577-pr3578.patch -# 8201509, PR3579: Zero: S390 31bit atomic_copy64 inline assembler is wrong -Patch569: 8201509-pr3579.patch -# 8165489, PR3589: Missing G1 barrier in Unsafe_GetObjectVolatile -Patch570: 8165489-pr3589.patch # PR3591: Fix for bug 3533 doesn't add -mstackrealign to JDK code Patch571: pr3591.patch # 8184309, PR3596: Build warnings from GCC 7.1 on Fedora 26 @@ -1169,6 +1159,44 @@ Patch575: 8197981-pr3548.patch Patch576: 8064786-pr3599.patch # 8062808, PR3548: Turn on the -Wreturn-type warning Patch577: 8062808-pr3548.patch +# 8207057, PR3613: Enable debug information for assembly code files +Patch206: 8207057-pr3613-hotspot-assembler-debuginfo.patch + +############################################# +# +# Patches appearing in 8u192 +# +############################################# +# S8031668, PR2842: TOOLCHAIN_FIND_COMPILER unexpectedly resolves symbolic links +Patch506: pr2842-01.patch +# S8148351, PR2842: Only display resolved symlink for compiler, do not change path +Patch507: pr2842-02.patch +# S6260348, PR3066: GTK+ L&F JTextComponent not respecting desktop caret blink rate +Patch526: 6260348-pr3066.patch +# 8061305, PR3335, RH1423421: Javadoc crashes when method name ends with "Property" +Patch538: 8061305-pr3335-rh1423421.patch +# 8188030, PR3459, RH1484079: AWT java apps fail to start when some minimal fonts are present +Patch560: 8188030-pr3459-rh1484079.patch +# 8205104, PR3539, RH1548475: Pass EXTRA_LDFLAGS to HotSpot build +Patch562: pr3539-rh1548475.patch +# 8185723, PR3553: Zero: segfaults on Power PC 32-bit +Patch565: 8185723-pr3553.patch +# 8186461, PR3557: Zero's atomic_copy64() should use SPE instructions on linux-powerpcspe +Patch566: 8186461-pr3557.patch +# 8201509, PR3579: Zero: S390 31bit atomic_copy64 inline assembler is wrong +Patch569: 8201509-pr3579.patch +# 8165489, PR3589: Missing G1 barrier in Unsafe_GetObjectVolatile +Patch570: 8165489-pr3589.patch +# 8075942, PR3602: ArrayIndexOutOfBoundsException in sun.java2d.pisces.Dasher.goTo +Patch578: 8075942-pr3602-rh1582032.patch +# 8203182, PR3603: Release session if initialization of SunPKCS11 Signature fails +Patch579: 8203182-pr3603-rh1568033.patch +# 8206406, PR3610, RH1597825: StubCodeDesc constructor publishes partially-constructed objects on StubCodeDesc::_list +Patch580: 8206406-pr3610-rh1597825.patch +# 8146115, PR3508, RH1463098: Improve docker container detection and resource configuration usage +Patch581: 8146115-pr3508-rh1463098.patch +# 8206425: .gnu_debuglink sections added unconditionally when no debuginfo is stripped +Patch204: 8206425-hotspot-remove-debuglink.patch ############################################# # @@ -1186,7 +1214,6 @@ Patch300: PR3183.patch # Local fixes # ############################################# - # PR1834, RH1022017: Reduce curves reported by SSL to those in NSS Patch525: pr1834-rh1022017.patch # Turn on AssumeMP by default on RHEL systems @@ -1612,6 +1639,10 @@ popd %patch575 %patch576 %patch577 +%patch578 +%patch579 +%patch580 +%patch581 # RPM-only fixes %patch525 diff --git a/sources b/sources index 32c9800..c3c111b 100644 --- a/sources +++ b/sources @@ -1,3 +1,3 @@ SHA512 (systemtap-tapset-3.6.0pre02.tar.xz) = 848f42ef7ca751e723fd50e3a6da14c0965ad4da37ea3331568658e27497b7a7e4b9aad3dedd264ad0bb5566c37a92302b905f10258a4e2c89dc4ba609e55481 -SHA512 (aarch64-port-jdk8u-aarch64-jdk8u172-b11.tar.xz) = 2c322d161fdc5feeaf80011698ac1bcf4311513f9dc7484cefea91a1eba1a1c5aaad024ce6a525995fe88adc30ef68100032eaaa4d00082f2310f676592d3790 -SHA512 (aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u172-b11--shenandoah-merge-2018-05-15.tar.xz) = 7020590f7d618460ab3fc81513edfcd2452c222c15800a376628a864b6bbb611f890e66143a26011f9e4cc534e516047c2c573f7682e5b0f325425eeee05a280 +SHA512 (aarch64-port-jdk8u-aarch64-jdk8u181-b13.tar.xz) = d22ddb8b0b76faa18067fe383a147345be5fe1bad77b50940ff2993f3356166143e5ac9e14d9ead4437c13b00c6b2a5c62093ad57645da15a3419238990a74ac +SHA512 (aarch64-port-jdk8u-shenandoah-aarch64-shenandoah-jdk8u181-b13.tar.xz) = b5611a5b13a8aa3c0e07e015e39b11241f96124bb9454d4151c54d4e9af004ea038cc3a27e3b9099b3061bb9225cb298551e0e726f79bc9bc9837aa912f1586c diff --git a/update_package.sh b/update_package.sh index ee8622e..e11001e 100755 --- a/update_package.sh +++ b/update_package.sh @@ -31,7 +31,7 @@ if [ "x$REPO_NAME" = "x" ] ; then REPO_NAME="jdk8u" fi if [ "x$VERSION" = "x" ] ; then - VERSION="aarch64-jdk8u172-b11" + VERSION="aarch64-jdk8u181-b13" fi if [ "x$COMPRESSION" = "x" ] ; then @@ -109,7 +109,7 @@ if [ "x$VERSION" = "xtip" ] ; then VERSION="tip" else #hardcoding version for anything else except tip - VERSION="aarch64-shenandoah-jdk8u172-b11--shenandoah-merge-2018-05-15" + VERSION="aarch64-shenandoah-jdk8u181-b13" fi MAIN_REPO_NAME=$REPO_NAME REPO_NAME=jdk8u-shenandoah