efx_tunnel.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2017-2018 Solarflare Communications Inc.
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions are met:
    9  *
   10  * 1. Redistributions of source code must retain the above copyright notice,
   11  *    this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright notice,
   13  *    this list of conditions and the following disclaimer in the documentation
   14  *    and/or other materials provided with the distribution.
   15  *
   16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
   18  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   19  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
   20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
   21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
   25  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
   26  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   27  *
   28  * The views and conclusions contained in the software and documentation are
   29  * those of the authors and should not be interpreted as representing official
   30  * policies, either expressed or implied, of the FreeBSD Project.
   31  */
   32 
   33 #include <sys/cdefs.h>
   34 __FBSDID("$FreeBSD$");
   35 
   36 #include "efx.h"
   37 #include "efx_impl.h"
   38 
   39 #if EFSYS_OPT_TUNNEL
   40 
   41 #if EFSYS_OPT_SIENA || EFSYS_OPT_HUNTINGTON
   42 static const efx_tunnel_ops_t   __efx_tunnel_dummy_ops = {
   43         NULL,   /* eto_udp_encap_supported */
   44         NULL,   /* eto_reconfigure */
   45 };
   46 #endif /* EFSYS_OPT_SIENA || EFSYS_OPT_HUNTINGTON */
   47 
   48 #if EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
   49 static  __checkReturn   boolean_t
   50 ef10_udp_encap_supported(
   51         __in            efx_nic_t *enp);
   52 
   53 static  __checkReturn   efx_rc_t
   54 ef10_tunnel_reconfigure(
   55         __in            efx_nic_t *enp);
   56 
   57 static const efx_tunnel_ops_t   __efx_tunnel_ef10_ops = {
   58         ef10_udp_encap_supported,       /* eto_udp_encap_supported */
   59         ef10_tunnel_reconfigure,        /* eto_reconfigure */
   60 };
   61 #endif /* EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */
   62 
   63 static  __checkReturn           efx_rc_t
   64 efx_mcdi_set_tunnel_encap_udp_ports(
   65         __in                    efx_nic_t *enp,
   66         __in                    efx_tunnel_cfg_t *etcp,
   67         __in                    boolean_t unloading,
   68         __out                   boolean_t *resetting)
   69 {
   70         efx_mcdi_req_t req;
   71         EFX_MCDI_DECLARE_BUF(payload,
   72                 MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_LENMAX,
   73                 MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_LEN);
   74         efx_word_t flags;
   75         efx_rc_t rc;
   76         unsigned int i;
   77         unsigned int entries_num;
   78 
   79         if (etcp == NULL)
   80                 entries_num = 0;
   81         else
   82                 entries_num = etcp->etc_udp_entries_num;
   83 
   84         req.emr_cmd = MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS;
   85         req.emr_in_buf = payload;
   86         req.emr_in_length =
   87             MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_LEN(entries_num);
   88         req.emr_out_buf = payload;
   89         req.emr_out_length = MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_LEN;
   90 
   91         EFX_POPULATE_WORD_1(flags,
   92             MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_UNLOADING,
   93             (unloading == B_TRUE) ? 1 : 0);
   94         MCDI_IN_SET_WORD(req, SET_TUNNEL_ENCAP_UDP_PORTS_IN_FLAGS,
   95             EFX_WORD_FIELD(flags, EFX_WORD_0));
   96 
   97         MCDI_IN_SET_WORD(req, SET_TUNNEL_ENCAP_UDP_PORTS_IN_NUM_ENTRIES,
   98             entries_num);
   99 
  100         for (i = 0; i < entries_num; ++i) {
  101                 uint16_t mcdi_udp_protocol;
  102 
  103                 switch (etcp->etc_udp_entries[i].etue_protocol) {
  104                 case EFX_TUNNEL_PROTOCOL_VXLAN:
  105                         mcdi_udp_protocol = TUNNEL_ENCAP_UDP_PORT_ENTRY_VXLAN;
  106                         break;
  107                 case EFX_TUNNEL_PROTOCOL_GENEVE:
  108                         mcdi_udp_protocol = TUNNEL_ENCAP_UDP_PORT_ENTRY_GENEVE;
  109                         break;
  110                 default:
  111                         rc = EINVAL;
  112                         goto fail1;
  113                 }
  114 
  115                 /*
  116                  * UDP port is MCDI native little-endian in the request
  117                  * and EFX_POPULATE_DWORD cares about conversion from
  118                  * host/CPU byte order to little-endian.
  119                  */
  120                 EFX_STATIC_ASSERT(sizeof (efx_dword_t) ==
  121                     TUNNEL_ENCAP_UDP_PORT_ENTRY_LEN);
  122                 EFX_POPULATE_DWORD_2(
  123                     MCDI_IN2(req, efx_dword_t,
  124                         SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES)[i],
  125                     TUNNEL_ENCAP_UDP_PORT_ENTRY_UDP_PORT,
  126                     etcp->etc_udp_entries[i].etue_port,
  127                     TUNNEL_ENCAP_UDP_PORT_ENTRY_PROTOCOL,
  128                     mcdi_udp_protocol);
  129         }
  130 
  131         efx_mcdi_execute(enp, &req);
  132 
  133         if (req.emr_rc != 0) {
  134                 rc = req.emr_rc;
  135                 goto fail2;
  136         }
  137 
  138         if (req.emr_out_length_used !=
  139             MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_OUT_LEN) {
  140                 rc = EMSGSIZE;
  141                 goto fail3;
  142         }
  143 
  144         *resetting = MCDI_OUT_WORD_FIELD(req,
  145             SET_TUNNEL_ENCAP_UDP_PORTS_OUT_FLAGS,
  146             SET_TUNNEL_ENCAP_UDP_PORTS_OUT_RESETTING);
  147 
  148         return (0);
  149 
  150 fail3:
  151         EFSYS_PROBE(fail3);
  152 
  153 fail2:
  154         EFSYS_PROBE(fail2);
  155 
  156 fail1:
  157         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  158 
  159         return (rc);
  160 }
  161 
  162         __checkReturn   efx_rc_t
  163 efx_tunnel_init(
  164         __in            efx_nic_t *enp)
  165 {
  166         efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
  167         const efx_tunnel_ops_t *etop;
  168         efx_rc_t rc;
  169 
  170         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
  171         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
  172         EFSYS_ASSERT(!(enp->en_mod_flags & EFX_MOD_TUNNEL));
  173 
  174         EFX_STATIC_ASSERT(EFX_TUNNEL_MAXNENTRIES ==
  175             MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS_IN_ENTRIES_MAXNUM);
  176 
  177         switch (enp->en_family) {
  178 #if EFSYS_OPT_SIENA
  179         case EFX_FAMILY_SIENA:
  180                 etop = &__efx_tunnel_dummy_ops;
  181                 break;
  182 #endif /* EFSYS_OPT_SIENA */
  183 
  184 #if EFSYS_OPT_HUNTINGTON
  185         case EFX_FAMILY_HUNTINGTON:
  186                 etop = &__efx_tunnel_dummy_ops;
  187                 break;
  188 #endif /* EFSYS_OPT_HUNTINGTON */
  189 
  190 #if EFSYS_OPT_MEDFORD
  191         case EFX_FAMILY_MEDFORD:
  192                 etop = &__efx_tunnel_ef10_ops;
  193                 break;
  194 #endif /* EFSYS_OPT_MEDFORD */
  195 
  196 #if EFSYS_OPT_MEDFORD2
  197         case EFX_FAMILY_MEDFORD2:
  198                 etop = &__efx_tunnel_ef10_ops;
  199                 break;
  200 #endif /* EFSYS_OPT_MEDFORD2 */
  201 
  202         default:
  203                 EFSYS_ASSERT(0);
  204                 rc = ENOTSUP;
  205                 goto fail1;
  206         }
  207 
  208         memset(etcp->etc_udp_entries, 0, sizeof (etcp->etc_udp_entries));
  209         etcp->etc_udp_entries_num = 0;
  210 
  211         enp->en_etop = etop;
  212         enp->en_mod_flags |= EFX_MOD_TUNNEL;
  213 
  214         return (0);
  215 
  216 fail1:
  217         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  218 
  219         enp->en_etop = NULL;
  220         enp->en_mod_flags &= ~EFX_MOD_TUNNEL;
  221 
  222         return (rc);
  223 }
  224 
  225                         void
  226 efx_tunnel_fini(
  227         __in            efx_nic_t *enp)
  228 {
  229         boolean_t resetting;
  230 
  231         EFSYS_ASSERT3U(enp->en_magic, ==, EFX_NIC_MAGIC);
  232         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_PROBE);
  233         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);
  234 
  235         if ((enp->en_etop->eto_udp_encap_supported != NULL) &&
  236             enp->en_etop->eto_udp_encap_supported(enp)) {
  237                 /*
  238                  * The UNLOADING flag allows the MC to suppress the datapath
  239                  * reset if it was set on the last call to
  240                  * MC_CMD_SET_TUNNEL_ENCAP_UDP_PORTS by all functions
  241                  */
  242                 (void) efx_mcdi_set_tunnel_encap_udp_ports(enp, NULL, B_TRUE,
  243                     &resetting);
  244         }
  245 
  246         enp->en_etop = NULL;
  247         enp->en_mod_flags &= ~EFX_MOD_TUNNEL;
  248 }
  249 
  250 static  __checkReturn   efx_rc_t
  251 efx_tunnel_config_find_udp_tunnel_entry(
  252         __in            efx_tunnel_cfg_t *etcp,
  253         __in            uint16_t port,
  254         __out           unsigned int *entryp)
  255 {
  256         unsigned int i;
  257 
  258         for (i = 0; i < etcp->etc_udp_entries_num; ++i) {
  259                 efx_tunnel_udp_entry_t *p = &etcp->etc_udp_entries[i];
  260 
  261                 if (p->etue_port == port) {
  262                         *entryp = i;
  263                         return (0);
  264                 }
  265         }
  266 
  267         return (ENOENT);
  268 }
  269 
  270         __checkReturn   efx_rc_t
  271 efx_tunnel_config_udp_add(
  272         __in            efx_nic_t *enp,
  273         __in            uint16_t port /* host/cpu-endian */,
  274         __in            efx_tunnel_protocol_t protocol)
  275 {
  276         const efx_nic_cfg_t *encp = &enp->en_nic_cfg;
  277         efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
  278         efsys_lock_state_t state;
  279         efx_rc_t rc;
  280         unsigned int entry;
  281 
  282         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);
  283 
  284         if (protocol >= EFX_TUNNEL_NPROTOS) {
  285                 rc = EINVAL;
  286                 goto fail1;
  287         }
  288 
  289         if ((encp->enc_tunnel_encapsulations_supported &
  290             (1u << protocol)) == 0) {
  291                 rc = ENOTSUP;
  292                 goto fail2;
  293         }
  294 
  295         EFSYS_LOCK(enp->en_eslp, state);
  296 
  297         rc = efx_tunnel_config_find_udp_tunnel_entry(etcp, port, &entry);
  298         if (rc == 0) {
  299                 rc = EEXIST;
  300                 goto fail3;
  301         }
  302 
  303         if (etcp->etc_udp_entries_num ==
  304             encp->enc_tunnel_config_udp_entries_max) {
  305                 rc = ENOSPC;
  306                 goto fail4;
  307         }
  308 
  309         etcp->etc_udp_entries[etcp->etc_udp_entries_num].etue_port = port;
  310         etcp->etc_udp_entries[etcp->etc_udp_entries_num].etue_protocol =
  311             protocol;
  312 
  313         etcp->etc_udp_entries_num++;
  314 
  315         EFSYS_UNLOCK(enp->en_eslp, state);
  316 
  317         return (0);
  318 
  319 fail4:
  320         EFSYS_PROBE(fail4);
  321 
  322 fail3:
  323         EFSYS_PROBE(fail3);
  324         EFSYS_UNLOCK(enp->en_eslp, state);
  325 
  326 fail2:
  327         EFSYS_PROBE(fail2);
  328 
  329 fail1:
  330         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  331 
  332         return (rc);
  333 }
  334 
  335         __checkReturn   efx_rc_t
  336 efx_tunnel_config_udp_remove(
  337         __in            efx_nic_t *enp,
  338         __in            uint16_t port /* host/cpu-endian */,
  339         __in            efx_tunnel_protocol_t protocol)
  340 {
  341         efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
  342         efsys_lock_state_t state;
  343         unsigned int entry;
  344         efx_rc_t rc;
  345 
  346         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);
  347 
  348         EFSYS_LOCK(enp->en_eslp, state);
  349 
  350         rc = efx_tunnel_config_find_udp_tunnel_entry(etcp, port, &entry);
  351         if (rc != 0)
  352                 goto fail1;
  353 
  354         if (etcp->etc_udp_entries[entry].etue_protocol != protocol) {
  355                 rc = EINVAL;
  356                 goto fail2;
  357         }
  358 
  359         EFSYS_ASSERT3U(etcp->etc_udp_entries_num, >, 0);
  360         etcp->etc_udp_entries_num--;
  361 
  362         if (entry < etcp->etc_udp_entries_num) {
  363                 memmove(&etcp->etc_udp_entries[entry],
  364                     &etcp->etc_udp_entries[entry + 1],
  365                     (etcp->etc_udp_entries_num - entry) *
  366                     sizeof (etcp->etc_udp_entries[0]));
  367         }
  368 
  369         memset(&etcp->etc_udp_entries[etcp->etc_udp_entries_num], 0,
  370             sizeof (etcp->etc_udp_entries[0]));
  371 
  372         EFSYS_UNLOCK(enp->en_eslp, state);
  373 
  374         return (0);
  375 
  376 fail2:
  377         EFSYS_PROBE(fail2);
  378 
  379 fail1:
  380         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  381         EFSYS_UNLOCK(enp->en_eslp, state);
  382 
  383         return (rc);
  384 }
  385 
  386                         void
  387 efx_tunnel_config_clear(
  388         __in                    efx_nic_t *enp)
  389 {
  390         efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
  391         efsys_lock_state_t state;
  392 
  393         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);
  394 
  395         EFSYS_LOCK(enp->en_eslp, state);
  396 
  397         etcp->etc_udp_entries_num = 0;
  398         memset(etcp->etc_udp_entries, 0, sizeof (etcp->etc_udp_entries));
  399 
  400         EFSYS_UNLOCK(enp->en_eslp, state);
  401 }
  402 
  403         __checkReturn   efx_rc_t
  404 efx_tunnel_reconfigure(
  405         __in            efx_nic_t *enp)
  406 {
  407         const efx_tunnel_ops_t *etop = enp->en_etop;
  408         efx_rc_t rc;
  409 
  410         EFSYS_ASSERT3U(enp->en_mod_flags, &, EFX_MOD_TUNNEL);
  411 
  412         if (etop->eto_reconfigure == NULL) {
  413                 rc = ENOTSUP;
  414                 goto fail1;
  415         }
  416 
  417         if ((rc = enp->en_etop->eto_reconfigure(enp)) != 0)
  418                 goto fail2;
  419 
  420         return (0);
  421 
  422 fail2:
  423         EFSYS_PROBE(fail2);
  424 
  425 fail1:
  426         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  427 
  428         return (rc);
  429 }
  430 
  431 #if EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2
  432 static  __checkReturn           boolean_t
  433 ef10_udp_encap_supported(
  434         __in            efx_nic_t *enp)
  435 {
  436         const efx_nic_cfg_t *encp = &enp->en_nic_cfg;
  437         uint32_t udp_tunnels_mask = 0;
  438 
  439         udp_tunnels_mask |= (1u << EFX_TUNNEL_PROTOCOL_VXLAN);
  440         udp_tunnels_mask |= (1u << EFX_TUNNEL_PROTOCOL_GENEVE);
  441 
  442         return ((encp->enc_tunnel_encapsulations_supported &
  443             udp_tunnels_mask) == 0 ? B_FALSE : B_TRUE);
  444 }
  445 
  446 static  __checkReturn   efx_rc_t
  447 ef10_tunnel_reconfigure(
  448         __in            efx_nic_t *enp)
  449 {
  450         efx_tunnel_cfg_t *etcp = &enp->en_tunnel_cfg;
  451         efx_rc_t rc;
  452         boolean_t resetting;
  453         efsys_lock_state_t state;
  454         efx_tunnel_cfg_t etc;
  455 
  456         EFSYS_LOCK(enp->en_eslp, state);
  457         memcpy(&etc, etcp, sizeof (etc));
  458         EFSYS_UNLOCK(enp->en_eslp, state);
  459 
  460         if (ef10_udp_encap_supported(enp) == B_FALSE) {
  461                 /*
  462                  * It is OK to apply empty UDP tunnel ports when UDP
  463                  * tunnel encapsulations are not supported - just nothing
  464                  * should be done.
  465                  */
  466                 if (etc.etc_udp_entries_num == 0)
  467                         return (0);
  468                 rc = ENOTSUP;
  469                 goto fail1;
  470         } else {
  471                 /*
  472                  * All PCI functions can see a reset upon the
  473                  * MCDI request completion
  474                  */
  475                 rc = efx_mcdi_set_tunnel_encap_udp_ports(enp, &etc, B_FALSE,
  476                     &resetting);
  477                 if (rc != 0)
  478                         goto fail2;
  479 
  480                 /*
  481                  * Although the caller should be able to handle MC reboot,
  482                  * it might come in handy to report the impending reboot
  483                  * by returning EAGAIN
  484                  */
  485                 return ((resetting) ? EAGAIN : 0);
  486         }
  487 fail2:
  488         EFSYS_PROBE(fail2);
  489 
  490 fail1:
  491         EFSYS_PROBE1(fail1, efx_rc_t, rc);
  492 
  493         return (rc);
  494 }
  495 #endif /* EFSYS_OPT_MEDFORD || EFSYS_OPT_MEDFORD2 */
  496 
  497 #endif /* EFSYS_OPT_TUNNEL */
Cache object: fdbda4b0a053ea4f5a336b8ff694b5bc
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/sfxge/common/efx_tunnel.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/sfxge/common/efx_tunnel.c
