From nobody Sun Nov 09 22:39:13 2025 X-Original-To: dev-commits-src-main@mlmmj.nyi.freebsd.org Received: from mx1.freebsd.org (mx1.freebsd.org [IPv6:2610:1c1:1:606c::19:1]) by mlmmj.nyi.freebsd.org (Postfix) with ESMTP id 4d4SQV0zvgz6G96x; Sun, 09 Nov 2025 22:39:14 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from mxrelay.nyi.freebsd.org (mxrelay.nyi.freebsd.org [IPv6:2610:1c1:1:606c::19:3]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256 client-signature RSA-PSS (4096 bits) client-digest SHA256) (Client CN "mxrelay.nyi.freebsd.org", Issuer "R12" (verified OK)) by mx1.freebsd.org (Postfix) with ESMTPS id 4d4SQT6rmNz3Dfg; Sun, 09 Nov 2025 22:39:13 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1762727954; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=Ii3EiE8E5nDdQMkP5BwZkKImAoDd3lj+LhjVgWB4Cgk=; b=mrOkwvNrvqI+9BLQr33inzYnsqL26sh1cAuCM5kjCnu9HHb82OYI6QWHVQRs3muGAwABFN d8MWduPzTlRdQpYel0eplQA0aTIfd2v8noBKJZTMl9dJD0aI8NuSXb5v/U+xIkgiCehlBZ DPsNqnldhTysR2GZI6Noe5ZTBuUYOST4VIA9Jy/ShuJfeKUi/KtVeaJMzJXV9Rb3F6mAIG LAhR43BY2hU39i+coqcVi5RLk/xsH0Ie7Z8su4Tef2EljNoW6AoB00latoHo2VpGigOzvk hkCS9iP16pBeWr/am0B8yTVggFQt1VZK6fqY7SVF01kw4cZuG8JTUrpU/bfScQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1762727954; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=Ii3EiE8E5nDdQMkP5BwZkKImAoDd3lj+LhjVgWB4Cgk=; b=jpE1ntwv9XNa2gDr5Ihx04KVJx/JyeVk3HNrTRjmFBgvPsaZ6n6OP36stvN3zWWvFX60eD /2Vjya+8HG1H7hTd+p1nI7GByMzvhfYur3orYJH0Ary/+eR1s/eaTgPk8EbmGpP2aCZOB4 Hkpd+2Wpd/LJDCdJbmm6BI7/snicdDm70g497y8Ub0aVxCSwIdZ6X2ADzxhk+5QnqxohvQ 1OOO3HJV++bAchhB2uxwkjVjUZzsqMowBG20VNze3mS7IEj4aLRYCvZtEwrW0zlvkKg2hT +YTku/NFipyEPGz2GLzyrWI2iSoMARLE8xvepxfqB3rr/gfh919n0agyuI/YPg== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1762727954; a=rsa-sha256; cv=none; b=vRya89KDoZsELoNgiAp4D0uNnyX70hGkP+rfawqedS/RDTry8GKiHuZmeFd4VL+BSzQRiB qcmT75dS7I16DXbLypcHVq8Fl00stFBdBHkp/lOpEjhywi2LUYzwTdZ+uqrkU4p3RlJNhJ 4DfvVeMkhsuuumAQM+ZpkchXwWWV7RZJfW1aXu9sIAAT/HFXUjkGo4UzxCXDRKl7uDs+R2 zNRIyXzWycWOKssbfWUjT6IFDPJlFTAuDJ9DjnH7+aZfpu7ggrOw5AQwatELiv7ElY/PKL T/PKEbcY9++WnWC+rL9+ibQHZJjGkrL/2sb5u9f8BBf9Q5bWyeCunSCvzhZLKw== ARC-Authentication-Results: i=1; mx1.freebsd.org; none Received: from gitrepo.freebsd.org (gitrepo.freebsd.org [IPv6:2610:1c1:1:6068::e6a:5]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (Client did not present a certificate) by mxrelay.nyi.freebsd.org (Postfix) with ESMTPS id 4d4SQT6L6Kzrpt; Sun, 09 Nov 2025 22:39:13 +0000 (UTC) (envelope-from git@FreeBSD.org) Received: from gitrepo.freebsd.org ([127.0.1.44]) by gitrepo.freebsd.org (8.18.1/8.18.1) with ESMTP id 5A9MdDnd003186; Sun, 9 Nov 2025 22:39:13 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.18.1/8.18.1/Submit) id 5A9MdDbd003184; Sun, 9 Nov 2025 22:39:13 GMT (envelope-from git) Date: Sun, 9 Nov 2025 22:39:13 GMT Message-Id: <202511092239.5A9MdDbd003184@gitrepo.freebsd.org> To: src-committers@FreeBSD.org, dev-commits-src-all@FreeBSD.org, dev-commits-src-main@FreeBSD.org From: Olivier Certner Subject: git: c3d2b68c6933 - main - kern: RACCT: Keep process credentials alive via references List-Id: Commit messages for the main branch of the src repository List-Archive: https://lists.freebsd.org/archives/dev-commits-src-main List-Help: List-Post: List-Subscribe: List-Unsubscribe: X-BeenThere: dev-commits-src-main@freebsd.org Sender: owner-dev-commits-src-main@FreeBSD.org MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit X-Git-Committer: olce X-Git-Repository: src X-Git-Refname: refs/heads/main X-Git-Reftype: branch X-Git-Commit: c3d2b68c6933d0610bc3e09e9b94f963b4dc85aa Auto-Submitted: auto-generated The branch main has been updated by olce: URL: https://cgit.FreeBSD.org/src/commit/?id=c3d2b68c6933d0610bc3e09e9b94f963b4dc85aa commit c3d2b68c6933d0610bc3e09e9b94f963b4dc85aa Author: Olivier Certner AuthorDate: 2025-11-03 18:21:08 +0000 Commit: Olivier Certner CommitDate: 2025-11-09 22:38:14 +0000 kern: RACCT: Keep process credentials alive via references In system calls changing process credentials, on RACCT, calls to racct_proc_ucred_changed() must be issued on the new credentials. Currently, this is done after the new credentials have been installed on the process via proc_set_cred() or proc_set_cred_enforce_proc_lim(), which modifies 'p_ucred'. Only the process lock guarantees that the new credentials pointed to by 'p_ucred' cannot themselves be concurrently modified, which would cause their 'struct ucred' to potentially lose its last reference from the process before the call to racct_proc_ucred_changed(), which needs one. For better code understandability and to avoid errors in future modifications, stop relying on proc_set_cred*() storing the passed 'struct ucred' in the process 'p_ucred' and on the process lock to avoid the reference taken by proc_set_cred*() to vanish. Instead, ensure that a reference is held when racct_proc_ucred_changed() is called. As racct_proc_ucred_changed() is actually passed explicit pointers to the old and new credentials, there is in fact no need to call it after proc_set_cred(). Instead, call it before proc_set_cred() and its taking over the reference. Since setcred() uses proc_set_cred_enforce_proc_lim(), which can fail, instead of proc_set_cred(), we instead take an additional reference with crhold(). Indeed, racct_proc_ucred_changed() should update resource accounting only if proc_set_cred_enforce_proc_lim() succeeds (an alternative would be to call it in advance and then in case of failure of the latter to call it again in order to backpedal the updated accounting, but we don't see a compelling reason to do that instead of taking an additional reference). While here, add to the documentation of proc_set_cred_enforce_proc_lim() that it does not take over the credentials reference in case of failure. While here, in racct_proc_ucred_changed()'s herald comment, add the precise condition in which this function must be called. No functional change intended. Reviewed by: kib MFC after: 1 week Sponsored by: The FreeBSD Foundation Differential Revision: https://reviews.freebsd.org/D53563 --- sys/kern/kern_jail.c | 9 ++++++-- sys/kern/kern_loginclass.c | 7 +++++- sys/kern/kern_prot.c | 54 +++++++++++++++++++++++++++++++++------------- sys/kern/kern_racct.c | 6 ++++-- 4 files changed, 56 insertions(+), 20 deletions(-) diff --git a/sys/kern/kern_jail.c b/sys/kern/kern_jail.c index 26a994ef0c32..d1149dd4fb3b 100644 --- a/sys/kern/kern_jail.c +++ b/sys/kern/kern_jail.c @@ -3046,14 +3046,19 @@ do_jail_attach(struct thread *td, struct prison *pr, int drflags) PROC_LOCK(p); oldcred = crcopysafe(p, newcred); newcred->cr_prison = pr; - proc_set_cred(p, newcred); - setsugid(p); #ifdef RACCT racct_proc_ucred_changed(p, oldcred, newcred); #endif #ifdef RCTL crhold(newcred); #endif + /* + * Takes over 'newcred''s reference, so 'newcred' must not be used + * besides this point except on RCTL where we took an additional + * reference above. + */ + proc_set_cred(p, newcred); + setsugid(p); PROC_UNLOCK(p); #ifdef RCTL rctl_proc_ucred_changed(p, newcred); diff --git a/sys/kern/kern_loginclass.c b/sys/kern/kern_loginclass.c index 0c111c4f78d8..07d388f18f8d 100644 --- a/sys/kern/kern_loginclass.c +++ b/sys/kern/kern_loginclass.c @@ -222,13 +222,18 @@ sys_setloginclass(struct thread *td, struct setloginclass_args *uap) PROC_LOCK(p); oldcred = crcopysafe(p, newcred); newcred->cr_loginclass = newlc; - proc_set_cred(p, newcred); #ifdef RACCT racct_proc_ucred_changed(p, oldcred, newcred); #endif #ifdef RCTL crhold(newcred); #endif + /* + * Takes over 'newcred''s reference, so 'newcred' must not be used + * besides this point except on RCTL where we took an additional + * reference above. + */ + proc_set_cred(p, newcred); PROC_UNLOCK(p); #ifdef RCTL rctl_proc_ucred_changed(p, newcred); diff --git a/sys/kern/kern_prot.c b/sys/kern/kern_prot.c index 47f9937e49aa..06696612f8c4 100644 --- a/sys/kern/kern_prot.c +++ b/sys/kern/kern_prot.c @@ -832,22 +832,31 @@ kern_setcred(struct thread *const td, const u_int flags, if (error != 0) goto unlock_finish; +#ifdef RACCT /* - * Set the new credentials, noting that they have changed. + * Hold a reference to 'new_cred', as we need to call some functions on + * it after proc_set_cred_enforce_proc_lim(). */ + crhold(new_cred); +#endif + + /* Set the new credentials. */ cred_set = proc_set_cred_enforce_proc_lim(p, new_cred); if (cred_set) { setsugid(p); - to_free_cred = old_cred; #ifdef RACCT + /* Adjust RACCT counters. */ racct_proc_ucred_changed(p, old_cred, new_cred); #endif -#ifdef RCTL - crhold(new_cred); -#endif + to_free_cred = old_cred; MPASS(error == 0); - } else + } else { +#ifdef RACCT + /* Matches the crhold() just before the containing 'if'. */ + crfree(new_cred); +#endif error = EAGAIN; + } unlock_finish: PROC_UNLOCK(p); @@ -857,10 +866,12 @@ unlock_finish: * finishing operations. */ -#ifdef RCTL +#ifdef RACCT if (cred_set) { +#ifdef RCTL rctl_proc_ucred_changed(p, new_cred); - /* Paired with the crhold() just above. */ +#endif + /* Paired with the crhold() above. */ crfree(new_cred); } #endif @@ -991,16 +1002,19 @@ sys_setuid(struct thread *td, struct setuid_args *uap) change_euid(newcred, uip); setsugid(p); } - /* - * This also transfers the proc count to the new user. - */ - proc_set_cred(p, newcred); + #ifdef RACCT racct_proc_ucred_changed(p, oldcred, newcred); #endif #ifdef RCTL crhold(newcred); #endif + /* + * Takes over 'newcred''s reference, so 'newcred' must not be used + * besides this point except on RCTL where we took an additional + * reference above. + */ + proc_set_cred(p, newcred); PROC_UNLOCK(p); #ifdef RCTL rctl_proc_ucred_changed(p, newcred); @@ -1404,13 +1418,18 @@ sys_setreuid(struct thread *td, struct setreuid_args *uap) change_svuid(newcred, newcred->cr_uid); setsugid(p); } - proc_set_cred(p, newcred); #ifdef RACCT racct_proc_ucred_changed(p, oldcred, newcred); #endif #ifdef RCTL crhold(newcred); #endif + /* + * Takes over 'newcred''s reference, so 'newcred' must not be used + * besides this point except on RCTL where we took an additional + * reference above. + */ + proc_set_cred(p, newcred); PROC_UNLOCK(p); #ifdef RCTL rctl_proc_ucred_changed(p, newcred); @@ -1552,13 +1571,18 @@ sys_setresuid(struct thread *td, struct setresuid_args *uap) change_svuid(newcred, suid); setsugid(p); } - proc_set_cred(p, newcred); #ifdef RACCT racct_proc_ucred_changed(p, oldcred, newcred); #endif #ifdef RCTL crhold(newcred); #endif + /* + * Takes over 'newcred''s reference, so 'newcred' must not be used + * besides this point except on RCTL where we took an additional + * reference above. + */ + proc_set_cred(p, newcred); PROC_UNLOCK(p); #ifdef RCTL rctl_proc_ucred_changed(p, newcred); @@ -2783,7 +2807,7 @@ cru2xt(struct thread *td, struct xucred *xcr) * 'enforce_proc_lim' being true and if no new process can be accounted to the * new real UID because of the current limit (see the inner comment for more * details) and the caller does not have privilege (PRIV_PROC_LIMIT) to override - * that. + * that. In this case, the reference to 'newcred' is not taken over. */ static bool _proc_set_cred(struct proc *p, struct ucred *newcred, bool enforce_proc_lim) diff --git a/sys/kern/kern_racct.c b/sys/kern/kern_racct.c index 17b64ad00bb5..d1324935bdc3 100644 --- a/sys/kern/kern_racct.c +++ b/sys/kern/kern_racct.c @@ -949,8 +949,10 @@ racct_proc_exit(struct proc *p) } /* - * Called after credentials change, to move resource utilisation - * between raccts. + * Called to signal credentials change, to move resource utilisation + * between raccts. Must be called with the proc lock held, in the same span as + * the credentials change itself (i.e., without the proc lock being unlocked + * between the two), but the order does not matter. */ void racct_proc_ucred_changed(struct proc *p, struct ucred *oldcred,