mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: "Mickaël Salaün" <mic@digikod.net>
To: "Günther Noack" <gnoack@google.com>
Cc: Ada Smith <adasmithgt@gmail.com>,
	Hungyu Lin <dennylin0707@gmail.com>,
	 James Morris <jmorris@namei.org>,
	Josef Bacik <josef@toxicpanda.com>,
	 Paul Moore <paul@paul-moore.com>,
	Serge Hallyn <serge@hallyn.com>,
	 Serge Hallyn <sergeh@kernel.org>,
	kernel-team@cloudflare.com, linux-kernel@vger.kernel.org,
	 linux-security-module@vger.kernel.org
Subject: Re: [PATCH v2 5/6] selftests/landlock: Test capability checks outside the capable hook
Date: Wed, 18 Nov 2026 18:11:50 +0100	[thread overview]
Message-ID: <20261118.eekieJebo8Ee@digikod.net> (raw)
In-Reply-To: <avx8yncGLuzDFVEa@google.com>

v3 should address your review.

On Tue, Nov 17, 2026 at 05:11:54PM +0100, Günther Noack wrote:
> On Tue, Nov 17, 2026 at 11:11:55AM +0100, Mickaël Salaün wrote:
> > Test the capability checks that commoncap makes from LSM hooks other
> > than capable and that the previous commits make Landlock restrict:
> > mapping below vm.mmap_min_addr (CAP_SYS_RAWIO) and adding inheritable
> > capabilities outside of the permitted set (CAP_SETPCAP).
> > 
> > Each test first checks that the operation fails without the capability,
> > so that it exercises the capability check, and then checks it with the
> > capability effective in four variants: unsandboxed, in a domain that
> > denies the capability, in a domain that allows it, and in a domain that
> > does not handle capabilities.  The mmap_addr tests map the last page
> > below vm.mmap_min_addr, and skip if the architecture rejects it before
> > the mmap_addr hook (e.g. 32-bit ARM).
> > 
> > Audit tests check that these denials are logged, that the admin reserve
> > check is not, and that allowed uses log nothing.  The admin reserve
> > check has no functional test: it only has an effect with
> > vm.overcommit_memory=2, a system-wide setting that a test cannot change
> > without racing with other processes.
> > 
> > Add CAP_SETPCAP and CAP_SYS_RAWIO to the capabilities that the tests may
> > raise, and drop the stale count from the comment of this list.
> > 
> > Without the mmap_addr and capset fixes, their denied variants and the
> > denial audit test fail.
> > 
> > Cc: Günther Noack <gnoack@google.com>
> > Cc: Paul Moore <paul@paul-moore.com>
> > Cc: Serge Hallyn <serge@hallyn.com>
> > Acked-by: Serge Hallyn (AMD) <sergeh@kernel.org>
> > Signed-off-by: Mickaël Salaün <mic@digikod.net>
> > ---
> > 
> > Changes since v1:
> > https://patch.msgid.link/20261110202436.2408244-6-mic@digikod.net
> > - Replace the admin reserve test, which changed system-wide overcommit
> >   settings and was racy (e.g. with swap, as reported by Sashiko), with a
> >   comment.
> > - Map the last page below vm.mmap_min_addr instead of page 0, and skip
> >   when the architecture rejects it, e.g. on 32-bit ARM (reported by
> >   Sashiko).
> > - Mention CAP_SETPCAP in the commit message (reported by Sashiko).
> > - Add Serge Hallyn's Acked-by.
> > ---
> >  tools/testing/selftests/landlock/cap_test.c | 336 ++++++++++++++++++++
> >  tools/testing/selftests/landlock/common.h   |   4 +-
> >  2 files changed, 339 insertions(+), 1 deletion(-)
> > 
> > diff --git a/tools/testing/selftests/landlock/cap_test.c b/tools/testing/selftests/landlock/cap_test.c
> > index 3d7fd02e21ed..39ef57a49dc9 100644
> > --- a/tools/testing/selftests/landlock/cap_test.c
> > +++ b/tools/testing/selftests/landlock/cap_test.c
> > @@ -12,7 +12,9 @@
> >  #include <linux/landlock.h>
> >  #include <sched.h>
> >  #include <stdio.h>
> > +#include <stdlib.h>
> >  #include <string.h>
> > +#include <sys/mman.h>
> >  #include <sys/mount.h>
> >  #include <sys/wait.h>
> >  #include <sys/xattr.h>
> > @@ -738,6 +740,251 @@ TEST(cap_target_userns_independent)
> >  	EXPECT_EQ(0, close(target_userns_fd));
> >  }
> >  
> > +/*
> > + * Capability checks that commoncap makes from hooks other than the capable
> > + * hook.  Each test first checks that the operation needs the capability, then
> > + * checks it with the capability effective.  Variants cover an unsandboxed
> > + * baseline, a domain that denies the capability, a domain that allows it, and a
> > + * domain that does not handle capabilities.
> > + */
> > +/* clang-format off */
> > +FIXTURE(cap_other_hooks) {};
> > +/* clang-format on */
> > +
> > +FIXTURE_VARIANT(cap_other_hooks)
> > +{
> > +	const bool is_sandboxed;
> > +	const bool handle_caps;
> > +	const bool is_allowed;
> > +};
> > +
> > +/* clang-format off */
> > +FIXTURE_VARIANT_ADD(cap_other_hooks, unsandboxed) {
> > +	.is_sandboxed = false,
> > +	.handle_caps = false,
> > +	.is_allowed = true,
> > +};
> > +/* clang-format on */
> > +
> > +/* clang-format off */
> > +FIXTURE_VARIANT_ADD(cap_other_hooks, denied) {
> > +	.is_sandboxed = true,
> > +	.handle_caps = true,
> > +	.is_allowed = false,
> > +};
> > +/* clang-format on */
> > +
> > +/* clang-format off */
> > +FIXTURE_VARIANT_ADD(cap_other_hooks, allowed) {
> > +	.is_sandboxed = true,
> > +	.handle_caps = true,
> > +	.is_allowed = true,
> > +};
> > +/* clang-format on */
> > +
> > +/* clang-format off */
> > +FIXTURE_VARIANT_ADD(cap_other_hooks, unhandled) {
> > +	.is_sandboxed = true,
> > +	.handle_caps = false,
> > +	.is_allowed = true,
> > +};
> > +/* clang-format on */
> > +
> > +FIXTURE_SETUP(cap_other_hooks)
> > +{
> > +	disable_caps(_metadata);
> > +}
> > +
> > +FIXTURE_TEARDOWN(cap_other_hooks)
> > +{
> > +}
> > +
> > +/*
> > + * Creates a ruleset that handles capabilities and allows @cap if @is_allowed,
> > + * or, if !@handle_caps, a ruleset that only handles a filesystem access right.
> > + * Returns the ruleset FD, or -1 with errno set.
> > + */
> > +static int create_variant_ruleset(const bool handle_caps, const bool is_allowed,
> > +				  const int cap)
> 
> Nit: Maybe rename "is_allowed" to "allow_caps", so that it's a bit
> clearer that this only makes sense in the case where caps are also
> handled.  Or maybe just guard it on "cap" being non-zero, and rename
> that appropriately?



