dotnet6.0/SOURCES/runtime-mono-memfunc-cgroup.patch

Index: a/src/mono/mono/utils/memfuncs.c
===================================================================
--- a/src/mono/mono/utils/memfuncs.c
+++ b/src/mono/mono/utils/memfuncs.c
@@ -343,6 +343,9 @@ mono_determine_physical_ram_available_si
 	host_page_size (host, &page_size);
 	return (guint64) vmstat.free_count * page_size;
 
+#elif defined (__FreeBSD__) || defined (__linux__) || defined (__APPLE__)
+	return (getPhysicalMemoryAvail());
+
 #elif defined (HAVE_SYSCONF)
 	gint64 page_size = -1, num_pages = -1;
 
Index: a/src/mono/mono/utils/memfuncs.h
===================================================================
--- a/src/mono/mono/utils/memfuncs.h
+++ b/src/mono/mono/utils/memfuncs.h
@@ -24,5 +24,10 @@ MONO_COMPONENT_API void mono_gc_memmove_
 void mono_gc_memmove_aligned (void *dest, const void *src, size_t size);
 guint64 mono_determine_physical_ram_size (void);
 guint64 mono_determine_physical_ram_available_size (void);
+#if defined (__FreeBSD__) || defined (__linux__) || defined (__APPLE__)
+size_t getRestrictedPhysicalMemoryLimit(void);
+gboolean getPhysicalMemoryUsed(size_t *);
+size_t getPhysicalMemoryAvail(void);
+#endif
 
 #endif
