From nobody Thu Nov 06 04:06:58 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 4d27tV69NKz6FlyT; Thu, 06 Nov 2025 04:06:58 +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 4d27tV5VKlz41N2; Thu, 06 Nov 2025 04:06:58 +0000 (UTC) (envelope-from git@FreeBSD.org) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1762402018; 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=vJvbOkxhPWdNlz6gZ8ceQXafZ6vpOyjuhwJ/TnE9ftM=; b=ByWO7PnMRZY2eLRUSsEtjZc7ZEeS5PiN/BuO0YEqHlbLlM9l+JQdYtWc0X+d6Xd2mWHft9 cziPh0U5dS7U1oho7AmaSbWscG6rGd4RNZbtB047Ak4KTnKYhItvDKUk3YwedzIRBuZZHW mbHuNJo+DSSWda8kPrT/s8B3XYQNSwtntJe8gVks6+ZV2xOHcIEbLrZi0CxmOfQIZ5ll9n Wjzx76QUjZCsVaBp2uGelccqyfeYf6PmkvbrwiA3YHBs6P+BUogJ2HbteczwES3kSDIppY B/q8j9jyFfOkOxXTKgGDwZIEUKtVnDZ1hcSYglJgwEe9bgHjpXbssyaVk5YOSg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=freebsd.org; s=dkim; t=1762402018; 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=vJvbOkxhPWdNlz6gZ8ceQXafZ6vpOyjuhwJ/TnE9ftM=; b=NisG+pyyV19nZUTIQQKNVD0QWd3hNKIKCywAQ9L/DfoQoJmpA76u3fH9PV7RNr2pBtrt/d VHnQHgrRcZiRh0qm8otu9yVSf/3SutPtOPzKf1pBaLeqDwMMqTHF9CNHnR6psH8wYUY/u0 DEU0U/QwGJTAFGHmlfdd1WptCMBGVvEByUrfKphYzOd1Hbb6uuxzfkzlrxh1+ZcUu7Pv3f hECdKfTncr7/aUnp5coLDfo0aseF5D10CFnlsdcy9PHggSBiapIkqh793c0krvGAi7w94p t8qNjaMS9/UwvJ7WqcOCYpZvOE07wFUd0T5MQpTI5WOunx8/qtjiZOfZDp8tdg== ARC-Seal: i=1; s=dkim; d=freebsd.org; t=1762402018; a=rsa-sha256; cv=none; b=u3v2541yNNyWL6HdfpxCZ5FWXju6TfS59LGP23LH5X3THYd+69/vJhkRVbe4DQii59zUSf 5BPri0BYOa9HMECS6TVbpEDZ2gwmVdJqZRHyIbWcgR+4xOuHc3r4VNrNeIpCcdaK//+w82 /gPAAvq0wiZa2nwYpNjrtns15Vgr7wSwDnDtq+rq72+jZhTk6y7+SK3G7ynchCZjyhHbGN XrSmQhcp18EI0NlVt7iOXSHAaaYuTpSFU5X0WJgq/OJdlODfmULKZK0WR83EHHo9NY8uWW 4SXH/lSPMhF3jZ95iBa8lvOT8KbinCEtBGT6aAV2PWr1Q/KzjmH9A0EdYa6zUA== 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 4d27tV54j9z1CCx; Thu, 06 Nov 2025 04:06:58 +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 5A646w3u046595; Thu, 6 Nov 2025 04:06:58 GMT (envelope-from git@gitrepo.freebsd.org) Received: (from git@localhost) by gitrepo.freebsd.org (8.18.1/8.18.1/Submit) id 5A646whD046593; Thu, 6 Nov 2025 04:06:58 GMT (envelope-from git) Date: Thu, 6 Nov 2025 04:06:58 GMT Message-Id: <202511060406.5A646whD046593@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: a5d1a0c9bfcc - 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: a5d1a0c9bfcca38528b861c5afb51ea9b1696b65 Auto-Submitted: auto-generated The branch main has been updated by olce: URL: https://cgit.FreeBSD.org/src/commit/?id=a5d1a0c9bfcca38528b861c5afb51ea9b1696b65 commit a5d1a0c9bfcca38528b861c5afb51ea9b1696b65 Author: Olivier Certner AuthorDate: 2025-11-03 18:21:08 +0000 Commit: Olivier Certner CommitDate: 2025-11-06 04:06:41 +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: 3 days 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 523b7e314a10..1b9bd4cf62d5 100644 --- a/sys/kern/kern_jail.c +++ b/sys/kern/kern_jail.c @@ -3043,14 +3043,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 3c145851b683..f93cee6d7698 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,