From: "Jarkko Sakkinen" <jarkko@kernel.org>
To: "Roberto Sassu" <roberto.sassu@huaweicloud.com>, <corbet@lwn.net>,
<paul@paul-moore.com>, <jmorris@namei.org>, <serge@hallyn.com>,
<akpm@linux-foundation.org>, <shuah@kernel.org>,
<mcoquelin.stm32@gmail.com>, <alexandre.torgue@foss.st.com>,
<mic@digikod.net>
Cc: <linux-security-module@vger.kernel.org>,
<linux-doc@vger.kernel.org>, <linux-kernel@vger.kernel.org>,
<linux-kselftest@vger.kernel.org>, <bpf@vger.kernel.org>,
<zohar@linux.ibm.com>, <dmitry.kasatkin@gmail.com>,
<linux-integrity@vger.kernel.org>, <wufan@linux.microsoft.com>,
<pbrobinson@gmail.com>, <zbyszek@in.waw.pl>, <hch@lst.de>,
<mjg59@srcf.ucam.org>, <pmatilai@redhat.com>, <jannh@google.com>,
<dhowells@redhat.com>, <jikos@kernel.org>, <mkoutny@suse.com>,
<ppavlu@suse.com>, <petr.vorel@gmail.com>, <mzerqung@0pointer.de>,
<kgold@linux.ibm.com>, "Roberto Sassu" <roberto.sassu@huawei.com>
Subject: Re: [PATCH v4 10/14] digest cache: Prefetch digest lists if requested
Date: Mon, 15 Apr 2024 22:42:49 +0300 [thread overview]
Message-ID: <D0KYBIKEMVBJ.3TUUWH3M4XW7I@kernel.org> (raw)
In-Reply-To: <20240415142436.2545003-11-roberto.sassu@huaweicloud.com>
On Mon Apr 15, 2024 at 5:24 PM EEST, Roberto Sassu wrote:
> From: Roberto Sassu <roberto.sassu@huawei.com>
>
> A desirable goal when doing integrity measurements is that they are done
> always in the same order across boots, so that the resulting PCR value
> becomes predictable and suitable for sealing policies. However, due to
> parallel execution of system services at boot, a deterministic order of
> measurements is difficult to achieve.
>
> The digest_cache LSM is not exempted from this issue. Under the assumption
> that only the digest list is measured, and file measurements are omitted if
> their digest is found in that digest list, a PCR can be predictable only if
> all files belong to the same digest list. Otherwise, it will still be
> unpredictable, since files accessed in a non-deterministic order will cause
> digest lists to be measured in a non-deterministic order too.
>
> Overcome this issue, if prefetching is enabled, by searching a digest list
> file name in digest_list_dir_lookup_filename() among the entries of the
> linked list built by digest_cache_dir_create(). If the file name does not
> match, read the digest list to trigger its measurement. Otherwise, also
> create a digest cache and return that to the caller. Release the extra
> reference of the directory digest cache in digest_cache_new(), since it was
> only used for the search and it is not going to be returned.
>
> Prefetching needs to be explicitly enabled by setting the new
> security.dig_prefetch xattr to 1 in the directory containing the digest
> lists. The newly introduced function digest_cache_prefetch_requested()
> checks first if the DIR_PREFETCH bit is set in dig_owner, otherwise it
> reads the xattr. digest_cache_create() sets DIR_PREFETCH in dig_owner, if
> prefetching is enabled, before declaring the digest cache as initialized.
>
> Signed-off-by: Roberto Sassu <roberto.sassu@huawei.com>
> ---
> include/uapi/linux/xattr.h | 3 +
> security/digest_cache/dir.c | 55 +++++++++++++++++-
> security/digest_cache/internal.h | 11 +++-
> security/digest_cache/main.c | 95 +++++++++++++++++++++++++++++++-
> security/digest_cache/populate.c | 8 ++-
> security/digest_cache/verif.c | 5 +-
> 6 files changed, 170 insertions(+), 7 deletions(-)
>
> diff --git a/include/uapi/linux/xattr.h b/include/uapi/linux/xattr.h
> index 8a58cf4bce65..8af33d38d9e8 100644
> --- a/include/uapi/linux/xattr.h
> +++ b/include/uapi/linux/xattr.h
> @@ -57,6 +57,9 @@
> #define XATTR_DIGEST_LIST_SUFFIX "digest_list"
> #define XATTR_NAME_DIGEST_LIST XATTR_SECURITY_PREFIX XATTR_DIGEST_LIST_SUFFIX
>
> +#define XATTR_DIG_PREFETCH_SUFFIX "dig_prefetch"
> +#define XATTR_NAME_DIG_PREFETCH XATTR_SECURITY_PREFIX XATTR_DIG_PREFETCH_SUFFIX
> +
> #define XATTR_SELINUX_SUFFIX "selinux"
> #define XATTR_NAME_SELINUX XATTR_SECURITY_PREFIX XATTR_SELINUX_SUFFIX
>
> diff --git a/security/digest_cache/dir.c b/security/digest_cache/dir.c
> index 7bfcdd5f7ef1..a7d203c15386 100644
> --- a/security/digest_cache/dir.c
> +++ b/security/digest_cache/dir.c
> @@ -54,6 +54,7 @@ static bool digest_cache_dir_iter(struct dir_context *__ctx, const char *name,
> new_entry->seq_num = UINT_MAX;
> new_entry->digest_cache = NULL;
> mutex_init(&new_entry->digest_cache_mutex);
> + new_entry->prefetched = false;
>
> if (new_entry->name[0] < '0' || new_entry->name[0] > '9')
> goto out;
> @@ -127,6 +128,7 @@ int digest_cache_dir_create(struct digest_cache *digest_cache,
> * @digest_cache: Digest cache
> * @digest: Digest to search
> * @algo: Algorithm of the digest to search
> + * @filename: File name of the digest list to search
> *
> * This function iterates over the linked list created by
> * digest_cache_dir_create() and looks up the digest in the digest cache of
> @@ -149,7 +151,8 @@ digest_cache_dir_lookup_digest(struct dentry *dentry,
> if (!dir_entry->digest_cache) {
> cache = digest_cache_create(dentry, digest_list_path,
> digest_cache->path_str,
> - dir_entry->name);
> + dir_entry->name, false,
> + false);
> /* Ignore digest caches that cannot be instantiated. */
> if (!cache) {
> mutex_unlock(&dir_entry->digest_cache_mutex);
> @@ -158,6 +161,8 @@ digest_cache_dir_lookup_digest(struct dentry *dentry,
>
> /* Consume extra ref. from digest_cache_create(). */
> dir_entry->digest_cache = cache;
> + /* Digest list was read, mark entry as prefetched. */
> + dir_entry->prefetched = true;
> }
> mutex_unlock(&dir_entry->digest_cache_mutex);
>
> @@ -171,6 +176,54 @@ digest_cache_dir_lookup_digest(struct dentry *dentry,
> return 0UL;
> }
>
> +/**
> + * digest_cache_dir_lookup_filename - Lookup a digest list
> + * @dentry: Dentry of the file whose digest list is looked up
> + * @digest_list_path: Path structure of the digest list directory
> + * @digest_cache: Digest cache
> + * @filename: File name of the digest list to search
> + *
> + * This function iterates over the linked list created by
> + * digest_cache_dir_create() and looks up a digest list with a matching file
> + * name among the entries. If there is no match, it prefetches (reads) the
> + * current digest list. Otherwise, it returns the digest cache pointer from
> + * digest_cache_create() to the caller.
> + *
> + * Return: A digest cache pointer if the digest list if found, NULL otherwise.
> + */
> +struct digest_cache *
> +digest_cache_dir_lookup_filename(struct dentry *dentry,
> + struct path *digest_list_path,
> + struct digest_cache *digest_cache,
> + char *filename)
> +{
> + struct digest_cache *cache;
> + struct dir_entry *dir_entry;
> + bool filename_found;
> +
> + list_for_each_entry(dir_entry, &digest_cache->dir_entries, list) {
> + mutex_lock(&dir_entry->digest_cache_mutex);
> + filename_found = !strcmp(dir_entry->name, filename);
> + if (!filename_found && dir_entry->prefetched) {
> + mutex_unlock(&dir_entry->digest_cache_mutex);
> + continue;
> + }
> +
> + cache = digest_cache_create(dentry, digest_list_path,
> + digest_cache->path_str,
> + dir_entry->name, false,
> + filename_found ? false : true);
> +
> + dir_entry->prefetched = true;
> + mutex_unlock(&dir_entry->digest_cache_mutex);
> +
> + if (filename_found)
> + return cache;
> + }
> +
> + return NULL;
> +}
> +
> /**
> * digest_cache_dir_free - Free the stored file list and put digest caches
> * @digest_cache: Digest cache
> diff --git a/security/digest_cache/internal.h b/security/digest_cache/internal.h
> index b7afca8e04da..c13b35f6b2c0 100644
> --- a/security/digest_cache/internal.h
> +++ b/security/digest_cache/internal.h
> @@ -17,6 +17,7 @@
> #define INIT_IN_PROGRESS 0 /* Digest cache being initialized. */
> #define INVALID 1 /* Digest cache marked as invalid. */
> #define IS_DIR 2 /* Digest cache created from dir. */
> +#define DIR_PREFETCH 3 /* Prefetching requested for dir. */
>
> /**
> * struct readdir_callback - Structure to store information for dir iteration
> @@ -37,6 +38,7 @@ struct readdir_callback {
> * @digest_cache: Digest cache associated to the directory entry
> * @digest_cache_mutex: Protects @digest_cache
> * @seq_num: Sequence number of the directory entry from file name
> + * @prefetched: Whether the digest list has been already prefetched
> * @name: File name of the directory entry
> *
> * This structure represents a directory entry with a digest cache created
> @@ -47,6 +49,7 @@ struct dir_entry {
> struct digest_cache *digest_cache;
> struct mutex digest_cache_mutex;
> unsigned int seq_num;
> + bool prefetched;
> char name[];
> } __packed;
>
> @@ -205,7 +208,8 @@ digest_cache_from_file_sec(const struct file *file)
> /* main.c */
> struct digest_cache *digest_cache_create(struct dentry *dentry,
> struct path *digest_list_path,
> - char *path_str, char *filename);
> + char *path_str, char *filename,
> + bool prefetch_req, bool prefetch);
>
> /* htable.c */
> int digest_cache_htable_init(struct digest_cache *digest_cache, u64 num_digests,
> @@ -236,6 +240,11 @@ digest_cache_dir_lookup_digest(struct dentry *dentry,
> struct path *digest_list_path,
> struct digest_cache *digest_cache, u8 *digest,
> enum hash_algo algo);
> +struct digest_cache *
> +digest_cache_dir_lookup_filename(struct dentry *dentry,
> + struct path *digest_list_path,
> + struct digest_cache *digest_cache,
> + char *filename);
> void digest_cache_dir_free(struct digest_cache *digest_cache);
>
> #endif /* _DIGEST_CACHE_INTERNAL_H */
> diff --git a/security/digest_cache/main.c b/security/digest_cache/main.c
> index 15f1486610a3..a5616fd07c1d 100644
> --- a/security/digest_cache/main.c
> +++ b/security/digest_cache/main.c
> @@ -83,6 +83,8 @@ static void digest_cache_free(struct digest_cache *digest_cache)
> * @digest_list_path: Path structure of the digest list
> * @path_str: Path string of the digest list
> * @filename: Digest list file name (can be an empty string)
> + * @prefetch_req: Whether prefetching has been requested
> + * @prefetch: Whether prefetching of a digest list is being done
> *
> * This function first locates, from the passed path, the digest list inode
> * from which the digest cache will be created or retrieved (if it already
> @@ -109,7 +111,8 @@ static void digest_cache_free(struct digest_cache *digest_cache)
> */
> struct digest_cache *digest_cache_create(struct dentry *dentry,
> struct path *digest_list_path,
> - char *path_str, char *filename)
> + char *path_str, char *filename,
> + bool prefetch_req, bool prefetch)
This has enough parameters to consider separate "digest_cache_descriptor"
or whatever. In some architectures this is beyond register parameters,
which is IMHO good threshold to consider that.
This will make e.g. tracing easier as you have to map only one parameter
to a known struct to inspect the values.
> {
> struct path file_path;
> struct digest_cache *digest_cache = NULL;
> @@ -148,6 +151,16 @@ struct digest_cache *digest_cache_create(struct dentry *dentry,
> dentry->d_name.name);
> goto out;
> }
> +
> + if (prefetch) {
> + /* Fine to fail, we are just prefetching. */
> + ret = digest_cache_populate(NULL, digest_list_path,
> + path_str, filename);
> + pr_debug("Digest list %s/%s %s prefetched\n",
> + path_str, filename,
> + !ret ? "has been" : "cannot be");
> + goto out;
> + }
> }
>
> dig_sec = digest_cache_get_security(inode);
> @@ -176,6 +189,11 @@ struct digest_cache *digest_cache_create(struct dentry *dentry,
>
> /* Make the other lock contenders wait until creation complete. */
> set_bit(INIT_IN_PROGRESS, &dig_sec->dig_owner->flags);
> +
> + /* Set DIR_PREFETCH if prefetching was requested. */
> + if (prefetch_req)
> + set_bit(DIR_PREFETCH, &digest_cache->flags);
> +
> mutex_unlock(&dig_sec->dig_owner_mutex);
>
> if (S_ISREG(inode->i_mode)) {
> @@ -220,6 +238,52 @@ struct digest_cache *digest_cache_create(struct dentry *dentry,
> return digest_cache;
> }
>
> +/**
> + * digest_cache_prefetch_requested - Verify if prefetching is requested
> + * @digest_list_path: Path structure of the digest list directory
> + * @path_str: Path string of the digest list directory
> + *
> + * This function verifies whether or not digest list prefetching is requested.
> + * If dig_owner exists in the inode security blob, it checks the DIR_PREFETCH
> + * bit (faster). Otherwise, it reads the new security.dig_prefetch xattr.
> + *
> + * Return: True if prefetching is requested, false otherwise.
> + */
> +static bool digest_cache_prefetch_requested(struct path *digest_list_path,
> + char *path_str)
> +{
> + struct digest_cache_security *dig_sec;
> + bool prefetch_req = false;
> + char prefetch_value;
> + struct inode *inode;
> + int ret;
> +
> + inode = d_backing_inode(digest_list_path->dentry);
> + dig_sec = digest_cache_get_security(inode);
> + if (unlikely(!dig_sec))
> + return false;
> +
> + mutex_lock(&dig_sec->dig_owner_mutex);
> + if (dig_sec->dig_owner) {
> + /* Reliable test: DIR_PREFETCH set with dig_owner_mutex held. */
> + prefetch_req = test_bit(DIR_PREFETCH,
> + &dig_sec->dig_owner->flags);
> + mutex_unlock(&dig_sec->dig_owner_mutex);
> + return prefetch_req;
> + }
> + mutex_unlock(&dig_sec->dig_owner_mutex);
> +
> + ret = vfs_getxattr(&nop_mnt_idmap, digest_list_path->dentry,
> + XATTR_NAME_DIG_PREFETCH, &prefetch_value, 1);
> + if (ret == 1 && prefetch_value == '1') {
> + pr_debug("Prefetching has been enabled for directory %s\n",
> + path_str);
> + prefetch_req = true;
> + }
> +
> + return prefetch_req;
> +}
> +
> /**
> * digest_cache_new - Retrieve digest list file name and request digest cache
> * @dentry: Dentry of the inode for which the digest cache will be used
> @@ -230,13 +294,19 @@ struct digest_cache *digest_cache_create(struct dentry *dentry,
> * with that file name. If security.digest_list is not found, this function
> * requests the creation of a digest cache on the parent directory.
> *
> + * On prefetching, if the default path is a directory and if
> + * security.digest_list is found, this function first retrieves the directory
> + * digest cache, and then calls digest_cache_dir_lookup_filename() to retrieve
> + * the desired digest cache in that directory.
> + *
> * Return: A new digest cache on success, NULL on error.
> */
> static struct digest_cache *digest_cache_new(struct dentry *dentry)
> {
> char filename[NAME_MAX + 1] = { 0 };
> - struct digest_cache *digest_cache = NULL;
> + struct digest_cache *digest_cache = NULL, *found;
> struct path default_path;
> + bool prefetch_req = false;
> int ret;
>
> ret = kern_path(default_path_str, 0, &default_path);
> @@ -273,9 +343,28 @@ static struct digest_cache *digest_cache_new(struct dentry *dentry)
> pr_debug("Found %s xattr in %s, default path: %s, digest list: %s\n",
> XATTR_NAME_DIGEST_LIST, dentry->d_name.name, default_path_str,
> filename);
> +
> + if (filename[0])
> + prefetch_req = digest_cache_prefetch_requested(&default_path,
> + default_path_str);
> create:
> + /* On prefetching, retrieve the directory digest cache. */
> digest_cache = digest_cache_create(dentry, &default_path,
> - default_path_str, filename);
> + default_path_str,
> + !prefetch_req ? filename : "",
> + prefetch_req, false);
> + if (!digest_cache)
> + goto out;
> +
> + if (prefetch_req) {
> + /* Find the digest cache with a matching file name. */
> + found = digest_cache_dir_lookup_filename(dentry, &default_path,
> + digest_cache,
> + filename);
> + /* Release ref. to the directory digest cache. */
> + digest_cache_put(digest_cache);
> + digest_cache = found;
> + }
> out:
> path_put(&default_path);
> return digest_cache;
> diff --git a/security/digest_cache/populate.c b/security/digest_cache/populate.c
> index 9c2fc2295310..17e7b011c367 100644
> --- a/security/digest_cache/populate.c
> +++ b/security/digest_cache/populate.c
> @@ -143,6 +143,12 @@ int digest_cache_populate(struct digest_cache *digest_cache,
> return ret;
> }
>
> + /* The caller wants just to read digest lists. */
> + if (!digest_cache) {
> + ret = 0;
> + goto out_vfree;
> + }
> +
> data_len = digest_cache_strip_modsig(data, ret);
>
> /* Digest list parsers initialize the hash table and add the digests. */
> @@ -151,7 +157,7 @@ int digest_cache_populate(struct digest_cache *digest_cache,
> if (ret < 0)
> pr_debug("Error parsing digest list %s%s%s, ret: %d\n",
> path_str, filename[0] ? "/" : "", filename, ret);
> -
> +out_vfree:
> vfree(data);
> return ret;
> }
> diff --git a/security/digest_cache/verif.c b/security/digest_cache/verif.c
> index 04023240d3b4..c42ae93261e2 100644
> --- a/security/digest_cache/verif.c
> +++ b/security/digest_cache/verif.c
> @@ -33,7 +33,7 @@ static void free_verif(struct digest_cache_verif *verif)
> * This function lets a verifier supply verification data about a digest list
> * being read to populate the digest cache.
> *
> - * Return: Zero on success, -ENOMEM if out of memory.
> + * Return: Zero on success, -ENOMEM if out of memory, -ENOENT on prefetching.
> */
> int digest_cache_verif_set(struct file *file, const char *verif_id, void *data,
> size_t size)
> @@ -41,6 +41,9 @@ int digest_cache_verif_set(struct file *file, const char *verif_id, void *data,
> struct digest_cache *digest_cache = digest_cache_from_file_sec(file);
> struct digest_cache_verif *new_verif;
>
> + if (!digest_cache)
> + return -ENOENT;
> +
> /*
> * All allocations must be atomic (non-sleepable) since kprobe does not
> * allow otherwise (kprobe is needed for testing).
BR, Jarkko
next prev parent reply other threads:[~2024-04-15 19:42 UTC|newest]
Thread overview: 49+ messages / expand[flat|nested] mbox.gz Atom feed top
2024-04-15 14:24 [PATCH v4 00/14] security: digest_cache LSM Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 01/14] lib: Add TLV parser Roberto Sassu
2024-04-15 19:19 ` Jarkko Sakkinen
2024-04-15 21:07 ` Randy Dunlap
2024-04-16 14:23 ` Jarkko Sakkinen
2024-04-15 14:24 ` [PATCH v4 02/14] security: Introduce the digest_cache LSM Roberto Sassu
2024-04-15 19:31 ` Jarkko Sakkinen
2024-04-16 7:09 ` Roberto Sassu
2024-04-16 14:33 ` Jarkko Sakkinen
2024-04-17 17:00 ` Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 03/14] digest_cache: Add securityfs interface Roberto Sassu
2024-04-15 19:32 ` Jarkko Sakkinen
2024-04-16 10:15 ` Roberto Sassu
2024-04-16 14:38 ` Jarkko Sakkinen
2024-04-15 14:24 ` [PATCH v4 04/14] digest_cache: Add hash tables and operations Roberto Sassu
2024-04-15 19:36 ` Jarkko Sakkinen
2024-04-16 10:28 ` Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 05/14] digest_cache: Populate the digest cache from a digest list Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 06/14] digest_cache: Parse tlv digest lists Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 07/14] digest_cache: Parse rpm " Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 08/14] digest_cache: Add management of verification data Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 09/14] digest_cache: Add support for directories Roberto Sassu
2024-04-15 19:39 ` Jarkko Sakkinen
2024-04-16 10:30 ` Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 10/14] digest cache: Prefetch digest lists if requested Roberto Sassu
2024-04-15 19:42 ` Jarkko Sakkinen [this message]
2024-04-16 10:34 ` Roberto Sassu
2024-04-16 14:47 ` Jarkko Sakkinen
2024-04-15 14:24 ` [PATCH v4 11/14] digest_cache: Reset digest cache on file/directory change Roberto Sassu
2024-04-15 19:44 ` Jarkko Sakkinen
2024-04-16 10:37 ` Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 12/14] digest_cache: Notify digest cache events Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 13/14] selftests/digest_cache: Add selftests for digest_cache LSM Roberto Sassu
2024-04-15 19:47 ` Jarkko Sakkinen
2024-04-16 10:39 ` Roberto Sassu
2024-04-15 14:24 ` [PATCH v4 14/14] docs: Add documentation of the " Roberto Sassu
2024-04-15 19:18 ` [PATCH v4 00/14] security: " Jarkko Sakkinen
2024-04-16 6:56 ` Roberto Sassu
2024-04-16 4:49 ` Bagas Sanjaya
[not found] ` <66201cd2.df0a0220.a8ad5.6fbaSMTPIN_ADDED_BROKEN@mx.google.com>
2024-04-19 11:18 ` Bagas Sanjaya
2024-04-19 20:05 ` Jarkko Sakkinen
2024-04-19 23:29 ` Roberto Sassu
2024-06-18 23:20 ` Paul Moore
2024-06-19 7:59 ` Roberto Sassu
2024-06-19 15:49 ` Paul Moore
2024-06-19 15:55 ` Roberto Sassu
2024-06-19 16:34 ` Paul Moore
2024-06-19 16:37 ` Roberto Sassu
2024-06-19 18:43 ` Paul Moore
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=D0KYBIKEMVBJ.3TUUWH3M4XW7I@kernel.org \
--to=jarkko@kernel.org \
--cc=akpm@linux-foundation.org \
--cc=alexandre.torgue@foss.st.com \
--cc=bpf@vger.kernel.org \
--cc=corbet@lwn.net \
--cc=dhowells@redhat.com \
--cc=dmitry.kasatkin@gmail.com \
--cc=hch@lst.de \
--cc=jannh@google.com \
--cc=jikos@kernel.org \
--cc=jmorris@namei.org \
--cc=kgold@linux.ibm.com \
--cc=linux-doc@vger.kernel.org \
--cc=linux-integrity@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=linux-security-module@vger.kernel.org \
--cc=mcoquelin.stm32@gmail.com \
--cc=mic@digikod.net \
--cc=mjg59@srcf.ucam.org \
--cc=mkoutny@suse.com \
--cc=mzerqung@0pointer.de \
--cc=paul@paul-moore.com \
--cc=pbrobinson@gmail.com \
--cc=petr.vorel@gmail.com \
--cc=pmatilai@redhat.com \
--cc=ppavlu@suse.com \
--cc=roberto.sassu@huawei.com \
--cc=roberto.sassu@huaweicloud.com \
--cc=serge@hallyn.com \
--cc=shuah@kernel.org \
--cc=wufan@linux.microsoft.com \
--cc=zbyszek@in.waw.pl \
--cc=zohar@linux.ibm.com \
/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;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).