diff --git a/build/cmake/CondorConfigure.cmake b/build/cmake/CondorConfigure.cmake

index e61fb4f..1094cb3 100644

--- a/build/cmake/CondorConfigure.cmake

+++ b/build/cmake/CondorConfigure.cmake

@@ -164,6 +164,7 @@ if( NOT WINDOWS)

 	check_function_exists("setlinebuf" HAVE_SETLINEBUF)

 	check_function_exists("snprintf" HAVE_SNPRINTF)

 	check_function_exists("snprintf" HAVE_WORKING_SNPRINTF)

+	check_function_exists("eventfd" HAVE_EVENTFD)

 	check_function_exists("stat64" HAVE_STAT64)

 	check_function_exists("_stati64" HAVE__STATI64)

diff --git a/src/condor_includes/config.h.cmake b/src/condor_includes/config.h.cmake

index b083945..3bd92b0 100644

--- a/src/condor_includes/config.h.cmake

+++ b/src/condor_includes/config.h.cmake

@@ -438,6 +438,9 @@

 /* Define to 1 if you have the 'snprintf' function. (USED)*/

 #cmakedefine HAVE_SNPRINTF 1

+/* Define to 1 if you have the 'eventfd' function. (USED)*/

+#cmakedefine HAVE_EVENTFD 1

+

 /* Define to 1 if you have the 'stat64' function. (USED)*/

 #cmakedefine HAVE_STAT64 1

diff --git a/src/condor_starter.V6.1/vanilla_proc.cpp b/src/condor_starter.V6.1/vanilla_proc.cpp

index 2e5538f..fe02dd3 100644

--- a/src/condor_starter.V6.1/vanilla_proc.cpp

+++ b/src/condor_starter.V6.1/vanilla_proc.cpp

@@ -42,9 +42,16 @@

 extern dynuser* myDynuser;

 #endif

+#if defined(HAVE_EVENTFD)

+#include <sys/eventfd.h>

+#endif

+

 extern CStarter *Starter;

-VanillaProc::VanillaProc(ClassAd* jobAd) : OsProc(jobAd)

+VanillaProc::VanillaProc(ClassAd* jobAd) : OsProc(jobAd),

+	m_memory_limit(-1),

+	m_oom_fd(-1),

+	m_oom_efd(-1)

 {

 #if !defined(WIN32)

 	m_escalation_tid = -1;

@@ -215,6 +222,12 @@ VanillaProc::StartJob()

 		}

 		fi.group_ptr = &tracking_gid;

 	}

+

+	// Increase the OOM score of this process; the child will inherit it.

+	// This way, the job will be heavily preferred to be killed over a normal process.

+	// OOM score is currently exponential - a score of 4 is a factor-16 increase in

+	// the OOM score.

+	setupOOMScore(4);

 #endif

 #if defined(HAVE_EXT_LIBCGROUP)

@@ -406,6 +419,7 @@ VanillaProc::StartJob()

 			int MemMb;

 			if (MachineAd->LookupInteger(ATTR_MEMORY, MemMb)) {

 				uint64_t MemMb_big = MemMb;

+				m_memory_limit = MemMb_big;

 				climits.set_memory_limit_bytes(1024*1024*MemMb_big, mem_is_soft);

 			} else {

 				dprintf(D_ALWAYS, "Not setting memory soft limit in cgroup because "

@@ -425,6 +439,14 @@ VanillaProc::StartJob()

 		} else {

 			dprintf(D_FULLDEBUG, "Invalid value of SlotWeight in machine ClassAd; ignoring.\n");

 		}

+		setupOOMEvent(cgroup);

+	}

+

+	// Now that the job is started, decrease the likelihood that the starter

+	// is killed instead of the job itself.

+	if (retval)

+	{

+		setupOOMScore(-4);

 	}

 #endif

@@ -611,5 +633,224 @@ VanillaProc::finishShutdownFast()

 	//   -gquinn, 2007-11-14

 	daemonCore->Kill_Family(JobPid);

+	if (m_oom_efd >= 0) {

+		dprintf(D_FULLDEBUG, "Closing event FD pipe in shutdown %d.\n", m_oom_efd);

+		daemonCore->Close_Pipe(m_oom_efd);

+		m_oom_efd = -1;

+	}

+	if (m_oom_fd >= 0) {

+		close(m_oom_fd);

+		m_oom_fd = -1;

+	}

+

 	return false;	// shutdown is pending, so return false

 }

+

+/*

+ * This will be called when the event fd fires, indicating an OOM event.

+ */

+int

+VanillaProc::outOfMemoryEvent(int /* fd */)

