Use a per-process mutex to protect time accounting instead of SCHED_LOCK().

Note that hardclock(9) still increments p_{u,s,i}ticks without holding a
lock.

ok visa@, cheloha@

1 files changed, 30 insertions, 25 deletions

diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c
index ffe560d7e38..4e972683eb7 100644
--- a/sys/kern/kern_resource.c
+++ b/sys/kern/kern_resource.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: kern_resource.c,v 1.60 2019/05/31 04:46:18 visa Exp $	*/
+/*	$OpenBSD: kern_resource.c,v 1.61 2019/05/31 19:51:09 mpi Exp $	*/
 /*	$NetBSD: kern_resource.c,v 1.38 1996/10/23 07:19:38 matthias Exp $	*/
 
 /*-
@@ -47,13 +47,13 @@
 #include <sys/ktrace.h>
 #include <sys/sched.h>
 #include <sys/signalvar.h>
-
+#include <sys/mutex.h>
 #include <sys/mount.h>
 #include <sys/syscallargs.h>
 
 #include <uvm/uvm_extern.h>
 
-void	tuagg_sub(struct tusage *, struct proc *);
+void	tuagg_sub(struct tusage *, struct tusage *);
 
 /*
  * Patchable maximum data and stack limits.
@@ -338,12 +338,12 @@ sys_getrlimit(struct proc *p, void *v, register_t *retval)
 }
 
 void
-tuagg_sub(struct tusage *tup, struct proc *p)
+tuagg_sub(struct tusage *ttup, struct tusage *ftup)
 {
-	timespecadd(&tup->tu_runtime, &p->p_rtime, &tup->tu_runtime);
-	tup->tu_uticks += p->p_uticks;
-	tup->tu_sticks += p->p_sticks;
-	tup->tu_iticks += p->p_iticks;
+	timespecadd(&ttup->tu_runtime, &ftup->tu_runtime, &ttup->tu_runtime);
+	ttup->tu_uticks += ftup->tu_uticks;
+	ttup->tu_sticks += ftup->tu_sticks;
+	ttup->tu_iticks += ftup->tu_iticks;
 }
 
 /*
@@ -351,24 +351,26 @@ tuagg_sub(struct tusage *tup, struct proc *p)
  * totals for the thread and process
  */
 void
-tuagg_unlocked(struct process *pr, struct proc *p)
+tuagg(struct proc *p, struct timespec *tsp)
 {
-	tuagg_sub(&pr->ps_tu, p);
-	tuagg_sub(&p->p_tu, p);
-	timespecclear(&p->p_rtime);
+	struct process *pr = p->p_p;
+	struct tusage tu;
+
+	mtx_enter(&pr->ps_mtx);
+	tu.tu_uticks = p->p_uticks;
+	tu.tu_sticks = p->p_sticks;
+	tu.tu_iticks = p->p_iticks;
 	p->p_uticks = 0;
 	p->p_sticks = 0;
 	p->p_iticks = 0;
-}
-
-void
-tuagg(struct process *pr, struct proc *p)
-{
-	int s;
+	if (tsp != NULL)
+		timespecadd(&p->p_rtime, tsp, &p->p_rtime);
+	tu.tu_runtime = p->p_rtime;
+	timespecclear(&p->p_rtime);
+	tuagg_sub(&pr->ps_tu, &tu);
+	tuagg_sub(&p->p_tu, &tu);
+	mtx_leave(&pr->ps_mtx);
 
-	SCHED_LOCK(s);
-	tuagg_unlocked(pr, p);
-	SCHED_UNLOCK(s);
 }
 
 /*
@@ -461,15 +463,19 @@ dogetrusage(struct proc *p, int who, struct rusage *rup)
 		/* add on all living threads */
 		TAILQ_FOREACH(q, &pr->ps_threads, p_thr_link) {
 			ruadd(rup, &q->p_ru);
-			tuagg(pr, q);
+			tuagg(q, NULL);
 		}
 
+		mtx_enter(&pr->ps_mtx);
 		calcru(&pr->ps_tu, &rup->ru_utime, &rup->ru_stime, NULL);
+		mtx_leave(&pr->ps_mtx);
 		break;
 
 	case RUSAGE_THREAD:
 		*rup = p->p_ru;
+		mtx_enter(&pr->ps_mtx);
 		calcru(&p->p_tu, &rup->ru_utime, &rup->ru_stime, NULL);
+		mtx_leave(&pr->ps_mtx);
 		break;
 
 	case RUSAGE_CHILDREN:
@@ -507,13 +513,12 @@ rucheck(void *arg)
 	struct process *pr = arg;
 	struct rlimit *rlim;
 	rlim_t runtime;
-	int s;
 
 	KERNEL_ASSERT_LOCKED();
 
-	SCHED_LOCK(s);
+	mtx_enter(&pr->ps_mtx);
 	runtime = pr->ps_tu.tu_runtime.tv_sec;
-	SCHED_UNLOCK(s);
+	mtx_leave(&pr->ps_mtx);
 
 	rlim = &pr->ps_limit->pl_rlimit[RLIMIT_CPU];
 	if (runtime >= rlim->rlim_cur) {