1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2013 Chelsio Communications, Inc. 5 * All rights reserved. 6 * Written by: Navdeep Parhar <np@FreeBSD.org> 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 */ 29 30 #include <sys/cdefs.h> 31 #include "opt_inet.h" 32 #include "opt_inet6.h" 33 34 #include <sys/param.h> 35 #include <sys/eventhandler.h> 36 #include <sys/lock.h> 37 #include <sys/types.h> 38 #include <sys/mbuf.h> 39 #include <sys/socket.h> 40 #include <sys/sockio.h> 41 #include <sys/sx.h> 42 #include <net/bpf.h> 43 #include <net/ethernet.h> 44 #include <net/if.h> 45 #include <net/if_clone.h> 46 #include <net/if_types.h> 47 48 #include "common/common.h" 49 #include "common/t4_msg.h" 50 #include "common/t4_regs.h" 51 #include "t4_ioctl.h" 52 53 /* 54 * Locking notes 55 * ============= 56 * 57 * An interface cloner is registered during mod_load and it can be used to 58 * create or destroy the tracing ifnet for an adapter at any time. It is 59 * possible for the cloned interface to outlive the adapter (adapter disappears 60 * in t4_detach but the tracing ifnet may live till mod_unload when removal of 61 * the cloner finally destroys any remaining cloned interfaces). When tracing 62 * filters are active, this ifnet is also receiving data. There are potential 63 * bad races between ifnet create, ifnet destroy, ifnet rx, ifnet ioctl, 64 * cxgbe_detach/t4_detach, mod_unload. 65 * 66 * a) The driver selects an iq for tracing (sc->traceq) inside a synch op. The 67 * iq is destroyed inside a synch op too (and sc->traceq updated). 68 * b) The cloner looks for an adapter that matches the name of the ifnet it's 69 * been asked to create, starts a synch op on that adapter, and proceeds only 70 * if the adapter has a tracing iq. 71 * c) The cloned ifnet and the adapter are coupled to each other via 72 * ifp->if_softc and sc->ifp. These can be modified only with the global 73 * t4_trace_lock sx as well as the sc->ifp_lock mutex held. Holding either 74 * of these will prevent any change. 75 * 76 * The order in which all the locks involved should be acquired are: 77 * t4_list_lock 78 * adapter lock 79 * (begin synch op and let go of the above two) 80 * t4_trace_lock 81 * sc->ifp_lock 82 */ 83 84 static struct sx t4_trace_lock; 85 static const char *t4_cloner_name = "tXnex"; 86 static struct if_clone *t4_cloner; 87 88 /* tracer ifnet routines. mostly no-ops. */ 89 static void tracer_init(void *); 90 static int tracer_ioctl(if_t, unsigned long, caddr_t); 91 static int tracer_transmit(if_t, struct mbuf *); 92 static void tracer_qflush(if_t); 93 static int tracer_media_change(if_t); 94 static void tracer_media_status(if_t, struct ifmediareq *); 95 96 /* match name (request/response) */ 97 struct match_rr { 98 const char *name; 99 int lock; /* set to 1 to returned sc locked. */ 100 struct adapter *sc; 101 int rc; 102 }; 103 104 static void 105 match_name(struct adapter *sc, void *arg) 106 { 107 struct match_rr *mrr = arg; 108 109 if (strcmp(device_get_nameunit(sc->dev), mrr->name) != 0) 110 return; 111 112 KASSERT(mrr->sc == NULL, ("%s: multiple matches (%p, %p) for %s", 113 __func__, mrr->sc, sc, mrr->name)); 114 115 mrr->sc = sc; 116 if (mrr->lock) 117 mrr->rc = begin_synchronized_op(mrr->sc, NULL, 0, "t4clon"); 118 else 119 mrr->rc = 0; 120 } 121 122 static int 123 t4_cloner_match(struct if_clone *ifc, const char *name) 124 { 125 126 if (strncmp(name, "t4nex", 5) != 0 && 127 strncmp(name, "t5nex", 5) != 0 && 128 strncmp(name, "t6nex", 5) != 0) 129 return (0); 130 if (name[5] < '0' || name[5] > '9') 131 return (0); 132 return (1); 133 } 134 135 static int 136 t4_cloner_create(struct if_clone *ifc, char *name, size_t len, caddr_t params) 137 { 138 struct match_rr mrr; 139 struct adapter *sc; 140 if_t ifp; 141 int rc; 142 const uint8_t lla[ETHER_ADDR_LEN] = {0, 0, 0, 0, 0, 0}; 143 144 mrr.name = name; 145 mrr.lock = 1; 146 mrr.sc = NULL; 147 mrr.rc = ENOENT; 148 t4_iterate(match_name, &mrr); 149 150 if (mrr.rc != 0) 151 return (mrr.rc); 152 sc = mrr.sc; 153 154 KASSERT(sc != NULL, ("%s: name (%s) matched but softc is NULL", 155 __func__, name)); 156 ASSERT_SYNCHRONIZED_OP(sc); 157 158 sx_xlock(&t4_trace_lock); 159 160 if (sc->ifp != NULL) { 161 rc = EEXIST; 162 goto done; 163 } 164 if (sc->traceq < 0) { 165 rc = EAGAIN; 166 goto done; 167 } 168 169 ifp = if_alloc(IFT_ETHER); 170 if (ifp == NULL) { 171 rc = ENOMEM; 172 goto done; 173 } 174 175 /* Note that if_xname is identical to the nexus nameunit */ 176 if_initname(ifp, name, -1); 177 if_setdname(ifp, t4_cloner_name); 178 if_setinitfn(ifp, tracer_init); 179 if_setflags(ifp, IFF_SIMPLEX | IFF_DRV_RUNNING); 180 if_setioctlfn(ifp, tracer_ioctl); 181 if_settransmitfn(ifp, tracer_transmit); 182 if_setqflushfn(ifp, tracer_qflush); 183 if_setcapabilities(ifp, IFCAP_JUMBO_MTU | IFCAP_VLAN_MTU); 184 ifmedia_init(&sc->media, IFM_IMASK, tracer_media_change, 185 tracer_media_status); 186 ifmedia_add(&sc->media, IFM_ETHER | IFM_FDX | IFM_NONE, 0, NULL); 187 ifmedia_set(&sc->media, IFM_ETHER | IFM_FDX | IFM_NONE); 188 sx_xunlock(&t4_trace_lock); 189 ether_ifattach(ifp, lla); 190 sx_xlock(&t4_trace_lock); 191 mtx_lock(&sc->ifp_lock); 192 if_setsoftc(ifp, sc); 193 sc->ifp = ifp; 194 mtx_unlock(&sc->ifp_lock); 195 rc = 0; 196 done: 197 sx_xunlock(&t4_trace_lock); 198 end_synchronized_op(sc, 0); 199 return (rc); 200 } 201 202 static int 203 t4_cloner_destroy(struct if_clone *ifc, if_t ifp) 204 { 205 struct adapter *sc; 206 207 sx_xlock(&t4_trace_lock); 208 sc = if_getsoftc(ifp); 209 if (sc != NULL) { 210 mtx_lock(&sc->ifp_lock); 211 sc->ifp = NULL; 212 if_setsoftc(ifp, NULL); 213 mtx_unlock(&sc->ifp_lock); 214 ifmedia_removeall(&sc->media); 215 } 216 sx_xunlock(&t4_trace_lock); 217 ether_ifdetach(ifp); 218 if_free(ifp); 219 220 return (0); 221 } 222 223 void 224 t4_tracer_modload(void) 225 { 226 227 sx_init(&t4_trace_lock, "T4/T5 tracer lock"); 228 t4_cloner = if_clone_advanced(t4_cloner_name, 0, t4_cloner_match, 229 t4_cloner_create, t4_cloner_destroy); 230 } 231 232 void 233 t4_tracer_modunload(void) 234 { 235 236 if (t4_cloner != NULL) { 237 /* 238 * The module is being unloaded so the nexus drivers have 239 * detached. The tracing interfaces can not outlive the nexus 240 * (ifp->if_softc is the nexus) and must have been destroyed 241 * already. XXX: but if_clone is opaque to us and we can't 242 * assert LIST_EMPTY(&t4_cloner->ifc_iflist) at this time. 243 */ 244 if_clone_detach(t4_cloner); 245 } 246 sx_destroy(&t4_trace_lock); 247 } 248 249 void 250 t4_tracer_port_detach(struct adapter *sc) 251 { 252 253 sx_xlock(&t4_trace_lock); 254 if (sc->ifp != NULL) { 255 mtx_lock(&sc->ifp_lock); 256 if_setsoftc(sc->ifp, NULL); 257 sc->ifp = NULL; 258 mtx_unlock(&sc->ifp_lock); 259 } 260 ifmedia_removeall(&sc->media); 261 sx_xunlock(&t4_trace_lock); 262 } 263 264 int 265 t4_get_tracer(struct adapter *sc, struct t4_tracer *t) 266 { 267 int rc, i, enabled; 268 struct trace_params tp; 269 270 if (t->idx >= NTRACE) { 271 t->idx = 0xff; 272 t->enabled = 0; 273 t->valid = 0; 274 return (0); 275 } 276 277 rc = begin_synchronized_op(sc, NULL, HOLD_LOCK | SLEEP_OK | INTR_OK, 278 "t4gett"); 279 if (rc) 280 return (rc); 281 282 if (hw_off_limits(sc)) { 283 rc = ENXIO; 284 goto done; 285 } 286 287 for (i = t->idx; i < NTRACE; i++) { 288 if (isset(&sc->tracer_valid, t->idx)) { 289 t4_get_trace_filter(sc, &tp, i, &enabled); 290 t->idx = i; 291 t->enabled = enabled; 292 t->valid = 1; 293 memcpy(&t->tp.data[0], &tp.data[0], sizeof(t->tp.data)); 294 memcpy(&t->tp.mask[0], &tp.mask[0], sizeof(t->tp.mask)); 295 t->tp.snap_len = tp.snap_len; 296 t->tp.min_len = tp.min_len; 297 t->tp.skip_ofst = tp.skip_ofst; 298 t->tp.skip_len = tp.skip_len; 299 t->tp.invert = tp.invert; 300 301 /* convert channel to port iff 0 <= port < 8. */ 302 if (tp.port < 4) 303 t->tp.port = sc->chan_map[tp.port]; 304 else if (tp.port < 8) 305 t->tp.port = sc->chan_map[tp.port - 4] + 4; 306 else 307 t->tp.port = tp.port; 308 309 goto done; 310 } 311 } 312 313 t->idx = 0xff; 314 t->enabled = 0; 315 t->valid = 0; 316 done: 317 end_synchronized_op(sc, LOCK_HELD); 318 319 return (rc); 320 } 321 322 int 323 t4_set_tracer(struct adapter *sc, struct t4_tracer *t) 324 { 325 int rc; 326 struct trace_params tp, *tpp; 327 328 if (t->idx >= NTRACE) 329 return (EINVAL); 330 331 rc = begin_synchronized_op(sc, NULL, HOLD_LOCK | SLEEP_OK | INTR_OK, 332 "t4sett"); 333 if (rc) 334 return (rc); 335 336 if (hw_off_limits(sc)) { 337 rc = ENXIO; 338 goto done; 339 } 340 341 /* 342 * If no tracing filter is specified this time then check if the filter 343 * at the index is valid anyway because it was set previously. If so 344 * then this is a legitimate enable/disable operation. 345 */ 346 if (t->valid == 0) { 347 if (isset(&sc->tracer_valid, t->idx)) 348 tpp = NULL; 349 else 350 rc = EINVAL; 351 goto done; 352 } 353 354 if (t->tp.port > 19 || t->tp.snap_len > 9600 || 355 t->tp.min_len > M_TFMINPKTSIZE || t->tp.skip_len > M_TFLENGTH || 356 t->tp.skip_ofst > M_TFOFFSET) { 357 rc = EINVAL; 358 goto done; 359 } 360 361 memcpy(&tp.data[0], &t->tp.data[0], sizeof(tp.data)); 362 memcpy(&tp.mask[0], &t->tp.mask[0], sizeof(tp.mask)); 363 tp.snap_len = t->tp.snap_len; 364 tp.min_len = t->tp.min_len; 365 tp.skip_ofst = t->tp.skip_ofst; 366 tp.skip_len = t->tp.skip_len; 367 tp.invert = !!t->tp.invert; 368 369 /* convert port to channel iff 0 <= port < 8. */ 370 if (t->tp.port < 4) { 371 if (sc->port[t->tp.port] == NULL) { 372 rc = EINVAL; 373 goto done; 374 } 375 tp.port = sc->port[t->tp.port]->tx_chan; 376 } else if (t->tp.port < 8) { 377 if (sc->port[t->tp.port - 4] == NULL) { 378 rc = EINVAL; 379 goto done; 380 } 381 tp.port = sc->port[t->tp.port - 4]->tx_chan + 4; 382 } else 383 tp.port = t->tp.port; 384 tpp = &tp; 385 done: 386 if (rc == 0) { 387 rc = -t4_set_trace_filter(sc, tpp, t->idx, t->enabled); 388 if (rc == 0) { 389 if (t->enabled) { 390 setbit(&sc->tracer_valid, t->idx); 391 if (sc->tracer_enabled == 0) { 392 t4_set_reg_field(sc, A_MPS_TRC_CFG, 393 F_TRCEN, F_TRCEN); 394 } 395 setbit(&sc->tracer_enabled, t->idx); 396 } else { 397 clrbit(&sc->tracer_enabled, t->idx); 398 if (sc->tracer_enabled == 0) { 399 t4_set_reg_field(sc, A_MPS_TRC_CFG, 400 F_TRCEN, 0); 401 } 402 } 403 } 404 } 405 end_synchronized_op(sc, LOCK_HELD); 406 407 return (rc); 408 } 409 410 int 411 t4_trace_pkt(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m) 412 { 413 struct adapter *sc = iq->adapter; 414 if_t ifp; 415 416 KASSERT(m != NULL, ("%s: no payload with opcode %02x", __func__, 417 rss->opcode)); 418 419 mtx_lock(&sc->ifp_lock); 420 ifp = sc->ifp; 421 if (sc->ifp) { 422 m_adj(m, sizeof(struct cpl_trace_pkt)); 423 m->m_pkthdr.rcvif = ifp; 424 ETHER_BPF_MTAP(ifp, m); 425 } 426 mtx_unlock(&sc->ifp_lock); 427 m_freem(m); 428 429 return (0); 430 } 431 432 int 433 t5_trace_pkt(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m) 434 { 435 struct adapter *sc = iq->adapter; 436 if_t ifp; 437 438 KASSERT(m != NULL, ("%s: no payload with opcode %02x", __func__, 439 rss->opcode)); 440 441 mtx_lock(&sc->ifp_lock); 442 ifp = sc->ifp; 443 if (ifp != NULL) { 444 m_adj(m, sizeof(struct cpl_t5_trace_pkt)); 445 m->m_pkthdr.rcvif = ifp; 446 ETHER_BPF_MTAP(ifp, m); 447 } 448 mtx_unlock(&sc->ifp_lock); 449 m_freem(m); 450 451 return (0); 452 } 453 454 455 static void 456 tracer_init(void *arg) 457 { 458 459 return; 460 } 461 462 static int 463 tracer_ioctl(if_t ifp, unsigned long cmd, caddr_t data) 464 { 465 int rc = 0; 466 struct adapter *sc; 467 struct ifreq *ifr = (struct ifreq *)data; 468 469 switch (cmd) { 470 case SIOCSIFMTU: 471 case SIOCSIFFLAGS: 472 case SIOCADDMULTI: 473 case SIOCDELMULTI: 474 case SIOCSIFCAP: 475 break; 476 case SIOCSIFMEDIA: 477 case SIOCGIFMEDIA: 478 case SIOCGIFXMEDIA: 479 sx_xlock(&t4_trace_lock); 480 sc = if_getsoftc(ifp); 481 if (sc == NULL) 482 rc = EIO; 483 else 484 rc = ifmedia_ioctl(ifp, ifr, &sc->media, cmd); 485 sx_xunlock(&t4_trace_lock); 486 break; 487 default: 488 rc = ether_ioctl(ifp, cmd, data); 489 } 490 491 return (rc); 492 } 493 494 static int 495 tracer_transmit(if_t ifp, struct mbuf *m) 496 { 497 498 m_freem(m); 499 return (0); 500 } 501 502 static void 503 tracer_qflush(if_t ifp) 504 { 505 506 return; 507 } 508 509 static int 510 tracer_media_change(if_t ifp) 511 { 512 513 return (EOPNOTSUPP); 514 } 515 516 static void 517 tracer_media_status(if_t ifp, struct ifmediareq *ifmr) 518 { 519 520 ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE; 521 522 return; 523 } 524