From nobody Fri Sep 25 00:40:53 2026 Received: from mail-wm2-f12.google.com (mail-wm2-f12.google.com [74.125.225.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C8AAA3EFD27 for ; Fri, 18 Sep 2026 09:11:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.225.140 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722683; cv=none; b=KLBLJOlf7JwdFhXedanSNlhEV0Fl8gpofEBOSA9cIqUveTWS5ITm7Elofs+6HxAZY9DYaQDd+KWMKF0a0uMQVRguixRQ6LA9ISWVG3RnuaiU0rHZeB6OXoN1zB9UzjKika4vqwfUpgNh0BQTUEwfu1ce6T6q4xvcuGXszOQDPeM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722683; c=relaxed/simple; bh=STCzW5M5EW9uUQOkS2hfX2s5skhk+EdAa196HwCnHIM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Wp/N5hS67UIDyE/1Sp186rHmokrw9eEas+iUxmpFhGm5z8DsgulziwZDO+10Vy6o8oYw2xLH74rKPQAXi2OWpkQ2mXsa1nnHifMAE8zNyIP+/Z98NlVZmlpckEGkgMUh1BdzfFI3wUVnl+i/OQjw0LNSaoci50VDIni7z4U7uVs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=r8JLc1jQ; arc=none smtp.client-ip=74.125.225.140 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="r8JLc1jQ" Received: by mail-wm2-f12.google.com with SMTP id 5b1f17b1804b1-49cd4ba9f68so6775675e9.1 for ; Fri, 18 Sep 2026 02:11:21 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789722680; x=1790327480; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=lQCtz3oTX1YW2gbSF1mQxat1U/wMyPCcu5DDLW4b9vc=; b=r8JLc1jQt3xPiJ8pi+YFdOJ+gtJwCqCrmCqxXmopJ2/Y9POVZfPrMFSS5VB5YgQLtC HaMZRC1GJ647DR/tr/RDKqsYGLsjAhY/9xj0eqjGIx+TSDw5ForgfB1mxuFXYNITIabD T+mIsPcwohV1HH1scQNQ2Vugw9XGevsMG+vrwRHNc/xhZPkdslCPVOWNUFtrtwmHgcrT 1M17iwqa6N4y0cy+0FztzJGPBC9qVqO/QBFdxj+J6hLEdNj6OK1p1iAsTr9ALJ5/q9+G CBuJqZkQoAwDPxeckNL1caB2rMWsU/BTujFeT6KaBvq7g1Kg+NP3RzlveWwxgnt6NVBq RK7w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789722680; x=1790327480; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=lQCtz3oTX1YW2gbSF1mQxat1U/wMyPCcu5DDLW4b9vc=; b=jejs8ukKMm54GlcYld/sloC++dPdAoix7vvYP8P9N5hqH35Q2r6vT4heD4KwduoFwD 7rG9HtWn1CiWHXrw0cgAa5kuI2V3QP6+bJ6ZAaP/yAb5IA5SvriVI2MUL1zuh4TNKMqI 0+WfqN/Io+Kfl7QJggv9fChWVk5kFBo0zT9MvzjV3RqC8/RcIKXjXyZn71dmavAr75oD XeBAI5LIo5DiBRb0jTbVzUnHf49JbPpW8dUtz/ZpuLRPIDT7/yb2JUxnqp5AcFpY9Kli 8tWnki9SaJMbWZJi23Vnds38zjXx8FtwCPe1k8+Q0M3dB9QfCbBAvhH/7+XFQ5UzfdAy JJig== X-Forwarded-Encrypted: i=1; AKwUvBw4StszHnOmW+tcJz0UAXTZBY4G5U9NPQ4n03ztyL5gPuEAdRyM3XPpNPhEgamOHR2ELqLGjg6kwL0JmzA=@vger.kernel.org X-Gm-Message-State: AFuF++mD6ADWDBJj8bJBHzAZwI78AzzMEkSxVGdyBq/IVaP6qLSCRbvM S7QumfsaQeY8L9XBUxhS7dzEjf0dk6gp2um+h7HF0t3QGaYgF36UUgE2 X-Gm-Gg: AYBFou21pLQIayjq0d3bz6gqhDA4B2jJeXyUfUp/zS+Rqy6hmgNy9svyuqfnEH7KI7M SRmHywY8ateKUTJEdkTfP05Y6SAghtspYQUQb4AIAjsDnSr214kNLca71diMSmU5uySCHCCLWnM Hkn6NcL08MYq0acjfV43EH4j4veKRfafNAs96BNTbtjmPIn0VtWPKwf9/cm6JndiLmqLMOQP4ru 8LoO5QP/2CcaBxa855P7XN9+wk7g6BqnrlmqLUmrNSWBDHvUz7e1ITOIFOqQQwaOicO4L4XNkUI 4uIKIlzWwqmK5+c9SB8jBTNU7Oz8etiU1cxcSSTXLoGf607JuV4WSLWSKdjUSjMfWTsBIqZ0lSi 9+A86A0OWyL5qhD4KK4Qa03JHjonCmverVrrhDDmykPodkRzW5tJ2YRO4eyaEdZpIzf+h6i28Wp 7V93f/1FTtJyJgE0Vc4Z0Ub7hO/zIEhDDAEgjYKMmKh1zbwGFMyoLNKh8Chzac728Rb41VuwNhW fg0PWkjtFVSvlk= X-Received: by 2002:a05:600c:4e89:b0:49d:10d6:fd55 with SMTP id 5b1f17b1804b1-49fc5681267mr21914985e9.1.1789722679822; Fri, 18 Sep 2026 02:11:19 -0700 (PDT) Received: from dell-desktop ([2a02:587:4b4e:8500:290c:210b:1c76:5710]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49fbd1d0978sm138774275e9.2.2026.09.18.02.11.17 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2026 02:11:19 -0700 (PDT) From: Anastasios Papagiannis To: bpf@vger.kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, david@kernel.org, akpm@linux-foundation.org, andrii@kernel.org, ast@kernel.org, brauner@kernel.org, daniel@iogearbox.net, eddyz87@gmail.com, kpsingh@kernel.org, ljs@kernel.org, matt@bobrowski.net, memxor@gmail.com, song@kernel.org, sun.jian.kdev@gmail.com, utilityemal77@gmail.com, viro@zeniv.linux.org.uk, tasos.papagiannnis@gmail.com Subject: [PATCH bpf-next v8 1/5] mm: Add copy_remote_mm_str() Date: Fri, 18 Sep 2026 12:10:54 +0300 Message-ID: <20260918091058.297740-2-tasos.papagiannnis@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> References: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" copy_remote_vm_str() gets the target address space from a struct task_struct. This does not work for an address space that exists but is not yet associated with a task_struct, such as the mm held by struct linux_binprm during exec. Add copy_remote_mm_str(), which operates directly on a struct mm_struct. Use a common internal interface for the MMU and NOMMU implementations and define both public wrappers in mm/util.c. Preserve the existing copy_remote_vm_str() behavior, including handling zero-length requests before acquiring the task's mm. Signed-off-by: Anastasios Papagiannis Acked-by: Lorenzo Stoakes (ARM) Acked-by: David Hildenbrand (Arm) --- include/linux/mm.h | 8 +++--- mm/internal.h | 3 +++ mm/memory.c | 43 ++------------------------------ mm/nommu.c | 43 ++------------------------------ mm/util.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 73 insertions(+), 86 deletions(-) diff --git a/include/linux/mm.h b/include/linux/mm.h index dd09c438fa23..63f40e615754 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -3325,10 +3325,10 @@ extern int access_process_vm(struct task_struct *ts= k, unsigned long addr, extern int access_remote_vm(struct mm_struct *mm, unsigned long addr, void *buf, int len, unsigned int gup_flags); =20 -#ifdef CONFIG_BPF_SYSCALL -extern int copy_remote_vm_str(struct task_struct *tsk, unsigned long addr, - void *buf, int len, unsigned int gup_flags); -#endif +int copy_remote_mm_str(struct mm_struct *mm, unsigned long addr, + void *buf, int len, unsigned int gup_flags); +int copy_remote_vm_str(struct task_struct *tsk, unsigned long addr, + void *buf, int len, unsigned int gup_flags); =20 long get_user_pages_remote(struct mm_struct *mm, unsigned long start, unsigned long nr_pages, diff --git a/mm/internal.h b/mm/internal.h index 38b1165212c9..557b29381355 100644 --- a/mm/internal.h +++ b/mm/internal.h @@ -25,6 +25,9 @@ struct folio_batch; struct hstate; =20 +int __copy_remote_mm_str(struct mm_struct *mm, unsigned long addr, + void *buf, int len, unsigned int gup_flags); + struct huge_bootmem_page { struct list_head list; struct hstate *hstate; diff --git a/mm/memory.c b/mm/memory.c index 8b0c2c735d3d..fc6933d7e9d3 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -7326,13 +7326,12 @@ int access_process_vm(struct task_struct *tsk, unsi= gned long addr, } EXPORT_SYMBOL_GPL(access_process_vm); =20 -#ifdef CONFIG_BPF_SYSCALL /* * Copy a string from another process's address space as given in mm. * If there is any error return -EFAULT. */ -static int __copy_remote_vm_str(struct mm_struct *mm, unsigned long addr, - void *buf, int len, unsigned int gup_flags) +int __copy_remote_mm_str(struct mm_struct *mm, unsigned long addr, + void *buf, int len, unsigned int gup_flags) { void *old_buf =3D buf; int err =3D 0; @@ -7408,44 +7407,6 @@ static int __copy_remote_vm_str(struct mm_struct *mm= , unsigned long addr, return buf - old_buf; } =20 -/** - * copy_remote_vm_str - copy a string from another process's address space. - * @tsk: the task of the target address space - * @addr: start address to read from - * @buf: destination buffer - * @len: number of bytes to copy - * @gup_flags: flags modifying lookup behaviour - * - * The caller must hold a reference on @mm. - * - * Return: number of bytes copied from @addr (source) to @buf (destination= ); - * not including the trailing NUL. Always guaranteed to leave NUL-terminat= ed - * buffer. On any error, return -EFAULT. - */ -int copy_remote_vm_str(struct task_struct *tsk, unsigned long addr, - void *buf, int len, unsigned int gup_flags) -{ - struct mm_struct *mm; - int ret; - - if (unlikely(len =3D=3D 0)) - return 0; - - mm =3D get_task_mm(tsk); - if (!mm) { - *(char *)buf =3D '\0'; - return -EFAULT; - } - - ret =3D __copy_remote_vm_str(mm, addr, buf, len, gup_flags); - - mmput(mm); - - return ret; -} -EXPORT_SYMBOL_GPL(copy_remote_vm_str); -#endif /* CONFIG_BPF_SYSCALL */ - /* * Print the name of a VMA. */ diff --git a/mm/nommu.c b/mm/nommu.c index 498e01ee40b0..9a810c35e7e9 100644 --- a/mm/nommu.c +++ b/mm/nommu.c @@ -1741,13 +1741,12 @@ int access_process_vm(struct task_struct *tsk, unsi= gned long addr, void *buf, in } EXPORT_SYMBOL_GPL(access_process_vm); =20 -#ifdef CONFIG_BPF_SYSCALL /* * Copy a string from another process's address space as given in mm. * If there is any error return -EFAULT. */ -static int __copy_remote_vm_str(struct mm_struct *mm, unsigned long addr, - void *buf, int len) +int __copy_remote_mm_str(struct mm_struct *mm, unsigned long addr, + void *buf, int len, unsigned int gup_flags) { unsigned long addr_end; struct vm_area_struct *vma; @@ -1782,44 +1781,6 @@ static int __copy_remote_vm_str(struct mm_struct *mm= , unsigned long addr, return ret; } =20 -/** - * copy_remote_vm_str - copy a string from another process's address space. - * @tsk: the task of the target address space - * @addr: start address to read from - * @buf: destination buffer - * @len: number of bytes to copy - * @gup_flags: flags modifying lookup behaviour (unused) - * - * The caller must hold a reference on @mm. - * - * Return: number of bytes copied from @addr (source) to @buf (destination= ); - * not including the trailing NUL. Always guaranteed to leave NUL-terminat= ed - * buffer. On any error, return -EFAULT. - */ -int copy_remote_vm_str(struct task_struct *tsk, unsigned long addr, - void *buf, int len, unsigned int gup_flags) -{ - struct mm_struct *mm; - int ret; - - if (unlikely(len =3D=3D 0)) - return 0; - - mm =3D get_task_mm(tsk); - if (!mm) { - *(char *)buf =3D '\0'; - return -EFAULT; - } - - ret =3D __copy_remote_vm_str(mm, addr, buf, len); - - mmput(mm); - - return ret; -} -EXPORT_SYMBOL_GPL(copy_remote_vm_str); -#endif /* CONFIG_BPF_SYSCALL */ - /** * nommu_shrink_inode_mappings - Shrink the shared mappings on an inode * @inode: The inode to check diff --git a/mm/util.c b/mm/util.c index bf0513d1d3d0..47c2e3ae8496 100644 --- a/mm/util.c +++ b/mm/util.c @@ -1061,6 +1061,68 @@ int get_cmdline(struct task_struct *task, char *buff= er, int buflen) return res; } =20 +#ifdef CONFIG_BPF_SYSCALL +/** + * copy_remote_mm_str - copy a string from a remote address space. + * @mm: the remote address space + * @addr: start address to read from + * @buf: destination buffer + * @len: number of bytes to copy + * @gup_flags: flags modifying lookup behaviour + * + * The caller must hold a reference on @mm. + * + * Return: number of bytes copied from @addr (source) to @buf (destination= ), + * not including the trailing NUL. If @len is zero, return 0 without acces= sing + * @buf. Otherwise, @buf is always NUL-terminated. On any error, return + * -EFAULT. + */ +int copy_remote_mm_str(struct mm_struct *mm, unsigned long addr, + void *buf, int len, unsigned int gup_flags) +{ + if (unlikely(len =3D=3D 0)) + return 0; + + return __copy_remote_mm_str(mm, addr, buf, len, gup_flags); +} + +/** + * copy_remote_vm_str - copy a string from another process's address space. + * @tsk: the task of the target address space + * @addr: start address to read from + * @buf: destination buffer + * @len: number of bytes to copy + * @gup_flags: flags modifying lookup behaviour + * + * Return: number of bytes copied from @addr (source) to @buf (destination= ), + * not including the trailing NUL. If @len is zero, return 0 without acces= sing + * @buf. Otherwise, @buf is always NUL-terminated. On any error, return + * -EFAULT. + */ +int copy_remote_vm_str(struct task_struct *tsk, unsigned long addr, + void *buf, int len, unsigned int gup_flags) +{ + struct mm_struct *mm; + int ret; + + if (unlikely(len =3D=3D 0)) + return 0; + + mm =3D get_task_mm(tsk); + if (!mm) { + *(char *)buf =3D '\0'; + return -EFAULT; + } + + ret =3D __copy_remote_mm_str(mm, addr, buf, len, gup_flags); + + mmput(mm); + + return ret; +} +EXPORT_SYMBOL_GPL(copy_remote_vm_str); +#endif /* CONFIG_BPF_SYSCALL */ + int __weak memcmp_pages(struct page *page1, struct page *page2) { char *addr1, *addr2; --=20 2.55.0 From nobody Fri Sep 25 00:40:53 2026 Received: from mail-wm2-f13.google.com (mail-wm2-f13.google.com [74.125.225.141]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id CEBDD4AF9C7 for ; Fri, 18 Sep 2026 09:11:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.225.141 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722687; cv=none; b=A1RYRKjxK69N+nVG5OemyQFAPeY008pjyU3SVFX3ok4xAPXTZzjEMVWrwNuFRQoQ02HmjrimyvrPO8HSpC15YU56oiJtlpysGWf/QeyPGfPAXR9zOnmmAl7Y+xZrKJbQyxjKNXLe5ZsLowS1c0Rzst1KKmQtIB/gu7Ub9qSeySA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722687; c=relaxed/simple; bh=oxBm833C8T+jxHgAdbU6D4xcv4E4TYoli1xZPpTW0yQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ByN994CayLnOlfmJrPqZ0Ji8biID2EKeDzRww8FAPj9kb2pbPPWTKTuWWlwnmTQDCqU0QL/5qKlsOaj6TK1JkgR3cQ0gc0bbJ0GlFxCJsB2/jUmzGntZzW9JtItr7OBSPhbHpRKpE0pWfYxNxc1h6CjkhPu4RpAudj8VT0thdRg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=FIb6S5VI; arc=none smtp.client-ip=74.125.225.141 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="FIb6S5VI" Received: by mail-wm2-f13.google.com with SMTP id 5b1f17b1804b1-49e7bcb94d3so3366895e9.2 for ; Fri, 18 Sep 2026 02:11:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789722684; x=1790327484; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=BcITG13Gvl8i0HA4g724jWVmnWns/ceZ5ECxTEaQlok=; b=FIb6S5VIl9HErXLXf5Fe7PjNK0bfdAWcityzeJbbPZkdgXU2pDq7mjpHJZyLUJjW8q SdyZvJddNcR4feZ8rlSEthkn69Qr5BFKlt5pT9FFuIimXOFkeopLSjz8jgeRFt3X2Uvr pdNb9HmpLKM1SGHE7kI7qbnQduD8fRQv0MpBaM5NBFAYo9pfoiUSIUkWW0Y86ciVptfW jV/OIr9u8w5Ocp8KoYH4Jum21j/3k9Vw1xCDDUIZHXSsjUeWUDwCarbOweFu57yGUsoZ d2e+hRuQ/QdfE1yE61YzY0RPRCSunnV+/K8BXUz7e/QdDIUU/zH8G3bpKp4z/KK8yXr+ ghgQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789722684; x=1790327484; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=BcITG13Gvl8i0HA4g724jWVmnWns/ceZ5ECxTEaQlok=; b=mcIWSS4YhUUGndDN5DsyJU7w0/yy/WHQ2wZGfKSpiao7R9nqweyFYecj92WxuknKHu Q9CRv/NAcdBONQE6odEJIvKfFZiZy8uzrUV+62ACul7auW7hi17E55JYuPOAc6sSXFlo 5SqwoswWfFmYkZTL+EmMrKeUXYQ5TYgAo//2chPVF6f+bjnC9DyuIqtvKu/oHi0HC/xD SM5/JqnxPUJfkqWpTot1VHBLWWJwtWfS6K1VTloKrnPbBCoT7FijoSBSs6F9blK0hNsn vmCBz1tW4NYTO7vB2mUz3MIx5aUUs9suUNM+X7wbVEt2QV5tb+9qW52YSGJ+3iDN9WyS klqQ== X-Forwarded-Encrypted: i=1; AKwUvBzOAmeXtFzEUYlt5N8mrHrCITv3CD6yMHiFfKWa21QwYh9Lpvl4DZdn62QhXDKwDKOQTn9gZsZm1rd2kvg=@vger.kernel.org X-Gm-Message-State: AFuF++l7lmtHaTl/vztriswzotNchdBja8DA4NMoWL992po3vyi43/Hf ebKsPZwLdTL1f+pP7BSf0xktNg0ggSbENcK8g9vo4psLrVRqg1FUVPHb X-Gm-Gg: AYBFou1e240ac2qHLVHMHpVzd5Kf104mkTkpxmNaJq+fiwn2hlEH2iTR/KgOhnqPVcb vHrzyX5DWublRUmOEV9BQXcf5KWRsq2EqDOCfLt531otX8rXMDOzEltWQ4+KGVzD32Q9FjgCEiD jha+I0MkBy16CIaMFny2DvSkki/pS89sU0IIfLUvV4+jLj9uIpaydGWu+09kWO/2x8c8CYvW+7r fM7Rl06mqBkLIZ99qeUA/WN3ZIUin+Rql1V+4ho93UQQzGiBnO0qHg6x7rBCsf5ZVciCS+YBMcF m2XzKVKABt7iWvwRQLH6o7WqI50bS0hUFTLbo2FUl6W42ZqQcVMs/92KIIcbJEkyZDfbluc5omv kCbfExmrLy4CLK11LWCkrnyv0bg4kv55227AvBdFXq1hONnKzhY2jTrzwiG+2rZp8mK8J4bUnQs 6NOtgU64ZU1xLU3p3SdIOX0d36a/LewRWW3d/WQq3nU/OezPbkZsXfhcSsRBaDRtWM0gL17zCTG riZKOJLOolqGqk= X-Received: by 2002:a05:600c:468c:b0:49d:16df:8521 with SMTP id 5b1f17b1804b1-49fc56811dcmr23639585e9.4.1789722683646; Fri, 18 Sep 2026 02:11:23 -0700 (PDT) Received: from dell-desktop ([2a02:587:4b4e:8500:290c:210b:1c76:5710]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49fbd1d0978sm138774275e9.2.2026.09.18.02.11.21 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2026 02:11:23 -0700 (PDT) From: Anastasios Papagiannis To: bpf@vger.kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, david@kernel.org, akpm@linux-foundation.org, andrii@kernel.org, ast@kernel.org, brauner@kernel.org, daniel@iogearbox.net, eddyz87@gmail.com, kpsingh@kernel.org, ljs@kernel.org, matt@bobrowski.net, memxor@gmail.com, song@kernel.org, sun.jian.kdev@gmail.com, utilityemal77@gmail.com, viro@zeniv.linux.org.uk, tasos.papagiannnis@gmail.com Subject: [PATCH bpf-next v8 2/5] exec: Clear bprm->mm before dropping its reference Date: Fri, 18 Sep 2026 12:10:55 +0300 Message-ID: <20260918091058.297740-3-tasos.papagiannnis@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> References: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Once mmput() drops the final reference to bprm->mm, the pointer must no longer remain accessible through struct linux_binprm. The successful exec path and the bprm initialization error path already clear bprm->mm when ownership is transferred or released. Do the same in free_bprm() before calling mmput(). This is required for BPF kfuncs where bprm->mm is either NULL or points to a live mm_struct to ensure safe access. Signed-off-by: Anastasios Papagiannis Reviewed-by: Sun Jian --- fs/exec.c | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/fs/exec.c b/fs/exec.c index 745f6eb5279e..4ddd403fd91c 100644 --- a/fs/exec.c +++ b/fs/exec.c @@ -1456,9 +1456,12 @@ void bprm_drop_loader(struct linux_binprm *bprm) =20 static void free_bprm(struct linux_binprm *bprm) { - if (bprm->mm) { + struct mm_struct *mm =3D bprm->mm; + + if (mm) { acct_arg_size(bprm, 0); - mmput(bprm->mm); + bprm->mm =3D NULL; + mmput(mm); } if (bprm->user_ns) put_user_ns(bprm->user_ns); --=20 2.55.0 From nobody Fri Sep 25 00:40:53 2026 Received: from mail-wm2-f13.google.com (mail-wm2-f13.google.com [74.125.225.141]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 1A1264B4053 for ; Fri, 18 Sep 2026 09:11:28 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.225.141 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722691; cv=none; b=IqWDFxn2HiiBi7oAVGfpJUdQdC05dL3Lb22kxjFh6VLV7Kk5spXhfvjgVxOPPUdn26Rr4AiB+/U8IsfGRwgUL7fHamZne/uQOlKSE/qvc3AGb4W3sj6FacUpJ1O9v/x8oinfymxV/iTlHBLUjloJA/zr5JmcZAeqCYyfG7emGjg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722691; c=relaxed/simple; bh=WysipF1mqedAt7TWX+jnDzYCZRvt4e7MAMvf3MNSBSA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=N6ohkMjIgCZo+Uhp3iXNzcj/e1h4fxX4H9I5vPu0jrhf9BzPD8/7Er1WvNLa0blO/dtZNSMlbhhdL4eDSOUbOhWLl81Jho1qo1Fiqfg+Lic2iTBVC5ICqAKm4hK3ihCv0Mi4e1R94IY6qyL7y7Giu54oFRSN9UyTVIo5IFRmzU8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=pz3y81+y; arc=none smtp.client-ip=74.125.225.141 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="pz3y81+y" Received: by mail-wm2-f13.google.com with SMTP id 5b1f17b1804b1-49cc9f581c4so2033155e9.0 for ; Fri, 18 Sep 2026 02:11:28 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789722687; x=1790327487; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=vgg2ZQjMkxD6u2VdMZWByOLhVUwC2QQ6a1L3XaBvWsU=; b=pz3y81+yTEYBs/nCGr4BdpncXFqyfLOXSJg6Hpy8MEYPbSGKLNwb65l5JgAvKSE8/o ZP8K+5lC4KOP2poyYvWTjsO+xiywk+dGxn3evSsk+N5d1OsC1d5PY8dTw//2AWcnEW4U rQ6qFf2heHi6qJvOUZx75Nvlgh2T6no1W9jFjxYBn4/qkDhdSev7KmQzU2+b4h/2wdA/ GJB4QJdd5B/i3+z2Ccx1Xgf0yOgE1zxoy56Gwl6KePfzVVNaidRJdqrc+4npjOcoK4RF lsnUphTW5B6UM945yUzPoO7FPM2DloZpZVeS3o3LGxAhY6rFEP06jhlpNo4CNaQfduz8 WIYw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789722687; x=1790327487; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=vgg2ZQjMkxD6u2VdMZWByOLhVUwC2QQ6a1L3XaBvWsU=; b=T234zNGil6D8KCV5/O5sukQqacjJBszhckLhU0oa8azJBUHCjp9xAbLhYnncOxrC6b bpTpOLv1EJYcBni+vdx3RKDj6sUI3u5Tcwv9aRDofDA+o4/np0Eh8dJj571TURD7pfNp /Y9dA9Cx3ZUxDYoudKNe/2LReiSkmsTUTEwT1DbLf+9aniqbqjQcdHawy/0uyFf+OS15 t7yTPCEDVLGu9ymBna7/GS11tZnkXWSq3cKBLg0qjrf3ErlO52JWEQwu46ncgiiNHX6I 7GKB24DTxWS701KS4ZOq1rmNsJ20vlZ93HzFaYdlURCDa9tNumYggz+NNkXmYWkzxdx7 NPmw== X-Forwarded-Encrypted: i=1; AKwUvBxoXsLLjqHNaWDWKN4CtL7ccdmbXRRxVv/YYkrJI4Nb77X00ZppOS33OE4QY+IFvXHpeOr2fW4XXBpJf1o=@vger.kernel.org X-Gm-Message-State: AFuF++nxG7guyeHvAcTvdIVcVSkw3swq1TVfvirZnU2c8srrf6CI+yBZ kw8Xg/zzkH919yM7GsfV70MQhnbI7aGt7OikimyDlN3uaVKbhwNEfSip X-Gm-Gg: AYBFou0tWdlM9a9eSoSInhBJqgecF+4kjxnEjwl/1wMzL0KUhCVKxsYHA1UT5t3yogX p8LzYs3+WrBTN+1ftm0O24/W2vAUJJ89W/FetsZtKFCRbo5X/Q9F3EvK4PJAFmF6sixJ1fzTod7 QlthQqL/CFJ2cySCVUlOoiq8i2iUtIHf6GAckOsAfEIXlHOVTekAK4IbxAiE9hfnQ5mih+tAe9J mAueJ59/ow/bt1+wpQ9i3+xiFSqfr2oxKHbmzk7sjYWbGjgdOrbGga6r52ABOng7XHsliZ0lTvm EntchhNo8te3wjHxlnhP1fYaLsA7RpBtXJw1nlJkeashLqzaTHTfkf7LbyGNc8rRVW0VcODdO5w Ww0OjqMP9MnrbbVgprAEWfXC6F7C1O5p72fpIcPBLwNlJ630fLc/cuvRxNUSgHq+eFwBfUNnbp4 Q6cA75p4bFzVBOnKGHAZnt03jnACF4RMEh76qafGicXiEIxnb+pcQ1Rjrp5to00xolkP4Z9hbeP U1Byci2K9bYYbU= X-Received: by 2002:a05:600c:83c9:b0:49c:f13e:e4d with SMTP id 5b1f17b1804b1-49fc4ff402cmr25215605e9.10.1789722686994; Fri, 18 Sep 2026 02:11:26 -0700 (PDT) Received: from dell-desktop ([2a02:587:4b4e:8500:290c:210b:1c76:5710]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49fbd1d0978sm138774275e9.2.2026.09.18.02.11.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2026 02:11:26 -0700 (PDT) From: Anastasios Papagiannis To: bpf@vger.kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, david@kernel.org, akpm@linux-foundation.org, andrii@kernel.org, ast@kernel.org, brauner@kernel.org, daniel@iogearbox.net, eddyz87@gmail.com, kpsingh@kernel.org, ljs@kernel.org, matt@bobrowski.net, memxor@gmail.com, song@kernel.org, sun.jian.kdev@gmail.com, utilityemal77@gmail.com, viro@zeniv.linux.org.uk, tasos.papagiannnis@gmail.com Subject: [PATCH bpf-next v8 3/5] bpf: Add user memory access kfuncs for mm_struct Date: Fri, 18 Sep 2026 12:10:56 +0300 Message-ID: <20260918091058.297740-4-tasos.papagiannnis@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> References: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" On CONFIG_MMU kernels, when security_bprm_check() runs, the argument and environment strings for the exec have been copied into bprm->mm. The new address space is not associated with a task_struct until exec_mmap(), so existing BPF user memory helpers cannot access it. Add bpf_copy_from_user_mm() and bpf_copy_from_user_mm_str() kfuncs. Both take a struct mm_struct pointer directly, allowing callers to access trusted address spaces that are not associated with a task_struct. bpf_copy_from_user_mm() has similar semantics to bpf_copy_from_user_task(). bpf_copy_from_user_mm_str() copies one NUL-terminated string and returns its size including the NUL terminator. It accepts BPF_F_PAD_ZEROS to clear unused destination bytes on success. Refactor the task-based helpers and the new mm-based kfuncs to share static internal implementations. The task-based interfaces validate their arguments before acquiring and holding a reference to the task's mm for the copy. No behavior change is intended for the existing task-based interfaces. Register both new kfuncs and mark them KF_SLEEPABLE because accessing a remote address space can fault. Signed-off-by: Anastasios Papagiannis Reviewed-by: Matt Bobrowski --- kernel/bpf/helpers.c | 130 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 118 insertions(+), 12 deletions(-) diff --git a/kernel/bpf/helpers.c b/kernel/bpf/helpers.c index 051b6654e57c..f6b3eee6098a 100644 --- a/kernel/bpf/helpers.c +++ b/kernel/bpf/helpers.c @@ -679,9 +679,44 @@ const struct bpf_func_proto bpf_copy_from_user_proto = =3D { .arg3_type =3D ARG_ANYTHING, }; =20 +static int __bpf_copy_from_user_mm(void *dst, u32 size, + const void __user *user_ptr, + struct mm_struct *mm) +{ + int ret; + + ret =3D access_remote_vm(mm, (unsigned long)user_ptr, dst, size, 0); + if (ret =3D=3D size) + return 0; + + memset(dst, 0, size); + /* Return -EFAULT for partial read */ + return ret < 0 ? ret : -EFAULT; +} + +static int __bpf_copy_from_user_mm_str(void *dst, u32 size, + const void __user *user_ptr, + struct mm_struct *mm, u64 flags) +{ + int ret; + + ret =3D copy_remote_mm_str(mm, (unsigned long)user_ptr, dst, size, 0); + if (ret < 0) { + if (flags & BPF_F_PAD_ZEROS) + memset(dst, 0, size); + return ret; + } + + if (flags & BPF_F_PAD_ZEROS) + memset(dst + ret, 0, size - ret); + + return ret + 1; +} + BPF_CALL_5(bpf_copy_from_user_task, void *, dst, u32, size, const void __user *, user_ptr, struct task_struct *, tsk, u64, flags) { + struct mm_struct *mm; int ret; =20 /* flags is not used yet */ @@ -691,13 +726,16 @@ BPF_CALL_5(bpf_copy_from_user_task, void *, dst, u32,= size, if (unlikely(!size)) return 0; =20 - ret =3D access_process_vm(tsk, (unsigned long)user_ptr, dst, size, 0); - if (ret =3D=3D size) - return 0; + mm =3D get_task_mm(tsk); + if (!mm) { + memset(dst, 0, size); + return -EFAULT; + } =20 - memset(dst, 0, size); - /* Return -EFAULT for partial read */ - return ret < 0 ? ret : -EFAULT; + ret =3D __bpf_copy_from_user_mm(dst, size, user_ptr, mm); + mmput(mm); + + return ret; } =20 const struct bpf_func_proto bpf_copy_from_user_task_proto =3D { @@ -3659,6 +3697,68 @@ __bpf_kfunc int bpf_copy_from_user_str(void *dst, u3= 2 dst__sz, const void __user return ret + 1; } =20 +/** + * bpf_copy_from_user_mm() - Copy data from an address space + * @dst: Destination address, in kernel space + * @dst__sz: Number of bytes to copy + * @unsafe_ptr__ign: Source address in the address space + * @mm: Address space to copy from + * @flags: Reserved for future use; must be zero + * + * Copies data from the user address space associated with @mm. The destin= ation + * is zeroed if an attempted copy cannot be completed in full. Unsupported + * flags return -EINVAL without modifying @dst. + * + * Return: 0 on success, -EINVAL if @flags is non-zero, or -EFAULT if the = copy + * fails or is partial. + */ +__bpf_kfunc int bpf_copy_from_user_mm(void *dst, u32 dst__sz, + const void __user *unsafe_ptr__ign, + struct mm_struct *mm, u64 flags) +{ + if (unlikely(flags)) + return -EINVAL; + + if (unlikely(!dst__sz)) + return 0; + + return __bpf_copy_from_user_mm(dst, dst__sz, unsafe_ptr__ign, mm); +} + +/** + * bpf_copy_from_user_mm_str() - Copy a string from an address space + * @dst: Destination address, in kernel space. This buffer mus= t be + * at least @dst__sz bytes long + * @dst__sz: Maximum number of bytes to copy, including the traili= ng NUL + * @unsafe_ptr__ign: Source address in the address space + * @mm: Address space to copy from + * @flags: The only supported flag is BPF_F_PAD_ZEROS + * + * Copies a NUL-terminated string from the user address space associated w= ith + * @mm. If the string is too long, @dst is still NUL-terminated unless @ds= t__sz + * is zero. + * + * If the flags are valid and BPF_F_PAD_ZEROS is set, the unused portion of + * @dst is cleared on success and all of @dst is cleared on a copy failure. + * Unsupported flags return -EINVAL without modifying @dst. + * + * Return: The number of copied bytes including the NUL terminator on succ= ess, + * or a negative error code on failure. + */ +__bpf_kfunc int bpf_copy_from_user_mm_str(void *dst, u32 dst__sz, + const void __user *unsafe_ptr__ign, + struct mm_struct *mm, u64 flags) +{ + if (unlikely(flags & ~BPF_F_PAD_ZEROS)) + return -EINVAL; + + if (unlikely(dst__sz =3D=3D 0)) + return 0; + + return __bpf_copy_from_user_mm_str(dst, dst__sz, unsafe_ptr__ign, + mm, flags); +} + /** * bpf_copy_from_user_task_str() - Copy a string from an task's address sp= ace * @dst: Destination address, in kernel space. This buffer mu= st be @@ -3682,6 +3782,7 @@ __bpf_kfunc int bpf_copy_from_user_task_str(void *dst= , u32 dst__sz, const void __user *unsafe_ptr__ign, struct task_struct *tsk, u64 flags) { + struct mm_struct *mm; int ret; =20 if (unlikely(flags & ~BPF_F_PAD_ZEROS)) @@ -3690,17 +3791,20 @@ __bpf_kfunc int bpf_copy_from_user_task_str(void *d= st, u32 dst__sz, if (unlikely(dst__sz =3D=3D 0)) return 0; =20 - ret =3D copy_remote_vm_str(tsk, (unsigned long)unsafe_ptr__ign, dst, dst_= _sz, 0); - if (ret < 0) { + mm =3D get_task_mm(tsk); + if (!mm) { if (flags & BPF_F_PAD_ZEROS) memset(dst, 0, dst__sz); - return ret; + else + *(char *)dst =3D '\0'; + return -EFAULT; } =20 - if (flags & BPF_F_PAD_ZEROS) - memset(dst + ret, 0, dst__sz - ret); + ret =3D __bpf_copy_from_user_mm_str(dst, dst__sz, unsafe_ptr__ign, + mm, flags); + mmput(mm); =20 - return ret + 1; + return ret; } =20 /* Keep unsigned long in prototype so that kfunc is usable when emitted to @@ -4925,6 +5029,8 @@ BTF_ID_FLAGS(func, bpf_iter_bits_new, KF_ITER_NEW) BTF_ID_FLAGS(func, bpf_iter_bits_next, KF_ITER_NEXT | KF_RET_NULL) BTF_ID_FLAGS(func, bpf_iter_bits_destroy, KF_ITER_DESTROY) BTF_ID_FLAGS(func, bpf_copy_from_user_str, KF_SLEEPABLE) +BTF_ID_FLAGS(func, bpf_copy_from_user_mm, KF_SLEEPABLE) +BTF_ID_FLAGS(func, bpf_copy_from_user_mm_str, KF_SLEEPABLE) BTF_ID_FLAGS(func, bpf_copy_from_user_task_str, KF_SLEEPABLE) BTF_ID_FLAGS(func, bpf_get_kmem_cache) BTF_ID_FLAGS(func, bpf_iter_kmem_cache_new, KF_ITER_NEW | KF_SLEEPABLE) --=20 2.55.0 From nobody Fri Sep 25 00:40:53 2026 Received: from mail-wm2-f13.google.com (mail-wm2-f13.google.com [74.125.225.141]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 142BD4B7A34 for ; Fri, 18 Sep 2026 09:11:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.225.141 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722696; cv=none; b=GhcOiaGLYgIn4eex5lfleQRguCwykmgnMntqtkp2/EppusPdoEAr2WMn3/VXrffAgooF6B2s/P5Oqb5vAET+wxP/ZimbPA7d8HpeXWxUcV4U16QMTPNiRXS9ZzdnyOreab74NfEALlX0hQ+Vq4H+ot1dpZgazfoi1njCe4f25fA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722696; c=relaxed/simple; bh=FiRsDZdzGXAipkwSasDiwYJgNjGQw/oWZmESPlkGMAY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=XvhtG5dt4cwpy6H3u6MMHLsDyPpqUI0Pjot1bchtBoDBxP8AWbiHuiUerqhsEyMFAt/zKgzSNtadaICQ5RPy28aDIZTk/528bqtlDvxSIrPsuWtpU7rnki+HL3TMU5KPjYCIfU+0HITwUS0UbW/J4z/nWbvjdHc13zezp1YiDrM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=T2rE5pUD; arc=none smtp.client-ip=74.125.225.141 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="T2rE5pUD" Received: by mail-wm2-f13.google.com with SMTP id 5b1f17b1804b1-49cd38e0e5dso7012275e9.2 for ; Fri, 18 Sep 2026 02:11:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789722692; x=1790327492; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=Lk08SIy6DJ+jXcktdOiUfMwYrHwPBwEtrnZT5485SRQ=; b=T2rE5pUDUz9gW62Q9CEtdygORMnmqJzD+vHMPUpMBghWky+98FjqdE0KI+JQxBKuwZ AdzaGmZgbDdEcQWiqzLzysFYe3CmHlGVJ1/kCNXCdAR7eA4+2cxfuI9EQg+XiW1kX6oe qQ0AkGX2fK3h1e997cDE4Byemv5PbRoQwb5mIo0gnZyfduvu5n0bg49w8iXtLHEyVjPa 9Dq8lisDk2bGiygJF/V7MG5Vv/b0jvkiEDOT+jXjVR9z4Gv2mUl2w6hujT+ZvkAPygnT t5qTDbk5BW4e+QbbL66WuTJuAuKaRrSPAqM50+bTDzD/KITm5W3bXJf9kXEm543AQMTK RK+w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789722692; x=1790327492; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=Lk08SIy6DJ+jXcktdOiUfMwYrHwPBwEtrnZT5485SRQ=; b=FlqoTXNAuoZQfkFIEWxiS5bTr1y7RS+2vVyPhJbjLOG6/H9oBQ0RczLUuzDm3xjOjL GHd84dpx7RV5qsE9ML0IHzglcZ2EokvrCrUS6bZcRQ5H40yd5CRKLM5QSw0Ax01T8xxI 7YZVa2Pgv0LiLhoI8mnTDKFjAi0abhO/OA2ArvoOrftgyeiJzwkBwbAbEg7Jb8xDsD+w RBWYggvWK+9vyE103y/8ThZiCffnRP+VsqwW8cvd9WAB+V0bInRAhZ5kLcFEhzf8I3EQ G8bR0OCOQlcW6vvAnC2snqavJ/dkTZmOvVs44qaW8u/hgEE4sTOAAT73YxaPt5IedSRD CbKA== X-Forwarded-Encrypted: i=1; AKwUvBwavagAWfQWggEKTm7sSwUSA+TKYngTBlkmiseito1DoSr0YnUViN38ZFSKZZsfRdANImm48K1PBTrVpqc=@vger.kernel.org X-Gm-Message-State: AFuF++mNwR4u25idmjESr4P8IbyjUddliXIuO20Zk9P4/iRQ7HpiJ33U n+UhHjwSIXCH3poB0mbcOcrj8J+B5ymXa3IqdFTJiEOpg1h8McdqV1pC X-Gm-Gg: AYBFou37TlEd+Cq6zSbei5aoxnq1eO3Jxxeb+31I8I3mtbwmgEOKziNGAzwdJvmN2DQ p3jvIyH79lD7nEhsLiNH+0Da8MoLcpmjQi2pA9FDaY8pxUqvSIv9+fLIdJ+kq12/Eq3JTJgo+DB ARmzDsx7nuZav/rgUsA9Q8spc2wJ8jXXs1QbrnyvpvjEjgtlmCrWU17b+ixswNb6LaVtd2uBU33 S8gxrUEdpW5mf88nwaaurMdERxPY3PaNSHLqWXGIEee5QwwM8uA6fksF/EM7dBxDZCTT5HKn7yI R+cIRz+IF9y7X1QICPEqiAJutH8Q4R26wCmgTZhgma35rGZbq5l87B+AoPr8BGW/t4nuouhbTAW Kw66lBAq1eULmrMnaHoK/0zXlVWqzEn12DY+qudqDkVp/x/pDV4PBT8mxSm8BmBlF9ExcPx8dwh FvhqqmldUlxOCIqjeK2cLhocplMIO9rfrTGSfsiNSNkoxrWQfpQd+1xELgmo7m4SNhGamRmIsAE +4gV4uL1eIb4Jq4 X-Received: by 2002:a05:600c:3b0a:b0:49f:bd3c:bc20 with SMTP id 5b1f17b1804b1-49fc573b7a2mr19145175e9.27.1789722691708; Fri, 18 Sep 2026 02:11:31 -0700 (PDT) Received: from dell-desktop ([2a02:587:4b4e:8500:290c:210b:1c76:5710]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49fbd1d0978sm138774275e9.2.2026.09.18.02.11.27 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2026 02:11:31 -0700 (PDT) From: Anastasios Papagiannis To: bpf@vger.kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, david@kernel.org, akpm@linux-foundation.org, andrii@kernel.org, ast@kernel.org, brauner@kernel.org, daniel@iogearbox.net, eddyz87@gmail.com, kpsingh@kernel.org, ljs@kernel.org, matt@bobrowski.net, memxor@gmail.com, song@kernel.org, sun.jian.kdev@gmail.com, utilityemal77@gmail.com, viro@zeniv.linux.org.uk, tasos.papagiannnis@gmail.com Subject: [PATCH bpf-next v8 4/5] bpf: Mark linux_binprm->mm as trusted-or-null Date: Fri, 18 Sep 2026 12:10:57 +0300 Message-ID: <20260918091058.297740-5-tasos.papagiannnis@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> References: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Mark linux_binprm->mm as a trusted-or-null nested pointer so BPF programs can pass it to kfuncs after a NULL check. The field is either NULL or points to a live mm_struct whenever BPF can access a linux_binprm. On successful exec, exec_mmap() installs the new address space before begin_new_exec() clears bprm->mm. The bprm_mm_init() error path clears the field before mmdrop(), and free_bprm() clears it before mmput(), as ensured by an earlier patch in this series. Update the existing LSM selftest to check bprm->mm for NULL before dereferencing it, as required for trusted-or-null pointers. Signed-off-by: Anastasios Papagiannis Reviewed-by: Sun Jian Reviewed-by: Matt Bobrowski --- kernel/bpf/verifier.c | 5 +++++ tools/testing/selftests/bpf/progs/lsm.c | 5 ++++- 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 6c6b8d8520cd..3539a768b921 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -5997,6 +5997,10 @@ BTF_TYPE_SAFE_TRUSTED_OR_NULL(struct dentry) { struct inode *d_inode; }; =20 +BTF_TYPE_SAFE_TRUSTED_OR_NULL(struct linux_binprm) { + struct mm_struct *mm; +}; + BTF_TYPE_SAFE_TRUSTED_OR_NULL(struct socket) { struct sock *sk; }; @@ -6051,6 +6055,7 @@ static bool type_is_trusted_or_null(struct bpf_verifi= er_env *env, { BTF_TYPE_EMIT(BTF_TYPE_SAFE_TRUSTED_OR_NULL(struct socket)); BTF_TYPE_EMIT(BTF_TYPE_SAFE_TRUSTED_OR_NULL(struct dentry)); + BTF_TYPE_EMIT(BTF_TYPE_SAFE_TRUSTED_OR_NULL(struct linux_binprm)); BTF_TYPE_EMIT(BTF_TYPE_SAFE_TRUSTED_OR_NULL(struct vm_area_struct)); =20 return btf_nested_type_is_trusted(&env->log, reg, field_name, btf_id, diff --git a/tools/testing/selftests/bpf/progs/lsm.c b/tools/testing/selfte= sts/bpf/progs/lsm.c index 7de173daf27b..7441d66c080c 100644 --- a/tools/testing/selftests/bpf/progs/lsm.c +++ b/tools/testing/selftests/bpf/progs/lsm.c @@ -113,6 +113,7 @@ int BPF_PROG(test_void_hook, struct linux_binprm *bprm) { __u32 pid =3D bpf_get_current_pid_tgid() >> 32; struct inner_map *inner_map; + struct mm_struct *mm; char args[64]; __u32 key =3D 0; __u64 *value; @@ -121,7 +122,9 @@ int BPF_PROG(test_void_hook, struct linux_binprm *bprm) bprm_count++; =20 bpf_copy_from_user(args, sizeof(args), (void *)bprm->vma->vm_mm->arg_star= t); - bpf_copy_from_user(args, sizeof(args), (void *)bprm->mm->arg_start); + mm =3D bprm->mm; + if (mm) + bpf_copy_from_user(args, sizeof(args), (void *)mm->arg_start); =20 value =3D bpf_map_lookup_elem(&array, &key); if (value) --=20 2.55.0 From nobody Fri Sep 25 00:40:53 2026 Received: from mail-wm2-f12.google.com (mail-wm2-f12.google.com [74.125.225.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 8A02C40F726 for ; Fri, 18 Sep 2026 09:11:37 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.225.140 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722699; cv=none; b=QaMX/c+MiTRyYFtLBXx73ngx4P87/oTYuPxdaEYdYKmUeC3W/wMssbTgay2UG/a1SNdV7q6iEVkQDomrogqTXE4nY12DplI8fx3S07onlbsOu/dFMPEnYfeRL/F/GSXFWmPnS/Jm0SCVMOMrYAlvqHAZ8XaVv/Bd5457orQ2rN0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1789722699; c=relaxed/simple; bh=GnQNNaO2NdAe4bfr6j79tdcCpkRyZDIf9oDO6K4Un58=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=ZLCM2WkzSNoyPtoisDoiNprZFkTGEo+6ouT6Uiz6iIUN1ykYw71LQyFxFgDk4P2NDYPBzfJAHiJqzRB2lptVyl92Pzkg+KXHwUuCumE0n5GwbD6XvBLZT0v1IiD8SANU8Y22JeEOTxLZvyx1VJmQ32N94G9kRpo3HqWYy7cmLxc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=WSMkcGyL; arc=none smtp.client-ip=74.125.225.140 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="WSMkcGyL" Received: by mail-wm2-f12.google.com with SMTP id 5b1f17b1804b1-49ccead2aecso2496805e9.0 for ; Fri, 18 Sep 2026 02:11:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1789722696; x=1790327496; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=fpIPJYBrAn9lh0X90aJ+LjetM4Yd20S6QCxk4a13+gY=; b=WSMkcGyLeThcjPB3yQKMfLgB5NXcufEm5GIyDXYbj1CFeGUzHHz3bgvzQNk0GylDjA PYo1FlOUkTdD5dG/ms9avQEdlevkcRbj6VTpBy2bEuV7u7rcPq5kbl0aT1DoTosBfW13 2PamQ8/eN91LUJAKp5USHESSY4R7t1SbWVIvFkcNMmtJwN81fCZY9VBxqKKnp+CwnCj3 06P0OHPFHr2oxfaRW3itkjbndyUnujIuPPlm1PTzMl1bvg5ZFO3isyYwl05CEIse4kDf psyRujXW5Q1LyL46x169UqAkQNlwJP/Kh8mRL94ddGcQtPOwMTvAv264EhIzvlbeu55d secg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1789722696; x=1790327496; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=fpIPJYBrAn9lh0X90aJ+LjetM4Yd20S6QCxk4a13+gY=; b=WhBic9H/yfEX0xOlTSQ0Om6fO0DmXwMo5dRz+/84YrRstaBlwr0FvBjB9TD6PF0z8t AiFn0x8XjMZ7h0rZTA9gfoDteMmu7Qwj3z/2930sGhJ5yB+Vjdqv4yl40irsIBJZ1Mib Ns3z3/QB+/355wwsQT3pFhtNA6ovlZOFeLtCaNA1TF5ShEr9fO3oJ4sDkPdVnkRKZ0Cj yVDwEAa8b8qKoEqW6NSrdaFSD3QgJHYL6mj96Kp2jto0JgV2cKSo35QlVzLASodKq7SB Rvt8NUjL5/NEq7kMBX+mUfGiyW77DitTaJB8uHylXVab5b/t3G/L/7gaFNnJKH3QkvXl Mjxw== X-Forwarded-Encrypted: i=1; AKwUvBzvLnRvRb3RMehRimhgnvCTEhp4miarrzY5X9B8n9U6SVFyMiyOzvcZxvuCLBkijQoTaKEEpbaBN+vmwNw=@vger.kernel.org X-Gm-Message-State: AFuF++kAEZ47xxKuq7hGbZHV35sKZKmTzpregcjVigFxah1Gu1g+CDBk QWpEtGMJzOqmFJF3ea/xcE1MxxuNew8Gb4zR2hMTooNFlOGWlBLheIyt X-Gm-Gg: AYBFou1TlhlJ9zw6NYXM+0kNOp/6vCTDM+vnfN9OUwFVwFudLpBOqne9j+hj2oFXKvX n6TEeO6SZc9yJ+KpB1ZvOxKCmSQ0gClUNqW94IwgZ/h+J9O4UtSu52CepL4hQ0zvIxRr9KdBbbw 7kNI4pSyZoQJ9yRKlWXhEZsRTSw8qC4hisTmunT0AP4eGHVCaBU8HO/WUxtseEOO9KABIIzN1sG q4B37xK/aWj7nJb4rm1eOF1PxyTB1/eJa/5Pr9/aFhx9DmSsFuLJnfEUcIqvZXaiu6BqRVKntq+ zBNwWGu+kAfqJf0M9FZX0BldEe06cnHq+gDpTcRik4z4VjqhWzJMMrS6WnbbpWQ9y+pgLVwugJo 97dVqbj+z0B/bKJEoqcgonCb/9Dqac46OI38bSGdcA783xySgLXNm8+OWVTLBq3r7qAp2QGD8uR TrRfRy6HUhfjnAwSCChhx+znEQ1MNJHzzS/DPW/UTKEvhgd0Gw6gJH4Uh5PpEyOlLMtLcJZb47b O3jPZXTXeamdNm7wcckViBeaw== X-Received: by 2002:a05:600c:3550:b0:49e:7d74:7b7a with SMTP id 5b1f17b1804b1-49fc56db8f3mr21040695e9.6.1789722695703; Fri, 18 Sep 2026 02:11:35 -0700 (PDT) Received: from dell-desktop ([2a02:587:4b4e:8500:290c:210b:1c76:5710]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49fbd1d0978sm138774275e9.2.2026.09.18.02.11.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 18 Sep 2026 02:11:35 -0700 (PDT) From: Anastasios Papagiannis To: bpf@vger.kernel.org Cc: linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org, david@kernel.org, akpm@linux-foundation.org, andrii@kernel.org, ast@kernel.org, brauner@kernel.org, daniel@iogearbox.net, eddyz87@gmail.com, kpsingh@kernel.org, ljs@kernel.org, matt@bobrowski.net, memxor@gmail.com, song@kernel.org, sun.jian.kdev@gmail.com, utilityemal77@gmail.com, viro@zeniv.linux.org.uk, tasos.papagiannnis@gmail.com Subject: [PATCH bpf-next v8 5/5] selftests/bpf: Test mm_struct user memory kfuncs with linux_binprm Date: Fri, 18 Sep 2026 12:10:58 +0300 Message-ID: <20260918091058.297740-6-tasos.papagiannnis@gmail.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> References: <20260918091058.297740-1-tasos.papagiannnis@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a sleepable BPF LSM program attached to bprm_check_security to test bpf_copy_from_user_mm() and bpf_copy_from_user_mm_str(). Starting at bprm->p, verify that bpf_copy_from_user_mm() can copy the contiguous NUL-separated argument and environment data. Then use bpf_copy_from_user_mm_str() to read each argument and environment string separately, advancing the offset by the length returned from each call. Signed-off-by: Anastasios Papagiannis --- .../bpf/prog_tests/copy_from_user_bprm.c | 65 +++++++++++++++++ .../selftests/bpf/progs/copy_from_user_bprm.c | 69 +++++++++++++++++++ 2 files changed, 134 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/copy_from_user_b= prm.c create mode 100644 tools/testing/selftests/bpf/progs/copy_from_user_bprm.c diff --git a/tools/testing/selftests/bpf/prog_tests/copy_from_user_bprm.c b= /tools/testing/selftests/bpf/prog_tests/copy_from_user_bprm.c new file mode 100644 index 000000000000..310370689427 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/copy_from_user_bprm.c @@ -0,0 +1,65 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include +#include + +#include + +#include "copy_from_user_bprm.skel.h" + +void test_copy_from_user_bprm(void) +{ + char data[] =3D "first\0second-argument\0SOME_ENV=3Da\0OTHER_ENV=3Dsometh= ing"; + char arg0[] =3D "first"; + char arg1[] =3D "second-argument"; + char env0[] =3D "SOME_ENV=3Da"; + char env1[] =3D "OTHER_ENV=3Dsomething"; + struct copy_from_user_bprm *skel; + pid_t child; + int status; + + skel =3D copy_from_user_bprm__open_and_load(); + if (!ASSERT_OK_PTR(skel, "open_and_load")) + return; + + if (!ASSERT_OK(copy_from_user_bprm__attach(skel), "attach")) + goto out; + + child =3D fork(); + if (!ASSERT_GE(child, 0, "fork")) + goto out; + + if (!child) { + char *const argv[] =3D { arg0, arg1, NULL }; + char *const envp[] =3D { env0, env1, NULL }; + + skel->bss->monitored_pid =3D getpid(); + execvpe("true", argv, envp); + _exit(errno); + } + + if (!ASSERT_EQ(waitpid(child, &status, 0), child, "waitpid")) + goto out; + + if (ASSERT_TRUE(WIFEXITED(status), "child_exited")) + ASSERT_EQ(WEXITSTATUS(status), EPERM, "exec_errno"); + + ASSERT_EQ(skel->bss->bprm_argc, 2, "bprm_argc"); + ASSERT_EQ(skel->bss->bprm_envc, 2, "bprm_envc"); + ASSERT_EQ(skel->bss->data_len, sizeof(data), "data_len"); + ASSERT_EQ(skel->bss->invalid_flags_ret, -EINVAL, "invalid_flags_ret"); + ASSERT_EQ(skel->bss->copy_ret, 0, "copy_ret"); + ASSERT_EQ(skel->bss->arg0_ret, sizeof(arg0), "arg0_ret"); + ASSERT_EQ(skel->bss->arg1_ret, sizeof(arg1), "arg1_ret"); + ASSERT_EQ(skel->bss->env0_ret, sizeof(env0), "env0_ret"); + ASSERT_EQ(skel->bss->env1_ret, sizeof(env1), "env1_ret"); + ASSERT_EQ(memcmp(skel->bss->data, data, sizeof(data)), 0, "data"); + ASSERT_EQ(memcmp(skel->bss->arg0, arg0, sizeof(arg0)), 0, "arg0"); + ASSERT_EQ(memcmp(skel->bss->arg1, arg1, sizeof(arg1)), 0, "arg1"); + ASSERT_EQ(memcmp(skel->bss->env0, env0, sizeof(env0)), 0, "env0"); + ASSERT_EQ(memcmp(skel->bss->env1, env1, sizeof(env1)), 0, "env1"); + +out: + copy_from_user_bprm__destroy(skel); +} diff --git a/tools/testing/selftests/bpf/progs/copy_from_user_bprm.c b/tool= s/testing/selftests/bpf/progs/copy_from_user_bprm.c new file mode 100644 index 000000000000..00ecba3ea567 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/copy_from_user_bprm.c @@ -0,0 +1,69 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include "vmlinux.h" + +#include +#include +#include + +char _license[] SEC("license") =3D "GPL"; + +int monitored_pid; +int bprm_argc; +int bprm_envc; +int data_len; +int invalid_flags_ret; +int copy_ret; +int arg0_ret; +int arg1_ret; +int env0_ret; +int env1_ret; +char data[64] =3D {}; +char arg0[32] =3D {}; +char arg1[32] =3D {}; +char env0[32] =3D {}; +char env1[32] =3D {}; + +SEC("lsm.s/bprm_check_security") +int BPF_PROG(check_exec_args, struct linux_binprm *bprm) +{ + u32 pid =3D bpf_get_current_pid_tgid() >> 32; + struct mm_struct *mm; + u64 offset =3D 0; + + if (pid !=3D monitored_pid) + return 0; + + mm =3D bprm->mm; + if (!mm) + return 0; + + bprm_argc =3D bprm->argc; + bprm_envc =3D bprm->envc; + + /* this is the total size of args and envs starting from bprm->p */ + data_len =3D bprm->exec - bprm->p; + + invalid_flags_ret =3D bpf_copy_from_user_mm(data, sizeof(data), (void *)b= prm->p, mm, ~0ULL); + + copy_ret =3D bpf_copy_from_user_mm(data, sizeof(data), (void *)bprm->p, m= m, 0); + if (copy_ret) + return 0; + + /* arg0 is at bprm->p */ + arg0_ret =3D bpf_copy_from_user_mm_str(arg0, sizeof(arg0), (void *)(bprm-= >p + offset), mm, BPF_F_PAD_ZEROS); + offset +=3D arg0_ret; + + /* arg1 is at bprm->p + arg0_ret */ + arg1_ret =3D bpf_copy_from_user_mm_str(arg1, sizeof(arg1), (void *)(bprm-= >p + offset), mm, BPF_F_PAD_ZEROS); + offset +=3D arg1_ret; + + /* env0 is at bprm->p + arg0_ret + arg1_ret */ + env0_ret =3D bpf_copy_from_user_mm_str(env0, sizeof(env0), (void *)(bprm-= >p + offset), mm, BPF_F_PAD_ZEROS); + offset +=3D env0_ret; + + /* env1 is at bprm->p + arg0_ret + arg1_ret + env0_ret */ + env1_ret =3D bpf_copy_from_user_mm_str(env1, sizeof(env1), (void *)(bprm-= >p + offset), mm, BPF_F_PAD_ZEROS); + + return -EPERM; +} --=20 2.55.0