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(struct ifnet *, unsigned long, caddr_t);
91 static int tracer_transmit(struct ifnet *, struct mbuf *);
92 static void tracer_qflush(struct ifnet *);
93 static int tracer_media_change(struct ifnet *);
94 static void tracer_media_status(struct ifnet *, 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
match_name(struct adapter * sc,void * arg)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
t4_cloner_match(struct if_clone * ifc,const char * name)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
t4_cloner_create(struct if_clone * ifc,char * name,size_t len,caddr_t params)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 struct ifnet *ifp;
141 int rc, unit;
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
170 unit = -1;
171 rc = ifc_alloc_unit(ifc, &unit);
172 if (rc != 0)
173 goto done;
174
175 ifp = if_alloc(IFT_ETHER);
176 /* Note that if_xname is not <if_dname><if_dunit>. */
177 strlcpy(ifp->if_xname, name, sizeof(ifp->if_xname));
178 ifp->if_dname = t4_cloner_name;
179 ifp->if_dunit = unit;
180 ifp->if_init = tracer_init;
181 ifp->if_flags = IFF_SIMPLEX | IFF_DRV_RUNNING;
182 ifp->if_ioctl = tracer_ioctl;
183 ifp->if_transmit = tracer_transmit;
184 ifp->if_qflush = tracer_qflush;
185 ifp->if_capabilities = IFCAP_JUMBO_MTU | IFCAP_VLAN_MTU;
186 ifmedia_init(&sc->media, IFM_IMASK, tracer_media_change,
187 tracer_media_status);
188 ifmedia_add(&sc->media, IFM_ETHER | IFM_FDX | IFM_NONE, 0, NULL);
189 ifmedia_set(&sc->media, IFM_ETHER | IFM_FDX | IFM_NONE);
190 ether_ifattach(ifp, lla);
191
192 mtx_lock(&sc->ifp_lock);
193 ifp->if_softc = sc;
194 sc->ifp = ifp;
195 mtx_unlock(&sc->ifp_lock);
196 done:
197 sx_xunlock(&t4_trace_lock);
198 end_synchronized_op(sc, 0);
199 return (rc);
200 }
201
202 static int
t4_cloner_destroy(struct if_clone * ifc,struct ifnet * ifp)203 t4_cloner_destroy(struct if_clone *ifc, struct ifnet *ifp)
204 {
205 struct adapter *sc;
206 int unit = ifp->if_dunit;
207
208 sx_xlock(&t4_trace_lock);
209 sc = ifp->if_softc;
210 if (sc != NULL) {
211 mtx_lock(&sc->ifp_lock);
212 sc->ifp = NULL;
213 ifp->if_softc = NULL;
214 mtx_unlock(&sc->ifp_lock);
215 ifmedia_removeall(&sc->media);
216 }
217 ether_ifdetach(ifp);
218 if_free(ifp);
219 ifc_free_unit(ifc, unit);
220 sx_xunlock(&t4_trace_lock);
221
222 return (0);
223 }
224
225 void
t4_tracer_modload(void)226 t4_tracer_modload(void)
227 {
228
229 sx_init(&t4_trace_lock, "T4/T5 tracer lock");
230 t4_cloner = if_clone_advanced(t4_cloner_name, 0, t4_cloner_match,
231 t4_cloner_create, t4_cloner_destroy);
232 }
233
234 void
t4_tracer_modunload(void)235 t4_tracer_modunload(void)
236 {
237
238 if (t4_cloner != NULL) {
239 /*
240 * The module is being unloaded so the nexus drivers have
241 * detached. The tracing interfaces can not outlive the nexus
242 * (ifp->if_softc is the nexus) and must have been destroyed
243 * already. XXX: but if_clone is opaque to us and we can't
244 * assert LIST_EMPTY(&t4_cloner->ifc_iflist) at this time.
245 */
246 if_clone_detach(t4_cloner);
247 }
248 sx_destroy(&t4_trace_lock);
249 }
250
251 void
t4_tracer_port_detach(struct adapter * sc)252 t4_tracer_port_detach(struct adapter *sc)
253 {
254
255 sx_xlock(&t4_trace_lock);
256 if (sc->ifp != NULL) {
257 mtx_lock(&sc->ifp_lock);
258 sc->ifp->if_softc = NULL;
259 sc->ifp = NULL;
260 mtx_unlock(&sc->ifp_lock);
261 }
262 ifmedia_removeall(&sc->media);
263 sx_xunlock(&t4_trace_lock);
264 }
265
266 int
t4_get_tracer(struct adapter * sc,struct t4_tracer * t)267 t4_get_tracer(struct adapter *sc, struct t4_tracer *t)
268 {
269 int rc, i, enabled;
270 struct trace_params tp;
271
272 if (t->idx >= NTRACE) {
273 t->idx = 0xff;
274 t->enabled = 0;
275 t->valid = 0;
276 return (0);
277 }
278
279 rc = begin_synchronized_op(sc, NULL, HOLD_LOCK | SLEEP_OK | INTR_OK,
280 "t4gett");
281 if (rc)
282 return (rc);
283
284 if (hw_off_limits(sc)) {
285 rc = ENXIO;
286 goto done;
287 }
288
289 for (i = t->idx; i < NTRACE; i++) {
290 if (isset(&sc->tracer_valid, t->idx)) {
291 t4_get_trace_filter(sc, &tp, i, &enabled);
292 t->idx = i;
293 t->enabled = enabled;
294 t->valid = 1;
295 memcpy(&t->tp.data[0], &tp.data[0], sizeof(t->tp.data));
296 memcpy(&t->tp.mask[0], &tp.mask[0], sizeof(t->tp.mask));
297 t->tp.snap_len = tp.snap_len;
298 t->tp.min_len = tp.min_len;
299 t->tp.skip_ofst = tp.skip_ofst;
300 t->tp.skip_len = tp.skip_len;
301 t->tp.invert = tp.invert;
302
303 /* convert channel to port iff 0 <= port < 8. */
304 if (tp.port < 4)
305 t->tp.port = sc->chan_map[tp.port];
306 else if (tp.port < 8)
307 t->tp.port = sc->chan_map[tp.port - 4] + 4;
308 else
309 t->tp.port = tp.port;
310
311 goto done;
312 }
313 }
314
315 t->idx = 0xff;
316 t->enabled = 0;
317 t->valid = 0;
318 done:
319 end_synchronized_op(sc, LOCK_HELD);
320
321 return (rc);
322 }
323
324 int
t4_set_tracer(struct adapter * sc,struct t4_tracer * t)325 t4_set_tracer(struct adapter *sc, struct t4_tracer *t)
326 {
327 int rc;
328 struct trace_params tp, *tpp;
329
330 if (t->idx >= NTRACE)
331 return (EINVAL);
332
333 rc = begin_synchronized_op(sc, NULL, HOLD_LOCK | SLEEP_OK | INTR_OK,
334 "t4sett");
335 if (rc)
336 return (rc);
337
338 if (hw_off_limits(sc)) {
339 rc = ENXIO;
340 goto done;
341 }
342
343 /*
344 * If no tracing filter is specified this time then check if the filter
345 * at the index is valid anyway because it was set previously. If so
346 * then this is a legitimate enable/disable operation.
347 */
348 if (t->valid == 0) {
349 if (isset(&sc->tracer_valid, t->idx))
350 tpp = NULL;
351 else
352 rc = EINVAL;
353 goto done;
354 }
355
356 if (t->tp.port > 19 || t->tp.snap_len > 9600 ||
357 t->tp.min_len > M_TFMINPKTSIZE || t->tp.skip_len > M_TFLENGTH ||
358 t->tp.skip_ofst > M_TFOFFSET) {
359 rc = EINVAL;
360 goto done;
361 }
362
363 memcpy(&tp.data[0], &t->tp.data[0], sizeof(tp.data));
364 memcpy(&tp.mask[0], &t->tp.mask[0], sizeof(tp.mask));
365 tp.snap_len = t->tp.snap_len;
366 tp.min_len = t->tp.min_len;
367 tp.skip_ofst = t->tp.skip_ofst;
368 tp.skip_len = t->tp.skip_len;
369 tp.invert = !!t->tp.invert;
370
371 /* convert port to channel iff 0 <= port < 8. */
372 if (t->tp.port < 4) {
373 if (sc->port[t->tp.port] == NULL) {
374 rc = EINVAL;
375 goto done;
376 }
377 tp.port = sc->port[t->tp.port]->tx_chan;
378 } else if (t->tp.port < 8) {
379 if (sc->port[t->tp.port - 4] == NULL) {
380 rc = EINVAL;
381 goto done;
382 }
383 tp.port = sc->port[t->tp.port - 4]->tx_chan + 4;
384 } else
385 tp.port = t->tp.port;
386 tpp = &tp;
387 done:
388 if (rc == 0) {
389 rc = -t4_set_trace_filter(sc, tpp, t->idx, t->enabled);
390 if (rc == 0) {
391 if (t->enabled) {
392 setbit(&sc->tracer_valid, t->idx);
393 if (sc->tracer_enabled == 0) {
394 t4_set_reg_field(sc, A_MPS_TRC_CFG,
395 F_TRCEN, F_TRCEN);
396 }
397 setbit(&sc->tracer_enabled, t->idx);
398 } else {
399 clrbit(&sc->tracer_enabled, t->idx);
400 if (sc->tracer_enabled == 0) {
401 t4_set_reg_field(sc, A_MPS_TRC_CFG,
402 F_TRCEN, 0);
403 }
404 }
405 }
406 }
407 end_synchronized_op(sc, LOCK_HELD);
408
409 return (rc);
410 }
411
412 int
t4_trace_pkt(struct sge_iq * iq,const struct rss_header * rss,struct mbuf * m)413 t4_trace_pkt(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
414 {
415 struct adapter *sc = iq->adapter;
416 struct ifnet *ifp;
417
418 KASSERT(m != NULL, ("%s: no payload with opcode %02x", __func__,
419 rss->opcode));
420
421 mtx_lock(&sc->ifp_lock);
422 ifp = sc->ifp;
423 if (sc->ifp) {
424 m_adj(m, sizeof(struct cpl_trace_pkt));
425 m->m_pkthdr.rcvif = ifp;
426 ETHER_BPF_MTAP(ifp, m);
427 }
428 mtx_unlock(&sc->ifp_lock);
429 m_freem(m);
430
431 return (0);
432 }
433
434 int
t5_trace_pkt(struct sge_iq * iq,const struct rss_header * rss,struct mbuf * m)435 t5_trace_pkt(struct sge_iq *iq, const struct rss_header *rss, struct mbuf *m)
436 {
437 struct adapter *sc = iq->adapter;
438 struct ifnet *ifp;
439
440 KASSERT(m != NULL, ("%s: no payload with opcode %02x", __func__,
441 rss->opcode));
442
443 mtx_lock(&sc->ifp_lock);
444 ifp = sc->ifp;
445 if (ifp != NULL) {
446 m_adj(m, sizeof(struct cpl_t5_trace_pkt));
447 m->m_pkthdr.rcvif = ifp;
448 ETHER_BPF_MTAP(ifp, m);
449 }
450 mtx_unlock(&sc->ifp_lock);
451 m_freem(m);
452
453 return (0);
454 }
455
456
457 static void
tracer_init(void * arg)458 tracer_init(void *arg)
459 {
460
461 return;
462 }
463
464 static int
tracer_ioctl(struct ifnet * ifp,unsigned long cmd,caddr_t data)465 tracer_ioctl(struct ifnet *ifp, unsigned long cmd, caddr_t data)
466 {
467 int rc = 0;
468 struct adapter *sc;
469 struct ifreq *ifr = (struct ifreq *)data;
470
471 switch (cmd) {
472 case SIOCSIFMTU:
473 case SIOCSIFFLAGS:
474 case SIOCADDMULTI:
475 case SIOCDELMULTI:
476 case SIOCSIFCAP:
477 break;
478 case SIOCSIFMEDIA:
479 case SIOCGIFMEDIA:
480 case SIOCGIFXMEDIA:
481 sx_xlock(&t4_trace_lock);
482 sc = ifp->if_softc;
483 if (sc == NULL)
484 rc = EIO;
485 else
486 rc = ifmedia_ioctl(ifp, ifr, &sc->media, cmd);
487 sx_xunlock(&t4_trace_lock);
488 break;
489 default:
490 rc = ether_ioctl(ifp, cmd, data);
491 }
492
493 return (rc);
494 }
495
496 static int
tracer_transmit(struct ifnet * ifp,struct mbuf * m)497 tracer_transmit(struct ifnet *ifp, struct mbuf *m)
498 {
499
500 m_freem(m);
501 return (0);
502 }
503
504 static void
tracer_qflush(struct ifnet * ifp)505 tracer_qflush(struct ifnet *ifp)
506 {
507
508 return;
509 }
510
511 static int
tracer_media_change(struct ifnet * ifp)512 tracer_media_change(struct ifnet *ifp)
513 {
514
515 return (EOPNOTSUPP);
516 }
517
518 static void
tracer_media_status(struct ifnet * ifp,struct ifmediareq * ifmr)519 tracer_media_status(struct ifnet *ifp, struct ifmediareq *ifmr)
520 {
521
522 ifmr->ifm_status = IFM_AVALID | IFM_ACTIVE;
523
524 return;
525 }
526