en_selftest.c

  1/*
  2 * Copyright (c) 2016, Mellanox Technologies, Ltd.  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#include <linux/ip.h>
 34#include <linux/udp.h>
 35#include <net/udp.h>
 36#include "en.h"
 37#include "en/port.h"
 38#include "eswitch.h"
 39#include "lib/mlx5.h"
 40
 41static int mlx5e_test_health_info(struct mlx5e_priv *priv)
 42{
 43	struct mlx5_core_health *health = &priv->mdev->priv.health;
 44
 45	return health->fatal_error ? 1 : 0;
 46}
 47
 48static int mlx5e_test_link_state(struct mlx5e_priv *priv)
 49{
 50	u8 port_state;
 51
 52	if (!netif_carrier_ok(priv->netdev))
 53		return 1;
 54
 55	port_state = mlx5_query_vport_state(priv->mdev, MLX5_VPORT_STATE_OP_MOD_VNIC_VPORT, 0);
 56	return port_state == VPORT_STATE_UP ? 0 : 1;
 57}
 58
 59static int mlx5e_test_link_speed(struct mlx5e_priv *priv)
 60{
 61	u32 speed;
 62
 63	if (!netif_carrier_ok(priv->netdev))
 64		return 1;
 65
 66	return mlx5e_port_linkspeed(priv->mdev, &speed);
 67}
 68
 69struct mlx5ehdr {
 70	__be32 version;
 71	__be64 magic;
 72};
 73
 74#ifdef CONFIG_INET
 75/* loopback test */
 76#define MLX5E_TEST_PKT_SIZE (sizeof(struct ethhdr) + sizeof(struct iphdr) +\
 77			     sizeof(struct udphdr) + sizeof(struct mlx5ehdr))
 78#define MLX5E_TEST_MAGIC 0x5AEED15C001ULL
 79
 80static struct sk_buff *mlx5e_test_get_udp_skb(struct mlx5e_priv *priv)
 81{
 82	struct sk_buff *skb = NULL;
 83	struct mlx5ehdr *mlxh;
 84	struct ethhdr *ethh;
 85	struct udphdr *udph;
 86	struct iphdr *iph;
 87	int    iplen;
 88
 89	skb = netdev_alloc_skb(priv->netdev, MLX5E_TEST_PKT_SIZE);
 90	if (!skb) {
 91		netdev_err(priv->netdev, "\tFailed to alloc loopback skb\n");
 92		return NULL;
 93	}
 94
 95	net_prefetchw(skb->data);
 96	skb_reserve(skb, NET_IP_ALIGN);
 97
 98	/*  Reserve for ethernet and IP header  */
 99	ethh = skb_push(skb, ETH_HLEN);
100	skb_reset_mac_header(skb);
101
102	skb_set_network_header(skb, skb->len);
103	iph = skb_put(skb, sizeof(struct iphdr));
104
105	skb_set_transport_header(skb, skb->len);
106	udph = skb_put(skb, sizeof(struct udphdr));
107
108	/* Fill ETH header */
109	ether_addr_copy(ethh->h_dest, priv->netdev->dev_addr);
110	eth_zero_addr(ethh->h_source);
111	ethh->h_proto = htons(ETH_P_IP);
112
113	/* Fill UDP header */
114	udph->source = htons(9);
115	udph->dest = htons(9); /* Discard Protocol */
116	udph->len = htons(sizeof(struct mlx5ehdr) + sizeof(struct udphdr));
117	udph->check = 0;
118
119	/* Fill IP header */
120	iph->ihl = 5;
121	iph->ttl = 32;
122	iph->version = 4;
123	iph->protocol = IPPROTO_UDP;
124	iplen = sizeof(struct iphdr) + sizeof(struct udphdr) +
125		sizeof(struct mlx5ehdr);
126	iph->tot_len = htons(iplen);
127	iph->frag_off = 0;
128	iph->saddr = 0;
129	iph->daddr = 0;
130	iph->tos = 0;
131	iph->id = 0;
132	ip_send_check(iph);
133
134	/* Fill test header and data */
135	mlxh = skb_put(skb, sizeof(*mlxh));
136	mlxh->version = 0;
137	mlxh->magic = cpu_to_be64(MLX5E_TEST_MAGIC);
138
139	skb->csum = 0;
140	skb->ip_summed = CHECKSUM_PARTIAL;
141	udp4_hwcsum(skb, iph->saddr, iph->daddr);
142
143	skb->protocol = htons(ETH_P_IP);
144	skb->pkt_type = PACKET_HOST;
145	skb->dev = priv->netdev;
146
147	return skb;
148}
149
150struct mlx5e_lbt_priv {
151	struct packet_type pt;
152	struct completion comp;
153	bool loopback_ok;
154	bool local_lb;
155};
156
157static int
158mlx5e_test_loopback_validate(struct sk_buff *skb,
159			     struct net_device *ndev,
160			     struct packet_type *pt,
161			     struct net_device *orig_ndev)
162{
163	struct mlx5e_lbt_priv *lbtp = pt->af_packet_priv;
164	struct mlx5ehdr *mlxh;
165	struct ethhdr *ethh;
166	struct udphdr *udph;
167	struct iphdr *iph;
168
169	if (skb_linearize(skb))
170		goto out;
171
172	/* We are only going to peek, no need to clone the SKB */
173	if (MLX5E_TEST_PKT_SIZE - ETH_HLEN > skb_headlen(skb))
174		goto out;
175
176	ethh = (struct ethhdr *)skb_mac_header(skb);
177	if (!ether_addr_equal(ethh->h_dest, orig_ndev->dev_addr))
178		goto out;
179
180	iph = ip_hdr(skb);
181	if (iph->protocol != IPPROTO_UDP)
182		goto out;
183
184	/* Don't assume skb_transport_header() was set */
185	udph = (struct udphdr *)((u8 *)iph + 4 * iph->ihl);
186	if (udph->dest != htons(9))
187		goto out;
188
189	mlxh = (struct mlx5ehdr *)((char *)udph + sizeof(*udph));
190	if (mlxh->magic != cpu_to_be64(MLX5E_TEST_MAGIC))
191		goto out; /* so close ! */
192
193	/* bingo */
194	lbtp->loopback_ok = true;
195	complete(&lbtp->comp);
196out:
197	kfree_skb(skb);
198	return 0;
199}
200
201static int mlx5e_test_loopback_setup(struct mlx5e_priv *priv,
202				     struct mlx5e_lbt_priv *lbtp)
203{
204	int err = 0;
205
206	/* Temporarily enable local_lb */
207	err = mlx5_nic_vport_query_local_lb(priv->mdev, &lbtp->local_lb);
208	if (err)
209		return err;
210
211	if (!lbtp->local_lb) {
212		err = mlx5_nic_vport_update_local_lb(priv->mdev, true);
213		if (err)
214			return err;
215	}
216
217	err = mlx5e_modify_tirs_lb(priv->mdev, true, false);
218	if (err)
219		goto out;
220
221	lbtp->loopback_ok = false;
222	init_completion(&lbtp->comp);
223
224	lbtp->pt.type = htons(ETH_P_IP);
225	lbtp->pt.func = mlx5e_test_loopback_validate;
226	lbtp->pt.dev = priv->netdev;
227	lbtp->pt.af_packet_priv = lbtp;
228	dev_add_pack(&lbtp->pt);
229
230	return 0;
231
232out:
233	if (!lbtp->local_lb)
234		mlx5_nic_vport_update_local_lb(priv->mdev, false);
235
236	return err;
237}
238
239static void mlx5e_test_loopback_cleanup(struct mlx5e_priv *priv,
240					struct mlx5e_lbt_priv *lbtp)
241{
242	if (!lbtp->local_lb)
243		mlx5_nic_vport_update_local_lb(priv->mdev, false);
244
245	dev_remove_pack(&lbtp->pt);
246	mlx5e_modify_tirs_lb(priv->mdev, false, false);
247}
248
249static int mlx5e_cond_loopback(struct mlx5e_priv *priv)
250{
251	if (is_mdev_switchdev_mode(priv->mdev))
252		return -EOPNOTSUPP;
253
254	if (mlx5_get_sd(priv->mdev))
255		return -EOPNOTSUPP;
256
257	return 0;
258}
259
260#define MLX5E_LB_VERIFY_TIMEOUT (msecs_to_jiffies(200))
261static int mlx5e_test_loopback(struct mlx5e_priv *priv)
262{
263	struct mlx5e_lbt_priv *lbtp;
264	struct sk_buff *skb = NULL;
265	int err;
266
267	if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) {
268		netdev_err(priv->netdev,
269			   "\tCan't perform loopback test while device is down\n");
270		return -ENODEV;
271	}
272
273	lbtp = kzalloc(sizeof(*lbtp), GFP_KERNEL);
274	if (!lbtp)
275		return -ENOMEM;
276	lbtp->loopback_ok = false;
277
278	err = mlx5e_test_loopback_setup(priv, lbtp);
279	if (err)
280		goto out;
281
282	skb = mlx5e_test_get_udp_skb(priv);
283	if (!skb) {
284		err = -ENOMEM;
285		goto cleanup;
286	}
287
288	skb_set_queue_mapping(skb, 0);
289	err = dev_queue_xmit(skb);
290	if (err) {
291		netdev_err(priv->netdev,
292			   "\tFailed to xmit loopback packet err(%d)\n",
293			   err);
294		goto cleanup;
295	}
296
297	wait_for_completion_timeout(&lbtp->comp, MLX5E_LB_VERIFY_TIMEOUT);
298	err = !lbtp->loopback_ok;
299
300cleanup:
301	mlx5e_test_loopback_cleanup(priv, lbtp);
302out:
303	kfree(lbtp);
304	return err;
305}
306#endif
307
308typedef int (*mlx5e_st_func)(struct mlx5e_priv *);
309
310struct mlx5e_st {
311	char name[ETH_GSTRING_LEN];
312	mlx5e_st_func st_func;
313	mlx5e_st_func cond_func;
314};
315
316static struct mlx5e_st mlx5e_sts[] = {
317	{ "Link Test", mlx5e_test_link_state },
318	{ "Speed Test", mlx5e_test_link_speed },
319	{ "Health Test", mlx5e_test_health_info },
320#ifdef CONFIG_INET
321	{ "Loopback Test", mlx5e_test_loopback, mlx5e_cond_loopback },
322#endif
323};
324
325#define MLX5E_ST_NUM ARRAY_SIZE(mlx5e_sts)
326
327void mlx5e_self_test(struct net_device *ndev, struct ethtool_test *etest,
328		     u64 *buf)
329{
330	struct mlx5e_priv *priv = netdev_priv(ndev);
331	int i, count = 0;
332
333	mutex_lock(&priv->state_lock);
334	netdev_info(ndev, "Self test begin..\n");
335
336	for (i = 0; i < MLX5E_ST_NUM; i++) {
337		struct mlx5e_st st = mlx5e_sts[i];
338
339		if (st.cond_func && st.cond_func(priv))
340			continue;
341		netdev_info(ndev, "\t[%d] %s start..\n", i, st.name);
342		buf[count] = st.st_func(priv);
343		netdev_info(ndev, "\t[%d] %s end: result(%lld)\n", i, st.name, buf[count]);
344		count++;
345	}
346
347	mutex_unlock(&priv->state_lock);
348
349	for (i = 0; i < count; i++) {
350		if (buf[i]) {
351			etest->flags |= ETH_TEST_FL_FAILED;
352			break;
353		}
354	}
355	netdev_info(ndev, "Self test out: status flags(0x%x)\n",
356		    etest->flags);
357}
358
359int mlx5e_self_test_fill_strings(struct mlx5e_priv *priv, u8 *data)
360{
361	int i, count = 0;
362
363	for (i = 0; i < MLX5E_ST_NUM; i++) {
364		struct mlx5e_st st = mlx5e_sts[i];
365
366		if (st.cond_func && st.cond_func(priv))
367			continue;
368		if (data)
369			ethtool_puts(&data, st.name);
370		count++;
371	}
372	return count;
373}
374
375int mlx5e_self_test_num(struct mlx5e_priv *priv)
376{
377	return mlx5e_self_test_fill_strings(priv, NULL);
378}