net/tls: add tracing for device/offload events

Add tracing of device-related interaction to aid performance
analysis, especially around resync:

 tls:tls_device_offload_set
 tls:tls_device_rx_resync_send
 tls:tls_device_rx_resync_nh_schedule
 tls:tls_device_rx_resync_nh_delay
 tls:tls_device_tx_resync_req
 tls:tls_device_tx_resync_send

Signed-off-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
index 61aabff..bcdcd6d 100644 (file)
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
@@ -872,7 +872,8 @@ nfp_net_tls_tx(struct nfp_net_dp *dp, struct nfp_net_r_vector *r_vec,
 
                /* jump forward, a TX may have gotten lost, need to sync TX */
                if (!resync_pending && seq - ntls->next_seq < U32_MAX / 4)
-                       tls_offload_tx_resync_request(nskb->sk);
+                       tls_offload_tx_resync_request(nskb->sk, seq,
+                                                     ntls->next_seq);
 
                *nr_frags = 0;
                return nskb;

diff --git a/include/net/tls.h b/include/net/tls.h
index 5c48cb9..38086ad 100644 (file)
--- a/include/net/tls.h
+++ b/include/net/tls.h
@@ -594,13 +594,6 @@ tls_offload_rx_resync_set_type(struct sock *sk, enum tls_offload_sync_type type)
        tls_offload_ctx_rx(tls_ctx)->resync_type = type;
 }
 
-static inline void tls_offload_tx_resync_request(struct sock *sk)
-{
-       struct tls_context *tls_ctx = tls_get_ctx(sk);
-
-       WARN_ON(test_and_set_bit(TLS_TX_SYNC_SCHED, &tls_ctx->flags));
-}
-
 /* Driver's seq tracking has to be disabled until resync succeeded */
 static inline bool tls_offload_tx_resync_pending(struct sock *sk)
 {
@@ -634,6 +627,7 @@ void tls_device_free_resources_tx(struct sock *sk);
 int tls_set_device_offload_rx(struct sock *sk, struct tls_context *ctx);
 void tls_device_offload_cleanup_rx(struct sock *sk);
 void tls_device_rx_resync_new_rec(struct sock *sk, u32 rcd_len, u32 seq);
+void tls_offload_tx_resync_request(struct sock *sk, u32 got_seq, u32 exp_seq);
 int tls_device_decrypted(struct sock *sk, struct sk_buff *skb);
 #else
 static inline void tls_device_init(void) {}

diff --git a/net/tls/Makefile b/net/tls/Makefile
index 95d8c06..0606d43 100644 (file)
--- a/net/tls/Makefile
+++ b/net/tls/Makefile
@@ -3,9 +3,11 @@
 # Makefile for the TLS subsystem.
 #
 
+CFLAGS_trace.o := -I$(src)
+
 obj-$(CONFIG_TLS) += tls.o
 
-tls-y := tls_main.o tls_sw.o
+tls-y := tls_main.o tls_sw.o trace.o
 
 tls-$(CONFIG_TLS_TOE) += tls_toe.o
 tls-$(CONFIG_TLS_DEVICE) += tls_device.o tls_device_fallback.o

diff --git a/net/tls/tls_device.c b/net/tls/tls_device.c
index f959487..9f423ca 100644 (file)
--- a/net/tls/tls_device.c
+++ b/net/tls/tls_device.c
@@ -38,6 +38,8 @@
 #include <net/tcp.h>
 #include <net/tls.h>
 
+#include "trace.h"
+
 /* device_offload_lock is used to synchronize tls_dev_add
  * against NETDEV_DOWN notifications.
  */
@@ -202,6 +204,15 @@ void tls_device_free_resources_tx(struct sock *sk)
        tls_free_partial_record(sk, tls_ctx);
 }
 