+{

+	std::stringstream ss;

+	if (m_memory_limit >= 0) {

+		ss << "Job has gone over memory limit of " << m_memory_limit << " megabytes.";

+	} else {

+		ss << "Job has encountered an out-of-memory event.";

+	}

+	Starter->jic->holdJob(ss.str().c_str(), CONDOR_HOLD_CODE_JobOutOfResources, 0);

+

+	// this will actually clean up the job

+	if ( Starter->Hold( ) ) {

+		dprintf( D_FULLDEBUG, "All jobs were removed due to OOM event.\n" );

+		Starter->allJobsDone();

+	}

+

+	dprintf(D_FULLDEBUG, "Closing event FD pipe %d.\n", m_oom_efd);

+	daemonCore->Close_Pipe(m_oom_efd);

+	close(m_oom_fd);

+	m_oom_efd = -1;

+	m_oom_fd = -1;

+

+	Starter->ShutdownFast();

+

+	return 0;

+}

+

+int

+VanillaProc::setupOOMScore(int new_score)

+{

+#if !defined(LINUX)

+	if (new_score) // Done to suppress compiler warnings.

+		return 0;

+	return 0;

+#endif

+	TemporaryPrivSentry sentry(PRIV_ROOT);

+	// oom_adj is deprecated on modern kernels and causes a deprecation warning when used.

+	int oom_score_fd = open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC);

+	if (oom_score_fd == -1) {

+		if (errno != ENOENT) {

+			dprintf(D_ALWAYS,

+				"Unable to open oom_score_adj for the starter: (errno=%u, %s)\n",

+				errno, strerror(errno));

+			return 1;

+		} else {

+			int oom_score_fd = open("/proc/self/oom_adj", O_WRONLY | O_CLOEXEC);

+			if (oom_score_fd == -1) {

+				dprintf(D_ALWAYS,

+					"Unable to open oom_adj for the starter: (errno=%u, %s)\n",

+					errno, strerror(errno));

+				return 1;

+			}

+		}

+	} else {

+		// oom_score_adj is linear; oom_adj was exponential.

+		if (new_score > 0)

+			new_score = 1 << new_score;

+		else

+			new_score = -(1 << -new_score);

+	}

+

+	std::stringstream ss;

+	ss << new_score;

+	std::string new_score_str = ss.str();

+        ssize_t nwritten = full_write(oom_score_fd, new_score_str.c_str(), new_score_str.length());

+	if (nwritten < 0) {

+		dprintf(D_ALWAYS,

+			"Unable to write into oom_adj file for the starter: (errno=%u, %s)\n",

+			errno, strerror(errno));

+		close(oom_score_fd);

+		return 1;

+	}

+	close(oom_score_fd);

+	return 0;

+}

+

+int

+VanillaProc::setupOOMEvent(const std::string &cgroup_string)

