*** old/src/os/linux/vm/os_linux.cpp	Thu Sep 21 13:56:09 2017
--- new/src/os/linux/vm/os_linux.cpp	Thu Sep 21 13:56:08 2017

*** 170,181 ****
--- 170,194 ----
  }
  
  julong os::Linux::available_memory() {
    // values in struct sysinfo are "unsigned long"
    struct sysinfo si;
    sysinfo(&si);
  
+   if (OSContainer::is_containerized()) {
+     julong avail_mem, 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 - mem_usage);
+           log_trace(os,container)("available container memory: %ld", avail_mem);
+           return avail_mem;
+         }
+       }
+     }
+   }
+ 
+   sysinfo(&si);
    return (julong)si.freeram * si.mem_unit;
  }
  
  julong os::physical_memory() {
    return Linux::physical_memory();

*** 1949,1958 ****
--- 1962,1973 ----
    os::Posix::print_rlimit_info(st);
  
    os::Posix::print_load_average(st);
  
    os::Linux::print_full_memory_info(st);
+ 
+   os::Linux::print_container_info(st);
  }
  
  // Try to identify popular distros.
  // Most Linux distributions have a /etc/XXX-release file, which contains
  // the OS version string. Newer Linux distributions have a /etc/lsb-release

*** 2086,2095 ****
--- 2101,2149 ----
    st->print("\n/proc/meminfo:\n");
    _print_ascii_file("/proc/meminfo", st);
    st->cr();
  }
  
+ void os::Linux::print_container_info(outputStream* st) {
+   st->print("container:");
+   if (OSContainer::is_containerized()) {
+     char *p;
+     jlong j;
+     int i;
+     st->print("Running in a container: true");
+     p = OSContainer::cpu_cpuset_cpus(); 
+     if (p < 0) st->print("OSContainer::cpu_cpuset_cpus() failed");
+     else {
+       st->print("OSContainer::cpu_cpuset_cpus: %s", p);
+       free(p);
+     }
+ 
+     i = OSContainer::active_processor_count();
+     if (i < 0) st->print("OSContainer::active_processor_count() failed");
+     else 
+       st->print("OSContainer::active_processor_count: %d", i);
+ 
+     j = OSContainer::memory_limit_in_bytes();
+     if (j < 0L) st->print("OSContainer::memory_limit_in_bytes() failed");
+     else 
+       st->print("OSContainer::memory_limit_in_bytes: %ld", j);
+ 
+     j = OSContainer::OSContainer::memory_usage_in_bytes();
+     if (j < 0L) st->print("OSContainer::memory_usage_in_bytes() failed");
+     else 
+       st->print("OSContainer::memory_usage_in_bytes: %ld", j);
+ 
+     j = OSContainer::OSContainer::memory_max_usage_in_bytes();
+     if (j < 0L) st->print("OSContainer::memory_max_usage_in_bytes() failed");
+     else 
+       st->print("OSContainer::memory_max_usage_in_bytes: %ld", j);
+   }
+   else {
+     st->print("Running in a container: false");
+   }
+ }
+ 
  void os::print_memory_info(outputStream* st) {
  
    st->print("Memory:");
    st->print(" %dk page", os::vm_page_size()>>10);
  

*** 4801,4811 ****
--- 4855,4864 ----
    }
  }
  
  // this is called _after_ the global arguments have been parsed
  jint os::init_2(void) {
  
    os::Posix::init_2();
  
    Linux::fast_thread_clock_init();
  
    // Allocate a single page and mark it as readable for safepoint polling

*** 4966,4975 ****
--- 5019,5046 ----
  int os::active_processor_count() {
    cpu_set_t cpus;  // can represent at most 1024 (CPU_SETSIZE) processors
    cpu_set_t* cpus_p = &cpus;
    int cpus_size = sizeof(cpu_set_t);
  
+   // User has overridden the number of active processors
+   if (!FLAG_IS_DEFAULT(ActiveProcessorCount)) {
+     log_trace(os)("active_processor_count: "
+                   "active processor count set by user : %d",
+                   (int)ActiveProcessorCount);
+     return ActiveProcessorCount;
+   }
+ 
+   if (OSContainer::is_containerized()) {
+     int active_cpus;
+     if ((active_cpus = OSContainer::active_processor_count()) > 0) {
+       log_trace(os,container)("active_processor_count: "
+                     "active processor count determined by OSContainer: %d",
+                     (int)active_cpus);
+       return active_cpus;
+     }
+   }
+ 
    int configured_cpus = processor_count();  // upper bound on available cpus
    int cpu_count = 0;
  
  // old build platforms may not support dynamic cpu sets
  #ifdef CPU_ALLOC