diff --git a/src/condor_procd/proc_family.cpp b/src/condor_procd/proc_family.cpp
index d35ffcc..29d9471 100644
--- a/src/condor_procd/proc_family.cpp
+++ b/src/condor_procd/proc_family.cpp
@@ -54,7 +54,9 @@ ProcFamily::ProcFamily(ProcFamilyMonitor* monitor,
 	m_member_list(NULL)
 #if defined(HAVE_EXT_LIBCGROUP)
 	, m_cgroup_string(""),
-	m_cm(CgroupManager::getInstance())
+	m_cm(CgroupManager::getInstance()),
+	m_initial_user_cpu(0),
+	m_initial_sys_cpu(0)
 #endif
 {
 #if !defined(WIN32)
@@ -188,6 +190,7 @@ after_migrate:
 		cgroup_free(&orig_cgroup);
 	}
 
+
 after_restore:
 	if (orig_cgroup_string != NULL) {
 		free(orig_cgroup_string);
@@ -231,6 +234,27 @@ ProcFamily::set_cgroup(const std::string &cgroup_string)
 		member = member->m_next;
 	}
 
+	// Record the amount of pre-existing CPU usage here.
+	m_initial_user_cpu = 0;
+	m_initial_sys_cpu = 0;
+	get_cpu_usage_cgroup(m_initial_user_cpu, m_initial_sys_cpu);
+
+	// Reset block IO controller
+	if (m_cm.isMounted(CgroupManager::BLOCK_CONTROLLER)) {
+		struct cgroup *tmp_cgroup = cgroup_new_cgroup(m_cgroup_string.c_str());
+		struct cgroup_controller *blkio_controller = cgroup_add_controller(tmp_cgroup, BLOCK_CONTROLLER_STR);
+		ASSERT (blkio_controller != NULL); // Block IO controller should already exist.
+		cgroup_add_value_uint64(blkio_controller, "blkio.reset_stats", 0);
+		int err;
+		if ((err = cgroup_modify_cgroup(tmp_cgroup))) {
+			// Not allowed to reset stats?
+			dprintf(D_ALWAYS,
+				"Unable to reset cgroup %s block IO statistics. "
+				"Some block IO accounting will be inaccurate (ProcFamily %u): %u %s\n",
+				m_cgroup_string.c_str(), m_root_pid, err, cgroup_strerror(err));
+		}
+	}
+
 	return 0;
 }
 
@@ -486,6 +510,40 @@ ProcFamily::aggregate_usage_cgroup_blockio(ProcFamilyUsage* usage)
 	return 0;
 }
 
