net/mlx5e: Avoid reset netdev stats on configuration changes
[sfrench/cifs-2.6.git] / drivers / net / ethernet / mellanox / mlx5 / core / en_accel / tls_rxtx.c
1 /*
2  * Copyright (c) 2018 Mellanox Technologies. All rights reserved.
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and/or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  *
32  */
33
34 #include "en_accel/tls.h"
35 #include "en_accel/tls_rxtx.h"
36
37 #define SYNDROME_OFFLOAD_REQUIRED 32
38 #define SYNDROME_SYNC 33
39
40 struct sync_info {
41         u64 rcd_sn;
42         s32 sync_len;
43         int nr_frags;
44         skb_frag_t frags[MAX_SKB_FRAGS];
45 };
46
47 struct mlx5e_tls_metadata {
48         /* One byte of syndrome followed by 3 bytes of swid */
49         __be32 syndrome_swid;
50         __be16 first_seq;
51         /* packet type ID field */
52         __be16 ethertype;
53 } __packed;
54
55 static int mlx5e_tls_add_metadata(struct sk_buff *skb, __be32 swid)
56 {
57         struct mlx5e_tls_metadata *pet;
58         struct ethhdr *eth;
59
60         if (skb_cow_head(skb, sizeof(struct mlx5e_tls_metadata)))
61                 return -ENOMEM;
62
63         eth = (struct ethhdr *)skb_push(skb, sizeof(struct mlx5e_tls_metadata));
64         skb->mac_header -= sizeof(struct mlx5e_tls_metadata);
65         pet = (struct mlx5e_tls_metadata *)(eth + 1);
66
67         memmove(skb->data, skb->data + sizeof(struct mlx5e_tls_metadata),
68                 2 * ETH_ALEN);
69
70         eth->h_proto = cpu_to_be16(MLX5E_METADATA_ETHER_TYPE);
71         pet->syndrome_swid = htonl(SYNDROME_OFFLOAD_REQUIRED << 24) | swid;
72
73         return 0;
74 }
75
76 static int mlx5e_tls_get_sync_data(struct mlx5e_tls_offload_context *context,
77                                    u32 tcp_seq, struct sync_info *info)
78 {
79         int remaining, i = 0, ret = -EINVAL;
80         struct tls_record_info *record;
81         unsigned long flags;
82         s32 sync_size;
83
84         spin_lock_irqsave(&context->base.lock, flags);
85         record = tls_get_record(&context->base, tcp_seq, &info->rcd_sn);
86
87         if (unlikely(!record))
88                 goto out;
89
90         sync_size = tcp_seq - tls_record_start_seq(record);
91         info->sync_len = sync_size;
92         if (unlikely(sync_size < 0)) {
93                 if (tls_record_is_start_marker(record))
94                         goto done;
95
96                 goto out;
97         }
98
99         remaining = sync_size;
100         while (remaining > 0) {
101                 info->frags[i] = record->frags[i];
102                 __skb_frag_ref(&info->frags[i]);
103                 remaining -= skb_frag_size(&info->frags[i]);
104
105                 if (remaining < 0)
106                         skb_frag_size_add(&info->frags[i], remaining);
107
108                 i++;
109         }
110         info->nr_frags = i;
111 done:
112         ret = 0;
113 out:
114         spin_unlock_irqrestore(&context->base.lock, flags);
115         return ret;
116 }
117
118 static void mlx5e_tls_complete_sync_skb(struct sk_buff *skb,
119                                         struct sk_buff *nskb, u32 tcp_seq,
120                                         int headln, __be64 rcd_sn)
121 {
122         struct mlx5e_tls_metadata *pet;
123         u8 syndrome = SYNDROME_SYNC;
124         struct iphdr *iph;
125         struct tcphdr *th;
126         int data_len, mss;
127
128         nskb->dev = skb->dev;
129         skb_reset_mac_header(nskb);
130         skb_set_network_header(nskb, skb_network_offset(skb));
131         skb_set_transport_header(nskb, skb_transport_offset(skb));
132         memcpy(nskb->data, skb->data, headln);
133         memcpy(nskb->data + headln, &rcd_sn, sizeof(rcd_sn));
134
135         iph = ip_hdr(nskb);
136         iph->tot_len = htons(nskb->len - skb_network_offset(nskb));
137         th = tcp_hdr(nskb);
138         data_len = nskb->len - headln;
139         tcp_seq -= data_len;
140         th->seq = htonl(tcp_seq);
141
142         mss = nskb->dev->mtu - (headln - skb_network_offset(nskb));
143         skb_shinfo(nskb)->gso_size = 0;
144         if (data_len > mss) {
145                 skb_shinfo(nskb)->gso_size = mss;
146                 skb_shinfo(nskb)->gso_segs = DIV_ROUND_UP(data_len, mss);
147         }
148         skb_shinfo(nskb)->gso_type = skb_shinfo(skb)->gso_type;
149
150         pet = (struct mlx5e_tls_metadata *)(nskb->data + sizeof(struct ethhdr));
151         memcpy(pet, &syndrome, sizeof(syndrome));
152         pet->first_seq = htons(tcp_seq);
153
154         /* MLX5 devices don't care about the checksum partial start, offset
155          * and pseudo header
156          */
157         nskb->ip_summed = CHECKSUM_PARTIAL;
158
159         nskb->xmit_more = 1;
160         nskb->queue_mapping = skb->queue_mapping;
161 }
162
163 static struct sk_buff *
164 mlx5e_tls_handle_ooo(struct mlx5e_tls_offload_context *context,
165                      struct mlx5e_txqsq *sq, struct sk_buff *skb,
166                      struct mlx5e_tx_wqe **wqe,
167                      u16 *pi,
168                      struct mlx5e_tls *tls)
169 {
170         u32 tcp_seq = ntohl(tcp_hdr(skb)->seq);
171         struct sync_info info;
172         struct sk_buff *nskb;
173         int linear_len = 0;
174         int headln;
175         int i;
176
177         sq->stats->tls_ooo++;
178
179         if (mlx5e_tls_get_sync_data(context, tcp_seq, &info)) {
180                 /* We might get here if a retransmission reaches the driver
181                  * after the relevant record is acked.
182                  * It should be safe to drop the packet in this case
183                  */
184                 atomic64_inc(&tls->sw_stats.tx_tls_drop_no_sync_data);
185                 goto err_out;
186         }
187
188         if (unlikely(info.sync_len < 0)) {
189                 u32 payload;
190
191                 headln = skb_transport_offset(skb) + tcp_hdrlen(skb);
192                 payload = skb->len - headln;
193                 if (likely(payload <= -info.sync_len))
194                         /* SKB payload doesn't require offload
195                          */
196                         return skb;
197
198                 atomic64_inc(&tls->sw_stats.tx_tls_drop_bypass_required);
199                 goto err_out;
200         }
201
202         if (unlikely(mlx5e_tls_add_metadata(skb, context->swid))) {
203                 atomic64_inc(&tls->sw_stats.tx_tls_drop_metadata);
204                 goto err_out;
205         }
206
207         headln = skb_transport_offset(skb) + tcp_hdrlen(skb);
208         linear_len += headln + sizeof(info.rcd_sn);
209         nskb = alloc_skb(linear_len, GFP_ATOMIC);
210         if (unlikely(!nskb)) {
211                 atomic64_inc(&tls->sw_stats.tx_tls_drop_resync_alloc);
212                 goto err_out;
213         }
214
215         context->expected_seq = tcp_seq + skb->len - headln;
216         skb_put(nskb, linear_len);
217         for (i = 0; i < info.nr_frags; i++)
218                 skb_shinfo(nskb)->frags[i] = info.frags[i];
219
220         skb_shinfo(nskb)->nr_frags = info.nr_frags;
221         nskb->data_len = info.sync_len;
222         nskb->len += info.sync_len;
223         sq->stats->tls_resync_bytes += nskb->len;
224         mlx5e_tls_complete_sync_skb(skb, nskb, tcp_seq, headln,
225                                     cpu_to_be64(info.rcd_sn));
226         mlx5e_sq_xmit(sq, nskb, *wqe, *pi);
227         mlx5e_sq_fetch_wqe(sq, wqe, pi);
228         return skb;
229
230 err_out:
231         dev_kfree_skb_any(skb);
232         return NULL;
233 }
234
235 struct sk_buff *mlx5e_tls_handle_tx_skb(struct net_device *netdev,
236                                         struct mlx5e_txqsq *sq,
237                                         struct sk_buff *skb,
238                                         struct mlx5e_tx_wqe **wqe,
239                                         u16 *pi)
240 {
241         struct mlx5e_priv *priv = netdev_priv(netdev);
242         struct mlx5e_tls_offload_context *context;
243         struct tls_context *tls_ctx;
244         u32 expected_seq;
245         int datalen;
246         u32 skb_seq;
247
248         if (!skb->sk || !tls_is_sk_tx_device_offloaded(skb->sk))
249                 goto out;
250
251         datalen = skb->len - (skb_transport_offset(skb) + tcp_hdrlen(skb));
252         if (!datalen)
253                 goto out;
254
255         tls_ctx = tls_get_ctx(skb->sk);
256         if (unlikely(tls_ctx->netdev != netdev))
257                 goto out;
258
259         skb_seq = ntohl(tcp_hdr(skb)->seq);
260         context = mlx5e_get_tls_tx_context(tls_ctx);
261         expected_seq = context->expected_seq;
262
263         if (unlikely(expected_seq != skb_seq)) {
264                 skb = mlx5e_tls_handle_ooo(context, sq, skb, wqe, pi, priv->tls);
265                 goto out;
266         }
267
268         if (unlikely(mlx5e_tls_add_metadata(skb, context->swid))) {
269                 atomic64_inc(&priv->tls->sw_stats.tx_tls_drop_metadata);
270                 dev_kfree_skb_any(skb);
271                 skb = NULL;
272                 goto out;
273         }
274
275         context->expected_seq = skb_seq + datalen;
276 out:
277         return skb;
278 }