+{

+#if !(defined(HAVE_EVENTFD) && defined(HAVE_EXT_LIBCGROUP))

+	return 0;

+#endif

+	// Initialize the event descriptor

+	m_oom_efd = eventfd(0, EFD_CLOEXEC);

+	if (m_oom_efd == -1) {

+		dprintf(D_ALWAYS,

+			"Unable to create new event FD for starter: %u %s\n",

+			errno, strerror(errno));

+		return 1;

+	}

+

+	// Find the memcg location on disk

+	void * handle = NULL;

+	struct cgroup_mount_point mount_info;

+	int ret = cgroup_get_controller_begin(&handle, &mount_info);

+	std::stringstream oom_control;

+	std::stringstream event_control;

+	bool found_memcg = false;

+	while (ret == 0) {

+		if (strcmp(mount_info.name, MEMORY_CONTROLLER_STR) == 0) {

+			found_memcg = true;

+			oom_control << mount_info.path << "/";

+			event_control << mount_info.path << "/";

+			break;

+		}

+		cgroup_get_controller_next(&handle, &mount_info);

+	}

+	if (!found_memcg && (ret != ECGEOF)) {

+		dprintf(D_ALWAYS,

+			"Error while locating memcg controller for starter: %u %s\n",

+			ret, cgroup_strerror(ret));

+		return 1;

+	}

+	cgroup_get_controller_end(&handle);

+	if (found_memcg == false) {

+		dprintf(D_ALWAYS,

+			"Memcg is not available; OOM notification disabled for starter.\n");

+		return 1;

+	}

+

+	// Finish constructing the location of the control files

+	oom_control << cgroup_string << "/memory.oom_control";

+	std::string oom_control_str = oom_control.str();

+	event_control << cgroup_string << "/cgroup.event_control";

+	std::string event_control_str = event_control.str();

+

+	// Open the oom_control and event control files

+	TemporaryPrivSentry sentry(PRIV_ROOT);

+	m_oom_fd = open(oom_control_str.c_str(), O_RDONLY | O_CLOEXEC);

+	if (m_oom_fd == -1) {

+		dprintf(D_ALWAYS,

+			"Unable to open the OOM control file for starter: %u %s\n",

+			errno, strerror(errno));

+		return 1;

+	}

+	int event_ctrl_fd = open(event_control_str.c_str(), O_WRONLY | O_CLOEXEC);

+	if (event_ctrl_fd == -1) {

+		dprintf(D_ALWAYS,

+			"Unable to open event control for starter: %u %s\n",

+			errno, strerror(errno));

+		return 1;

+	}

+

+	// Inform Linux we will be handling the OOM events for this container.

+	int oom_fd2 = open(oom_control_str.c_str(), O_WRONLY | O_CLOEXEC);

+	if (oom_fd2 == -1) {

+		dprintf(D_ALWAYS,

+			"Unable to open the OOM control file for writing for starter: %u %s\n",

+			errno, strerror(errno));

+		return 1;

+	}

+	const char limits [] = "1";

+        ssize_t nwritten = full_write(oom_fd2, &limits, 1);

+	if (nwritten < 0) {

+		dprintf(D_ALWAYS,

+			"Unable to set OOM control to %s for starter: %u %s\n",

+				limits, errno, strerror(errno));

+		close(event_ctrl_fd);

+		close(oom_fd2);

+		return 1;

+	}

+	close(oom_fd2);

+

+	// Create the subscription string:

+	std::stringstream sub_ss;

+	sub_ss << m_oom_efd << " " << m_oom_fd;

+	std::string sub_str = sub_ss.str();

+

+	if ((nwritten = full_write(event_ctrl_fd, sub_str.c_str(), sub_str.size())) < 0) {

+		dprintf(D_ALWAYS,

+			"Unable to write into event control file for starter: %u %s\n",

+			errno, strerror(errno));

+		close(event_ctrl_fd);

+		return 1;

+	}

+	close(event_ctrl_fd);

+

+	// Fool DC into talking to the eventfd

+	int pipes[2]; pipes[0] = -1; pipes[1] = -1;

+	int fd_to_replace = -1;

+	if (daemonCore->Create_Pipe(pipes, true) == -1 || pipes[0] == -1) {

+		dprintf(D_ALWAYS, "Unable to create a DC pipe\n");

+		close(m_oom_efd);

+		m_oom_efd = -1;

+		close(m_oom_fd);

+		m_oom_fd = -1;

+		return 1;

+	}

+	if ( daemonCore->Get_Pipe_FD(pipes[0], &fd_to_replace) == -1 || fd_to_replace == -1) {

+		dprintf(D_ALWAYS, "Unable to lookup pipe's FD\n");

+		close(m_oom_efd); m_oom_efd = -1;

+		close(m_oom_fd); m_oom_fd = -1;

+		daemonCore->Close_Pipe(pipes[0]);

+		daemonCore->Close_Pipe(pipes[1]);

+	}

+	dup3(m_oom_efd, fd_to_replace, O_CLOEXEC);

+	close(m_oom_efd);

+	m_oom_efd = pipes[0];

+

+	// Inform DC we want to recieve notifications from this FD.

+	daemonCore->Register_Pipe(pipes[0],"OOM event fd", static_cast<PipeHandlercpp>(&VanillaProc::outOfMemoryEvent),"OOM Event Handler",this,HANDLE_READ);

+	return 0;

+}

+

diff --git a/src/condor_starter.V6.1/vanilla_proc.h b/src/condor_starter.V6.1/vanilla_proc.h

index d524cf5..90b4741 100644

--- a/src/condor_starter.V6.1/vanilla_proc.h

+++ b/src/condor_starter.V6.1/vanilla_proc.h

@@ -74,6 +74,15 @@ private:

 #if !defined(WIN32)

 	int m_escalation_tid;

 #endif

+

+	// Configure OOM killer for this job

+	int m_memory_limit; // Memory limit, in MB.

+	int m_oom_fd; // The file descriptor which recieves events

+	int m_oom_efd; // The event FD to watch

+	int setupOOMScore(int new_score);

+	int outOfMemoryEvent(int fd);

+	int setupOOMEvent(const std::string & cgroup_string);

+

 };

 #endif

diff --git a/src/condor_utils/condor_holdcodes.h b/src/condor_utils/condor_holdcodes.h

index d788d6e..3083db3 100644

--- a/src/condor_utils/condor_holdcodes.h

+++ b/src/condor_utils/condor_holdcodes.h

@@ -128,4 +128,6 @@ const int CONDOR_HOLD_CODE_GlexecChownSandboxToCondor = 30;

 const int CONDOR_HOLD_CODE_PrivsepChownSandboxToCondor = 31;

+const int CONDOR_HOLD_CODE_JobOutOfResources = 32;

+

 #endif