> 
> > +{
> > +	const struct landlock_ruleset_attr fs_attr = {
> > +		.handled_access_fs = LANDLOCK_ACCESS_FS_READ_FILE,
> > +	};
> > +	int ruleset_fd, err;
> > +
> > +	if (!handle_caps)
> > +		return landlock_create_ruleset(&fs_attr, sizeof(fs_attr), 0);
> > +
> > +	ruleset_fd = create_cap_ruleset();
> > +	if (ruleset_fd < 0 || !is_allowed)
> > +		return ruleset_fd;
> > +
> > +	if (add_cap_rule(ruleset_fd, cap)) {
> > +		err = errno;
> > +		close(ruleset_fd);
> > +		errno = err;
> > +		return -1;
> > +	}
> > +	return ruleset_fd;
> > +}
> > +
> > +static void
> > +enforce_cap_variant(struct __test_metadata *const _metadata,
> > +		    const FIXTURE_VARIANT(cap_other_hooks) *const variant,
> > +		    const int cap)
> > +{
> > +	int ruleset_fd;
> > +
> > +	if (!variant->is_sandboxed)
> > +		return;
> > +
> > +	ruleset_fd = create_variant_ruleset(variant->handle_caps,
> > +					    variant->is_allowed, cap);
> > +	ASSERT_LE(0, ruleset_fd);
> > +	enforce_ruleset(_metadata, ruleset_fd);
> > +	EXPECT_EQ(0, close(ruleset_fd));
> > +}
> > +
> > +static unsigned long read_sysctl(struct __test_metadata *const _metadata,
> > +				 const char *const path)
> > +{
> > +	char buf[32];
> > +	ssize_t len;
> > +	int fd;
> > +
> > +	fd = open(path, O_RDONLY | O_CLOEXEC);
> > +	ASSERT_LE(0, fd)
> > +	{
> > +		TH_LOG("Failed to open %s: %s", path, strerror(errno));
> > +	}
> > +	len = read(fd, buf, sizeof(buf) - 1);
> > +	ASSERT_LT(0, len);
> > +	EXPECT_EQ(0, close(fd));
> > +
> > +	buf[len] = '\0';
> > +	return strtoul(buf, NULL, 10);
> > +}
> > +
> > +/*
> > + * Returns the last page below the vm.mmap_min_addr sysctl, or MAP_FAILED if
> > + * there is none or if the architecture rejects it before the mmap_addr hook
> > + * (e.g. below FIRST_USER_ADDRESS on 32-bit ARM).  The caller must not have
> > + * CAP_SYS_RAWIO in its effective set.
> > + */
> > +static void *get_low_page(struct __test_metadata *const _metadata)
> > +{
> > +	const size_t page_size = sysconf(_SC_PAGESIZE);
> > +	unsigned long min_addr;
> > +	void *addr, *ret;
> > +
> > +	min_addr = read_sysctl(_metadata, "/proc/sys/vm/mmap_min_addr");
> > +	if (!min_addr)
> > +		return MAP_FAILED;
> > +
> > +	addr = (void *)((min_addr - 1) & ~(page_size - 1));
> > +	ret = mmap(addr, page_size, PROT_READ,
> > +		   MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
> > +	ASSERT_EQ(MAP_FAILED, ret);
> > +	if (errno == EINVAL)
> > +		return MAP_FAILED;
> > +
> > +	ASSERT_EQ(EPERM, errno);
> > +	return addr;
> > +}
> > +
> > +/*
> > + * cap_mmap_addr() requires CAP_SYS_RAWIO to map below the vm.mmap_min_addr
> > + * sysctl (dac_mmap_min_addr).
> > + */
> > +TEST_F(cap_other_hooks, mmap_min_addr)
> > +{
> > +	const size_t page_size = sysconf(_SC_PAGESIZE);
> > +	void *low_page, *addr;
> > +
> > +	low_page = get_low_page(_metadata);
> > +	if (low_page == MAP_FAILED)
> > +		SKIP(return, "Cannot map below vm.mmap_min_addr");
> > +
> > +	enforce_cap_variant(_metadata, variant, CAP_SYS_RAWIO);
> > +
> > +	addr = mmap(low_page, page_size, PROT_READ,
> > +		    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
> > +	EXPECT_EQ(MAP_FAILED, addr);
> > +	EXPECT_EQ(EPERM, errno);
> > +
> > +	set_cap(_metadata, CAP_SYS_RAWIO);
> > +	addr = mmap(low_page, page_size, PROT_READ,
> > +		    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
> > +	if (variant->is_allowed) {
> > +		EXPECT_EQ(low_page, addr)
> > +		{
> > +			TH_LOG("Failed to map below vm.mmap_min_addr: %s",
> > +			       strerror(errno));
> > +		}
> > +		if (addr != MAP_FAILED)
> > +			EXPECT_EQ(0, munmap(addr, page_size));
> 
> If you used ASSERT(low_page, addr) above, you would not need to check
> for MAP_FAILED here.
> 
> I get the feeling that you are using EXPECT because you want to do the
> munmap call?  Is that strictly necessary?  I believe that the tests
> are running in a fork, so if they mess up their memory mapping, it
> wouldn't be problematic?  (We already have many other cleanups that
> don't get done properly if an ASSERT fails, e.g. FD closing)
> 
> 
> > +	} else {
> > +		EXPECT_EQ(MAP_FAILED, addr);
> > +		EXPECT_EQ(EPERM, errno);
> 
> Same here.
> 
> errno is undefined unless the mmap failed, so the line checking for
> MAP_FAILED should use ASSERT_EQ IMHO.
> 
> Compare my selftest cleanup commit for that at:
> https://lore.kernel.org/all/20261104-selftests-refactor-v2-24-c52f23f7ce33@gmail.com/
> 
> > +		if (addr != MAP_FAILED)
> > +			munmap(addr, page_size);
> > +	}
> > +	clear_cap(_metadata, CAP_SYS_RAWIO);
> > +}
> > +
> > +static int add_inheritable_cap(const cap_value_t cap)
> > +{
> > +	cap_t cap_p;
> > +	int ret, err;
> > +
> > +	cap_p = cap_get_proc();
> > +	if (!cap_p)
> > +		return -1;
> > +
> > +	ret = cap_set_flag(cap_p, CAP_INHERITABLE, 1, &cap, CAP_SET);
> > +	if (!ret)
> > +		ret = cap_set_proc(cap_p);
> > +	err = errno;
> > +	cap_free(cap_p);
> > +	errno = err;
> > +	return ret;
> > +}
> > +
> > +/*
> > + * cap_capset() requires CAP_SETPCAP to add an inheritable capability that is
> > + * not in the permitted set.  CAP_NET_RAW is in the bounding set, but
> > + * disable_caps() does not put it in the permitted set.
> > + */
> > +TEST_F(cap_other_hooks, capset_inheritable)
> > +{
> > +	enforce_cap_variant(_metadata, variant, CAP_SETPCAP);
> > +
> > +	EXPECT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
> > +	EXPECT_EQ(EPERM, errno);
> 
> Ditto about errno checking and ASSERT.
> 
> > +
> > +	set_cap(_metadata, CAP_SETPCAP);
> > +	if (variant->is_allowed) {
> > +		EXPECT_EQ(0, add_inheritable_cap(CAP_NET_RAW))
> > +		{
> > +			TH_LOG("Failed to raise CAP_NET_RAW: %s",
> > +			       strerror(errno));
> > +		}
> > +	} else {
> > +		EXPECT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
> > +		EXPECT_EQ(EPERM, errno);
> 
> Also here (errno checking and ASSERT).  I'll refrain from commenting
> on these further below to not spam you, but there are more instances
> of it below.
> 
> 
> > +	}
> > +	clear_cap(_metadata, CAP_SETPCAP);
> > +}
> > +
> > +/*
> > + * cap_vm_enough_memory() lets CAP_SYS_ADMIN use the vm.admin_reserve_kbytes
> > + * reserve, but only with vm.overcommit_memory=2.  The Landlock check of this
> > + * reserve has no functional test: it would have to change these system-wide
> > + * settings and set a tight commit limit, which could make allocations of other
> > + * processes fail and would race with them.  cap_audit.other_hooks checks that
> > + * this check is not logged.
> > + */
> > +
> >  /* Audit tests */
> >  
> >  static int matches_log_cap(int audit_fd, int cap_number)
> > @@ -828,6 +1075,95 @@ TEST_F(cap_audit, denied)
> >  	EXPECT_EQ(0, records.domain);
> >  }
> >  
> > +/*
> > + * Denials in the capset and mmap_addr paths are audited like capable hook
> > + * denials.  The vm_enough_memory hook only withholds the admin reserve, with
> > + * CAP_OPT_NOAUDIT, so an accounted mapping made with CAP_SYS_ADMIN effective
> > + * leaves no record.
> > + */
> > +TEST_F(cap_audit, other_hooks)
> > +{
> > +	const size_t page_size = sysconf(_SC_PAGESIZE);
> > +	struct audit_records records = {};
> > +	void *low_page, *addr;
> > +	int ruleset_fd;
> > +	__u64 domain_id;
> > +
> > +	low_page = get_low_page(_metadata);
> > +	ruleset_fd = create_cap_ruleset();
> > +	ASSERT_LE(0, ruleset_fd);
> > +	/* Allow CAP_AUDIT_CONTROL for child-side audit cleanup. */
> > +	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_AUDIT_CONTROL));
> > +	enforce_ruleset(_metadata, ruleset_fd);
> > +	EXPECT_EQ(0, close(ruleset_fd));
> > +
> > +	set_cap(_metadata, CAP_SETPCAP);
> > +	EXPECT_EQ(-1, add_inheritable_cap(CAP_NET_RAW));
> > +	EXPECT_EQ(EPERM, errno);
> > +	clear_cap(_metadata, CAP_SETPCAP);
> > +	EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SETPCAP));
> > +	EXPECT_EQ(0, matches_log_domain_allocated(self->audit_fd, getpid(),
> > +						  &domain_id));
> > +
> > +	if (low_page != MAP_FAILED) {
> > +		set_cap(_metadata, CAP_SYS_RAWIO);
> > +		addr = mmap(low_page, page_size, PROT_READ,
> > +			    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
> > +		EXPECT_EQ(MAP_FAILED, addr);
> > +		EXPECT_EQ(EPERM, errno);
> > +		clear_cap(_metadata, CAP_SYS_RAWIO);
> > +		EXPECT_EQ(0, matches_log_cap(self->audit_fd, CAP_SYS_RAWIO));
> > +	}
> > +
> > +	set_cap(_metadata, CAP_SYS_ADMIN);
> > +	addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE,
> > +		    MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
> > +	EXPECT_NE(MAP_FAILED, addr);
> > +	clear_cap(_metadata, CAP_SYS_ADMIN);
> > +	if (addr != MAP_FAILED)
> > +		EXPECT_EQ(0, munmap(addr, page_size));
> > +
> > +	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
> > +	EXPECT_EQ(0, records.access);
> > +	EXPECT_EQ(0, records.domain);
> 
> Similar problem: "records" is undefined if audit_count_records fails,
> so audit_count_records should use ASSERT.  See
> https://lore.kernel.org/all/20261104-selftests-refactor-v2-12-c52f23f7ce33@gmail.com/
> which fixes this across all existing tests.
> 
> 
> > +}
> > +
> > +/* Allowed capability uses in the capset and mmap_addr paths. */
> > +TEST_F(cap_audit, other_hooks_allowed)
> > +{
> > +	const size_t page_size = sysconf(_SC_PAGESIZE);
> > +	struct audit_records records = {};
> > +	void *low_page, *addr;
> > +	int ruleset_fd;
> > +
> > +	low_page = get_low_page(_metadata);
> > +	ruleset_fd = create_cap_ruleset();
> > +	ASSERT_LE(0, ruleset_fd);
> > +	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_SETPCAP));
> > +	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_SYS_RAWIO));
> > +	/* Allow CAP_AUDIT_CONTROL for child-side audit cleanup. */
> > +	ASSERT_EQ(0, add_cap_rule(ruleset_fd, CAP_AUDIT_CONTROL));
> > +	enforce_ruleset(_metadata, ruleset_fd);
> > +	EXPECT_EQ(0, close(ruleset_fd));
> > +
> > +	set_cap(_metadata, CAP_SETPCAP);
> > +	EXPECT_EQ(0, add_inheritable_cap(CAP_NET_RAW));
> > +	clear_cap(_metadata, CAP_SETPCAP);
> > +
> > +	if (low_page != MAP_FAILED) {
> > +		set_cap(_metadata, CAP_SYS_RAWIO);
> > +		addr = mmap(low_page, page_size, PROT_READ,
> > +			    MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
> > +		EXPECT_EQ(low_page, addr);
> > +		clear_cap(_metadata, CAP_SYS_RAWIO);
> > +		if (addr != MAP_FAILED)
> > +			EXPECT_EQ(0, munmap(addr, page_size));
> > +	}
> > +
> > +	EXPECT_EQ(0, audit_count_records(self->audit_fd, &records));
> > +	EXPECT_EQ(0, records.access);
> 
> Here as well.
> 
> > +}
> > +
> >  TEST_F(cap_audit, allowed)
> >  {
> >  	struct audit_records records = {};
> > diff --git a/tools/testing/selftests/landlock/common.h b/tools/testing/selftests/landlock/common.h
> > index e29406900c04..a6fdfb422fad 100644
> > --- a/tools/testing/selftests/landlock/common.h
> > +++ b/tools/testing/selftests/landlock/common.h
> > @@ -36,7 +36,7 @@ static const char bin_wait_pipe_sandbox[] = "./wait-pipe-sandbox";
> >  static void _init_caps(struct __test_metadata *const _metadata, bool drop_all)
> >  {
> >  	cap_t cap_p;
> > -	/* Only these three capabilities are useful for the tests. */
> > +	/* Only these capabilities are useful for the tests. */
> >  	const cap_value_t caps[] = {
> >  		/* clang-format off */
> >  		CAP_AUDIT_CONTROL,
> > @@ -44,9 +44,11 @@ static void _init_caps(struct __test_metadata *const _metadata, bool drop_all)
> >  		CAP_MKNOD,
> >  		CAP_NET_ADMIN,
> >  		CAP_NET_BIND_SERVICE,
> > +		CAP_SETPCAP,
> >  		CAP_SETUID,
> >  		CAP_SYS_ADMIN,
> >  		CAP_SYS_CHROOT,
> > +		CAP_SYS_RAWIO,
> >  		/* clang-format on */
> >  	};
> >  	const unsigned int noroot = SECBIT_NOROOT | SECBIT_NOROOT_LOCKED;
> > -- 
> > 2.56.0
> > 
> 

  reply	other threads:[~2026-11-18 17:11 UTC|newest]

Thread overview: 17+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17 10:11 [PATCH v2 0/6] Fix Landlock mediation of commoncap's capability checks Mickaël Salaün
2026-11-17 10:11 ` [PATCH v2 1/6] landlock: Factor out capability denial checks Mickaël Salaün
2026-11-17 13:56   ` Günther Noack
2026-11-17 10:11 ` [PATCH v2 2/6] landlock: Mediate CAP_SYS_RAWIO for mappings below mmap_min_addr Mickaël Salaün
2026-11-17 14:23   ` Günther Noack
2026-11-18 17:00     ` Mickaël Salaün
2026-11-17 10:11 ` [PATCH v2 3/6] landlock: Mediate CAP_SETPCAP for inheritable capabilities Mickaël Salaün
2026-11-17 15:41   ` Günther Noack
2026-11-18 17:01     ` Mickaël Salaün
2026-11-17 10:11 ` [PATCH v2 4/6] landlock: Mediate CAP_SYS_ADMIN for the admin memory reserve Mickaël Salaün
2026-11-17 15:43   ` Günther Noack
2026-11-17 10:11 ` [PATCH v2 5/6] selftests/landlock: Test capability checks outside the capable hook Mickaël Salaün
2026-11-17 16:11   ` Günther Noack
2026-11-18 17:11     ` Mickaël Salaün [this message]
2026-11-17 10:11 ` [PATCH v2 6/6] landlock: Fix capability restriction documentation Mickaël Salaün
2026-11-17 16:25   ` Günther Noack
2026-11-18 17:11     ` Mickaël Salaün

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261118.eekieJebo8Ee@digikod.net \
    --to=mic@digikod.net \
    --cc=adasmithgt@gmail.com \
    --cc=dennylin0707@gmail.com \
    --cc=gnoack@google.com \
    --cc=jmorris@namei.org \
    --cc=josef@toxicpanda.com \
    --cc=kernel-team@cloudflare.com \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-security-module@vger.kernel.org \
    --cc=paul@paul-moore.com \
    --cc=serge@hallyn.com \
    --cc=sergeh@kernel.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®