Index: a/src/mono/mono/utils/mono-cgroup.c
===================================================================
--- /dev/null
+++ b/src/mono/mono/utils/mono-cgroup.c
@@ -0,0 +1,709 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+/*++
+
+Module Name:
+
+    mono-cgroup.cpp
+
+Abstract:
+    Read the memory limit for the current process
+--*/
+#ifdef __FreeBSD__
+#define _WITH_GETLINE
+#endif
+
+#include <config.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <glib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/resource.h>
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <sys/param.h>
+#include <sys/mount.h>
+#else
+#include <sys/vfs.h>
+#endif
+#include <errno.h>
+#include <limits.h>
+
+#ifndef SIZE_T_MAX
+# define SIZE_T_MAX (~(size_t)0)
+#endif
+
+#define CGROUP2_SUPER_MAGIC 0x63677270
+#define TMPFS_MAGIC 0x01021994
+
+#define PROC_MOUNTINFO_FILENAME "/proc/self/mountinfo"
+#define PROC_CGROUP_FILENAME "/proc/self/cgroup"
+#define PROC_STATM_FILENAME "/proc/self/statm"
+#define CGROUP1_MEMORY_LIMIT_FILENAME "/memory.limit_in_bytes"
+#define CGROUP2_MEMORY_LIMIT_FILENAME "/memory.max"
+#define CGROUP_MEMORY_STAT_FILENAME "/memory.stat"
+
+static void initialize(void);
+static gboolean readMemoryValueFromFile(const char *, guint64 *);
+static gboolean getPhysicalMemoryLimit(guint64 *);
+static gboolean getPhysicalMemoryUsage(size_t *);
+static int findCGroupVersion(void);
+static gboolean isCGroup1MemorySubsystem(const char *);
+static char *findCGroupPath(gboolean (*is_subsystem)(const char *));
+static void findHierarchyMount(gboolean (*is_subsystem)(const char *), char **, char **);
+static char *findCGroupPathForSubsystem(gboolean (*is_subsystem)(const char *));
+static gboolean getCGroupMemoryLimit(guint64 *, const char *);
+static gboolean getCGroupMemoryUsage(size_t *);
+static size_t getPhysicalMemoryTotal(guint64);
+
+size_t getRestrictedPhysicalMemoryLimit(void);
+gboolean getPhysicalMemoryUsed(size_t *);
+size_t getPhysicalMemoryAvail(void);
+
+// the cgroup version number or 0 to indicate cgroups are not found or not enabled
+static int s_cgroup_version;
+
+static char *s_memory_cgroup_path = NULL;
+
+static const char *s_mem_stat_key_names[4];
+static size_t s_mem_stat_key_lengths[4];
+static size_t s_mem_stat_n_keys = 0;
+static long pageSize;
+
+/**
+ * @initialize
+ *
+ * Initialize variables used by the calculation routines.
+ */
+static void 
+initialize()
+{
+	s_cgroup_version = findCGroupVersion();
+	s_memory_cgroup_path = findCGroupPath(s_cgroup_version == 1 ? &isCGroup1MemorySubsystem : NULL);
+
+	if (s_cgroup_version == 1) {
+		s_mem_stat_n_keys = 4;
+		s_mem_stat_key_names[0] = "total_inactive_anon ";
+		s_mem_stat_key_names[1] = "total_active_anon ";
+		s_mem_stat_key_names[2] = "total_dirty ";
+		s_mem_stat_key_names[3] = "total_unevictable ";
+	} else {
+		s_mem_stat_n_keys = 3;
+		s_mem_stat_key_names[0] = "anon ";
+		s_mem_stat_key_names[1] = "file_dirty ";
+		s_mem_stat_key_names[2] = "unevictable ";
+	}
+
+	for (size_t i = 0; i < s_mem_stat_n_keys; i++)
+		s_mem_stat_key_lengths[i] = strlen(s_mem_stat_key_names[i]);
+
+	pageSize = sysconf(_SC_PAGE_SIZE);
+}
+
+/**
+ * @readMemoryValueFromFile
+ *
+ * @param[in] filename - name of file containing value
+ * @param[out] val - pointer to the result area
+ * @returns True or False depending if value was found
+ *
+ * Read a value from a specified /sys/fs/cgroup/memory file
+ */
+static gboolean 
+readMemoryValueFromFile(const char* filename, guint64* val)
+{
+	gboolean result = FALSE;
+	char *line = NULL;
+	size_t lineLen = 0;
+	char *endptr = NULL;
+	guint64 num = 0, multiplier;
+	FILE *file = NULL;
+
+	if (val == NULL) {
+		file = fopen(filename, "r");
+		if (file != NULL) {
+			if (getline(&line, &lineLen, file) != -1) {
+				errno = 0;
+				num = strtoull(line, &endptr, 0);
+				if (line != endptr && errno == 0) {
+					multiplier = 1;
+
+					switch (*endptr)
+					{
+					case 'g':
+					case 'G': 
+						multiplier = 1024;
+					case 'm':
+					case 'M': 
+						multiplier = multiplier * 1024;
+					case 'k':
+					case 'K': 
+						multiplier = multiplier * 1024;
+					}
+
+					*val = num * multiplier;
+					result = TRUE;
+					if (*val / multiplier != num)
+						result = FALSE;
+				}
+			}
+		}
+	}
+
+	if (file)
+		fclose(file);
+	free(line);
+	return result;
+}
+
+/**
+ * @getPhysicalMemoryLimit
+ *
+ * @param[out] val - pointer to the result area
+ * @returns True or False depending if a limit was found
+ *
+ * Interrogate the cgroup memory values to determine if there's
+ * a limit on physical memory.
+ */
+static gboolean 
+getPhysicalMemoryLimit(guint64 *val)
+{
+	if (s_mem_stat_n_keys == 0)
+		initialize();
+
+	if (s_cgroup_version == 0)
+		return FALSE;
+	else if (s_cgroup_version == 1)
+		return getCGroupMemoryLimit(val, CGROUP1_MEMORY_LIMIT_FILENAME);
+	else if (s_cgroup_version == 2)
+		return getCGroupMemoryLimit(val, CGROUP2_MEMORY_LIMIT_FILENAME);
+	else {
+		g_assert(!"Unknown cgroup version.");
+		return FALSE;
+	}
+}
+
+/**
+ * @getPhysicalMemoryUsage
+ *
+ * @param[out] val - pointer to the result area
+ * @returns True or False depending if a usage value was found
+ *
+ * Interrogate the cgroup memory values to determine how much 
+ * memory is in use.
+ */
+static gboolean 
+getPhysicalMemoryUsage(size_t *val)
+{
+	if (s_cgroup_version == 0)
+		return FALSE;
+	else if (s_cgroup_version == 1)
+		return getCGroupMemoryUsage(val);
+	else if (s_cgroup_version == 2)
+		return getCGroupMemoryUsage(val);
+	else {
+		g_assert(!"Unknown cgroup version.");
+		return FALSE;
+	}
+}
+
+/**
+ * @findGroupVersion
+ *
+ * @returns cgroup version
+ *
+ * Inspect the /sys/fs/cgroup hierachy to determine what version of 
+ * group we are using
+ */
+static int 
+findCGroupVersion()
+{
+	// It is possible to have both cgroup v1 and v2 enabled on a system.
+	// Most non-bleeding-edge Linux distributions fall in this group. We
+	// look at the file system type of /sys/fs/cgroup to determine which
+	// one is the default. For more details, see:
+	// https://systemd.io/CGROUP_DELEGATION/#three-different-tree-setups-
+	// We dont care about the difference between the "legacy" and "hybrid"
+	// modes because both of those involve cgroup v1 controllers managing
+	// resources.
+
+
+	struct statfs stats;
+	int result = statfs("/sys/fs/cgroup", &stats);
+	if (result != 0)
+		return 0;
+
+	switch (stats.f_type) {
+	case TMPFS_MAGIC: return 1;
+	case CGROUP2_SUPER_MAGIC: return 2;
+	default:
+		g_assert(!"Unexpected file system type for /sys/fs/cgroup");
+		return 0;
+	}
+}
+
+/**
+ * @isCGroup1MemorySubsystem
+ *
+ * @param[in] strTok - Token for comparison
+ * @returns True if token matches "memory"
+ *
+ * Check if we've found the memory component of /sys/fs/cgroup
+ */
+static gboolean 
+isCGroup1MemorySubsystem(const char *strTok)
+{
+	return strcmp("memory", strTok) == 0;
+}
+
+/**
+ * @findCGroupPath
+ *
+ * @param[in] is_subsystem - Function used to compare tokens
+ * @returns Path to cgroup
+ *
+ * Navigate the /sys/fs/cgroup to try and find the correct cgroup path
+ */
+static char *
+findCGroupPath(gboolean (*is_subsystem)(const char *))
+{
+	char *cgroup_path = NULL;
+	char *hierarchy_mount = NULL;
+	char *hierarchy_root = NULL;
+	char *cgroup_path_relative_to_mount = NULL;
+	size_t common_path_prefix_len;
+
+	findHierarchyMount(is_subsystem, &hierarchy_mount, &hierarchy_root);
+	if (hierarchy_mount != NULL && hierarchy_root != NULL) {
+
+		cgroup_path_relative_to_mount = findCGroupPathForSubsystem(is_subsystem);
+		if (cgroup_path_relative_to_mount != NULL) {
+
+			cgroup_path = (char*)malloc(strlen(hierarchy_mount) + strlen(cgroup_path_relative_to_mount) + 1);
+			if (cgroup_path != NULL) {
+
+				strcpy(cgroup_path, hierarchy_mount);
+				// For a host cgroup, we need to append the relative path.
+				// The root and cgroup path can share a common prefix of the path that should not be appended.
+				// Example 1 (docker):
+				// hierarchy_mount:               /sys/fs/cgroup/cpu
+				// hierarchy_root:                /docker/87ee2de57e51bc75175a4d2e81b71d162811b179d549d6601ed70b58cad83578
+				// cgroup_path_relative_to_mount: /docker/87ee2de57e51bc75175a4d2e81b71d162811b179d549d6601ed70b58cad83578/my_named_cgroup
+				// append do the cgroup_path:     /my_named_cgroup
+				// final cgroup_path:             /sys/fs/cgroup/cpu/my_named_cgroup
+				//
+				// Example 2 (out of docker)
+				// hierarchy_mount:               /sys/fs/cgroup/cpu
+				// hierarchy_root:                /
+				// cgroup_path_relative_to_mount: /my_named_cgroup
+				// append do the cgroup_path:     /my_named_cgroup
+				// final cgroup_path:             /sys/fs/cgroup/cpu/my_named_cgroup
+				common_path_prefix_len = strlen(hierarchy_root);
+				if ((common_path_prefix_len == 1) || 
+				    (strncmp(hierarchy_root, cgroup_path_relative_to_mount, common_path_prefix_len) != 0))
+					common_path_prefix_len = 0;
+
+				g_assert((cgroup_path_relative_to_mount[common_path_prefix_len] == '/') || 
+				         (cgroup_path_relative_to_mount[common_path_prefix_len] == '\0'));
+
+				strcat(cgroup_path, cgroup_path_relative_to_mount + common_path_prefix_len);
+			}
+		}
+	}
+
+	free(hierarchy_mount);
+	free(hierarchy_root);
+	free(cgroup_path_relative_to_mount);
+	return cgroup_path;
+}
+
+/**
+ * @findHierarchyMount
+ *
+ * @param[in] is_subsystem - Comparison function
+ * @param[out] pmountpath -
+ * @param[out] pmountroot -
+ *
+ * Check the /proc filesystem to determine the root and mount path of /sys/fs/cgroup data
+ */
+static void 
+findHierarchyMount(gboolean (*is_subsystem)(const char *), char** pmountpath, char** pmountroot)
+{
+	char *line = NULL;
+	size_t lineLen = 0, maxLineLen = 0;
+	char *filesystemType = NULL;
+	char *options = NULL;
+	char *mountpath = NULL;
+	char *mountroot = NULL;
+
+	FILE *mountinfofile = fopen(PROC_MOUNTINFO_FILENAME, "r");
+	if (mountinfofile == NULL) 
+		goto done;
+
+	while (getline(&line, &lineLen, mountinfofile) != -1) {
+		if (filesystemType == NULL || lineLen > maxLineLen) {
+			free(filesystemType);
+			filesystemType = NULL;
+			free(options);
+			options = NULL;
+			filesystemType = (char*)malloc(lineLen+1);
+			if (filesystemType == NULL)
+				goto done;
+			options = (char*)malloc(lineLen+1);
+			if (options == NULL)
+				goto done;
+			maxLineLen = lineLen;
+		}
+
+		char *separatorChar = strstr(line, " - ");
+
+		// See man page of proc to get format for /proc/self/mountinfo file
+		int sscanfRet = sscanf(separatorChar,
+		   " - %s %*s %s",
+		   filesystemType,
+		   options);
+		if (sscanfRet != 2) {
+			g_assert(!"Failed to parse mount info file contents with sscanf.");
+			goto done;
+		}
+
+		if (strncmp(filesystemType, "cgroup", 6) == 0) {
+			gboolean isSubsystemMatch = is_subsystem == NULL;
+			if (!isSubsystemMatch) {
+				char *context = NULL;
+				char *strTok = strtok_r(options, ",", &context);
+				while (!isSubsystemMatch && strTok != NULL)
+				{
+					isSubsystemMatch = is_subsystem(strTok);
+					strTok = strtok_r(NULL, ",", &context);
+				}
+			}
+			if (isSubsystemMatch) {
+				mountpath = (char*)malloc(lineLen+1);
+				if (mountpath == NULL)
+					goto done;
+				mountroot = (char*)malloc(lineLen+1);
+				if (mountroot == NULL)
+					goto done;
+
+				sscanfRet = sscanf(line,
+					   "%*s %*s %*s %s %s ",
+					   mountroot,
+					   mountpath);
+				if (sscanfRet != 2)
+					g_assert(!"Failed to parse mount info file contents with sscanf.");
+
+				// assign the output arguments and clear the locals so we don't free them.
+				*pmountpath = mountpath;
+				*pmountroot = mountroot;
+				mountpath = mountroot = NULL;
+			}
+		}
+	}
+done:
+	free(mountpath);
+	free(mountroot);
+	free(filesystemType);
+	free(options);
+	free(line);
+	if (mountinfofile)
+		fclose(mountinfofile);
+}
+
+/**
+ * @findCGroupPathForSubsystem
+ *
+ * @param[in] is_subsystem - Comparison function
+ * @returns cgroup path for the memory subsystem
+ *
+ * Check the /proc filesystem to determine the root and mount path of /sys/fs/cgroup data
+ */
+static char * 
+findCGroupPathForSubsystem(gboolean (*is_subsystem)(const char *))
+{
+	char *line = NULL;
+	size_t lineLen = 0;
+	size_t maxLineLen = 0;
+	char *subsystem_list = NULL;
+	char *cgroup_path = NULL;
+	gboolean result = FALSE;
+
+	FILE *cgroupfile = fopen(PROC_CGROUP_FILENAME, "r");
+	if (cgroupfile == NULL)
+		goto done;
+
+	while (!result && getline(&line, &lineLen, cgroupfile) != -1) {
+		if (subsystem_list == NULL || lineLen > maxLineLen) {
+			free(subsystem_list);
+			subsystem_list = NULL;
+			free(cgroup_path);
+			cgroup_path = NULL;
+			subsystem_list = (char*)malloc(lineLen+1);
+			if (subsystem_list == NULL)
+				goto done;
+			cgroup_path = (char*)malloc(lineLen+1);
+			if (cgroup_path == NULL)
+				goto done;
+			maxLineLen = lineLen;
+		}
+
+		if (s_cgroup_version == 1) {
+			// See man page of proc to get format for /proc/self/cgroup file
+			int sscanfRet = sscanf(line,
+			"%*[^:]:%[^:]:%s",
+			subsystem_list,
+			cgroup_path);
+			if (sscanfRet != 2) {
+				g_assert(!"Failed to parse cgroup info file contents with sscanf.");
+				goto done;
+			}
+
+			char* context = NULL;
+			char* strTok = strtok_r(subsystem_list, ",", &context);
+			while (strTok != NULL) {
+				if (is_subsystem(strTok)) {
+					result = TRUE;
+					break;
+				}
+				strTok = strtok_r(NULL, ",", &context);
+			}
+		} else if (s_cgroup_version == 2) {
+			// See https://www.kernel.org/doc/Documentation/cgroup-v2.txt
+			// Look for a "0::/some/path"
+			int sscanfRet = sscanf(line,
+			"0::%s",
+			cgroup_path);
+			if (sscanfRet == 1)
+			{
+				result = TRUE;
+			}
+		} else {
+			g_assert(!"Unknown cgroup version in mountinfo.");
+			goto done;
+		}
+	}
+done:
+	free(subsystem_list);
+	if (!result) {
+		free(cgroup_path);
+		cgroup_path = NULL;
+	}
+	free(line);
+	if (cgroupfile)
+		fclose(cgroupfile);
+	return cgroup_path;
+}
+
+/**
+ * @getCGroupMemoryLimit
+ *
+ * @param[out] val - Memory limit
+ * @param[in] filename - name of file from which to extract limit
+ * @returns True if value found
+ *
+ * Extract memory limit from specified /sys/fs/cgroup/memory file
+ */
+static gboolean 
+getCGroupMemoryLimit(guint64 *val, const char *filename)
+{
+	if (s_memory_cgroup_path == NULL)
+		return FALSE;
+
+	char* mem_limit_filename = NULL;
+	if (asprintf(&mem_limit_filename, "%s%s", s_memory_cgroup_path, filename) < 0)
+		return FALSE;
+
+	gboolean result = readMemoryValueFromFile(mem_limit_filename, val);
+	free(mem_limit_filename);
+	return result;
+}
+
+/**
+ * @getCGroupMemoryUsage
+ *
+ * @param[out] val - Memory limit
+ * @returns True if value found
+ *
+ * Extract memory usage from /sys/fs/cgroup/memory.stat file
+ */
+static gboolean 
+getCGroupMemoryUsage(size_t *val)
+{
+	if (s_memory_cgroup_path == NULL)
+		return FALSE;
+
+	char *stat_filename = NULL;
+	if (asprintf(&stat_filename, "%s%s", s_memory_cgroup_path, CGROUP_MEMORY_STAT_FILENAME) < 0)
+		return FALSE;
+
+	FILE *stat_file = fopen(stat_filename, "r");
+	free(stat_filename);
+	if (stat_file == NULL)
+		return FALSE;
+
+	char *line = NULL;
+	size_t lineLen = 0;
+	size_t readValues = 0;
+	char *endptr;
+
+	*val = 0;
+	while (getline(&line, &lineLen, stat_file) != -1 && readValues < s_mem_stat_n_keys) {
+		for (size_t i = 0; i < s_mem_stat_n_keys; i++) {
+			if (strncmp(line, s_mem_stat_key_names[i], s_mem_stat_key_lengths[i]) == 0) {
+				errno = 0;
+				const char *startptr = line + s_mem_stat_key_lengths[i];
+				*val += strtoll(startptr, &endptr, 10);
+				if (endptr != startptr && errno == 0)
+					readValues++;
+
+				break;
+			}
+		}
+	}
+
+	fclose(stat_file);
+	free(line);
+
+	if (readValues == s_mem_stat_n_keys)
+		return TRUE;
+
+	return FALSE;
+}
+
+/**
+ * @getRestrictedPhysicalMemoryLimit
+ *
+ * @returns Physical memory limit
+ *
+ * Determine if there are any limits on memory and return the value
+ * if so. Zero represents no limit.
+ */
+size_t 
+getRestrictedPhysicalMemoryLimit()
+{
+	guint64 physical_memory_limit = 0;
+
+	if (s_mem_stat_n_keys == 0)
+		initialize();
+
+	if (!getPhysicalMemoryLimit(&physical_memory_limit))
+		return 0;
+
+	// If there's no memory limit specified on the container this
+	// actually returns 0x7FFFFFFFFFFFF000 (2^63-1 rounded down to
+	// 4k which is a common page size). So we know we are not
+	// running in a memory restricted environment.
+	if (physical_memory_limit > 0x7FFFFFFF00000000)
+		return 0;
+
+	return (getPhysicalMemoryTotal(physical_memory_limit));
+}
+
+/**
+ * @getPhysicalMemoryTotal
+ *
+ * @param[in] physical_memory_limit - The max memory on the system
+ * @returns Physical memory total
+ *
+ * Check the input limit against any system limits or actual memory on system
+ */
+static size_t
+getPhysicalMemoryTotal(size_t physical_memory_limit)
+{
+	struct rlimit curr_rlimit;
+	size_t rlimit_soft_limit = (size_t)RLIM_INFINITY;
+	if (getrlimit(RLIMIT_AS, &curr_rlimit) == 0)
+		rlimit_soft_limit = curr_rlimit.rlim_cur;
+	physical_memory_limit = (physical_memory_limit < rlimit_soft_limit) ?
+				 physical_memory_limit : rlimit_soft_limit;
+
+	// Ensure that limit is not greater than real memory size
+	long pages = sysconf(_SC_PHYS_PAGES);
+	if (pages != -1) {
+		if (pageSize != -1) {
+			physical_memory_limit = (physical_memory_limit < (size_t)pages * pageSize) ?
+						 physical_memory_limit : (size_t)pages * pageSize;
+		}
+	}
+
+	if (physical_memory_limit > ULONG_MAX) {
+		// It is observed in practice when the memory is unrestricted, Linux control
+		// group returns a physical limit that is bigger than the address space
+		return ULONG_MAX;
+	} else
+		return (size_t)physical_memory_limit;
+}
+
+/**
+ * @getPhysicalMemoryUsed
+ *
+ * @param[out] val - pointer to the memory usage value 
+ * @returns True if we are able to determine usage
+ *
+ * Determine the amount of memory in use
+ */
+gboolean 
+getPhysicalMemoryUsed(size_t *val)
+{
+	gboolean result = FALSE;
+	size_t linelen;
+	char *line = NULL;
+
+	if (val == NULL)
+		return FALSE;
+
+	// Linux uses cgroup usage to trigger oom kills.
+	if (getPhysicalMemoryUsage(val))
+		return TRUE;
+
+	// process resident set size.
+	FILE* file = fopen(PROC_STATM_FILENAME, "r");
+	if (file != NULL && getline(&line, &linelen, file) != -1) {
+		char* context = NULL;
+		char* strTok = strtok_r(line, " ", &context);
+		strTok = strtok_r(NULL, " ", &context);
+
+		errno = 0;
+		*val = strtoull(strTok, NULL, 0);
+		if (errno == 0) {
+			if (pageSize != -1) {
+				*val = *val * pageSize;
+				result = TRUE;
+			}
+		}
+	}
+
+	if (file)
+		fclose(file);
+	free(line);
+	return result;
+}
+
+/**
+ * @getPhysicalMemoryAvail
+ *
+ * @returns Amount of memory available
+ *
+ * Determine the amount of memory available by examininig any limits and
+ * checking what memory is in use.
+ */
+size_t
+getPhysicalMemoryAvail()
+{
+	size_t max, used, avail, sysAvail;
+
+	max = getRestrictedPhysicalMemoryLimit();
+
+	if (max == 0)
+		max = getPhysicalMemoryTotal(ULONG_MAX);
+
+	if (getPhysicalMemoryUsed(&used))
+		avail = max - used;
+	else
+		avail = max;
+
+	sysAvail = sysconf(_SC_AVPHYS_PAGES) * pageSize;
+	return (avail < sysAvail ? avail : sysAvail);
+}
Index: a/src/mono/mono/utils/CMakeLists.txt
===================================================================
--- a/src/mono/mono/utils/CMakeLists.txt
+++ b/src/mono/mono/utils/CMakeLists.txt
@@ -32,6 +32,7 @@ set(utils_common_sources
     mono-sha1.c
     mono-logger.c
     mono-logger-internals.h
+    mono-cgroup.c
     mono-codeman.c
     mono-counters.c
     mono-compiler.h