+int ProcFamily::get_cpu_usage_cgroup(long &user_time, long &sys_time) {
+
+	if (!m_cm.isMounted(CgroupManager::CPUACCT_CONTROLLER)) {
+		return 1;
+	}
+
+	void * handle = NULL;
+	u_int64_t tmp = 0;
+	struct cgroup_stat stats;
+	int err = cgroup_read_stats_begin(CPUACCT_CONTROLLER_STR, m_cgroup_string.c_str(), &handle, &stats);
+	while (err != ECGEOF) {
+		if (err > 0) {
+			dprintf(D_PROCFAMILY,
+				"Unable to read cgroup %s cpuacct stats (ProcFamily %u): %s.\n",
+				m_cgroup_string.c_str(), m_root_pid, cgroup_strerror(err));
+			break;
+		}
+		if (_check_stat_uint64(stats, "user", &tmp)) {
+			user_time = tmp/clock_tick-m_initial_user_cpu;
+		} else if (_check_stat_uint64(stats, "system", &tmp)) {
+			sys_time = tmp/clock_tick-m_initial_sys_cpu;
+		}
+			err = cgroup_read_stats_next(&handle, &stats);
+	}
+	if (handle != NULL) {
+		cgroup_read_stats_end(&handle);
+	}
+	if (err != ECGEOF) {
+		dprintf(D_ALWAYS, "Internal cgroup error when retrieving CPU statistics: %s\n", cgroup_strerror(err));
+		return 1;
+	}
+	return 0;
+}
+
 int
 ProcFamily::aggregate_usage_cgroup(ProcFamilyUsage* usage)
 {
@@ -496,16 +554,13 @@ ProcFamily::aggregate_usage_cgroup(ProcFamilyUsage* usage)
 
 	int err;
 	struct cgroup_stat stats;
-	void **handle;
+	void *handle = NULL;
 	u_int64_t tmp = 0, image = 0;
 	bool found_rss = false;
 
 	// Update memory
-	handle = (void **)malloc(sizeof(void*));
-	ASSERT (handle != NULL);
-	*handle = NULL;
 
-	err = cgroup_read_stats_begin(MEMORY_CONTROLLER_STR, m_cgroup_string.c_str(), handle, &stats);
+	err = cgroup_read_stats_begin(MEMORY_CONTROLLER_STR, m_cgroup_string.c_str(), &handle, &stats);
 	while (err != ECGEOF) {
 		if (err > 0) {
 			dprintf(D_PROCFAMILY,
@@ -522,10 +577,10 @@ ProcFamily::aggregate_usage_cgroup(ProcFamilyUsage* usage)
 		} else if (_check_stat_uint64(stats, "total_swap", &tmp)) {
 			image += tmp;
 		}
-		err = cgroup_read_stats_next(handle, &stats);
+		err = cgroup_read_stats_next(&handle, &stats);
 	}
-	if (*handle != NULL) {
-		cgroup_read_stats_end(handle);
+	if (handle != NULL) {
+		cgroup_read_stats_end(&handle);
 	}
 	if (found_rss) {
 		usage->total_image_size = image/1024;
@@ -540,29 +595,12 @@ ProcFamily::aggregate_usage_cgroup(ProcFamilyUsage* usage)
 		m_max_image_size = image/1024;
 	}
 	// Try updating the max size using cgroups
-	update_max_image_size_cgroup();
+	// XXX: This is taken out for now - kernel calculates max INCLUDING
+	// the filesystem cache.  Not what you want.
+	//update_max_image_size_cgroup();
 
 	// Update CPU
-	*handle = NULL;
-	err = cgroup_read_stats_begin(CPUACCT_CONTROLLER_STR, m_cgroup_string.c_str(), handle, &stats);
-	while (err != ECGEOF) {
-		if (err > 0) {
-			dprintf(D_PROCFAMILY,
-				"Unable to read cgroup %s cpuacct stats (ProcFamily %u): %s.\n",
-				m_cgroup_string.c_str(), m_root_pid, cgroup_strerror(err));
-			break;
-		}
-		if (_check_stat_uint64(stats, "user", &tmp)) {
-			usage->user_cpu_time = tmp/clock_tick;
-		} else if (_check_stat_uint64(stats, "system", &tmp)) {
-			usage->sys_cpu_time = tmp/clock_tick;
-		}
-		err = cgroup_read_stats_next(handle, &stats);
-	}
-	if (*handle != NULL) {
-		cgroup_read_stats_end(handle);
-	}
-	free(handle);
+	get_cpu_usage_cgroup(usage->user_cpu_time, usage->sys_cpu_time);
 
 	aggregate_usage_cgroup_blockio(usage);

--- a/src/condor_procd/proc_family.h
+++ b/src/condor_procd/proc_family.h
@@ -181,6 +181,11 @@ private:
 	std::string m_cgroup_string;
 	CgroupManager &m_cm;
 	static long clock_tick;
+	// Sometimes Condor doesn't successfully clear out the cgroup from the
+	// previous run.  Hence, we subtract off any CPU usage found at the
+	// start of the job.
+	long m_initial_user_cpu;
+	long m_initial_sys_cpu;
 	static bool have_warned_about_memsw;
 
 	int count_tasks_cgroup();
@@ -190,6 +195,7 @@ private:
 	int spree_cgroup(int);
 	int migrate_to_cgroup(pid_t);
 	void update_max_image_size_cgroup();
+	int get_cpu_usage_cgroup(long &user_cpu, long &sys_cpu);
 #endif
 };