+void tls_offload_tx_resync_request(struct sock *sk, u32 got_seq, u32 exp_seq)
+{
+       struct tls_context *tls_ctx = tls_get_ctx(sk);
+
+       trace_tls_device_tx_resync_req(sk, got_seq, exp_seq);
+       WARN_ON(test_and_set_bit(TLS_TX_SYNC_SCHED, &tls_ctx->flags));
+}
+EXPORT_SYMBOL_GPL(tls_offload_tx_resync_request);
+
 static void tls_device_resync_tx(struct sock *sk, struct tls_context *tls_ctx,
                                 u32 seq)
 {
@@ -216,6 +227,7 @@ static void tls_device_resync_tx(struct sock *sk, struct tls_context *tls_ctx,
 
        rcd_sn = tls_ctx->tx.rec_seq;
 
+       trace_tls_device_tx_resync_send(sk, seq, rcd_sn);
        down_read(&device_offload_lock);
        netdev = tls_ctx->netdev;
        if (netdev)
@@ -637,10 +649,13 @@ void tls_device_write_space(struct sock *sk, struct tls_context *ctx)
 static void tls_device_resync_rx(struct tls_context *tls_ctx,
                                 struct sock *sk, u32 seq, u8 *rcd_sn)
 {
+       struct tls_offload_context_rx *rx_ctx = tls_offload_ctx_rx(tls_ctx);
        struct net_device *netdev;
 
        if (WARN_ON(test_and_set_bit(TLS_RX_SYNC_RUNNING, &tls_ctx->flags)))
                return;
+
+       trace_tls_device_rx_resync_send(sk, seq, rcd_sn, rx_ctx->resync_type);
        netdev = READ_ONCE(tls_ctx->netdev);
        if (netdev)
                netdev->tlsdev_ops->tls_dev_resync(netdev, sk, seq, rcd_sn,
@@ -653,8 +668,8 @@ void tls_device_rx_resync_new_rec(struct sock *sk, u32 rcd_len, u32 seq)
        struct tls_context *tls_ctx = tls_get_ctx(sk);
        struct tls_offload_context_rx *rx_ctx;
        u8 rcd_sn[TLS_MAX_REC_SEQ_SIZE];
+       u32 sock_data, is_req_pending;
        struct tls_prot_info *prot;
-       u32 is_req_pending;
        s64 resync_req;
        u32 req_seq;
 
@@ -683,8 +698,12 @@ void tls_device_rx_resync_new_rec(struct sock *sk, u32 rcd_len, u32 seq)
                /* head of next rec is already in, note that the sock_inq will
                 * include the currently parsed message when called from parser
                 */
-               if (tcp_inq(sk) > rcd_len)
+               sock_data = tcp_inq(sk);
+               if (sock_data > rcd_len) {
+                       trace_tls_device_rx_resync_nh_delay(sk, sock_data,
+                                                           rcd_len);
                        return;
+               }
 
                rx_ctx->resync_nh_do_now = 0;
                seq += rcd_len;
@@ -728,6 +747,7 @@ static void tls_device_core_ctrl_rx_resync(struct tls_context *tls_ctx,
 
        /* head of next rec is already in, parser will sync for us */
        if (tcp_inq(sk) > rxm->full_len) {
+               trace_tls_device_rx_resync_nh_schedule(sk);
                ctx->resync_nh_do_now = 1;
        } else {
                struct tls_prot_info *prot = &tls_ctx->prot_info;
@@ -1013,6 +1033,8 @@ int tls_set_device_offload(struct sock *sk, struct tls_context *ctx)
        rc = netdev->tlsdev_ops->tls_dev_add(netdev, sk, TLS_OFFLOAD_CTX_DIR_TX,
                                             &ctx->crypto_send.info,
                                             tcp_sk(sk)->write_seq);
+       trace_tls_device_offload_set(sk, TLS_OFFLOAD_CTX_DIR_TX,
+                                    tcp_sk(sk)->write_seq, rec_seq, rc);
        if (rc)
                goto release_lock;
 
@@ -1049,6 +1071,7 @@ free_marker_record:
 
 int tls_set_device_offload_rx(struct sock *sk, struct tls_context *ctx)
 {
+       struct tls12_crypto_info_aes_gcm_128 *info;
        struct tls_offload_context_rx *context;
        struct net_device *netdev;
        int rc = 0;
@@ -1096,6 +1119,9 @@ int tls_set_device_offload_rx(struct sock *sk, struct tls_context *ctx)
        rc = netdev->tlsdev_ops->tls_dev_add(netdev, sk, TLS_OFFLOAD_CTX_DIR_RX,
                                             &ctx->crypto_recv.info,
                                             tcp_sk(sk)->copied_seq);
+       info = (void *)&ctx->crypto_recv.info;
+       trace_tls_device_offload_set(sk, TLS_OFFLOAD_CTX_DIR_RX,
+                                    tcp_sk(sk)->copied_seq, info->rec_seq, rc);
        if (rc)
                goto free_sw_resources;
 

diff --git a/net/tls/trace.c b/net/tls/trace.c
new file mode 100644 (file)
index 0000000..e374913
--- /dev/null
+++ b/net/tls/trace.c
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
+/* Copyright (C) 2019 Netronome Systems, Inc. */
+
+#include <linux/module.h>
+
+#ifndef __CHECKER__
+#define CREATE_TRACE_POINTS
+#include "trace.h"
+
+#endif

diff --git a/net/tls/trace.h b/net/tls/trace.h
new file mode 100644 (file)
index 0000000..95b6ded
--- /dev/null
+++ b/net/tls/trace.h
@@ -0,0 +1,169 @@
+/* SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) */
+/* Copyright (C) 2019 Netronome Systems, Inc. */
+
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM tls
+
+#if !defined(_TLS_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
+#define _TLS_TRACE_H_
+
+#include <asm/unaligned.h>
+#include <linux/tracepoint.h>
+
+struct sock;
+
+TRACE_EVENT(tls_device_offload_set,
+
+       TP_PROTO(struct sock *sk, int dir, u32 tcp_seq, u8 *rec_no, int ret),
+
+       TP_ARGS(sk, dir, tcp_seq, rec_no, ret),
+
+       TP_STRUCT__entry(
+               __field(        struct sock *,  sk              )
+               __field(        u64,            rec_no          )
+               __field(        int,            dir             )
+               __field(        u32,            tcp_seq         )
+               __field(        int,            ret             )
+       ),
+
+       TP_fast_assign(
+               __entry->sk = sk;
+               __entry->rec_no = get_unaligned_be64(rec_no);
+               __entry->dir = dir;
+               __entry->tcp_seq = tcp_seq;
+               __entry->ret = ret;
+       ),
+
+       TP_printk(
+               "sk=%p direction=%d tcp_seq=%u rec_no=%llu ret=%d",
+               __entry->sk, __entry->dir, __entry->tcp_seq, __entry->rec_no,
+               __entry->ret
+       )
+);
+
+TRACE_EVENT(tls_device_rx_resync_send,
+
+       TP_PROTO(struct sock *sk, u32 tcp_seq, u8 *rec_no, int sync_type),
+
+       TP_ARGS(sk, tcp_seq, rec_no, sync_type),
+
+       TP_STRUCT__entry(
+               __field(        struct sock *,  sk              )
+               __field(        u64,            rec_no          )
+               __field(        u32,            tcp_seq         )
+               __field(        int,            sync_type       )
+       ),
+
+       TP_fast_assign(
+               __entry->sk = sk;
+               __entry->rec_no = get_unaligned_be64(rec_no);
+               __entry->tcp_seq = tcp_seq;
+               __entry->sync_type = sync_type;
+       ),
+
+       TP_printk(
+               "sk=%p tcp_seq=%u rec_no=%llu sync_type=%d",
+               __entry->sk, __entry->tcp_seq, __entry->rec_no,
+               __entry->sync_type
+       )
+);
+
+TRACE_EVENT(tls_device_rx_resync_nh_schedule,
+
+       TP_PROTO(struct sock *sk),
+
+       TP_ARGS(sk),
+
+       TP_STRUCT__entry(
+               __field(        struct sock *,  sk              )
+       ),
+
+       TP_fast_assign(
+               __entry->sk = sk;
+       ),
+
+       TP_printk(
+               "sk=%p", __entry->sk
+       )
+);
+
+TRACE_EVENT(tls_device_rx_resync_nh_delay,
+
+       TP_PROTO(struct sock *sk, u32 sock_data, u32 rec_len),
+
+       TP_ARGS(sk, sock_data, rec_len),
+
+       TP_STRUCT__entry(
+               __field(        struct sock *,  sk              )
+               __field(        u32,            sock_data       )
+               __field(        u32,            rec_len         )
+       ),
+
+       TP_fast_assign(
+               __entry->sk = sk;
+               __entry->sock_data = sock_data;
+               __entry->rec_len = rec_len;
+       ),
+
+       TP_printk(
+               "sk=%p sock_data=%u rec_len=%u",
+               __entry->sk, __entry->sock_data, __entry->rec_len
+       )
+);
+
+TRACE_EVENT(tls_device_tx_resync_req,
+
+       TP_PROTO(struct sock *sk, u32 tcp_seq, u32 exp_tcp_seq),
+
+       TP_ARGS(sk, tcp_seq, exp_tcp_seq),
+
+       TP_STRUCT__entry(
+               __field(        struct sock *,  sk              )
+               __field(        u32,            tcp_seq         )
+               __field(        u32,            exp_tcp_seq     )
+       ),
+
+       TP_fast_assign(
+               __entry->sk = sk;
+               __entry->tcp_seq = tcp_seq;
+               __entry->exp_tcp_seq = exp_tcp_seq;
+       ),
+
+       TP_printk(
+               "sk=%p tcp_seq=%u exp_tcp_seq=%u",
+               __entry->sk, __entry->tcp_seq, __entry->exp_tcp_seq
+       )
+);
+
+TRACE_EVENT(tls_device_tx_resync_send,
+
+       TP_PROTO(struct sock *sk, u32 tcp_seq, u8 *rec_no),
+
+       TP_ARGS(sk, tcp_seq, rec_no),
+
+       TP_STRUCT__entry(
+               __field(        struct sock *,  sk              )
+               __field(        u64,            rec_no          )
+               __field(        u32,            tcp_seq         )
+       ),
+
+       TP_fast_assign(
+               __entry->sk = sk;
+               __entry->rec_no = get_unaligned_be64(rec_no);
+               __entry->tcp_seq = tcp_seq;
+       ),
+
+       TP_printk(
+               "sk=%p tcp_seq=%u rec_no=%llu",
+               __entry->sk, __entry->tcp_seq, __entry->rec_no
+       )
+);
+
+#endif /* _TLS_TRACE_H_ */
+
+#undef TRACE_INCLUDE_PATH
+#define TRACE_INCLUDE_PATH .
+#undef TRACE_INCLUDE_FILE
+#define TRACE_INCLUDE_FILE trace
+
+#include <trace/define_trace.h>