sys/dev/sfxge/common/efx_tunnel.c

   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 */