From: Stan Iliev <stani@google.com>
To: Tony Nguyen <anthony.l.nguyen@intel.com>,
Przemek Kitszel <przemyslaw.kitszel@intel.com>,
"David S. Miller" <davem@davemloft.net>,
Eric Dumazet <edumazet@kernel.org>,
Jakub Kicinski <kuba@kernel.org>, Paolo Abeni <pabeni@redhat.com>,
Andrew Lunn <andrew+netdev@lunn.ch>,
intel-wired-lan@lists.osuosl.org
Cc: netdev@vger.kernel.org, linux-kernel@vger.kernel.org,
David Decotigny <decot@google.com>,
Madhu Chittim <madhu.chittim@intel.com>,
Emil Tantilov <emil.s.tantilov@intel.com>,
Sridhar Samudrala <sridhar.samudrala@intel.com>,
Brian Vazquez <brianvv@google.com>, Li Li <boolli@google.com>,
Alexander Lobakin <aleksander.lobakin@intel.com>,
Daniel Zahka <daniel.zahka@gmail.com>,
Willem de Bruijn <willemdebruijn.kernel@gmail.com>,
Kees Cook <kees@kernel.org>,
"Gustavo A. R. Silva" <gustavoars@kernel.org>,
linux-hardening@vger.kernel.org
Subject: [PATCH iwl-next 14/15] idpf: psp: add support for psp tx key insertion
Date: Tue, 17 Nov 2026 14:55:20 +0000 [thread overview]
Message-ID: <20261117145522.1910636-15-stani@google.com> (raw)
In-Reply-To: <20261117145522.1910636-1-stani@google.com>
Add support for inserting TX keys into the SADB:
- Introduce struct virtchnl2_insert_psp_key and
struct virtchnl2_psp_insert_keys_request.
- Add the insert queue, a list of the TX keys to insert with their SPI
and key.
- Implement idpf_send_insert_psp_keys(), called from the PSP work,
which inserts up to IDPF_PSP_INSERT_KEYS_MAX (101) queued TX keys
with one asynchronous request. A request that couldn't be sent puts
its keys back in the queue, they are sent again after a delay.
- Implement its response callback idpf_psp_insert_keys_cb(): the CP
inserts the keys in request order and stops at the first failure,
the keys without a valid SA index in the reply are failed. The
callback queues the work again for the next request, so the work
never waits for a reply.
- The keys are wiped once the request completed, the request buffer is
freed with kfree_sensitive() by idpf_send_mb_msg_kfree().
Signed-off-by: Stan Iliev <stani@google.com>
---
drivers/net/ethernet/intel/idpf/idpf_psp.c | 13 ++
.../net/ethernet/intel/idpf/idpf_psp_def.h | 12 +-
.../ethernet/intel/idpf/idpf_psp_virtchnl.c | 190 ++++++++++++++++++
.../ethernet/intel/idpf/idpf_psp_virtchnl.h | 1 +
.../intel/idpf/idpf_psp_virtchnl_def.h | 4 +
include/linux/net/intel/virtchnl2.h | 35 ++++
6 files changed, 254 insertions(+), 1 deletion(-)
diff --git a/drivers/net/ethernet/intel/idpf/idpf_psp.c b/drivers/net/ethernet/intel/idpf/idpf_psp.c
index 373edbef9a7e..95926ac99777 100644
--- a/drivers/net/ethernet/intel/idpf/idpf_psp.c
+++ b/drivers/net/ethernet/intel/idpf/idpf_psp.c
@@ -66,6 +66,7 @@ static void idpf_psp_work(struct work_struct *work)
test_bit(IDPF_REMOVE_IN_PROG, adapter->flags))
return;
+ idpf_send_insert_psp_keys(adapter);
if (idpf_send_delete_psp_keys(adapter))
idpf_queue_psp_work(adapter);
}
@@ -208,6 +209,7 @@ void idpf_psp_init(struct idpf_adapter *adapter)
INIT_DELAYED_WORK(&psp->work, idpf_psp_work);
spin_lock_init(&psp->insert_lock);
timer_setup(&psp->insert_timer, idpf_psp_insert_timeout, 0);
+ INIT_LIST_HEAD(&psp->ins_list);
psp->initialized = true;
}
@@ -266,6 +268,8 @@ void idpf_psp_quiesce(struct idpf_adapter *adapter)
spin_lock_bh(&psp->insert_lock);
req = psp->insert_req;
psp->insert_req = NULL;
+ list_splice_init(&psp->ins_list, &keys);
+ WRITE_ONCE(psp->ins_queued, 0);
spin_unlock_bh(&psp->insert_lock);
if (req) {
@@ -276,6 +280,12 @@ void idpf_psp_quiesce(struct idpf_adapter *adapter)
kfree(req);
}
+ list_for_each_entry_safe(key, tmp, &keys, ins_node) {
+ list_del_init(&key->ins_node);
+ idpf_psp_tx_key_failed(adapter, key);
+ idpf_psp_tx_key_put(key);
+ }
+
spin_lock_bh(&psp->del_lock);
list_splice_init(&psp->del_list, &keys);
spin_unlock_bh(&psp->del_lock);
@@ -322,6 +332,7 @@ struct idpf_psp_tx_key *idpf_psp_tx_key_alloc(void)
key->idx = IDPF_PSP_IDX_IN_PROG;
key->hw_idx = IDPF_PSP_IDX_NONE;
INIT_LIST_HEAD(&key->del_node);
+ INIT_LIST_HEAD(&key->ins_node);
return key;
}
@@ -335,6 +346,8 @@ static void idpf_psp_tx_key_free(struct kref *ref)
struct idpf_psp_tx_key *key = container_of(ref, struct idpf_psp_tx_key,
ref);
+ /* In case the key was never copied into an insert request */
+ memzero_explicit(key->key, sizeof(key->key));
/* The TX path may still read the SA index of the key */
kfree_rcu(key, rcu);
}
diff --git a/drivers/net/ethernet/intel/idpf/idpf_psp_def.h b/drivers/net/ethernet/intel/idpf/idpf_psp_def.h
index 4c42755615cb..5af3347d9596 100644
--- a/drivers/net/ethernet/intel/idpf/idpf_psp_def.h
+++ b/drivers/net/ethernet/intel/idpf/idpf_psp_def.h
@@ -39,6 +39,9 @@
* @idx: SA index the TX path uses, or IDPF_PSP_IDX_IN_PROG,
* IDPF_PSP_IDX_ERROR or IDPF_PSP_IDX_DELETED. Read without @lock.
* @hw_idx: SA index of the key in the SADB, IDPF_PSP_IDX_NONE if it has none
+ * @spi: SPI of the key
+ * @key: the key, wiped once copied into the insert request
+ * @ins_node: entry in the insert queue, see idpf_psp_queue_insert()
* @del_node: entry in the delete queue, see idpf_psp_queue_delete()
* @del_single: delete @hw_idx in a request of its own, after a request that
* failed
@@ -49,6 +52,9 @@ struct idpf_psp_tx_key {
spinlock_t lock; /* protects the SA indexes and tx_queue */
u32 idx;
u32 hw_idx;
+ __be32 spi;
+ u8 key[VIRTCHNL2_PSP_KEY_SIZE_V0];
+ struct list_head ins_node;
struct list_head del_node;
bool del_single;
struct rcu_head rcu;
@@ -122,10 +128,12 @@ struct idpf_psp_rx_gen {
* @del_list: TX keys whose SA index is queued for deletion
* @wq: workqueue of @work
* @work: sends the insertion and deletion requests
- * @insert_lock: protects @insert_req
+ * @insert_lock: protects @insert_req, @ins_list and @ins_queued
* @insert_req: the VIRTCHNL2_OP_PSP_INSERT_KEYS request in flight, if any
* @insert_timer: makes the mailbox task time out a lost insert request,
* see idpf_psp_insert_timeout()
+ * @ins_list: TX keys queued for insertion
+ * @ins_queued: number of keys in @ins_list
* @keys_allocated: RX keys allocated
* @keys_inserted: TX keys inserted into the SADB
* @insert_errors: TX keys whose insertion failed
@@ -162,6 +170,8 @@ struct idpf_adapter_psp {
spinlock_t insert_lock; /* protects the insertions */
struct idpf_psp_insert_req *insert_req;
struct timer_list insert_timer;
+ struct list_head ins_list;
+ u32 ins_queued;
atomic_t keys_allocated;
atomic_t keys_inserted;
atomic_t insert_errors;
diff --git a/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.c b/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.c
index e813dca8961d..480b56ce8164 100644
--- a/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.c
+++ b/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.c
@@ -559,6 +559,79 @@ bool idpf_send_delete_psp_keys(struct idpf_adapter *adapter)
return false;
}
+/**
+ * idpf_psp_insert_keys_cb - VIRTCHNL2_OP_PSP_INSERT_KEYS response callback
+ * @ctx: struct idpf_psp_insert_req of the request
+ * @buff: reply, NULL if the request timed out
+ * @status: 0 on success, -EFAULT if the CP failed the request, -ETIMEDOUT if
+ * the request timed out
+ *
+ * libie calls the response callback once per request that was sent, except on
+ * shutdown, see idpf_psp_quiesce(). It is called from the mailbox task with the
+ * transaction locked, it must not sleep. The CP inserts the keys in request
+ * order and stops at the first failure: the keys without an SA index in the
+ * reply failed.
+ */
+static void idpf_psp_insert_keys_cb(void *ctx, struct kvec *buff, int status)
+{
+ const struct virtchnl2_psp_insert_keys_response *resp = NULL;
+ struct idpf_psp_insert_req *req = ctx;
+ struct idpf_adapter *adapter = req->adapter;
+ struct idpf_adapter_psp *psp = &adapter->psp;
+ u32 i, num_sa_indexes = 0;
+
+ if (!status) {
+ size_t reply_sz = buff && buff->iov_base ? buff->iov_len : 0;
+
+ if (reply_sz >= sizeof(*resp)) {
+ resp = buff->iov_base;
+ num_sa_indexes = min3(le32_to_cpu(resp->num_sa_indexes),
+ (u32)((reply_sz - sizeof(*resp)) /
+ sizeof(resp->sa_indexes[0])),
+ req->num_keys);
+ } else {
+ net_warn_ratelimited("%s: short reply %zu\n", __func__,
+ reply_sz);
+ }
+ } else {
+ net_warn_ratelimited("%s: request %s\n", __func__,
+ status == -ETIMEDOUT ? "timed out" :
+ "failed");
+ }
+
+ spin_lock_bh(&psp->insert_lock);
+ if (psp->insert_req == req)
+ psp->insert_req = NULL;
+ spin_unlock_bh(&psp->insert_lock);
+ timer_delete(&psp->insert_timer);
+
+ for (i = 0; i < req->num_keys; i++) {
+ struct idpf_psp_tx_key *key = req->keys[i];
+ u32 saidx = IDPF_PSP_IDX_NONE;
+
+ if (i < num_sa_indexes)
+ saidx = le32_to_cpu(resp->sa_indexes[i]);
+
+ if (idpf_psp_saidx_ok(adapter, saidx)) {
+ idpf_psp_tx_key_inserted(adapter, key, saidx);
+ } else {
+ if (i < num_sa_indexes)
+ net_warn_ratelimited("%s: invalid SA index %u\n",
+ __func__, saidx);
+ idpf_psp_tx_key_failed(adapter, key);
+ }
+
+ /* The key was copied into the request */
+ memzero_explicit(key->key, sizeof(key->key));
+ idpf_psp_tx_key_put(key);
+ }
+
+ kfree(req);
+
+ /* Send the next request */
+ idpf_queue_psp_work(adapter);
+}
+
/**
* idpf_psp_insert_late - Delete the SA indexes of a late insertion reply
* @adapter: Driver specific private structure
@@ -600,6 +673,123 @@ static void idpf_psp_insert_late(struct idpf_adapter *adapter,
}
}
+/**
+ * idpf_psp_insert_requeue - Queue the TX keys of an unsent request again
+ * @adapter: Driver specific private structure
+ * @req: insert request that couldn't be sent
+ *
+ * The keys are sent again after a delay, see idpf_retry_psp_work().
+ */
+static void idpf_psp_insert_requeue(struct idpf_adapter *adapter,
+ struct idpf_psp_insert_req *req)
+{
+ struct idpf_adapter_psp *psp = &adapter->psp;
+ u32 i;
+
+ spin_lock_bh(&psp->insert_lock);
+ if (psp->insert_req == req)
+ psp->insert_req = NULL;
+ /* In request order, at the head of the queue */
+ for (i = req->num_keys; i; i--)
+ list_add(&req->keys[i - 1]->ins_node, &psp->ins_list);
+ WRITE_ONCE(psp->ins_queued, psp->ins_queued + req->num_keys);
+ spin_unlock_bh(&psp->insert_lock);
+
+ kfree(req);
+ idpf_retry_psp_work(adapter);
+}
+
+/**
+ * idpf_send_insert_psp_keys - Insert queued TX keys into the SADB
+ * @adapter: Driver specific private structure
+ *
+ * Send one asynchronous VIRTCHNL2_OP_PSP_INSERT_KEYS request for the TX keys
+ * queued by idpf_psp_queue_insert(), at most as many as fit in one message.
+ * At most one request is in flight: the response callback queues the PSP work
+ * again, see idpf_psp_insert_keys_cb(). Called from the PSP work.
+ */
+void idpf_send_insert_psp_keys(struct idpf_adapter *adapter)
+{
+ struct libie_ctlq_xn_send_params xn_params = {
+ .chnl_opcode = VIRTCHNL2_OP_PSP_INSERT_KEYS,
+ .timeout_ms = IDPF_VC_XN_PSP_RESPONSE_TIMEOUT_MSEC,
+ .resp_cb = idpf_psp_insert_keys_cb,
+ };
+ struct virtchnl2_psp_insert_keys_request *key_req;
+ struct idpf_adapter_psp *psp = &adapter->psp;
+ struct idpf_psp_insert_req *req;
+ u32 i, num_keys;
+ size_t buf_size;
+ int err;
+
+ BUILD_BUG_ON(struct_size_t(struct virtchnl2_psp_insert_keys_request,
+ keys, IDPF_PSP_INSERT_KEYS_MAX) >
+ LIBIE_CTLQ_MAX_BUF_LEN);
+
+ spin_lock_bh(&psp->insert_lock);
+ num_keys = psp->insert_req ? 0 :
+ min_t(u32, psp->ins_queued, IDPF_PSP_INSERT_KEYS_MAX);
+ spin_unlock_bh(&psp->insert_lock);
+ if (!num_keys)
+ return;
+
+ req = kzalloc(struct_size(req, keys, num_keys), GFP_KERNEL);
+ if (!req) {
+ idpf_retry_psp_work(adapter);
+ return;
+ }
+
+ req->adapter = adapter;
+
+ /* Keys may have been deleted meanwhile */
+ spin_lock_bh(&psp->insert_lock);
+ req->num_keys = min(num_keys, psp->ins_queued);
+ for (i = 0; i < req->num_keys; i++) {
+ req->keys[i] = list_first_entry(&psp->ins_list,
+ struct idpf_psp_tx_key,
+ ins_node);
+ list_del_init(&req->keys[i]->ins_node);
+ }
+ WRITE_ONCE(psp->ins_queued, psp->ins_queued - req->num_keys);
+ if (req->num_keys)
+ psp->insert_req = req;
+ spin_unlock_bh(&psp->insert_lock);
+
+ if (!req->num_keys) {
+ kfree(req);
+ return;
+ }
+
+ buf_size = struct_size(key_req, keys, req->num_keys);
+ key_req = kzalloc(buf_size, GFP_KERNEL);
+ if (!key_req) {
+ idpf_psp_insert_requeue(adapter, req);
+ return;
+ }
+
+ key_req->vport_id = cpu_to_le32(READ_ONCE(psp->vport_id));
+ key_req->num_keys = cpu_to_le32(req->num_keys);
+ /* key_req->domain stays zeroed: VIRTCHNL2_PSP_DOMAIN_NONE */
+ for (i = 0; i < req->num_keys; i++) {
+ key_req->keys[i].spi = cpu_to_le32(be32_to_cpu(req->keys[i]->spi));
+ key_req->keys[i].key_type = VIRTCHNL2_PSP_KEY_TYPE_V0;
+ memcpy(key_req->keys[i].v0_key, req->keys[i]->key,
+ VIRTCHNL2_PSP_KEY_SIZE_V0);
+ }
+
+ /* The request can complete as soon as it is sent */
+ xn_params.send_ctx = req;
+ idpf_psp_insert_timer_arm(adapter, xn_params.timeout_ms);
+ err = idpf_send_mb_msg_kfree(adapter, &xn_params, key_req, buf_size);
+ if (err) {
+ /* libie only calls the response callback of sent requests */
+ timer_delete(&psp->insert_timer);
+ net_warn_ratelimited("%s: request not sent: %d\n", __func__,
+ err);
+ idpf_psp_insert_requeue(adapter, req);
+ }
+}
+
/**
* idpf_psp_recv_late_reply - Handle a late reply to a PSP request
* @adapter: Driver specific private structure
diff --git a/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.h b/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.h
index 8d8ce4478842..0013a9134cfc 100644
--- a/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.h
+++ b/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl.h
@@ -18,5 +18,6 @@ int idpf_psp_rotation_request(struct idpf_adapter *adapter);
int idpf_send_get_psp_global_stats(struct idpf_adapter *adapter,
struct virtchnl2_psp_global_stats_response *stats);
bool idpf_send_delete_psp_keys(struct idpf_adapter *adapter);
+void idpf_send_insert_psp_keys(struct idpf_adapter *adapter);
#endif /* !_IDPF_PSP_VIRTCHNL_H_ */
diff --git a/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl_def.h b/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl_def.h
index 69a61fa421e0..76b00946119b 100644
--- a/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl_def.h
+++ b/drivers/net/ethernet/intel/idpf/idpf_psp_virtchnl_def.h
@@ -12,6 +12,10 @@
/* PSP key insertion and deletion requests must fit in one mailbox buffer,
* which limits the number of TX keys and SA indexes per request.
*/
+#define IDPF_PSP_INSERT_KEYS_MAX \
+ ((LIBIE_CTLQ_MAX_BUF_LEN - \
+ sizeof(struct virtchnl2_psp_insert_keys_request)) / \
+ sizeof(struct virtchnl2_insert_psp_key))
#define IDPF_PSP_DELETE_KEYS_MAX \
((LIBIE_CTLQ_MAX_BUF_LEN - \
sizeof(struct virtchnl2_psp_delete_keys_request)) / \
diff --git a/include/linux/net/intel/virtchnl2.h b/include/linux/net/intel/virtchnl2.h
index b8940e33fd04..225ddee93409 100644
--- a/include/linux/net/intel/virtchnl2.h
+++ b/include/linux/net/intel/virtchnl2.h
@@ -1992,6 +1992,41 @@ struct virtchnl2_psp_allocate_keys_response {
};
VIRTCHNL2_CHECK_STRUCT_LEN(16, virtchnl2_psp_allocate_keys_response);
+/**
+ * struct virtchnl2_insert_psp_key - PSP TX key entry to insert into SADB
+ * @spi: Security parameter index
+ * @key_type: See enum virtchnl2_psp_key_type
+ * @pad: Reserved/padding
+ * @v0_key: 128-bit key for V0
+ * @v1_key: 256-bit key for V1
+ */
+struct virtchnl2_insert_psp_key {
+ __le32 spi;
+ u8 key_type;
+ u8 pad[3];
+ union {
+ u8 v0_key[VIRTCHNL2_PSP_KEY_SIZE_V0];
+ u8 v1_key[VIRTCHNL2_PSP_KEY_SIZE_V1];
+ };
+};
+VIRTCHNL2_CHECK_STRUCT_LEN(40, virtchnl2_insert_psp_key);
+
+/**
+ * struct virtchnl2_psp_insert_keys_request - Insert PSP TX keys request
+ * @vport_id: Virtual port ID
+ * @num_keys: Number of keys to insert
+ * @domain: Key domain, must be zero-filled if VIRTCHNL2_CAP_PSP_DOMAIN was
+ * not granted
+ * @keys: Flexible array of keys to insert
+ */
+struct virtchnl2_psp_insert_keys_request {
+ __le32 vport_id;
+ __le32 num_keys;
+ struct virtchnl2_psp_key_domain domain;
+ struct virtchnl2_insert_psp_key keys[] __counted_by_le(num_keys);
+};
+VIRTCHNL2_CHECK_STRUCT_LEN(24, virtchnl2_psp_insert_keys_request);
+
/**
* struct virtchnl2_psp_insert_keys_response - Insert PSP TX keys response
* @vport_id: Virtual port ID
--
2.56.0.679.gc527c65306-goog
next prev parent reply other threads:[~2026-11-17 14:55 UTC|newest]
Thread overview: 16+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-17 14:55 [PATCH iwl-next 00/15] idpf: add PSP offload support, part 1 Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 01/15] libie: wipe copied small send buffers on release Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 02/15] idpf: wipe mailbox " Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 03/15] idpf: make the mailbox workqueue visible in sysfs Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 04/15] idpf: psp: add psp offload initialization Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 05/15] idpf: psp: add support for crypto capabilities Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 06/15] idpf: psp: add support for psp capabilities Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 07/15] idpf: psp: add support for fips compliance status Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 08/15] idpf: psp: add support for psp rx key allocation Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 09/15] idpf: psp: add support for psp key rotation Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 10/15] idpf: psp: add support for psp statistics Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 11/15] idpf: psp: add psp tx key state Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 12/15] idpf: psp: add support for psp tx key deletion Stan Iliev
2026-11-17 14:55 ` [PATCH iwl-next 13/15] idpf: psp: add psp work and tx key insertion completion Stan Iliev
2026-11-17 14:55 ` Stan Iliev [this message]
2026-11-17 14:55 ` [PATCH iwl-next 15/15] idpf: psp: add psp tx key registration Stan Iliev
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=20261117145522.1910636-15-stani@google.com \
--to=stani@google.com \
--cc=aleksander.lobakin@intel.com \
--cc=andrew+netdev@lunn.ch \
--cc=anthony.l.nguyen@intel.com \
--cc=boolli@google.com \
--cc=brianvv@google.com \
--cc=daniel.zahka@gmail.com \
--cc=davem@davemloft.net \
--cc=decot@google.com \
--cc=edumazet@kernel.org \
--cc=emil.s.tantilov@intel.com \
--cc=gustavoars@kernel.org \
--cc=intel-wired-lan@lists.osuosl.org \
--cc=kees@kernel.org \
--cc=kuba@kernel.org \
--cc=linux-hardening@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=madhu.chittim@intel.com \
--cc=netdev@vger.kernel.org \
--cc=pabeni@redhat.com \
--cc=przemyslaw.kitszel@intel.com \
--cc=sridhar.samudrala@intel.com \
--cc=willemdebruijn.kernel@gmail.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
all inboxes | Powered by JetHome®