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

+ *