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 41 static 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 48 static 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 59 static 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 69 struct 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 80 static 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 udp_set_len_short(udph, 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 150 struct mlx5e_lbt_priv { 151 struct packet_type pt; 152 struct completion comp; 153 bool loopback_ok; 154 bool local_lb; 155 }; 156 157 static int 158 mlx5e_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 skb = skb_share_check(skb, GFP_ATOMIC); 170 if (!skb) 171 goto out; 172 173 if (skb_linearize(skb)) 174 goto out; 175 176 /* We are only going to peek, no need to clone the SKB */ 177 if (MLX5E_TEST_PKT_SIZE - ETH_HLEN > skb_headlen(skb)) 178 goto out; 179 180 ethh = (struct ethhdr *)skb_mac_header(skb); 181 if (!ether_addr_equal(ethh->h_dest, orig_ndev->dev_addr)) 182 goto out; 183 184 iph = ip_hdr(skb); 185 if (iph->protocol != IPPROTO_UDP) 186 goto out; 187 188 /* Don't assume skb_transport_header() was set */ 189 udph = (struct udphdr *)((u8 *)iph + 4 * iph->ihl); 190 if (udph->dest != htons(9)) 191 goto out; 192 193 mlxh = (struct mlx5ehdr *)((char *)udph + sizeof(*udph)); 194 if (mlxh->magic != cpu_to_be64(MLX5E_TEST_MAGIC)) 195 goto out; /* so close ! */ 196 197 /* bingo */ 198 lbtp->loopback_ok = true; 199 complete(&lbtp->comp); 200 out: 201 kfree_skb(skb); 202 return 0; 203 } 204 205 static int mlx5e_test_loopback_setup(struct mlx5e_priv *priv, 206 struct mlx5e_lbt_priv *lbtp) 207 { 208 int err = 0; 209 210 /* Temporarily enable local_lb */ 211 err = mlx5_nic_vport_query_local_lb(priv->mdev, &lbtp->local_lb); 212 if (err) 213 return err; 214 215 if (!lbtp->local_lb) { 216 err = mlx5_nic_vport_update_local_lb(priv->mdev, true); 217 if (err) 218 return err; 219 } 220 221 err = mlx5e_modify_tirs_lb(priv->mdev, true, false); 222 if (err) 223 goto out; 224 225 lbtp->loopback_ok = false; 226 init_completion(&lbtp->comp); 227 228 lbtp->pt.type = htons(ETH_P_IP); 229 lbtp->pt.func = mlx5e_test_loopback_validate; 230 lbtp->pt.dev = priv->netdev; 231 lbtp->pt.af_packet_priv = lbtp; 232 dev_add_pack(&lbtp->pt); 233 234 return 0; 235 236 out: 237 if (!lbtp->local_lb) 238 mlx5_nic_vport_update_local_lb(priv->mdev, false); 239 240 return err; 241 } 242 243 static void mlx5e_test_loopback_cleanup(struct mlx5e_priv *priv, 244 struct mlx5e_lbt_priv *lbtp) 245 { 246 if (!lbtp->local_lb) 247 mlx5_nic_vport_update_local_lb(priv->mdev, false); 248 249 dev_remove_pack(&lbtp->pt); 250 mlx5e_modify_tirs_lb(priv->mdev, false, false); 251 } 252 253 static int mlx5e_cond_loopback(struct mlx5e_priv *priv) 254 { 255 if (is_mdev_switchdev_mode(priv->mdev)) 256 return -EOPNOTSUPP; 257 258 if (mlx5_get_sd(priv->mdev)) 259 return -EOPNOTSUPP; 260 261 return 0; 262 } 263 264 #define MLX5E_LB_VERIFY_TIMEOUT (msecs_to_jiffies(200)) 265 static int mlx5e_test_loopback(struct mlx5e_priv *priv) 266 { 267 struct mlx5e_lbt_priv *lbtp; 268 struct sk_buff *skb = NULL; 269 int err; 270 271 if (!test_bit(MLX5E_STATE_OPENED, &priv->state)) { 272 netdev_err(priv->netdev, 273 "\tCan't perform loopback test while device is down\n"); 274 return -ENODEV; 275 } 276 277 lbtp = kzalloc_obj(*lbtp); 278 if (!lbtp) 279 return -ENOMEM; 280 lbtp->loopback_ok = false; 281 282 err = mlx5e_test_loopback_setup(priv, lbtp); 283 if (err) 284 goto out; 285 286 skb = mlx5e_test_get_udp_skb(priv); 287 if (!skb) { 288 err = -ENOMEM; 289 goto cleanup; 290 } 291 292 skb_set_queue_mapping(skb, 0); 293 err = dev_queue_xmit(skb); 294 if (err) { 295 netdev_err(priv->netdev, 296 "\tFailed to xmit loopback packet err(%d)\n", 297 err); 298 goto cleanup; 299 } 300 301 wait_for_completion_timeout(&lbtp->comp, MLX5E_LB_VERIFY_TIMEOUT); 302 err = !lbtp->loopback_ok; 303 304 cleanup: 305 mlx5e_test_loopback_cleanup(priv, lbtp); 306 out: 307 kfree(lbtp); 308 return err; 309 } 310 #endif 311 312 typedef int (*mlx5e_st_func)(struct mlx5e_priv *); 313 314 struct mlx5e_st { 315 char name[ETH_GSTRING_LEN]; 316 mlx5e_st_func st_func; 317 mlx5e_st_func cond_func; 318 }; 319 320 static struct mlx5e_st mlx5e_sts[] = { 321 { "Link Test", mlx5e_test_link_state }, 322 { "Speed Test", mlx5e_test_link_speed }, 323 { "Health Test", mlx5e_test_health_info }, 324 #ifdef CONFIG_INET 325 { "Loopback Test", mlx5e_test_loopback, mlx5e_cond_loopback }, 326 #endif 327 }; 328 329 #define MLX5E_ST_NUM ARRAY_SIZE(mlx5e_sts) 330 331 void mlx5e_self_test(struct net_device *ndev, struct ethtool_test *etest, 332 u64 *buf) 333 { 334 struct mlx5e_priv *priv = netdev_priv(ndev); 335 int i, count = 0; 336 337 mutex_lock(&priv->state_lock); 338 netdev_info(ndev, "Self test begin..\n"); 339 340 for (i = 0; i < MLX5E_ST_NUM; i++) { 341 struct mlx5e_st st = mlx5e_sts[i]; 342 343 if (st.cond_func && st.cond_func(priv)) 344 continue; 345 netdev_info(ndev, "\t[%d] %s start..\n", i, st.name); 346 buf[count] = st.st_func(priv); 347 netdev_info(ndev, "\t[%d] %s end: result(%lld)\n", i, st.name, buf[count]); 348 count++; 349 } 350 351 mutex_unlock(&priv->state_lock); 352 353 for (i = 0; i < count; i++) { 354 if (buf[i]) { 355 etest->flags |= ETH_TEST_FL_FAILED; 356 break; 357 } 358 } 359 netdev_info(ndev, "Self test out: status flags(0x%x)\n", 360 etest->flags); 361 } 362 363 int mlx5e_self_test_fill_strings(struct mlx5e_priv *priv, u8 *data) 364 { 365 int i, count = 0; 366 367 for (i = 0; i < MLX5E_ST_NUM; i++) { 368 struct mlx5e_st st = mlx5e_sts[i]; 369 370 if (st.cond_func && st.cond_func(priv)) 371 continue; 372 if (data) 373 ethtool_puts(&data, st.name); 374 count++; 375 } 376 return count; 377 } 378 379 int mlx5e_self_test_num(struct mlx5e_priv *priv) 380 { 381 return mlx5e_self_test_fill_strings(priv, NULL); 382 } 383