1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Portions of this file
4 * Copyright(c) 2016-2017 Intel Deutschland GmbH
5 * Copyright (C) 2018, 2020-2025 Intel Corporation
6 */
7#undef TRACE_SYSTEM
8#define TRACE_SYSTEM cfg80211
9
10#if !defined(__RDEV_OPS_TRACE) || defined(TRACE_HEADER_MULTI_READ)
11#define __RDEV_OPS_TRACE
12
13#include <linux/tracepoint.h>
14
15#include <linux/rtnetlink.h>
16#include <linux/etherdevice.h>
17#include <net/cfg80211.h>
18#include "core.h"
19
20#define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN)
21#define MAC_ASSIGN(entry_mac, given_mac) do { \
22 if (given_mac) \
23 memcpy(__entry->entry_mac, given_mac, ETH_ALEN); \
24 else \
25 eth_zero_addr(__entry->entry_mac); \
26 } while (0)
27
28#define MAXNAME 32
29#define WIPHY_ENTRY __array(char, wiphy_name, 32)
30#define WIPHY_ASSIGN strscpy(__entry->wiphy_name, wiphy_name(wiphy), MAXNAME)
31#define WIPHY_PR_FMT "%s"
32#define WIPHY_PR_ARG __entry->wiphy_name
33
34#define WDEV_ENTRY __field(u32, id)
35#define WDEV_ASSIGN (__entry->id) = (!IS_ERR_OR_NULL(wdev) \
36 ? wdev->identifier : 0)
37#define WDEV_PR_FMT "wdev(%u)"
38#define WDEV_PR_ARG (__entry->id)
39
40#define NETDEV_ENTRY __array(char, name, IFNAMSIZ) \
41 __field(int, ifindex)
42#define NETDEV_ASSIGN \
43 do { \
44 memcpy(__entry->name, netdev->name, IFNAMSIZ); \
45 (__entry->ifindex) = (netdev->ifindex); \
46 } while (0)
47#define NETDEV_PR_FMT "netdev:%s(%d)"
48#define NETDEV_PR_ARG __entry->name, __entry->ifindex
49
50#define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout) \
51 __field(u16, dot11MeshConfirmTimeout) \
52 __field(u16, dot11MeshHoldingTimeout) \
53 __field(u16, dot11MeshMaxPeerLinks) \
54 __field(u8, dot11MeshMaxRetries) \
55 __field(u8, dot11MeshTTL) \
56 __field(u8, element_ttl) \
57 __field(bool, auto_open_plinks) \
58 __field(u32, dot11MeshNbrOffsetMaxNeighbor) \
59 __field(u8, dot11MeshHWMPmaxPREQretries) \
60 __field(u32, path_refresh_time) \
61 __field(u32, dot11MeshHWMPactivePathTimeout) \
62 __field(u16, min_discovery_timeout) \
63 __field(u16, dot11MeshHWMPpreqMinInterval) \
64 __field(u16, dot11MeshHWMPperrMinInterval) \
65 __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \
66 __field(u8, dot11MeshHWMPRootMode) \
67 __field(u16, dot11MeshHWMPRannInterval) \
68 __field(bool, dot11MeshGateAnnouncementProtocol) \
69 __field(bool, dot11MeshForwarding) \
70 __field(s32, rssi_threshold) \
71 __field(u16, ht_opmode) \
72 __field(u32, dot11MeshHWMPactivePathToRootTimeout) \
73 __field(u16, dot11MeshHWMProotInterval) \
74 __field(u16, dot11MeshHWMPconfirmationInterval) \
75 __field(bool, dot11MeshNolearn)
76#define MESH_CFG_ASSIGN \
77 do { \
78 __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \
79 __entry->dot11MeshConfirmTimeout = \
80 conf->dot11MeshConfirmTimeout; \
81 __entry->dot11MeshHoldingTimeout = \
82 conf->dot11MeshHoldingTimeout; \
83 __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \
84 __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries; \
85 __entry->dot11MeshTTL = conf->dot11MeshTTL; \
86 __entry->element_ttl = conf->element_ttl; \
87 __entry->auto_open_plinks = conf->auto_open_plinks; \
88 __entry->dot11MeshNbrOffsetMaxNeighbor = \
89 conf->dot11MeshNbrOffsetMaxNeighbor; \
90 __entry->dot11MeshHWMPmaxPREQretries = \
91 conf->dot11MeshHWMPmaxPREQretries; \
92 __entry->path_refresh_time = conf->path_refresh_time; \
93 __entry->dot11MeshHWMPactivePathTimeout = \
94 conf->dot11MeshHWMPactivePathTimeout; \
95 __entry->min_discovery_timeout = conf->min_discovery_timeout; \
96 __entry->dot11MeshHWMPpreqMinInterval = \
97 conf->dot11MeshHWMPpreqMinInterval; \
98 __entry->dot11MeshHWMPperrMinInterval = \
99 conf->dot11MeshHWMPperrMinInterval; \
100 __entry->dot11MeshHWMPnetDiameterTraversalTime = \
101 conf->dot11MeshHWMPnetDiameterTraversalTime; \
102 __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \
103 __entry->dot11MeshHWMPRannInterval = \
104 conf->dot11MeshHWMPRannInterval; \
105 __entry->dot11MeshGateAnnouncementProtocol = \
106 conf->dot11MeshGateAnnouncementProtocol; \
107 __entry->dot11MeshForwarding = conf->dot11MeshForwarding; \
108 __entry->rssi_threshold = conf->rssi_threshold; \
109 __entry->ht_opmode = conf->ht_opmode; \
110 __entry->dot11MeshHWMPactivePathToRootTimeout = \
111 conf->dot11MeshHWMPactivePathToRootTimeout; \
112 __entry->dot11MeshHWMProotInterval = \
113 conf->dot11MeshHWMProotInterval; \
114 __entry->dot11MeshHWMPconfirmationInterval = \
115 conf->dot11MeshHWMPconfirmationInterval; \
116 __entry->dot11MeshNolearn = conf->dot11MeshNolearn; \
117 } while (0)
118
119#define CHAN_ENTRY __field(enum nl80211_band, band) \
120 __field(u32, center_freq) \
121 __field(u16, freq_offset)
122#define CHAN_ASSIGN(chan) \
123 do { \
124 if (chan) { \
125 __entry->band = chan->band; \
126 __entry->center_freq = chan->center_freq; \
127 __entry->freq_offset = chan->freq_offset; \
128 } else { \
129 __entry->band = 0; \
130 __entry->center_freq = 0; \
131 __entry->freq_offset = 0; \
132 } \
133 } while (0)
134#define CHAN_PR_FMT "band: %d, freq: %u.%03u"
135#define CHAN_PR_ARG __entry->band, __entry->center_freq, __entry->freq_offset
136
137#define CHAN_DEF_ENTRY __field(enum nl80211_band, band) \
138 __field(u32, control_freq) \
139 __field(u32, freq_offset) \
140 __field(u32, width) \
141 __field(u32, center_freq1) \
142 __field(u32, freq1_offset) \
143 __field(u32, center_freq2) \
144 __field(u16, punctured)
145#define CHAN_DEF_ASSIGN(chandef) \
146 do { \
147 if ((chandef) && (chandef)->chan) { \
148 __entry->band = (chandef)->chan->band; \
149 __entry->control_freq = \
150 (chandef)->chan->center_freq; \
151 __entry->freq_offset = \
152 (chandef)->chan->freq_offset; \
153 __entry->width = (chandef)->width; \
154 __entry->center_freq1 = (chandef)->center_freq1;\
155 __entry->freq1_offset = (chandef)->freq1_offset;\
156 __entry->center_freq2 = (chandef)->center_freq2;\
157 __entry->punctured = (chandef)->punctured; \
158 } else { \
159 __entry->band = 0; \
160 __entry->control_freq = 0; \
161 __entry->freq_offset = 0; \
162 __entry->width = 0; \
163 __entry->center_freq1 = 0; \
164 __entry->freq1_offset = 0; \
165 __entry->center_freq2 = 0; \
166 __entry->punctured = 0; \
167 } \
168 } while (0)
169#define CHAN_DEF_PR_FMT \
170 "band: %d, control freq: %u.%03u, width: %d, cf1: %u.%03u, cf2: %u, punct: 0x%x"
171#define CHAN_DEF_PR_ARG __entry->band, __entry->control_freq, \
172 __entry->freq_offset, __entry->width, \
173 __entry->center_freq1, __entry->freq1_offset, \
174 __entry->center_freq2, __entry->punctured
175
176#define FILS_AAD_ASSIGN(fa) \
177 do { \
178 if (fa) { \
179 ether_addr_copy(__entry->macaddr, fa->macaddr); \
180 __entry->kek_len = fa->kek_len; \
181 } else { \
182 eth_zero_addr(__entry->macaddr); \
183 __entry->kek_len = 0; \
184 } \
185 } while (0)
186#define FILS_AAD_PR_FMT \
187 "macaddr: %pM, kek_len: %d"
188
189#define SINFO_ENTRY __field(int, generation) \
190 __field(u32, connected_time) \
191 __field(u32, inactive_time) \
192 __field(u32, rx_bytes) \
193 __field(u32, tx_bytes) \
194 __field(u32, rx_packets) \
195 __field(u32, tx_packets) \
196 __field(u32, tx_retries) \
197 __field(u32, tx_failed) \
198 __field(u32, rx_dropped_misc) \
199 __field(u32, beacon_loss_count) \
200 __field(u16, llid) \
201 __field(u16, plid) \
202 __field(u8, plink_state)
203#define SINFO_ASSIGN \
204 do { \
205 __entry->generation = sinfo->generation; \
206 __entry->connected_time = sinfo->connected_time; \
207 __entry->inactive_time = sinfo->inactive_time; \
208 __entry->rx_bytes = sinfo->rx_bytes; \
209 __entry->tx_bytes = sinfo->tx_bytes; \
210 __entry->rx_packets = sinfo->rx_packets; \
211 __entry->tx_packets = sinfo->tx_packets; \
212 __entry->tx_retries = sinfo->tx_retries; \
213 __entry->tx_failed = sinfo->tx_failed; \
214 __entry->rx_dropped_misc = sinfo->rx_dropped_misc; \
215 __entry->beacon_loss_count = sinfo->beacon_loss_count; \
216 __entry->llid = sinfo->llid; \
217 __entry->plid = sinfo->plid; \
218 __entry->plink_state = sinfo->plink_state; \
219 } while (0)
220
221#define BOOL_TO_STR(bo) (bo) ? "true" : "false"
222
223#define QOS_MAP_ENTRY __field(u8, num_des) \
224 __array(u8, dscp_exception, \
225 2 * IEEE80211_QOS_MAP_MAX_EX) \
226 __array(u8, up, IEEE80211_QOS_MAP_LEN_MIN)
227#define QOS_MAP_ASSIGN(qos_map) \
228 do { \
229 if ((qos_map)) { \
230 __entry->num_des = (qos_map)->num_des; \
231 memcpy(__entry->dscp_exception, \
232 &(qos_map)->dscp_exception, \
233 2 * IEEE80211_QOS_MAP_MAX_EX); \
234 memcpy(__entry->up, &(qos_map)->up, \
235 IEEE80211_QOS_MAP_LEN_MIN); \
236 } else { \
237 __entry->num_des = 0; \
238 memset(__entry->dscp_exception, 0, \
239 2 * IEEE80211_QOS_MAP_MAX_EX); \
240 memset(__entry->up, 0, \
241 IEEE80211_QOS_MAP_LEN_MIN); \
242 } \
243 } while (0)
244
245/*************************************************************
246 * wiphy work traces *
247 *************************************************************/
248
249DECLARE_EVENT_CLASS(wiphy_work_event,
250 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
251 TP_ARGS(wiphy, work),
252 TP_STRUCT__entry(
253 WIPHY_ENTRY
254 __field(void *, instance)
255 __field(void *, func)
256 ),
257 TP_fast_assign(
258 WIPHY_ASSIGN;
259 __entry->instance = work;
260 __entry->func = work ? work->func : NULL;
261 ),
262 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS",
263 WIPHY_PR_ARG, __entry->instance, __entry->func)
264);
265
266DEFINE_EVENT(wiphy_work_event, wiphy_work_queue,
267 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
268 TP_ARGS(wiphy, work)
269);
270
271DEFINE_EVENT(wiphy_work_event, wiphy_work_run,
272 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
273 TP_ARGS(wiphy, work)
274);
275
276DEFINE_EVENT(wiphy_work_event, wiphy_work_cancel,
277 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
278 TP_ARGS(wiphy, work)
279);
280
281DEFINE_EVENT(wiphy_work_event, wiphy_work_flush,
282 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work),
283 TP_ARGS(wiphy, work)
284);
285
286TRACE_EVENT(wiphy_delayed_work_queue,
287 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work,
288 unsigned long delay),
289 TP_ARGS(wiphy, work, delay),
290 TP_STRUCT__entry(
291 WIPHY_ENTRY
292 __field(void *, instance)
293 __field(void *, func)
294 __field(unsigned long, delay)
295 ),
296 TP_fast_assign(
297 WIPHY_ASSIGN;
298 __entry->instance = work;
299 __entry->func = work->func;
300 __entry->delay = delay;
301 ),
302 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS delay=%ld",
303 WIPHY_PR_ARG, __entry->instance, __entry->func,
304 __entry->delay)
305);
306
307TRACE_EVENT(wiphy_hrtimer_work_queue,
308 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work,
309 ktime_t delay),
310 TP_ARGS(wiphy, work, delay),
311 TP_STRUCT__entry(
312 WIPHY_ENTRY
313 __field(void *, instance)
314 __field(void *, func)
315 __field(ktime_t, delay)
316 ),
317 TP_fast_assign(
318 WIPHY_ASSIGN;
319 __entry->instance = work;
320 __entry->func = work->func;
321 __entry->delay = delay;
322 ),
323 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS delay=%llu",
324 WIPHY_PR_ARG, __entry->instance, __entry->func,
325 __entry->delay)
326);
327
328TRACE_EVENT(wiphy_work_worker_start,
329 TP_PROTO(struct wiphy *wiphy),
330 TP_ARGS(wiphy),
331 TP_STRUCT__entry(
332 WIPHY_ENTRY
333 ),
334 TP_fast_assign(
335 WIPHY_ASSIGN;
336 ),
337 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
338);
339
340/*************************************************************
341 * rdev->ops traces *
342 *************************************************************/
343
344TRACE_EVENT(rdev_suspend,
345 TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow),
346 TP_ARGS(wiphy, wow),
347 TP_STRUCT__entry(
348 WIPHY_ENTRY
349 __field(bool, any)
350 __field(bool, disconnect)
351 __field(bool, magic_pkt)
352 __field(bool, gtk_rekey_failure)
353 __field(bool, eap_identity_req)
354 __field(bool, four_way_handshake)
355 __field(bool, rfkill_release)
356 __field(bool, valid_wow)
357 ),
358 TP_fast_assign(
359 WIPHY_ASSIGN;
360 if (wow) {
361 __entry->any = wow->any;
362 __entry->disconnect = wow->disconnect;
363 __entry->magic_pkt = wow->magic_pkt;
364 __entry->gtk_rekey_failure = wow->gtk_rekey_failure;
365 __entry->eap_identity_req = wow->eap_identity_req;
366 __entry->four_way_handshake = wow->four_way_handshake;
367 __entry->rfkill_release = wow->rfkill_release;
368 __entry->valid_wow = true;
369 } else {
370 __entry->valid_wow = false;
371 }
372 ),
373 TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, "
374 "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, "
375 "four way handshake: %d, rfkill release: %d.",
376 WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)",
377 __entry->any, __entry->disconnect, __entry->magic_pkt,
378 __entry->gtk_rekey_failure, __entry->eap_identity_req,
379 __entry->four_way_handshake, __entry->rfkill_release)
380);
381
382TRACE_EVENT(rdev_return_int,
383 TP_PROTO(struct wiphy *wiphy, int ret),
384 TP_ARGS(wiphy, ret),
385 TP_STRUCT__entry(
386 WIPHY_ENTRY
387 __field(int, ret)
388 ),
389 TP_fast_assign(
390 WIPHY_ASSIGN;
391 __entry->ret = ret;
392 ),
393 TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret)
394);
395
396TRACE_EVENT(rdev_scan,
397 TP_PROTO(struct wiphy *wiphy,
398 struct cfg80211_scan_request_int *request),
399 TP_ARGS(wiphy, request),
400 TP_STRUCT__entry(
401 WIPHY_ENTRY
402 ),
403 TP_fast_assign(
404 WIPHY_ASSIGN;
405 ),
406 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
407);
408
409DECLARE_EVENT_CLASS(wiphy_only_evt,
410 TP_PROTO(struct wiphy *wiphy),
411 TP_ARGS(wiphy),
412 TP_STRUCT__entry(
413 WIPHY_ENTRY
414 ),
415 TP_fast_assign(
416 WIPHY_ASSIGN;
417 ),
418 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
419);
420
421DEFINE_EVENT(wiphy_only_evt, rdev_resume,
422 TP_PROTO(struct wiphy *wiphy),
423 TP_ARGS(wiphy)
424);
425
426DEFINE_EVENT(wiphy_only_evt, rdev_return_void,
427 TP_PROTO(struct wiphy *wiphy),
428 TP_ARGS(wiphy)
429);
430
431TRACE_EVENT(rdev_get_antenna,
432 TP_PROTO(struct wiphy *wiphy, int radio_idx),
433 TP_ARGS(wiphy, radio_idx),
434 TP_STRUCT__entry(
435 WIPHY_ENTRY
436 __field(int, radio_idx)
437 ),
438 TP_fast_assign(
439 WIPHY_ASSIGN;
440 __entry->radio_idx = radio_idx;
441 ),
442 TP_printk(WIPHY_PR_FMT ", radio_idx: %d",
443 WIPHY_PR_ARG, __entry->radio_idx)
444);
445
446DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll,
447 TP_PROTO(struct wiphy *wiphy),
448 TP_ARGS(wiphy)
449);
450
451DECLARE_EVENT_CLASS(wiphy_enabled_evt,
452 TP_PROTO(struct wiphy *wiphy, bool enabled),
453 TP_ARGS(wiphy, enabled),
454 TP_STRUCT__entry(
455 WIPHY_ENTRY
456 __field(bool, enabled)
457 ),
458 TP_fast_assign(
459 WIPHY_ASSIGN;
460 __entry->enabled = enabled;
461 ),
462 TP_printk(WIPHY_PR_FMT ", %senabled ",
463 WIPHY_PR_ARG, __entry->enabled ? "" : "not ")
464);
465
466DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup,
467 TP_PROTO(struct wiphy *wiphy, bool enabled),
468 TP_ARGS(wiphy, enabled)
469);
470
471TRACE_EVENT(rdev_add_virtual_intf,
472 TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type),
473 TP_ARGS(wiphy, name, type),
474 TP_STRUCT__entry(
475 WIPHY_ENTRY
476 __string(vir_intf_name, name ? name : "<noname>")
477 __field(enum nl80211_iftype, type)
478 ),
479 TP_fast_assign(
480 WIPHY_ASSIGN;
481 __assign_str(vir_intf_name);
482 __entry->type = type;
483 ),
484 TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d",
485 WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type)
486);
487
488DECLARE_EVENT_CLASS(wiphy_wdev_evt,
489 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
490 TP_ARGS(wiphy, wdev),
491 TP_STRUCT__entry(
492 WIPHY_ENTRY
493 WDEV_ENTRY
494 ),
495 TP_fast_assign(
496 WIPHY_ASSIGN;
497 WDEV_ASSIGN;
498 ),
499 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
500);
501
502DECLARE_EVENT_CLASS(wiphy_wdev_cookie_evt,
503 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
504 TP_ARGS(wiphy, wdev, cookie),
505 TP_STRUCT__entry(
506 WIPHY_ENTRY
507 WDEV_ENTRY
508 __field(u64, cookie)
509 ),
510 TP_fast_assign(
511 WIPHY_ASSIGN;
512 WDEV_ASSIGN;
513 __entry->cookie = cookie;
514 ),
515 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %lld",
516 WIPHY_PR_ARG, WDEV_PR_ARG,
517 (unsigned long long)__entry->cookie)
518);
519
520DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev,
521 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
522 TP_ARGS(wiphy, wdev)
523);
524
525DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf,
526 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
527 TP_ARGS(wiphy, wdev)
528);
529
530TRACE_EVENT(rdev_change_virtual_intf,
531 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
532 enum nl80211_iftype type),
533 TP_ARGS(wiphy, netdev, type),
534 TP_STRUCT__entry(
535 WIPHY_ENTRY
536 NETDEV_ENTRY
537 __field(enum nl80211_iftype, type)
538 ),
539 TP_fast_assign(
540 WIPHY_ASSIGN;
541 NETDEV_ASSIGN;
542 __entry->type = type;
543 ),
544 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", type: %d",
545 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type)
546);
547
548DECLARE_EVENT_CLASS(key_handle,
549 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
550 u8 key_index, bool pairwise, const u8 *mac_addr),
551 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr),
552 TP_STRUCT__entry(
553 WIPHY_ENTRY
554 NETDEV_ENTRY
555 MAC_ENTRY(mac_addr)
556 __field(int, link_id)
557 __field(u8, key_index)
558 __field(bool, pairwise)
559 ),
560 TP_fast_assign(
561 WIPHY_ASSIGN;
562 NETDEV_ASSIGN;
563 MAC_ASSIGN(mac_addr, mac_addr);
564 __entry->link_id = link_id;
565 __entry->key_index = key_index;
566 __entry->pairwise = pairwise;
567 ),
568 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
569 "key_index: %u, pairwise: %s, mac addr: %pM",
570 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
571 __entry->key_index, BOOL_TO_STR(__entry->pairwise),
572 __entry->mac_addr)
573);
574
575DEFINE_EVENT(key_handle, rdev_get_key,
576 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
577 u8 key_index, bool pairwise, const u8 *mac_addr),
578 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr)
579);
580
581DEFINE_EVENT(key_handle, rdev_del_key,
582 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
583 u8 key_index, bool pairwise, const u8 *mac_addr),
584 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr)
585);
586
587TRACE_EVENT(rdev_add_key,
588 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
589 u8 key_index, bool pairwise, const u8 *mac_addr, u8 mode),
590 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr, mode),
591 TP_STRUCT__entry(
592 WIPHY_ENTRY
593 NETDEV_ENTRY
594 MAC_ENTRY(mac_addr)
595 __field(int, link_id)
596 __field(u8, key_index)
597 __field(bool, pairwise)
598 __field(u8, mode)
599 ),
600 TP_fast_assign(
601 WIPHY_ASSIGN;
602 NETDEV_ASSIGN;
603 MAC_ASSIGN(mac_addr, mac_addr);
604 __entry->link_id = link_id;
605 __entry->key_index = key_index;
606 __entry->pairwise = pairwise;
607 __entry->mode = mode;
608 ),
609 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
610 "key_index: %u, mode: %u, pairwise: %s, "
611 "mac addr: %pM",
612 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
613 __entry->key_index, __entry->mode,
614 BOOL_TO_STR(__entry->pairwise), __entry->mac_addr)
615);
616
617TRACE_EVENT(rdev_set_default_key,
618 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
619 u8 key_index, bool unicast, bool multicast),
620 TP_ARGS(wiphy, netdev, link_id, key_index, unicast, multicast),
621 TP_STRUCT__entry(
622 WIPHY_ENTRY
623 NETDEV_ENTRY
624 __field(int, link_id)
625 __field(u8, key_index)
626 __field(bool, unicast)
627 __field(bool, multicast)
628 ),
629 TP_fast_assign(
630 WIPHY_ASSIGN;
631 NETDEV_ASSIGN;
632 __entry->link_id = link_id;
633 __entry->key_index = key_index;
634 __entry->unicast = unicast;
635 __entry->multicast = multicast;
636 ),
637 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
638 "key index: %u, unicast: %s, multicast: %s",
639 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
640 __entry->key_index, BOOL_TO_STR(__entry->unicast),
641 BOOL_TO_STR(__entry->multicast))
642);
643
644TRACE_EVENT(rdev_set_default_mgmt_key,
645 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
646 u8 key_index),
647 TP_ARGS(wiphy, netdev, link_id, key_index),
648 TP_STRUCT__entry(
649 WIPHY_ENTRY
650 NETDEV_ENTRY
651 __field(int, link_id)
652 __field(u8, key_index)
653 ),
654 TP_fast_assign(
655 WIPHY_ASSIGN;
656 NETDEV_ASSIGN;
657 __entry->link_id = link_id;
658 __entry->key_index = key_index;
659 ),
660 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
661 "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG,
662 __entry->link_id, __entry->key_index)
663);
664
665TRACE_EVENT(rdev_set_default_beacon_key,
666 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id,
667 u8 key_index),
668 TP_ARGS(wiphy, netdev, link_id, key_index),
669 TP_STRUCT__entry(
670 WIPHY_ENTRY
671 NETDEV_ENTRY
672 __field(int, link_id)
673 __field(u8, key_index)
674 ),
675 TP_fast_assign(
676 WIPHY_ASSIGN;
677 NETDEV_ASSIGN;
678 __entry->link_id = link_id;
679 __entry->key_index = key_index;
680 ),
681 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, "
682 "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG,
683 __entry->link_id, __entry->key_index)
684);
685
686TRACE_EVENT(rdev_start_ap,
687 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
688 struct cfg80211_ap_settings *settings),
689 TP_ARGS(wiphy, netdev, settings),
690 TP_STRUCT__entry(
691 WIPHY_ENTRY
692 NETDEV_ENTRY
693 CHAN_DEF_ENTRY
694 __field(int, beacon_interval)
695 __field(int, dtim_period)
696 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
697 __field(enum nl80211_hidden_ssid, hidden_ssid)
698 __field(u32, wpa_ver)
699 __field(bool, privacy)
700 __field(enum nl80211_auth_type, auth_type)
701 __field(int, inactivity_timeout)
702 __field(unsigned int, link_id)
703 ),
704 TP_fast_assign(
705 WIPHY_ASSIGN;
706 NETDEV_ASSIGN;
707 CHAN_DEF_ASSIGN(&settings->chandef);
708 __entry->beacon_interval = settings->beacon_interval;
709 __entry->dtim_period = settings->dtim_period;
710 __entry->hidden_ssid = settings->hidden_ssid;
711 __entry->wpa_ver = settings->crypto.wpa_versions;
712 __entry->privacy = settings->privacy;
713 __entry->auth_type = settings->auth_type;
714 __entry->inactivity_timeout = settings->inactivity_timeout;
715 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
716 memcpy(__entry->ssid, settings->ssid, settings->ssid_len);
717 __entry->link_id = settings->beacon.link_id;
718 ),
719 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", AP settings - ssid: %s, "
720 CHAN_DEF_PR_FMT ", beacon interval: %d, dtim period: %d, "
721 "hidden ssid: %d, wpa versions: %u, privacy: %s, "
722 "auth type: %d, inactivity timeout: %d, link_id: %d",
723 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_DEF_PR_ARG,
724 __entry->beacon_interval, __entry->dtim_period,
725 __entry->hidden_ssid, __entry->wpa_ver,
726 BOOL_TO_STR(__entry->privacy), __entry->auth_type,
727 __entry->inactivity_timeout, __entry->link_id)
728);
729
730TRACE_EVENT(rdev_change_beacon,
731 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
732 struct cfg80211_ap_update *info),
733 TP_ARGS(wiphy, netdev, info),
734 TP_STRUCT__entry(
735 WIPHY_ENTRY
736 NETDEV_ENTRY
737 __field(int, link_id)
738 __dynamic_array(u8, head, info->beacon.head_len)
739 __dynamic_array(u8, tail, info->beacon.tail_len)
740 __dynamic_array(u8, beacon_ies, info->beacon.beacon_ies_len)
741 __dynamic_array(u8, proberesp_ies, info->beacon.proberesp_ies_len)
742 __dynamic_array(u8, assocresp_ies, info->beacon.assocresp_ies_len)
743 __dynamic_array(u8, probe_resp, info->beacon.probe_resp_len)
744 ),
745 TP_fast_assign(
746 WIPHY_ASSIGN;
747 NETDEV_ASSIGN;
748 __entry->link_id = info->beacon.link_id;
749 if (info->beacon.head)
750 memcpy(__get_dynamic_array(head),
751 info->beacon.head,
752 info->beacon.head_len);
753 if (info->beacon.tail)
754 memcpy(__get_dynamic_array(tail),
755 info->beacon.tail,
756 info->beacon.tail_len);
757 if (info->beacon.beacon_ies)
758 memcpy(__get_dynamic_array(beacon_ies),
759 info->beacon.beacon_ies,
760 info->beacon.beacon_ies_len);
761 if (info->beacon.proberesp_ies)
762 memcpy(__get_dynamic_array(proberesp_ies),
763 info->beacon.proberesp_ies,
764 info->beacon.proberesp_ies_len);
765 if (info->beacon.assocresp_ies)
766 memcpy(__get_dynamic_array(assocresp_ies),
767 info->beacon.assocresp_ies,
768 info->beacon.assocresp_ies_len);
769 if (info->beacon.probe_resp)
770 memcpy(__get_dynamic_array(probe_resp),
771 info->beacon.probe_resp,
772 info->beacon.probe_resp_len);
773 ),
774 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id:%d",
775 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
776);
777
778TRACE_EVENT(rdev_stop_ap,
779 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
780 unsigned int link_id),
781 TP_ARGS(wiphy, netdev, link_id),
782 TP_STRUCT__entry(
783 WIPHY_ENTRY
784 NETDEV_ENTRY
785 __field(unsigned int, link_id)
786 ),
787 TP_fast_assign(
788 WIPHY_ASSIGN;
789 NETDEV_ASSIGN;
790 __entry->link_id = link_id;
791 ),
792 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d",
793 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
794);
795
796DECLARE_EVENT_CLASS(wiphy_netdev_evt,
797 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
798 TP_ARGS(wiphy, netdev),
799 TP_STRUCT__entry(
800 WIPHY_ENTRY
801 NETDEV_ENTRY
802 ),
803 TP_fast_assign(
804 WIPHY_ASSIGN;
805 NETDEV_ASSIGN;
806 ),
807 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
808);
809
810DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data,
811 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
812 TP_ARGS(wiphy, netdev)
813);
814
815DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config,
816 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
817 TP_ARGS(wiphy, netdev)
818);
819
820DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh,
821 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
822 TP_ARGS(wiphy, netdev)
823);
824
825DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss,
826 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
827 TP_ARGS(wiphy, netdev)
828);
829
830DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb,
831 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
832 TP_ARGS(wiphy, netdev)
833);
834
835DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa,
836 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
837 TP_ARGS(wiphy, netdev)
838);
839
840TRACE_EVENT(rdev_end_cac,
841 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
842 unsigned int link_id),
843 TP_ARGS(wiphy, netdev, link_id),
844 TP_STRUCT__entry(
845 WIPHY_ENTRY
846 NETDEV_ENTRY
847 __field(unsigned int, link_id)
848 ),
849 TP_fast_assign(
850 WIPHY_ASSIGN;
851 NETDEV_ASSIGN;
852 __entry->link_id = link_id;
853 ),
854 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d",
855 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id)
856);
857
858DECLARE_EVENT_CLASS(station_add_change,
859 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
860 struct station_parameters *params),
861 TP_ARGS(wiphy, netdev, mac, params),
862 TP_STRUCT__entry(
863 WIPHY_ENTRY
864 NETDEV_ENTRY
865 MAC_ENTRY(sta_mac)
866 __field(u32, sta_flags_mask)
867 __field(u32, sta_flags_set)
868 __field(u32, sta_modify_mask)
869 __field(int, listen_interval)
870 __field(u16, capability)
871 __field(u16, aid)
872 __field(u8, plink_action)
873 __field(u8, plink_state)
874 __field(u8, uapsd_queues)
875 __field(u8, max_sp)
876 __field(u8, opmode_notif)
877 __field(bool, opmode_notif_used)
878 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
879 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap))
880 __array(char, vlan, IFNAMSIZ)
881 __dynamic_array(u8, supported_rates,
882 params->link_sta_params.supported_rates_len)
883 __dynamic_array(u8, ext_capab, params->ext_capab_len)
884 __dynamic_array(u8, supported_channels,
885 params->supported_channels_len)
886 __dynamic_array(u8, supported_oper_classes,
887 params->supported_oper_classes_len)
888 ),
889 TP_fast_assign(
890 WIPHY_ASSIGN;
891 NETDEV_ASSIGN;
892 MAC_ASSIGN(sta_mac, mac);
893 __entry->sta_flags_mask = params->sta_flags_mask;
894 __entry->sta_flags_set = params->sta_flags_set;
895 __entry->sta_modify_mask = params->sta_modify_mask;
896 __entry->listen_interval = params->listen_interval;
897 __entry->aid = params->aid;
898 __entry->plink_action = params->plink_action;
899 __entry->plink_state = params->plink_state;
900 __entry->uapsd_queues = params->uapsd_queues;
901 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
902 if (params->link_sta_params.ht_capa)
903 memcpy(__entry->ht_capa,
904 params->link_sta_params.ht_capa,
905 sizeof(struct ieee80211_ht_cap));
906 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap));
907 if (params->link_sta_params.vht_capa)
908 memcpy(__entry->vht_capa,
909 params->link_sta_params.vht_capa,
910 sizeof(struct ieee80211_vht_cap));
911 memset(__entry->vlan, 0, sizeof(__entry->vlan));
912 if (params->vlan)
913 memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ);
914 if (params->link_sta_params.supported_rates &&
915 params->link_sta_params.supported_rates_len)
916 memcpy(__get_dynamic_array(supported_rates),
917 params->link_sta_params.supported_rates,
918 params->link_sta_params.supported_rates_len);
919 if (params->ext_capab && params->ext_capab_len)
920 memcpy(__get_dynamic_array(ext_capab),
921 params->ext_capab,
922 params->ext_capab_len);
923 if (params->supported_channels &&
924 params->supported_channels_len)
925 memcpy(__get_dynamic_array(supported_channels),
926 params->supported_channels,
927 params->supported_channels_len);
928 if (params->supported_oper_classes &&
929 params->supported_oper_classes_len)
930 memcpy(__get_dynamic_array(supported_oper_classes),
931 params->supported_oper_classes,
932 params->supported_oper_classes_len);
933 __entry->max_sp = params->max_sp;
934 __entry->capability = params->capability;
935 __entry->opmode_notif = params->link_sta_params.opmode_notif;
936 __entry->opmode_notif_used =
937 params->link_sta_params.opmode_notif_used;
938 ),
939 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
940 ", station flags mask: 0x%x, station flags set: 0x%x, "
941 "station modify mask: 0x%x, listen interval: %d, aid: %u, "
942 "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s",
943 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
944 __entry->sta_flags_mask, __entry->sta_flags_set,
945 __entry->sta_modify_mask, __entry->listen_interval,
946 __entry->aid, __entry->plink_action, __entry->plink_state,
947 __entry->uapsd_queues, __entry->vlan)
948);
949
950DEFINE_EVENT(station_add_change, rdev_add_station,
951 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
952 struct station_parameters *params),
953 TP_ARGS(wiphy, netdev, mac, params)
954);
955
956DEFINE_EVENT(station_add_change, rdev_change_station,
957 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
958 struct station_parameters *params),
959 TP_ARGS(wiphy, netdev, mac, params)
960);
961
962DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt,
963 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
964 TP_ARGS(wiphy, netdev, mac),
965 TP_STRUCT__entry(
966 WIPHY_ENTRY
967 NETDEV_ENTRY
968 MAC_ENTRY(sta_mac)
969 ),
970 TP_fast_assign(
971 WIPHY_ASSIGN;
972 NETDEV_ASSIGN;
973 MAC_ASSIGN(sta_mac, mac);
974 ),
975 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: %pM",
976 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac)
977);
978
979DECLARE_EVENT_CLASS(station_del,
980 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
981 struct station_del_parameters *params),
982 TP_ARGS(wiphy, netdev, params),
983 TP_STRUCT__entry(
984 WIPHY_ENTRY
985 NETDEV_ENTRY
986 MAC_ENTRY(sta_mac)
987 __field(u8, subtype)
988 __field(u16, reason_code)
989 __field(int, link_id)
990 ),
991 TP_fast_assign(
992 WIPHY_ASSIGN;
993 NETDEV_ASSIGN;
994 MAC_ASSIGN(sta_mac, params->mac);
995 __entry->subtype = params->subtype;
996 __entry->reason_code = params->reason_code;
997 __entry->link_id = params->link_id;
998 ),
999 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
1000 ", subtype: %u, reason_code: %u, link_id: %d",
1001 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
1002 __entry->subtype, __entry->reason_code,
1003 __entry->link_id)
1004);
1005
1006DEFINE_EVENT(station_del, rdev_del_station,
1007 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1008 struct station_del_parameters *params),
1009 TP_ARGS(wiphy, netdev, params)
1010);
1011
1012DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station,
1013 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
1014 TP_ARGS(wiphy, netdev, mac)
1015);
1016
1017DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath,
1018 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
1019 TP_ARGS(wiphy, netdev, mac)
1020);
1021
1022TRACE_EVENT(rdev_dump_station,
1023 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
1024 u8 *mac),
1025 TP_ARGS(wiphy, netdev, _idx, mac),
1026 TP_STRUCT__entry(
1027 WIPHY_ENTRY
1028 NETDEV_ENTRY
1029 MAC_ENTRY(sta_mac)
1030 __field(int, idx)
1031 ),
1032 TP_fast_assign(
1033 WIPHY_ASSIGN;
1034 NETDEV_ASSIGN;
1035 MAC_ASSIGN(sta_mac, mac);
1036 __entry->idx = _idx;
1037 ),
1038 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM, idx: %d",
1039 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac,
1040 __entry->idx)
1041);
1042
1043TRACE_EVENT(rdev_return_int_station_info,
1044 TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo),
1045 TP_ARGS(wiphy, ret, sinfo),
1046 TP_STRUCT__entry(
1047 WIPHY_ENTRY
1048 __field(int, ret)
1049 SINFO_ENTRY
1050 ),
1051 TP_fast_assign(
1052 WIPHY_ASSIGN;
1053 __entry->ret = ret;
1054 SINFO_ASSIGN;
1055 ),
1056 TP_printk(WIPHY_PR_FMT ", returned %d" ,
1057 WIPHY_PR_ARG, __entry->ret)
1058);
1059
1060DECLARE_EVENT_CLASS(mpath_evt,
1061 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
1062 u8 *next_hop),
1063 TP_ARGS(wiphy, netdev, dst, next_hop),
1064 TP_STRUCT__entry(
1065 WIPHY_ENTRY
1066 NETDEV_ENTRY
1067 MAC_ENTRY(dst)
1068 MAC_ENTRY(next_hop)
1069 ),
1070 TP_fast_assign(
1071 WIPHY_ASSIGN;
1072 NETDEV_ASSIGN;
1073 MAC_ASSIGN(dst, dst);
1074 MAC_ASSIGN(next_hop, next_hop);
1075 ),
1076 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM, next hop: %pM",
1077 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dst,
1078 __entry->next_hop)
1079);
1080
1081DEFINE_EVENT(mpath_evt, rdev_add_mpath,
1082 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
1083 u8 *next_hop),
1084 TP_ARGS(wiphy, netdev, dst, next_hop)
1085);
1086
1087DEFINE_EVENT(mpath_evt, rdev_change_mpath,
1088 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
1089 u8 *next_hop),
1090 TP_ARGS(wiphy, netdev, dst, next_hop)
1091);
1092
1093DEFINE_EVENT(mpath_evt, rdev_get_mpath,
1094 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
1095 u8 *next_hop),
1096 TP_ARGS(wiphy, netdev, dst, next_hop)
1097);
1098
1099TRACE_EVENT(rdev_dump_mpath,
1100 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
1101 u8 *dst, u8 *next_hop),
1102 TP_ARGS(wiphy, netdev, _idx, dst, next_hop),
1103 TP_STRUCT__entry(
1104 WIPHY_ENTRY
1105 NETDEV_ENTRY
1106 MAC_ENTRY(dst)
1107 MAC_ENTRY(next_hop)
1108 __field(int, idx)
1109 ),
1110 TP_fast_assign(
1111 WIPHY_ASSIGN;
1112 NETDEV_ASSIGN;
1113 MAC_ASSIGN(dst, dst);
1114 MAC_ASSIGN(next_hop, next_hop);
1115 __entry->idx = _idx;
1116 ),
1117 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, next hop: %pM",
1118 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,
1119 __entry->next_hop)
1120);
1121
1122TRACE_EVENT(rdev_get_mpp,
1123 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1124 u8 *dst, u8 *mpp),
1125 TP_ARGS(wiphy, netdev, dst, mpp),
1126 TP_STRUCT__entry(
1127 WIPHY_ENTRY
1128 NETDEV_ENTRY
1129 MAC_ENTRY(dst)
1130 MAC_ENTRY(mpp)
1131 ),
1132 TP_fast_assign(
1133 WIPHY_ASSIGN;
1134 NETDEV_ASSIGN;
1135 MAC_ASSIGN(dst, dst);
1136 MAC_ASSIGN(mpp, mpp);
1137 ),
1138 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM"
1139 ", mpp: %pM", WIPHY_PR_ARG, NETDEV_PR_ARG,
1140 __entry->dst, __entry->mpp)
1141);
1142
1143TRACE_EVENT(rdev_dump_mpp,
1144 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx,
1145 u8 *dst, u8 *mpp),
1146 TP_ARGS(wiphy, netdev, _idx, dst, mpp),
1147 TP_STRUCT__entry(
1148 WIPHY_ENTRY
1149 NETDEV_ENTRY
1150 MAC_ENTRY(dst)
1151 MAC_ENTRY(mpp)
1152 __field(int, idx)
1153 ),
1154 TP_fast_assign(
1155 WIPHY_ASSIGN;
1156 NETDEV_ASSIGN;
1157 MAC_ASSIGN(dst, dst);
1158 MAC_ASSIGN(mpp, mpp);
1159 __entry->idx = _idx;
1160 ),
1161 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, mpp: %pM",
1162 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst,
1163 __entry->mpp)
1164);
1165
1166TRACE_EVENT(rdev_return_int_mpath_info,
1167 TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo),
1168 TP_ARGS(wiphy, ret, pinfo),
1169 TP_STRUCT__entry(
1170 WIPHY_ENTRY
1171 __field(int, ret)
1172 __field(int, generation)
1173 __field(u32, filled)
1174 __field(u32, frame_qlen)
1175 __field(u32, sn)
1176 __field(u32, metric)
1177 __field(u32, exptime)
1178 __field(u32, discovery_timeout)
1179 __field(u8, discovery_retries)
1180 __field(u8, flags)
1181 ),
1182 TP_fast_assign(
1183 WIPHY_ASSIGN;
1184 __entry->ret = ret;
1185 __entry->generation = pinfo->generation;
1186 __entry->filled = pinfo->filled;
1187 __entry->frame_qlen = pinfo->frame_qlen;
1188 __entry->sn = pinfo->sn;
1189 __entry->metric = pinfo->metric;
1190 __entry->exptime = pinfo->exptime;
1191 __entry->discovery_timeout = pinfo->discovery_timeout;
1192 __entry->discovery_retries = pinfo->discovery_retries;
1193 __entry->flags = pinfo->flags;
1194 ),
1195 TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, "
1196 "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u,"
1197 " discovery timeout: %u, discovery retries: %u, flags: 0x%x",
1198 WIPHY_PR_ARG, __entry->ret, __entry->generation,
1199 __entry->filled, __entry->frame_qlen, __entry->sn,
1200 __entry->metric, __entry->exptime, __entry->discovery_timeout,
1201 __entry->discovery_retries, __entry->flags)
1202);
1203
1204TRACE_EVENT(rdev_return_int_mesh_config,
1205 TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf),
1206 TP_ARGS(wiphy, ret, conf),
1207 TP_STRUCT__entry(
1208 WIPHY_ENTRY
1209 MESH_CFG_ENTRY
1210 __field(int, ret)
1211 ),
1212 TP_fast_assign(
1213 WIPHY_ASSIGN;
1214 MESH_CFG_ASSIGN;
1215 __entry->ret = ret;
1216 ),
1217 TP_printk(WIPHY_PR_FMT ", returned: %d",
1218 WIPHY_PR_ARG, __entry->ret)
1219);
1220
1221TRACE_EVENT(rdev_update_mesh_config,
1222 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask,
1223 const struct mesh_config *conf),
1224 TP_ARGS(wiphy, netdev, mask, conf),
1225 TP_STRUCT__entry(
1226 WIPHY_ENTRY
1227 NETDEV_ENTRY
1228 MESH_CFG_ENTRY
1229 __field(u32, mask)
1230 ),
1231 TP_fast_assign(
1232 WIPHY_ASSIGN;
1233 NETDEV_ASSIGN;
1234 MESH_CFG_ASSIGN;
1235 __entry->mask = mask;
1236 ),
1237 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u",
1238 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask)
1239);
1240
1241TRACE_EVENT(rdev_join_mesh,
1242 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1243 const struct mesh_config *conf,
1244 const struct mesh_setup *setup),
1245 TP_ARGS(wiphy, netdev, conf, setup),
1246 TP_STRUCT__entry(
1247 WIPHY_ENTRY
1248 NETDEV_ENTRY
1249 MESH_CFG_ENTRY
1250 ),
1251 TP_fast_assign(
1252 WIPHY_ASSIGN;
1253 NETDEV_ASSIGN;
1254 MESH_CFG_ASSIGN;
1255 ),
1256 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
1257 WIPHY_PR_ARG, NETDEV_PR_ARG)
1258);
1259
1260TRACE_EVENT(rdev_change_bss,
1261 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1262 struct bss_parameters *params),
1263 TP_ARGS(wiphy, netdev, params),
1264 TP_STRUCT__entry(
1265 WIPHY_ENTRY
1266 NETDEV_ENTRY
1267 __field(int, use_cts_prot)
1268 __field(int, use_short_preamble)
1269 __field(int, use_short_slot_time)
1270 __field(int, ap_isolate)
1271 __field(int, ht_opmode)
1272 ),
1273 TP_fast_assign(
1274 WIPHY_ASSIGN;
1275 NETDEV_ASSIGN;
1276 __entry->use_cts_prot = params->use_cts_prot;
1277 __entry->use_short_preamble = params->use_short_preamble;
1278 __entry->use_short_slot_time = params->use_short_slot_time;
1279 __entry->ap_isolate = params->ap_isolate;
1280 __entry->ht_opmode = params->ht_opmode;
1281 ),
1282 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, "
1283 "use short preamble: %d, use short slot time: %d, "
1284 "ap isolate: %d, ht opmode: %d",
1285 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot,
1286 __entry->use_short_preamble, __entry->use_short_slot_time,
1287 __entry->ap_isolate, __entry->ht_opmode)
1288);
1289
1290TRACE_EVENT(rdev_inform_bss,
1291 TP_PROTO(struct wiphy *wiphy, struct cfg80211_bss *bss),
1292 TP_ARGS(wiphy, bss),
1293 TP_STRUCT__entry(
1294 WIPHY_ENTRY
1295 MAC_ENTRY(bssid)
1296 CHAN_ENTRY
1297 ),
1298 TP_fast_assign(
1299 WIPHY_ASSIGN;
1300 MAC_ASSIGN(bssid, bss->bssid);
1301 CHAN_ASSIGN(bss->channel);
1302 ),
1303 TP_printk(WIPHY_PR_FMT ", %pM, " CHAN_PR_FMT,
1304 WIPHY_PR_ARG, __entry->bssid, CHAN_PR_ARG)
1305);
1306
1307TRACE_EVENT(rdev_set_txq_params,
1308 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1309 struct ieee80211_txq_params *params),
1310 TP_ARGS(wiphy, netdev, params),
1311 TP_STRUCT__entry(
1312 WIPHY_ENTRY
1313 NETDEV_ENTRY
1314 __field(enum nl80211_ac, ac)
1315 __field(u16, txop)
1316 __field(u16, cwmin)
1317 __field(u16, cwmax)
1318 __field(u8, aifs)
1319 ),
1320 TP_fast_assign(
1321 WIPHY_ASSIGN;
1322 NETDEV_ASSIGN;
1323 __entry->ac = params->ac;
1324 __entry->txop = params->txop;
1325 __entry->cwmin = params->cwmin;
1326 __entry->cwmax = params->cwmax;
1327 __entry->aifs = params->aifs;
1328 ),
1329 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u",
1330 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop,
1331 __entry->cwmin, __entry->cwmax, __entry->aifs)
1332);
1333
1334TRACE_EVENT(rdev_libertas_set_mesh_channel,
1335 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1336 struct ieee80211_channel *chan),
1337 TP_ARGS(wiphy, netdev, chan),
1338 TP_STRUCT__entry(
1339 WIPHY_ENTRY
1340 NETDEV_ENTRY
1341 CHAN_ENTRY
1342 ),
1343 TP_fast_assign(
1344 WIPHY_ASSIGN;
1345 NETDEV_ASSIGN;
1346 CHAN_ASSIGN(chan);
1347 ),
1348 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG,
1349 NETDEV_PR_ARG, CHAN_PR_ARG)
1350);
1351
1352TRACE_EVENT(rdev_set_monitor_channel,
1353 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1354 struct cfg80211_chan_def *chandef),
1355 TP_ARGS(wiphy, netdev, chandef),
1356 TP_STRUCT__entry(
1357 WIPHY_ENTRY
1358 NETDEV_ENTRY
1359 CHAN_DEF_ENTRY
1360 ),
1361 TP_fast_assign(
1362 WIPHY_ASSIGN;
1363 NETDEV_ASSIGN;
1364 CHAN_DEF_ASSIGN(chandef);
1365 ),
1366 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
1367 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
1368);
1369
1370TRACE_EVENT(rdev_auth,
1371 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1372 struct cfg80211_auth_request *req),
1373 TP_ARGS(wiphy, netdev, req),
1374 TP_STRUCT__entry(
1375 WIPHY_ENTRY
1376 NETDEV_ENTRY
1377 MAC_ENTRY(bssid)
1378 __field(enum nl80211_auth_type, auth_type)
1379 ),
1380 TP_fast_assign(
1381 WIPHY_ASSIGN;
1382 NETDEV_ASSIGN;
1383 if (req->bss)
1384 MAC_ASSIGN(bssid, req->bss->bssid);
1385 else
1386 eth_zero_addr(__entry->bssid);
1387 __entry->auth_type = req->auth_type;
1388 ),
1389 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: %pM",
1390 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type,
1391 __entry->bssid)
1392);
1393
1394TRACE_EVENT(rdev_assoc,
1395 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1396 struct cfg80211_assoc_request *req),
1397 TP_ARGS(wiphy, netdev, req),
1398 TP_STRUCT__entry(
1399 WIPHY_ENTRY
1400 NETDEV_ENTRY
1401 MAC_ENTRY(bssid)
1402 MAC_ENTRY(prev_bssid)
1403 __field(bool, use_mfp)
1404 __field(u32, flags)
1405 __dynamic_array(u8, elements, req->ie_len)
1406 __array(u8, ht_capa, sizeof(struct ieee80211_ht_cap))
1407 __array(u8, ht_capa_mask, sizeof(struct ieee80211_ht_cap))
1408 __array(u8, vht_capa, sizeof(struct ieee80211_vht_cap))
1409 __array(u8, vht_capa_mask, sizeof(struct ieee80211_vht_cap))
1410 __dynamic_array(u8, fils_kek, req->fils_kek_len)
1411 __dynamic_array(u8, fils_nonces,
1412 req->fils_nonces ? 2 * FILS_NONCE_LEN : 0)
1413 __field(u16, ext_mld_capa_ops)
1414 ),
1415 TP_fast_assign(
1416 WIPHY_ASSIGN;
1417 NETDEV_ASSIGN;
1418 if (req->bss)
1419 MAC_ASSIGN(bssid, req->bss->bssid);
1420 else
1421 eth_zero_addr(__entry->bssid);
1422 MAC_ASSIGN(prev_bssid, req->prev_bssid);
1423 __entry->use_mfp = req->use_mfp;
1424 __entry->flags = req->flags;
1425 if (req->ie)
1426 memcpy(__get_dynamic_array(elements),
1427 req->ie, req->ie_len);
1428 memcpy(__entry->ht_capa, &req->ht_capa, sizeof(req->ht_capa));
1429 memcpy(__entry->ht_capa_mask, &req->ht_capa_mask,
1430 sizeof(req->ht_capa_mask));
1431 memcpy(__entry->vht_capa, &req->vht_capa, sizeof(req->vht_capa));
1432 memcpy(__entry->vht_capa_mask, &req->vht_capa_mask,
1433 sizeof(req->vht_capa_mask));
1434 if (req->fils_kek)
1435 memcpy(__get_dynamic_array(fils_kek),
1436 req->fils_kek, req->fils_kek_len);
1437 if (req->fils_nonces)
1438 memcpy(__get_dynamic_array(fils_nonces),
1439 req->fils_nonces, 2 * FILS_NONCE_LEN);
1440 __entry->ext_mld_capa_ops = req->ext_mld_capa_ops;
1441 ),
1442 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
1443 ", previous bssid: %pM, use mfp: %s, flags: 0x%x",
1444 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
1445 __entry->prev_bssid, BOOL_TO_STR(__entry->use_mfp),
1446 __entry->flags)
1447);
1448
1449TRACE_EVENT(rdev_deauth,
1450 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1451 struct cfg80211_deauth_request *req),
1452 TP_ARGS(wiphy, netdev, req),
1453 TP_STRUCT__entry(
1454 WIPHY_ENTRY
1455 NETDEV_ENTRY
1456 MAC_ENTRY(bssid)
1457 __field(u16, reason_code)
1458 __field(bool, local_state_change)
1459 ),
1460 TP_fast_assign(
1461 WIPHY_ASSIGN;
1462 NETDEV_ASSIGN;
1463 MAC_ASSIGN(bssid, req->bssid);
1464 __entry->reason_code = req->reason_code;
1465 __entry->local_state_change = req->local_state_change;
1466 ),
1467 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, reason: %u, local_state_change:%d",
1468 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
1469 __entry->reason_code, __entry->local_state_change)
1470);
1471
1472TRACE_EVENT(rdev_disassoc,
1473 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1474 struct cfg80211_disassoc_request *req),
1475 TP_ARGS(wiphy, netdev, req),
1476 TP_STRUCT__entry(
1477 WIPHY_ENTRY
1478 NETDEV_ENTRY
1479 MAC_ENTRY(bssid)
1480 __field(u16, reason_code)
1481 __field(bool, local_state_change)
1482 ),
1483 TP_fast_assign(
1484 WIPHY_ASSIGN;
1485 NETDEV_ASSIGN;
1486 MAC_ASSIGN(bssid, req->ap_addr);
1487 __entry->reason_code = req->reason_code;
1488 __entry->local_state_change = req->local_state_change;
1489 ),
1490 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
1491 ", reason: %u, local state change: %s",
1492 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
1493 __entry->reason_code,
1494 BOOL_TO_STR(__entry->local_state_change))
1495);
1496
1497TRACE_EVENT(rdev_mgmt_tx_cancel_wait,
1498 TP_PROTO(struct wiphy *wiphy,
1499 struct wireless_dev *wdev, u64 cookie),
1500 TP_ARGS(wiphy, wdev, cookie),
1501 TP_STRUCT__entry(
1502 WIPHY_ENTRY
1503 WDEV_ENTRY
1504 __field(u64, cookie)
1505 ),
1506 TP_fast_assign(
1507 WIPHY_ASSIGN;
1508 WDEV_ASSIGN;
1509 __entry->cookie = cookie;
1510 ),
1511 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ",
1512 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
1513);
1514
1515TRACE_EVENT(rdev_set_power_mgmt,
1516 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1517 bool enabled, int timeout),
1518 TP_ARGS(wiphy, netdev, enabled, timeout),
1519 TP_STRUCT__entry(
1520 WIPHY_ENTRY
1521 NETDEV_ENTRY
1522 __field(bool, enabled)
1523 __field(int, timeout)
1524 ),
1525 TP_fast_assign(
1526 WIPHY_ASSIGN;
1527 NETDEV_ASSIGN;
1528 __entry->enabled = enabled;
1529 __entry->timeout = timeout;
1530 ),
1531 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ",
1532 WIPHY_PR_ARG, NETDEV_PR_ARG,
1533 __entry->enabled ? "" : "not ", __entry->timeout)
1534);
1535
1536TRACE_EVENT(rdev_connect,
1537 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1538 struct cfg80211_connect_params *sme),
1539 TP_ARGS(wiphy, netdev, sme),
1540 TP_STRUCT__entry(
1541 WIPHY_ENTRY
1542 NETDEV_ENTRY
1543 MAC_ENTRY(bssid)
1544 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1545 __field(enum nl80211_auth_type, auth_type)
1546 __field(bool, privacy)
1547 __field(u32, wpa_versions)
1548 __field(u32, flags)
1549 MAC_ENTRY(prev_bssid)
1550 ),
1551 TP_fast_assign(
1552 WIPHY_ASSIGN;
1553 NETDEV_ASSIGN;
1554 MAC_ASSIGN(bssid, sme->bssid);
1555 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1556 memcpy(__entry->ssid, sme->ssid, sme->ssid_len);
1557 __entry->auth_type = sme->auth_type;
1558 __entry->privacy = sme->privacy;
1559 __entry->wpa_versions = sme->crypto.wpa_versions;
1560 __entry->flags = sme->flags;
1561 MAC_ASSIGN(prev_bssid, sme->prev_bssid);
1562 ),
1563 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
1564 ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, "
1565 "flags: 0x%x, previous bssid: %pM",
1566 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid,
1567 __entry->auth_type, BOOL_TO_STR(__entry->privacy),
1568 __entry->wpa_versions, __entry->flags, __entry->prev_bssid)
1569);
1570
1571TRACE_EVENT(rdev_update_connect_params,
1572 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1573 struct cfg80211_connect_params *sme, u32 changed),
1574 TP_ARGS(wiphy, netdev, sme, changed),
1575 TP_STRUCT__entry(
1576 WIPHY_ENTRY
1577 NETDEV_ENTRY
1578 __field(u32, changed)
1579 ),
1580 TP_fast_assign(
1581 WIPHY_ASSIGN;
1582 NETDEV_ASSIGN;
1583 __entry->changed = changed;
1584 ),
1585 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", parameters changed: %u",
1586 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->changed)
1587);
1588
1589TRACE_EVENT(rdev_set_cqm_rssi_config,
1590 TP_PROTO(struct wiphy *wiphy,
1591 struct net_device *netdev, s32 rssi_thold,
1592 u32 rssi_hyst),
1593 TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst),
1594 TP_STRUCT__entry(
1595 WIPHY_ENTRY
1596 NETDEV_ENTRY
1597 __field(s32, rssi_thold)
1598 __field(u32, rssi_hyst)
1599 ),
1600 TP_fast_assign(
1601 WIPHY_ASSIGN;
1602 NETDEV_ASSIGN;
1603 __entry->rssi_thold = rssi_thold;
1604 __entry->rssi_hyst = rssi_hyst;
1605 ),
1606 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
1607 ", rssi_thold: %d, rssi_hyst: %u ",
1608 WIPHY_PR_ARG, NETDEV_PR_ARG,
1609 __entry->rssi_thold, __entry->rssi_hyst)
1610);
1611
1612TRACE_EVENT(rdev_set_cqm_rssi_range_config,
1613 TP_PROTO(struct wiphy *wiphy,
1614 struct net_device *netdev, s32 low, s32 high),
1615 TP_ARGS(wiphy, netdev, low, high),
1616 TP_STRUCT__entry(
1617 WIPHY_ENTRY
1618 NETDEV_ENTRY
1619 __field(s32, rssi_low)
1620 __field(s32, rssi_high)
1621 ),
1622 TP_fast_assign(
1623 WIPHY_ASSIGN;
1624 NETDEV_ASSIGN;
1625 __entry->rssi_low = low;
1626 __entry->rssi_high = high;
1627 ),
1628 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
1629 ", range: %d - %d ",
1630 WIPHY_PR_ARG, NETDEV_PR_ARG,
1631 __entry->rssi_low, __entry->rssi_high)
1632);
1633
1634TRACE_EVENT(rdev_set_cqm_txe_config,
1635 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate,
1636 u32 pkts, u32 intvl),
1637 TP_ARGS(wiphy, netdev, rate, pkts, intvl),
1638 TP_STRUCT__entry(
1639 WIPHY_ENTRY
1640 NETDEV_ENTRY
1641 __field(u32, rate)
1642 __field(u32, pkts)
1643 __field(u32, intvl)
1644 ),
1645 TP_fast_assign(
1646 WIPHY_ASSIGN;
1647 NETDEV_ASSIGN;
1648 __entry->rate = rate;
1649 __entry->pkts = pkts;
1650 __entry->intvl = intvl;
1651 ),
1652 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u",
1653 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts,
1654 __entry->intvl)
1655);
1656
1657TRACE_EVENT(rdev_disconnect,
1658 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1659 u16 reason_code),
1660 TP_ARGS(wiphy, netdev, reason_code),
1661 TP_STRUCT__entry(
1662 WIPHY_ENTRY
1663 NETDEV_ENTRY
1664 __field(u16, reason_code)
1665 ),
1666 TP_fast_assign(
1667 WIPHY_ASSIGN;
1668 NETDEV_ASSIGN;
1669 __entry->reason_code = reason_code;
1670 ),
1671 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG,
1672 NETDEV_PR_ARG, __entry->reason_code)
1673);
1674
1675TRACE_EVENT(rdev_join_ibss,
1676 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1677 struct cfg80211_ibss_params *params),
1678 TP_ARGS(wiphy, netdev, params),
1679 TP_STRUCT__entry(
1680 WIPHY_ENTRY
1681 NETDEV_ENTRY
1682 MAC_ENTRY(bssid)
1683 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1684 ),
1685 TP_fast_assign(
1686 WIPHY_ASSIGN;
1687 NETDEV_ASSIGN;
1688 MAC_ASSIGN(bssid, params->bssid);
1689 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1690 memcpy(__entry->ssid, params->ssid, params->ssid_len);
1691 ),
1692 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, ssid: %s",
1693 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid)
1694);
1695
1696TRACE_EVENT(rdev_join_ocb,
1697 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1698 const struct ocb_setup *setup),
1699 TP_ARGS(wiphy, netdev, setup),
1700 TP_STRUCT__entry(
1701 WIPHY_ENTRY
1702 NETDEV_ENTRY
1703 ),
1704 TP_fast_assign(
1705 WIPHY_ASSIGN;
1706 NETDEV_ASSIGN;
1707 ),
1708 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
1709 WIPHY_PR_ARG, NETDEV_PR_ARG)
1710);
1711
1712TRACE_EVENT(rdev_set_wiphy_params,
1713 TP_PROTO(struct wiphy *wiphy, int radio_idx, u32 changed),
1714 TP_ARGS(wiphy, radio_idx, changed),
1715 TP_STRUCT__entry(
1716 WIPHY_ENTRY
1717 __field(int, radio_idx)
1718 __field(u32, changed)
1719 ),
1720 TP_fast_assign(
1721 WIPHY_ASSIGN;
1722 __entry->radio_idx = radio_idx;
1723 __entry->changed = changed;
1724 ),
1725 TP_printk(WIPHY_PR_FMT ", radio_idx: %d, changed: %u",
1726 WIPHY_PR_ARG, __entry->radio_idx, __entry->changed)
1727);
1728
1729DECLARE_EVENT_CLASS(wiphy_wdev_link_evt,
1730 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1731 unsigned int link_id),
1732 TP_ARGS(wiphy, wdev, link_id),
1733 TP_STRUCT__entry(
1734 WIPHY_ENTRY
1735 WDEV_ENTRY
1736 __field(unsigned int, link_id)
1737 ),
1738 TP_fast_assign(
1739 WIPHY_ASSIGN;
1740 WDEV_ASSIGN;
1741 __entry->link_id = link_id;
1742 ),
1743 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", link_id: %u",
1744 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->link_id)
1745);
1746
1747TRACE_EVENT(rdev_get_tx_power,
1748 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1749 int radio_idx, unsigned int link_id),
1750 TP_ARGS(wiphy, wdev, radio_idx, link_id),
1751 TP_STRUCT__entry(
1752 WIPHY_ENTRY
1753 WDEV_ENTRY
1754 __field(int, radio_idx)
1755 __field(unsigned int, link_id)
1756 ),
1757 TP_fast_assign(
1758 WIPHY_ASSIGN;
1759 WDEV_ASSIGN;
1760 __entry->radio_idx = radio_idx;
1761 __entry->link_id = link_id;
1762 ),
1763 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
1764 ", radio_idx: %d, link_id: %u",
1765 WIPHY_PR_ARG, WDEV_PR_ARG,
1766 __entry->radio_idx, __entry->link_id)
1767);
1768
1769TRACE_EVENT(rdev_set_tx_power,
1770 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1771 int radio_idx, enum nl80211_tx_power_setting type,
1772 int mbm),
1773 TP_ARGS(wiphy, wdev, radio_idx, type, mbm),
1774 TP_STRUCT__entry(
1775 WIPHY_ENTRY
1776 WDEV_ENTRY
1777 __field(int, radio_idx)
1778 __field(enum nl80211_tx_power_setting, type)
1779 __field(int, mbm)
1780 ),
1781 TP_fast_assign(
1782 WIPHY_ASSIGN;
1783 WDEV_ASSIGN;
1784 __entry->radio_idx = radio_idx;
1785 __entry->type = type;
1786 __entry->mbm = mbm;
1787 ),
1788 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
1789 ", radio_idx: %d, type: %u, mbm: %d",
1790 WIPHY_PR_ARG, WDEV_PR_ARG,
1791 __entry->radio_idx, __entry->type, __entry->mbm)
1792);
1793
1794TRACE_EVENT(rdev_return_int_int,
1795 TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill),
1796 TP_ARGS(wiphy, func_ret, func_fill),
1797 TP_STRUCT__entry(
1798 WIPHY_ENTRY
1799 __field(int, func_ret)
1800 __field(int, func_fill)
1801 ),
1802 TP_fast_assign(
1803 WIPHY_ASSIGN;
1804 __entry->func_ret = func_ret;
1805 __entry->func_fill = func_fill;
1806 ),
1807 TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d",
1808 WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill)
1809);
1810
1811#ifdef CONFIG_NL80211_TESTMODE
1812TRACE_EVENT(rdev_testmode_cmd,
1813 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1814 TP_ARGS(wiphy, wdev),
1815 TP_STRUCT__entry(
1816 WIPHY_ENTRY
1817 WDEV_ENTRY
1818 ),
1819 TP_fast_assign(
1820 WIPHY_ASSIGN;
1821 WDEV_ASSIGN;
1822 ),
1823 TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
1824);
1825
1826TRACE_EVENT(rdev_testmode_dump,
1827 TP_PROTO(struct wiphy *wiphy),
1828 TP_ARGS(wiphy),
1829 TP_STRUCT__entry(
1830 WIPHY_ENTRY
1831 ),
1832 TP_fast_assign(
1833 WIPHY_ASSIGN;
1834 ),
1835 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
1836);
1837#endif /* CONFIG_NL80211_TESTMODE */
1838
1839TRACE_EVENT(rdev_set_bitrate_mask,
1840 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1841 unsigned int link_id,
1842 const u8 *peer, const struct cfg80211_bitrate_mask *mask),
1843 TP_ARGS(wiphy, netdev, link_id, peer, mask),
1844 TP_STRUCT__entry(
1845 WIPHY_ENTRY
1846 NETDEV_ENTRY
1847 __field(unsigned int, link_id)
1848 MAC_ENTRY(peer)
1849 ),
1850 TP_fast_assign(
1851 WIPHY_ASSIGN;
1852 NETDEV_ASSIGN;
1853 __entry->link_id = link_id;
1854 MAC_ASSIGN(peer, peer);
1855 ),
1856 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, peer: %pM",
1857 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id,
1858 __entry->peer)
1859);
1860
1861TRACE_EVENT(rdev_update_mgmt_frame_registrations,
1862 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1863 struct mgmt_frame_regs *upd),
1864 TP_ARGS(wiphy, wdev, upd),
1865 TP_STRUCT__entry(
1866 WIPHY_ENTRY
1867 WDEV_ENTRY
1868 __field(u16, global_stypes)
1869 __field(u16, interface_stypes)
1870 ),
1871 TP_fast_assign(
1872 WIPHY_ASSIGN;
1873 WDEV_ASSIGN;
1874 __entry->global_stypes = upd->global_stypes;
1875 __entry->interface_stypes = upd->interface_stypes;
1876 ),
1877 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", global: 0x%.2x, intf: 0x%.2x",
1878 WIPHY_PR_ARG, WDEV_PR_ARG,
1879 __entry->global_stypes, __entry->interface_stypes)
1880);
1881
1882TRACE_EVENT(rdev_return_int_tx_rx,
1883 TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx),
1884 TP_ARGS(wiphy, ret, tx, rx),
1885 TP_STRUCT__entry(
1886 WIPHY_ENTRY
1887 __field(int, ret)
1888 __field(u32, tx)
1889 __field(u32, rx)
1890 ),
1891 TP_fast_assign(
1892 WIPHY_ASSIGN;
1893 __entry->ret = ret;
1894 __entry->tx = tx;
1895 __entry->rx = rx;
1896 ),
1897 TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u",
1898 WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx)
1899);
1900
1901TRACE_EVENT(rdev_return_void_tx_rx,
1902 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max,
1903 u32 rx, u32 rx_max),
1904 TP_ARGS(wiphy, tx, tx_max, rx, rx_max),
1905 TP_STRUCT__entry(
1906 WIPHY_ENTRY
1907 __field(u32, tx)
1908 __field(u32, tx_max)
1909 __field(u32, rx)
1910 __field(u32, rx_max)
1911 ),
1912 TP_fast_assign(
1913 WIPHY_ASSIGN;
1914 __entry->tx = tx;
1915 __entry->tx_max = tx_max;
1916 __entry->rx = rx;
1917 __entry->rx_max = rx_max;
1918 ),
1919 TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ",
1920 WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx,
1921 __entry->rx_max)
1922);
1923
1924TRACE_EVENT(rdev_set_antenna,
1925 TP_PROTO(struct wiphy *wiphy, int radio_idx, u32 tx, u32 rx),
1926 TP_ARGS(wiphy, radio_idx, tx, rx),
1927 TP_STRUCT__entry(
1928 WIPHY_ENTRY
1929 __field(int, radio_idx)
1930 __field(u32, tx)
1931 __field(u32, rx)
1932 ),
1933 TP_fast_assign(
1934 WIPHY_ASSIGN;
1935 __entry->radio_idx = radio_idx;
1936 __entry->tx = tx;
1937 __entry->rx = rx;
1938 ),
1939 TP_printk(WIPHY_PR_FMT ", radio_idx: %d, tx: %u, rx: %u ",
1940 WIPHY_PR_ARG, __entry->radio_idx,
1941 __entry->tx, __entry->rx)
1942);
1943
1944DECLARE_EVENT_CLASS(wiphy_netdev_id_evt,
1945 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
1946 TP_ARGS(wiphy, netdev, id),
1947 TP_STRUCT__entry(
1948 WIPHY_ENTRY
1949 NETDEV_ENTRY
1950 __field(u64, id)
1951 ),
1952 TP_fast_assign(
1953 WIPHY_ASSIGN;
1954 NETDEV_ASSIGN;
1955 __entry->id = id;
1956 ),
1957 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", id: %llu",
1958 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->id)
1959);
1960
1961DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start,
1962 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
1963 TP_ARGS(wiphy, netdev, id)
1964);
1965
1966DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop,
1967 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id),
1968 TP_ARGS(wiphy, netdev, id)
1969);
1970
1971TRACE_EVENT(rdev_tdls_mgmt,
1972 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1973 u8 *peer, int link_id, u8 action_code, u8 dialog_token,
1974 u16 status_code, u32 peer_capability,
1975 bool initiator, const u8 *buf, size_t len),
1976 TP_ARGS(wiphy, netdev, peer, link_id, action_code, dialog_token,
1977 status_code, peer_capability, initiator, buf, len),
1978 TP_STRUCT__entry(
1979 WIPHY_ENTRY
1980 NETDEV_ENTRY
1981 MAC_ENTRY(peer)
1982 __field(int, link_id)
1983 __field(u8, action_code)
1984 __field(u8, dialog_token)
1985 __field(u16, status_code)
1986 __field(u32, peer_capability)
1987 __field(bool, initiator)
1988 __dynamic_array(u8, buf, len)
1989 ),
1990 TP_fast_assign(
1991 WIPHY_ASSIGN;
1992 NETDEV_ASSIGN;
1993 MAC_ASSIGN(peer, peer);
1994 __entry->link_id = link_id;
1995 __entry->action_code = action_code;
1996 __entry->dialog_token = dialog_token;
1997 __entry->status_code = status_code;
1998 __entry->peer_capability = peer_capability;
1999 __entry->initiator = initiator;
2000 memcpy(__get_dynamic_array(buf), buf, len);
2001 ),
2002 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM"
2003 ", link_id: %d, action_code: %u "
2004 "dialog_token: %u, status_code: %u, peer_capability: %u "
2005 "initiator: %s buf: %#.2x ",
2006 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer,
2007 __entry->link_id, __entry->action_code, __entry->dialog_token,
2008 __entry->status_code, __entry->peer_capability,
2009 BOOL_TO_STR(__entry->initiator),
2010 ((u8 *)__get_dynamic_array(buf))[0])
2011);
2012
2013TRACE_EVENT(rdev_dump_survey,
2014 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx),
2015 TP_ARGS(wiphy, netdev, _idx),
2016 TP_STRUCT__entry(
2017 WIPHY_ENTRY
2018 NETDEV_ENTRY
2019 __field(int, idx)
2020 ),
2021 TP_fast_assign(
2022 WIPHY_ASSIGN;
2023 NETDEV_ASSIGN;
2024 __entry->idx = _idx;
2025 ),
2026 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d",
2027 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx)
2028);
2029
2030TRACE_EVENT(rdev_return_int_survey_info,
2031 TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info),
2032 TP_ARGS(wiphy, ret, info),
2033 TP_STRUCT__entry(
2034 WIPHY_ENTRY
2035 CHAN_ENTRY
2036 __field(int, ret)
2037 __field(u64, time)
2038 __field(u64, time_busy)
2039 __field(u64, time_ext_busy)
2040 __field(u64, time_rx)
2041 __field(u64, time_tx)
2042 __field(u64, time_scan)
2043 __field(u32, filled)
2044 __field(s8, noise)
2045 ),
2046 TP_fast_assign(
2047 WIPHY_ASSIGN;
2048 CHAN_ASSIGN(info->channel);
2049 __entry->ret = ret;
2050 __entry->time = info->time;
2051 __entry->time_busy = info->time_busy;
2052 __entry->time_ext_busy = info->time_ext_busy;
2053 __entry->time_rx = info->time_rx;
2054 __entry->time_tx = info->time_tx;
2055 __entry->time_scan = info->time_scan;
2056 __entry->filled = info->filled;
2057 __entry->noise = info->noise;
2058 ),
2059 TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT
2060 ", channel time: %llu, channel time busy: %llu, "
2061 "channel time extension busy: %llu, channel time rx: %llu, "
2062 "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d",
2063 WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG,
2064 __entry->time, __entry->time_busy,
2065 __entry->time_ext_busy, __entry->time_rx,
2066 __entry->time_tx, __entry->time_scan,
2067 __entry->filled, __entry->noise)
2068);
2069
2070TRACE_EVENT(rdev_tdls_oper,
2071 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2072 u8 *peer, enum nl80211_tdls_operation oper),
2073 TP_ARGS(wiphy, netdev, peer, oper),
2074 TP_STRUCT__entry(
2075 WIPHY_ENTRY
2076 NETDEV_ENTRY
2077 MAC_ENTRY(peer)
2078 __field(enum nl80211_tdls_operation, oper)
2079 ),
2080 TP_fast_assign(
2081 WIPHY_ASSIGN;
2082 NETDEV_ASSIGN;
2083 MAC_ASSIGN(peer, peer);
2084 __entry->oper = oper;
2085 ),
2086 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, oper: %d",
2087 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper)
2088);
2089
2090DECLARE_EVENT_CLASS(rdev_pmksa,
2091 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2092 struct cfg80211_pmksa *pmksa),
2093 TP_ARGS(wiphy, netdev, pmksa),
2094 TP_STRUCT__entry(
2095 WIPHY_ENTRY
2096 NETDEV_ENTRY
2097 MAC_ENTRY(bssid)
2098 ),
2099 TP_fast_assign(
2100 WIPHY_ASSIGN;
2101 NETDEV_ASSIGN;
2102 MAC_ASSIGN(bssid, pmksa->bssid);
2103 ),
2104 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM",
2105 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid)
2106);
2107
2108TRACE_EVENT(rdev_probe_client,
2109 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2110 const u8 *peer),
2111 TP_ARGS(wiphy, netdev, peer),
2112 TP_STRUCT__entry(
2113 WIPHY_ENTRY
2114 NETDEV_ENTRY
2115 MAC_ENTRY(peer)
2116 ),
2117 TP_fast_assign(
2118 WIPHY_ASSIGN;
2119 NETDEV_ASSIGN;
2120 MAC_ASSIGN(peer, peer);
2121 ),
2122 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM",
2123 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer)
2124);
2125
2126DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa,
2127 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2128 struct cfg80211_pmksa *pmksa),
2129 TP_ARGS(wiphy, netdev, pmksa)
2130);
2131
2132DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa,
2133 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2134 struct cfg80211_pmksa *pmksa),
2135 TP_ARGS(wiphy, netdev, pmksa)
2136);
2137
2138TRACE_EVENT(rdev_remain_on_channel,
2139 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2140 struct ieee80211_channel *chan,
2141 unsigned int duration),
2142 TP_ARGS(wiphy, wdev, chan, duration),
2143 TP_STRUCT__entry(
2144 WIPHY_ENTRY
2145 WDEV_ENTRY
2146 CHAN_ENTRY
2147 __field(unsigned int, duration)
2148 ),
2149 TP_fast_assign(
2150 WIPHY_ASSIGN;
2151 WDEV_ASSIGN;
2152 CHAN_ASSIGN(chan);
2153 __entry->duration = duration;
2154 ),
2155 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u",
2156 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration)
2157);
2158
2159TRACE_EVENT(rdev_return_int_cookie,
2160 TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie),
2161 TP_ARGS(wiphy, ret, cookie),
2162 TP_STRUCT__entry(
2163 WIPHY_ENTRY
2164 __field(int, ret)
2165 __field(u64, cookie)
2166 ),
2167 TP_fast_assign(
2168 WIPHY_ASSIGN;
2169 __entry->ret = ret;
2170 __entry->cookie = cookie;
2171 ),
2172 TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu",
2173 WIPHY_PR_ARG, __entry->ret, __entry->cookie)
2174);
2175
2176TRACE_EVENT(rdev_cancel_remain_on_channel,
2177 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
2178 TP_ARGS(wiphy, wdev, cookie),
2179 TP_STRUCT__entry(
2180 WIPHY_ENTRY
2181 WDEV_ENTRY
2182 __field(u64, cookie)
2183 ),
2184 TP_fast_assign(
2185 WIPHY_ASSIGN;
2186 WDEV_ASSIGN;
2187 __entry->cookie = cookie;
2188 ),
2189 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu",
2190 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
2191);
2192
2193TRACE_EVENT(rdev_mgmt_tx,
2194 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2195 struct cfg80211_mgmt_tx_params *params),
2196 TP_ARGS(wiphy, wdev, params),
2197 TP_STRUCT__entry(
2198 WIPHY_ENTRY
2199 WDEV_ENTRY
2200 CHAN_ENTRY
2201 __field(bool, offchan)
2202 __field(unsigned int, wait)
2203 __field(bool, no_cck)
2204 __field(bool, dont_wait_for_ack)
2205 ),
2206 TP_fast_assign(
2207 WIPHY_ASSIGN;
2208 WDEV_ASSIGN;
2209 CHAN_ASSIGN(params->chan);
2210 __entry->offchan = params->offchan;
2211 __entry->wait = params->wait;
2212 __entry->no_cck = params->no_cck;
2213 __entry->dont_wait_for_ack = params->dont_wait_for_ack;
2214 ),
2215 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s,"
2216 " wait: %u, no cck: %s, dont wait for ack: %s",
2217 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG,
2218 BOOL_TO_STR(__entry->offchan), __entry->wait,
2219 BOOL_TO_STR(__entry->no_cck),
2220 BOOL_TO_STR(__entry->dont_wait_for_ack))
2221);
2222
2223TRACE_EVENT(rdev_tx_control_port,
2224 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2225 const u8 *buf, size_t len, const u8 *dest, __be16 proto,
2226 bool unencrypted, int link_id),
2227 TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted, link_id),
2228 TP_STRUCT__entry(
2229 WIPHY_ENTRY
2230 NETDEV_ENTRY
2231 MAC_ENTRY(dest)
2232 __field(__be16, proto)
2233 __field(bool, unencrypted)
2234 __field(int, link_id)
2235 ),
2236 TP_fast_assign(
2237 WIPHY_ASSIGN;
2238 NETDEV_ASSIGN;
2239 MAC_ASSIGN(dest, dest);
2240 __entry->proto = proto;
2241 __entry->unencrypted = unencrypted;
2242 __entry->link_id = link_id;
2243 ),
2244 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM,"
2245 " proto: 0x%x, unencrypted: %s, link: %d",
2246 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest,
2247 be16_to_cpu(__entry->proto),
2248 BOOL_TO_STR(__entry->unencrypted),
2249 __entry->link_id)
2250);
2251
2252TRACE_EVENT(rdev_set_noack_map,
2253 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2254 u16 noack_map),
2255 TP_ARGS(wiphy, netdev, noack_map),
2256 TP_STRUCT__entry(
2257 WIPHY_ENTRY
2258 NETDEV_ENTRY
2259 __field(u16, noack_map)
2260 ),
2261 TP_fast_assign(
2262 WIPHY_ASSIGN;
2263 NETDEV_ASSIGN;
2264 __entry->noack_map = noack_map;
2265 ),
2266 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u",
2267 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map)
2268);
2269DEFINE_EVENT(wiphy_wdev_link_evt, rdev_get_channel,
2270 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2271 unsigned int link_id),
2272 TP_ARGS(wiphy, wdev, link_id)
2273);
2274
2275TRACE_EVENT(rdev_return_chandef,
2276 TP_PROTO(struct wiphy *wiphy, int ret,
2277 struct cfg80211_chan_def *chandef),
2278 TP_ARGS(wiphy, ret, chandef),
2279 TP_STRUCT__entry(
2280 WIPHY_ENTRY
2281 __field(int, ret)
2282 CHAN_DEF_ENTRY
2283 ),
2284 TP_fast_assign(
2285 WIPHY_ASSIGN;
2286 if (ret == 0)
2287 CHAN_DEF_ASSIGN(chandef);
2288 else
2289 CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL);
2290 __entry->ret = ret;
2291 ),
2292 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d",
2293 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret)
2294);
2295
2296DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device,
2297 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2298 TP_ARGS(wiphy, wdev)
2299);
2300
2301DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device,
2302 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2303 TP_ARGS(wiphy, wdev)
2304);
2305
2306TRACE_EVENT(rdev_start_nan,
2307 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2308 struct cfg80211_nan_conf *conf),
2309 TP_ARGS(wiphy, wdev, conf),
2310 TP_STRUCT__entry(
2311 WIPHY_ENTRY
2312 WDEV_ENTRY
2313 __field(u8, master_pref)
2314 __field(u8, bands)
2315 ),
2316 TP_fast_assign(
2317 WIPHY_ASSIGN;
2318 WDEV_ASSIGN;
2319 __entry->master_pref = conf->master_pref;
2320 __entry->bands = conf->bands;
2321 ),
2322 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
2323 ", master preference: %u, bands: 0x%0x",
2324 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref,
2325 __entry->bands)
2326);
2327
2328TRACE_EVENT(rdev_nan_change_conf,
2329 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2330 struct cfg80211_nan_conf *conf, u32 changes),
2331 TP_ARGS(wiphy, wdev, conf, changes),
2332 TP_STRUCT__entry(
2333 WIPHY_ENTRY
2334 WDEV_ENTRY
2335 __field(u8, master_pref)
2336 __field(u8, bands)
2337 __field(u32, changes)
2338 ),
2339 TP_fast_assign(
2340 WIPHY_ASSIGN;
2341 WDEV_ASSIGN;
2342 __entry->master_pref = conf->master_pref;
2343 __entry->bands = conf->bands;
2344 __entry->changes = changes;
2345 ),
2346 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT
2347 ", master preference: %u, bands: 0x%0x, changes: %x",
2348 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref,
2349 __entry->bands, __entry->changes)
2350);
2351
2352DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan,
2353 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2354 TP_ARGS(wiphy, wdev)
2355);
2356
2357TRACE_EVENT(rdev_add_nan_func,
2358 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2359 const struct cfg80211_nan_func *func),
2360 TP_ARGS(wiphy, wdev, func),
2361 TP_STRUCT__entry(
2362 WIPHY_ENTRY
2363 WDEV_ENTRY
2364 __field(u8, func_type)
2365 __field(u64, cookie)
2366 ),
2367 TP_fast_assign(
2368 WIPHY_ASSIGN;
2369 WDEV_ASSIGN;
2370 __entry->func_type = func->type;
2371 __entry->cookie = func->cookie
2372 ),
2373 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type=%u, cookie=%llu",
2374 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->func_type,
2375 __entry->cookie)
2376);
2377
2378TRACE_EVENT(rdev_del_nan_func,
2379 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2380 u64 cookie),
2381 TP_ARGS(wiphy, wdev, cookie),
2382 TP_STRUCT__entry(
2383 WIPHY_ENTRY
2384 WDEV_ENTRY
2385 __field(u64, cookie)
2386 ),
2387 TP_fast_assign(
2388 WIPHY_ASSIGN;
2389 WDEV_ASSIGN;
2390 __entry->cookie = cookie;
2391 ),
2392 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie=%llu",
2393 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
2394);
2395
2396TRACE_EVENT(rdev_set_mac_acl,
2397 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2398 struct cfg80211_acl_data *params),
2399 TP_ARGS(wiphy, netdev, params),
2400 TP_STRUCT__entry(
2401 WIPHY_ENTRY
2402 NETDEV_ENTRY
2403 __field(u32, acl_policy)
2404 ),
2405 TP_fast_assign(
2406 WIPHY_ASSIGN;
2407 NETDEV_ASSIGN;
2408 __entry->acl_policy = params->acl_policy;
2409 ),
2410 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d",
2411 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy)
2412);
2413
2414TRACE_EVENT(rdev_update_ft_ies,
2415 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2416 struct cfg80211_update_ft_ies_params *ftie),
2417 TP_ARGS(wiphy, netdev, ftie),
2418 TP_STRUCT__entry(
2419 WIPHY_ENTRY
2420 NETDEV_ENTRY
2421 __field(u16, md)
2422 __dynamic_array(u8, ie, ftie->ie_len)
2423 ),
2424 TP_fast_assign(
2425 WIPHY_ASSIGN;
2426 NETDEV_ASSIGN;
2427 __entry->md = ftie->md;
2428 memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len);
2429 ),
2430 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x",
2431 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md)
2432);
2433
2434TRACE_EVENT(rdev_crit_proto_start,
2435 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2436 enum nl80211_crit_proto_id protocol, u16 duration),
2437 TP_ARGS(wiphy, wdev, protocol, duration),
2438 TP_STRUCT__entry(
2439 WIPHY_ENTRY
2440 WDEV_ENTRY
2441 __field(u16, proto)
2442 __field(u16, duration)
2443 ),
2444 TP_fast_assign(
2445 WIPHY_ASSIGN;
2446 WDEV_ASSIGN;
2447 __entry->proto = protocol;
2448 __entry->duration = duration;
2449 ),
2450 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u",
2451 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration)
2452);
2453
2454TRACE_EVENT(rdev_crit_proto_stop,
2455 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2456 TP_ARGS(wiphy, wdev),
2457 TP_STRUCT__entry(
2458 WIPHY_ENTRY
2459 WDEV_ENTRY
2460 ),
2461 TP_fast_assign(
2462 WIPHY_ASSIGN;
2463 WDEV_ASSIGN;
2464 ),
2465 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
2466 WIPHY_PR_ARG, WDEV_PR_ARG)
2467);
2468
2469TRACE_EVENT(rdev_channel_switch,
2470 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2471 struct cfg80211_csa_settings *params),
2472 TP_ARGS(wiphy, netdev, params),
2473 TP_STRUCT__entry(
2474 WIPHY_ENTRY
2475 NETDEV_ENTRY
2476 CHAN_DEF_ENTRY
2477 __field(bool, radar_required)
2478 __field(bool, block_tx)
2479 __field(u8, count)
2480 __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon)
2481 __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp)
2482 __field(u8, link_id)
2483 ),
2484 TP_fast_assign(
2485 WIPHY_ASSIGN;
2486 NETDEV_ASSIGN;
2487 CHAN_DEF_ASSIGN(&params->chandef);
2488 __entry->radar_required = params->radar_required;
2489 __entry->block_tx = params->block_tx;
2490 __entry->count = params->count;
2491 memcpy(__get_dynamic_array(bcn_ofs),
2492 params->counter_offsets_beacon,
2493 params->n_counter_offsets_beacon * sizeof(u16));
2494
2495 /* probe response offsets are optional */
2496 if (params->n_counter_offsets_presp)
2497 memcpy(__get_dynamic_array(pres_ofs),
2498 params->counter_offsets_presp,
2499 params->n_counter_offsets_presp * sizeof(u16));
2500 __entry->link_id = params->link_id;
2501 ),
2502 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT
2503 ", block_tx: %d, count: %u, radar_required: %d, link_id: %d",
2504 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
2505 __entry->block_tx, __entry->count, __entry->radar_required,
2506 __entry->link_id)
2507);
2508
2509TRACE_EVENT(rdev_set_qos_map,
2510 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2511 struct cfg80211_qos_map *qos_map),
2512 TP_ARGS(wiphy, netdev, qos_map),
2513 TP_STRUCT__entry(
2514 WIPHY_ENTRY
2515 NETDEV_ENTRY
2516 QOS_MAP_ENTRY
2517 ),
2518 TP_fast_assign(
2519 WIPHY_ASSIGN;
2520 NETDEV_ASSIGN;
2521 QOS_MAP_ASSIGN(qos_map);
2522 ),
2523 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u",
2524 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des)
2525);
2526
2527TRACE_EVENT(rdev_set_ap_chanwidth,
2528 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2529 unsigned int link_id,
2530 struct cfg80211_chan_def *chandef),
2531 TP_ARGS(wiphy, netdev, link_id, chandef),
2532 TP_STRUCT__entry(
2533 WIPHY_ENTRY
2534 NETDEV_ENTRY
2535 CHAN_DEF_ENTRY
2536 __field(unsigned int, link_id)
2537 ),
2538 TP_fast_assign(
2539 WIPHY_ASSIGN;
2540 NETDEV_ASSIGN;
2541 CHAN_DEF_ASSIGN(chandef);
2542 __entry->link_id = link_id;
2543 ),
2544 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d",
2545 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
2546 __entry->link_id)
2547);
2548
2549TRACE_EVENT(rdev_add_tx_ts,
2550 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2551 u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time),
2552 TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time),
2553 TP_STRUCT__entry(
2554 WIPHY_ENTRY
2555 NETDEV_ENTRY
2556 MAC_ENTRY(peer)
2557 __field(u8, tsid)
2558 __field(u8, user_prio)
2559 __field(u16, admitted_time)
2560 ),
2561 TP_fast_assign(
2562 WIPHY_ASSIGN;
2563 NETDEV_ASSIGN;
2564 MAC_ASSIGN(peer, peer);
2565 __entry->tsid = tsid;
2566 __entry->user_prio = user_prio;
2567 __entry->admitted_time = admitted_time;
2568 ),
2569 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d, UP %d, time %d",
2570 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer,
2571 __entry->tsid, __entry->user_prio, __entry->admitted_time)
2572);
2573
2574TRACE_EVENT(rdev_del_tx_ts,
2575 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2576 u8 tsid, const u8 *peer),
2577 TP_ARGS(wiphy, netdev, tsid, peer),
2578 TP_STRUCT__entry(
2579 WIPHY_ENTRY
2580 NETDEV_ENTRY
2581 MAC_ENTRY(peer)
2582 __field(u8, tsid)
2583 ),
2584 TP_fast_assign(
2585 WIPHY_ASSIGN;
2586 NETDEV_ASSIGN;
2587 MAC_ASSIGN(peer, peer);
2588 __entry->tsid = tsid;
2589 ),
2590 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d",
2591 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tsid)
2592);
2593
2594TRACE_EVENT(rdev_tdls_channel_switch,
2595 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2596 const u8 *addr, u8 oper_class,
2597 struct cfg80211_chan_def *chandef),
2598 TP_ARGS(wiphy, netdev, addr, oper_class, chandef),
2599 TP_STRUCT__entry(
2600 WIPHY_ENTRY
2601 NETDEV_ENTRY
2602 MAC_ENTRY(addr)
2603 __field(u8, oper_class)
2604 CHAN_DEF_ENTRY
2605 ),
2606 TP_fast_assign(
2607 WIPHY_ASSIGN;
2608 NETDEV_ASSIGN;
2609 MAC_ASSIGN(addr, addr);
2610 CHAN_DEF_ASSIGN(chandef);
2611 ),
2612 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM"
2613 " oper class %d, " CHAN_DEF_PR_FMT,
2614 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr,
2615 __entry->oper_class, CHAN_DEF_PR_ARG)
2616);
2617
2618TRACE_EVENT(rdev_tdls_cancel_channel_switch,
2619 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2620 const u8 *addr),
2621 TP_ARGS(wiphy, netdev, addr),
2622 TP_STRUCT__entry(
2623 WIPHY_ENTRY
2624 NETDEV_ENTRY
2625 MAC_ENTRY(addr)
2626 ),
2627 TP_fast_assign(
2628 WIPHY_ASSIGN;
2629 NETDEV_ASSIGN;
2630 MAC_ASSIGN(addr, addr);
2631 ),
2632 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM",
2633 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr)
2634);
2635
2636TRACE_EVENT(rdev_set_pmk,
2637 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2638 struct cfg80211_pmk_conf *pmk_conf),
2639
2640 TP_ARGS(wiphy, netdev, pmk_conf),
2641
2642 TP_STRUCT__entry(
2643 WIPHY_ENTRY
2644 NETDEV_ENTRY
2645 MAC_ENTRY(aa)
2646 __field(u8, pmk_len)
2647 __field(u8, pmk_r0_name_len)
2648 __dynamic_array(u8, pmk, pmk_conf->pmk_len)
2649 __dynamic_array(u8, pmk_r0_name, WLAN_PMK_NAME_LEN)
2650 ),
2651
2652 TP_fast_assign(
2653 WIPHY_ASSIGN;
2654 NETDEV_ASSIGN;
2655 MAC_ASSIGN(aa, pmk_conf->aa);
2656 __entry->pmk_len = pmk_conf->pmk_len;
2657 __entry->pmk_r0_name_len =
2658 pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0;
2659 memcpy(__get_dynamic_array(pmk), pmk_conf->pmk,
2660 pmk_conf->pmk_len);
2661 memcpy(__get_dynamic_array(pmk_r0_name), pmk_conf->pmk_r0_name,
2662 pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0);
2663 ),
2664
2665 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM"
2666 "pmk_len=%u, pmk: %s pmk_r0_name: %s", WIPHY_PR_ARG,
2667 NETDEV_PR_ARG, __entry->aa, __entry->pmk_len,
2668 __print_array(__get_dynamic_array(pmk),
2669 __get_dynamic_array_len(pmk), 1),
2670 __entry->pmk_r0_name_len ?
2671 __print_array(__get_dynamic_array(pmk_r0_name),
2672 __get_dynamic_array_len(pmk_r0_name), 1) : "")
2673);
2674
2675TRACE_EVENT(rdev_del_pmk,
2676 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa),
2677
2678 TP_ARGS(wiphy, netdev, aa),
2679
2680 TP_STRUCT__entry(
2681 WIPHY_ENTRY
2682 NETDEV_ENTRY
2683 MAC_ENTRY(aa)
2684 ),
2685
2686 TP_fast_assign(
2687 WIPHY_ASSIGN;
2688 NETDEV_ASSIGN;
2689 MAC_ASSIGN(aa, aa);
2690 ),
2691
2692 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM",
2693 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->aa)
2694);
2695
2696TRACE_EVENT(rdev_external_auth,
2697 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2698 struct cfg80211_external_auth_params *params),
2699 TP_ARGS(wiphy, netdev, params),
2700 TP_STRUCT__entry(WIPHY_ENTRY
2701 NETDEV_ENTRY
2702 MAC_ENTRY(bssid)
2703 __array(u8, ssid, IEEE80211_MAX_SSID_LEN + 1)
2704 __field(u16, status)
2705 MAC_ENTRY(mld_addr)
2706 ),
2707 TP_fast_assign(WIPHY_ASSIGN;
2708 NETDEV_ASSIGN;
2709 MAC_ASSIGN(bssid, params->bssid);
2710 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
2711 memcpy(__entry->ssid, params->ssid.ssid,
2712 params->ssid.ssid_len);
2713 __entry->status = params->status;
2714 MAC_ASSIGN(mld_addr, params->mld_addr);
2715 ),
2716 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM"
2717 ", ssid: %s, status: %u, mld_addr: %pM",
2718 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid,
2719 __entry->ssid, __entry->status, __entry->mld_addr)
2720);
2721
2722TRACE_EVENT(rdev_start_radar_detection,
2723 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2724 struct cfg80211_chan_def *chandef,
2725 u32 cac_time_ms, int link_id),
2726 TP_ARGS(wiphy, netdev, chandef, cac_time_ms, link_id),
2727 TP_STRUCT__entry(
2728 WIPHY_ENTRY
2729 NETDEV_ENTRY
2730 CHAN_DEF_ENTRY
2731 __field(u32, cac_time_ms)
2732 __field(int, link_id)
2733 ),
2734 TP_fast_assign(
2735 WIPHY_ASSIGN;
2736 NETDEV_ASSIGN;
2737 CHAN_DEF_ASSIGN(chandef);
2738 __entry->cac_time_ms = cac_time_ms;
2739 __entry->link_id = link_id;
2740 ),
2741 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT
2742 ", cac_time_ms=%u, link_id=%d",
2743 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
2744 __entry->cac_time_ms, __entry->link_id)
2745);
2746
2747TRACE_EVENT(rdev_set_mcast_rate,
2748 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2749 int *mcast_rate),
2750 TP_ARGS(wiphy, netdev, mcast_rate),
2751 TP_STRUCT__entry(
2752 WIPHY_ENTRY
2753 NETDEV_ENTRY
2754 __array(int, mcast_rate, NUM_NL80211_BANDS)
2755 ),
2756 TP_fast_assign(
2757 WIPHY_ASSIGN;
2758 NETDEV_ASSIGN;
2759 memcpy(__entry->mcast_rate, mcast_rate,
2760 sizeof(int) * NUM_NL80211_BANDS);
2761 ),
2762 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", "
2763 "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 6GHz=0x%x, 60GHz=0x%x]",
2764 WIPHY_PR_ARG, NETDEV_PR_ARG,
2765 __entry->mcast_rate[NL80211_BAND_2GHZ],
2766 __entry->mcast_rate[NL80211_BAND_5GHZ],
2767 __entry->mcast_rate[NL80211_BAND_6GHZ],
2768 __entry->mcast_rate[NL80211_BAND_60GHZ])
2769);
2770
2771TRACE_EVENT(rdev_set_coalesce,
2772 TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce),
2773 TP_ARGS(wiphy, coalesce),
2774 TP_STRUCT__entry(
2775 WIPHY_ENTRY
2776 __field(int, n_rules)
2777 ),
2778 TP_fast_assign(
2779 WIPHY_ASSIGN;
2780 __entry->n_rules = coalesce ? coalesce->n_rules : 0;
2781 ),
2782 TP_printk(WIPHY_PR_FMT ", n_rules=%d",
2783 WIPHY_PR_ARG, __entry->n_rules)
2784);
2785
2786DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan,
2787 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2788 TP_ARGS(wiphy, wdev)
2789);
2790
2791TRACE_EVENT(rdev_set_multicast_to_unicast,
2792 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2793 const bool enabled),
2794 TP_ARGS(wiphy, netdev, enabled),
2795 TP_STRUCT__entry(
2796 WIPHY_ENTRY
2797 NETDEV_ENTRY
2798 __field(bool, enabled)
2799 ),
2800 TP_fast_assign(
2801 WIPHY_ASSIGN;
2802 NETDEV_ASSIGN;
2803 __entry->enabled = enabled;
2804 ),
2805 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", unicast: %s",
2806 WIPHY_PR_ARG, NETDEV_PR_ARG,
2807 BOOL_TO_STR(__entry->enabled))
2808);
2809
2810DEFINE_EVENT(wiphy_wdev_evt, rdev_get_txq_stats,
2811 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2812 TP_ARGS(wiphy, wdev)
2813);
2814
2815TRACE_EVENT(rdev_get_ftm_responder_stats,
2816 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2817 struct cfg80211_ftm_responder_stats *ftm_stats),
2818
2819 TP_ARGS(wiphy, netdev, ftm_stats),
2820
2821 TP_STRUCT__entry(
2822 WIPHY_ENTRY
2823 NETDEV_ENTRY
2824 __field(u64, timestamp)
2825 __field(u32, success_num)
2826 __field(u32, partial_num)
2827 __field(u32, failed_num)
2828 __field(u32, asap_num)
2829 __field(u32, non_asap_num)
2830 __field(u64, duration)
2831 __field(u32, unknown_triggers)
2832 __field(u32, reschedule)
2833 __field(u32, out_of_window)
2834 ),
2835
2836 TP_fast_assign(
2837 WIPHY_ASSIGN;
2838 NETDEV_ASSIGN;
2839 __entry->success_num = ftm_stats->success_num;
2840 __entry->partial_num = ftm_stats->partial_num;
2841 __entry->failed_num = ftm_stats->failed_num;
2842 __entry->asap_num = ftm_stats->asap_num;
2843 __entry->non_asap_num = ftm_stats->non_asap_num;
2844 __entry->duration = ftm_stats->total_duration_ms;
2845 __entry->unknown_triggers = ftm_stats->unknown_triggers_num;
2846 __entry->reschedule = ftm_stats->reschedule_requests_num;
2847 __entry->out_of_window = ftm_stats->out_of_window_triggers_num;
2848 ),
2849
2850 TP_printk(WIPHY_PR_FMT "Ftm responder stats: success %u, partial %u, "
2851 "failed %u, asap %u, non asap %u, total duration %llu, unknown "
2852 "triggers %u, rescheduled %u, out of window %u", WIPHY_PR_ARG,
2853 __entry->success_num, __entry->partial_num, __entry->failed_num,
2854 __entry->asap_num, __entry->non_asap_num, __entry->duration,
2855 __entry->unknown_triggers, __entry->reschedule,
2856 __entry->out_of_window)
2857);
2858
2859DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_start_pmsr,
2860 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
2861 TP_ARGS(wiphy, wdev, cookie)
2862);
2863
2864DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_abort_pmsr,
2865 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
2866 TP_ARGS(wiphy, wdev, cookie)
2867);
2868
2869TRACE_EVENT(rdev_set_fils_aad,
2870 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2871 struct cfg80211_fils_aad *fils_aad),
2872 TP_ARGS(wiphy, netdev, fils_aad),
2873 TP_STRUCT__entry(WIPHY_ENTRY
2874 NETDEV_ENTRY
2875 __array(u8, macaddr, ETH_ALEN)
2876 __field(u8, kek_len)
2877 ),
2878 TP_fast_assign(WIPHY_ASSIGN;
2879 NETDEV_ASSIGN;
2880 FILS_AAD_ASSIGN(fils_aad);
2881 ),
2882 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " FILS_AAD_PR_FMT,
2883 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr,
2884 __entry->kek_len)
2885);
2886
2887TRACE_EVENT(rdev_update_owe_info,
2888 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2889 struct cfg80211_update_owe_info *owe_info),
2890 TP_ARGS(wiphy, netdev, owe_info),
2891 TP_STRUCT__entry(WIPHY_ENTRY
2892 NETDEV_ENTRY
2893 MAC_ENTRY(peer)
2894 __field(u16, status)
2895 __dynamic_array(u8, ie, owe_info->ie_len)),
2896 TP_fast_assign(WIPHY_ASSIGN;
2897 NETDEV_ASSIGN;
2898 MAC_ASSIGN(peer, owe_info->peer);
2899 __entry->status = owe_info->status;
2900 memcpy(__get_dynamic_array(ie),
2901 owe_info->ie, owe_info->ie_len);),
2902 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM"
2903 " status %d", WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer,
2904 __entry->status)
2905);
2906
2907TRACE_EVENT(rdev_probe_mesh_link,
2908 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2909 const u8 *dest, const u8 *buf, size_t len),
2910 TP_ARGS(wiphy, netdev, dest, buf, len),
2911 TP_STRUCT__entry(
2912 WIPHY_ENTRY
2913 NETDEV_ENTRY
2914 MAC_ENTRY(dest)
2915 ),
2916 TP_fast_assign(
2917 WIPHY_ASSIGN;
2918 NETDEV_ASSIGN;
2919 MAC_ASSIGN(dest, dest);
2920 ),
2921 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM",
2922 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest)
2923);
2924
2925TRACE_EVENT(rdev_set_tid_config,
2926 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2927 struct cfg80211_tid_config *tid_conf),
2928 TP_ARGS(wiphy, netdev, tid_conf),
2929 TP_STRUCT__entry(
2930 WIPHY_ENTRY
2931 NETDEV_ENTRY
2932 MAC_ENTRY(peer)
2933 ),
2934 TP_fast_assign(
2935 WIPHY_ASSIGN;
2936 NETDEV_ASSIGN;
2937 MAC_ASSIGN(peer, tid_conf->peer);
2938 ),
2939 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM",
2940 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer)
2941);
2942
2943TRACE_EVENT(rdev_reset_tid_config,
2944 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2945 const u8 *peer, u8 tids),
2946 TP_ARGS(wiphy, netdev, peer, tids),
2947 TP_STRUCT__entry(
2948 WIPHY_ENTRY
2949 NETDEV_ENTRY
2950 MAC_ENTRY(peer)
2951 __field(u8, tids)
2952 ),
2953 TP_fast_assign(
2954 WIPHY_ASSIGN;
2955 NETDEV_ASSIGN;
2956 MAC_ASSIGN(peer, peer);
2957 __entry->tids = tids;
2958 ),
2959 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM, tids: 0x%x",
2960 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tids)
2961);
2962
2963TRACE_EVENT(rdev_set_sar_specs,
2964 TP_PROTO(struct wiphy *wiphy, struct cfg80211_sar_specs *sar),
2965 TP_ARGS(wiphy, sar),
2966 TP_STRUCT__entry(
2967 WIPHY_ENTRY
2968 __field(u16, type)
2969 __field(u16, num)
2970 ),
2971 TP_fast_assign(
2972 WIPHY_ASSIGN;
2973 __entry->type = sar->type;
2974 __entry->num = sar->num_sub_specs;
2975
2976 ),
2977 TP_printk(WIPHY_PR_FMT ", Set type:%d, num_specs:%d",
2978 WIPHY_PR_ARG, __entry->type, __entry->num)
2979);
2980
2981TRACE_EVENT(rdev_color_change,
2982 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2983 struct cfg80211_color_change_settings *params),
2984 TP_ARGS(wiphy, netdev, params),
2985 TP_STRUCT__entry(
2986 WIPHY_ENTRY
2987 NETDEV_ENTRY
2988 __field(u8, count)
2989 __field(u16, bcn_ofs)
2990 __field(u16, pres_ofs)
2991 __field(u8, link_id)
2992 ),
2993 TP_fast_assign(
2994 WIPHY_ASSIGN;
2995 NETDEV_ASSIGN;
2996 __entry->count = params->count;
2997 __entry->bcn_ofs = params->counter_offset_beacon;
2998 __entry->pres_ofs = params->counter_offset_presp;
2999 __entry->link_id = params->link_id;
3000 ),
3001 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
3002 ", count: %u, link_id: %d",
3003 WIPHY_PR_ARG, NETDEV_PR_ARG,
3004 __entry->count, __entry->link_id)
3005);
3006
3007TRACE_EVENT(rdev_set_radar_background,
3008 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef),
3009
3010 TP_ARGS(wiphy, chandef),
3011
3012 TP_STRUCT__entry(
3013 WIPHY_ENTRY
3014 CHAN_DEF_ENTRY
3015 ),
3016
3017 TP_fast_assign(
3018 WIPHY_ASSIGN;
3019 CHAN_DEF_ASSIGN(chandef)
3020 ),
3021
3022 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
3023 WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
3024);
3025
3026DEFINE_EVENT(wiphy_wdev_link_evt, rdev_add_intf_link,
3027 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3028 unsigned int link_id),
3029 TP_ARGS(wiphy, wdev, link_id)
3030);
3031
3032DEFINE_EVENT(wiphy_wdev_link_evt, rdev_del_intf_link,
3033 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3034 unsigned int link_id),
3035 TP_ARGS(wiphy, wdev, link_id)
3036);
3037
3038TRACE_EVENT(rdev_del_link_station,
3039 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3040 struct link_station_del_parameters *params),
3041 TP_ARGS(wiphy, netdev, params),
3042 TP_STRUCT__entry(
3043 WIPHY_ENTRY
3044 NETDEV_ENTRY
3045 __array(u8, mld_mac, 6)
3046 __field(u32, link_id)
3047 ),
3048 TP_fast_assign(
3049 WIPHY_ASSIGN;
3050 NETDEV_ASSIGN;
3051 memset(__entry->mld_mac, 0, 6);
3052 if (params->mld_mac)
3053 memcpy(__entry->mld_mac, params->mld_mac, 6);
3054 __entry->link_id = params->link_id;
3055 ),
3056 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
3057 ", link id: %u",
3058 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac,
3059 __entry->link_id)
3060);
3061
3062TRACE_EVENT(rdev_set_hw_timestamp,
3063 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3064 struct cfg80211_set_hw_timestamp *hwts),
3065
3066 TP_ARGS(wiphy, netdev, hwts),
3067
3068 TP_STRUCT__entry(
3069 WIPHY_ENTRY
3070 NETDEV_ENTRY
3071 MAC_ENTRY(macaddr)
3072 __field(bool, enable)
3073 ),
3074
3075 TP_fast_assign(
3076 WIPHY_ASSIGN;
3077 NETDEV_ASSIGN;
3078 MAC_ASSIGN(macaddr, hwts->macaddr);
3079 __entry->enable = hwts->enable;
3080 ),
3081
3082 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac %pM, enable: %u",
3083 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr,
3084 __entry->enable)
3085);
3086
3087TRACE_EVENT(rdev_set_ttlm,
3088 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3089 struct cfg80211_ttlm_params *params),
3090 TP_ARGS(wiphy, netdev, params),
3091 TP_STRUCT__entry(
3092 WIPHY_ENTRY
3093 NETDEV_ENTRY
3094 __array(u8, dlink, sizeof(u16) * 8)
3095 __array(u8, ulink, sizeof(u16) * 8)
3096 ),
3097 TP_fast_assign(
3098 WIPHY_ASSIGN;
3099 NETDEV_ASSIGN;
3100 memcpy(__entry->dlink, params->dlink, sizeof(params->dlink));
3101 memcpy(__entry->ulink, params->ulink, sizeof(params->ulink));
3102 ),
3103 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
3104 WIPHY_PR_ARG, NETDEV_PR_ARG)
3105);
3106
3107TRACE_EVENT(rdev_set_epcs,
3108 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3109 bool val),
3110 TP_ARGS(wiphy, netdev, val),
3111 TP_STRUCT__entry(
3112 WIPHY_ENTRY
3113 NETDEV_ENTRY
3114 __field(bool, val)
3115 ),
3116 TP_fast_assign(
3117 WIPHY_ASSIGN;
3118 NETDEV_ASSIGN;
3119 __entry->val = val;
3120 ),
3121 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", config=%u",
3122 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->val)
3123);
3124
3125/*************************************************************
3126 * cfg80211 exported functions traces *
3127 *************************************************************/
3128
3129TRACE_EVENT(cfg80211_return_bool,
3130 TP_PROTO(bool ret),
3131 TP_ARGS(ret),
3132 TP_STRUCT__entry(
3133 __field(bool, ret)
3134 ),
3135 TP_fast_assign(
3136 __entry->ret = ret;
3137 ),
3138 TP_printk("returned %s", BOOL_TO_STR(__entry->ret))
3139);
3140
3141DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt,
3142 TP_PROTO(struct net_device *netdev, const u8 *macaddr),
3143 TP_ARGS(netdev, macaddr),
3144 TP_STRUCT__entry(
3145 NETDEV_ENTRY
3146 MAC_ENTRY(macaddr)
3147 ),
3148 TP_fast_assign(
3149 NETDEV_ASSIGN;
3150 MAC_ASSIGN(macaddr, macaddr);
3151 ),
3152 TP_printk(NETDEV_PR_FMT ", mac: %pM",
3153 NETDEV_PR_ARG, __entry->macaddr)
3154);
3155
3156DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate,
3157 TP_PROTO(struct net_device *netdev, const u8 *macaddr),
3158 TP_ARGS(netdev, macaddr)
3159);
3160
3161TRACE_EVENT(cfg80211_send_rx_assoc,
3162 TP_PROTO(struct net_device *netdev,
3163 const struct cfg80211_rx_assoc_resp_data *data),
3164 TP_ARGS(netdev, data),
3165 TP_STRUCT__entry(
3166 NETDEV_ENTRY
3167 MAC_ENTRY(ap_addr)
3168 ),
3169 TP_fast_assign(
3170 NETDEV_ASSIGN;
3171 MAC_ASSIGN(ap_addr,
3172 data->ap_mld_addr ?: data->links[0].bss->bssid);
3173 ),
3174 TP_printk(NETDEV_PR_FMT ", %pM",
3175 NETDEV_PR_ARG, __entry->ap_addr)
3176);
3177
3178DECLARE_EVENT_CLASS(netdev_frame_event,
3179 TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
3180 TP_ARGS(netdev, buf, len),
3181 TP_STRUCT__entry(
3182 NETDEV_ENTRY
3183 __dynamic_array(u8, frame, len)
3184 ),
3185 TP_fast_assign(
3186 NETDEV_ASSIGN;
3187 memcpy(__get_dynamic_array(frame), buf, len);
3188 ),
3189 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x",
3190 NETDEV_PR_ARG,
3191 le16_to_cpup((__le16 *)__get_dynamic_array(frame)))
3192);
3193
3194DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt,
3195 TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
3196 TP_ARGS(netdev, buf, len)
3197);
3198
3199DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt,
3200 TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
3201 TP_ARGS(netdev, buf, len)
3202);
3203
3204TRACE_EVENT(cfg80211_tx_mlme_mgmt,
3205 TP_PROTO(struct net_device *netdev, const u8 *buf, int len,
3206 bool reconnect),
3207 TP_ARGS(netdev, buf, len, reconnect),
3208 TP_STRUCT__entry(
3209 NETDEV_ENTRY
3210 __dynamic_array(u8, frame, len)
3211 __field(int, reconnect)
3212 ),
3213 TP_fast_assign(
3214 NETDEV_ASSIGN;
3215 memcpy(__get_dynamic_array(frame), buf, len);
3216 __entry->reconnect = reconnect;
3217 ),
3218 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x reconnect:%d",
3219 NETDEV_PR_ARG,
3220 le16_to_cpup((__le16 *)__get_dynamic_array(frame)),
3221 __entry->reconnect)
3222);
3223
3224DECLARE_EVENT_CLASS(netdev_mac_evt,
3225 TP_PROTO(struct net_device *netdev, const u8 *mac),
3226 TP_ARGS(netdev, mac),
3227 TP_STRUCT__entry(
3228 NETDEV_ENTRY
3229 MAC_ENTRY(mac)
3230 ),
3231 TP_fast_assign(
3232 NETDEV_ASSIGN;
3233 MAC_ASSIGN(mac, mac)
3234 ),
3235 TP_printk(NETDEV_PR_FMT ", mac: %pM",
3236 NETDEV_PR_ARG, __entry->mac)
3237);
3238
3239DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout,
3240 TP_PROTO(struct net_device *netdev, const u8 *mac),
3241 TP_ARGS(netdev, mac)
3242);
3243
3244TRACE_EVENT(cfg80211_send_assoc_failure,
3245 TP_PROTO(struct net_device *netdev,
3246 struct cfg80211_assoc_failure *data),
3247 TP_ARGS(netdev, data),
3248 TP_STRUCT__entry(
3249 NETDEV_ENTRY
3250 MAC_ENTRY(ap_addr)
3251 __field(bool, timeout)
3252 ),
3253 TP_fast_assign(
3254 NETDEV_ASSIGN;
3255 MAC_ASSIGN(ap_addr, data->ap_mld_addr ?: data->bss[0]->bssid);
3256 __entry->timeout = data->timeout;
3257 ),
3258 TP_printk(NETDEV_PR_FMT ", mac: %pM, timeout: %d",
3259 NETDEV_PR_ARG, __entry->ap_addr, __entry->timeout)
3260);
3261
3262TRACE_EVENT(cfg80211_michael_mic_failure,
3263 TP_PROTO(struct net_device *netdev, const u8 *addr,
3264 enum nl80211_key_type key_type, int key_id, const u8 *tsc),
3265 TP_ARGS(netdev, addr, key_type, key_id, tsc),
3266 TP_STRUCT__entry(
3267 NETDEV_ENTRY
3268 MAC_ENTRY(addr)
3269 __field(enum nl80211_key_type, key_type)
3270 __field(int, key_id)
3271 __array(u8, tsc, 6)
3272 ),
3273 TP_fast_assign(
3274 NETDEV_ASSIGN;
3275 MAC_ASSIGN(addr, addr);
3276 __entry->key_type = key_type;
3277 __entry->key_id = key_id;
3278 if (tsc)
3279 memcpy(__entry->tsc, tsc, 6);
3280 ),
3281 TP_printk(NETDEV_PR_FMT ", %pM, key type: %d, key id: %d, tsc: %pm",
3282 NETDEV_PR_ARG, __entry->addr, __entry->key_type,
3283 __entry->key_id, __entry->tsc)
3284);
3285
3286TRACE_EVENT(cfg80211_ready_on_channel,
3287 TP_PROTO(struct wireless_dev *wdev, u64 cookie,
3288 struct ieee80211_channel *chan,
3289 unsigned int duration),
3290 TP_ARGS(wdev, cookie, chan, duration),
3291 TP_STRUCT__entry(
3292 WDEV_ENTRY
3293 __field(u64, cookie)
3294 CHAN_ENTRY
3295 __field(unsigned int, duration)
3296 ),
3297 TP_fast_assign(
3298 WDEV_ASSIGN;
3299 __entry->cookie = cookie;
3300 CHAN_ASSIGN(chan);
3301 __entry->duration = duration;
3302 ),
3303 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u",
3304 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG,
3305 __entry->duration)
3306);
3307
3308TRACE_EVENT(cfg80211_ready_on_channel_expired,
3309 TP_PROTO(struct wireless_dev *wdev, u64 cookie,
3310 struct ieee80211_channel *chan),
3311 TP_ARGS(wdev, cookie, chan),
3312 TP_STRUCT__entry(
3313 WDEV_ENTRY
3314 __field(u64, cookie)
3315 CHAN_ENTRY
3316 ),
3317 TP_fast_assign(
3318 WDEV_ASSIGN;
3319 __entry->cookie = cookie;
3320 CHAN_ASSIGN(chan);
3321 ),
3322 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT,
3323 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG)
3324);
3325
3326TRACE_EVENT(cfg80211_tx_mgmt_expired,
3327 TP_PROTO(struct wireless_dev *wdev, u64 cookie,
3328 struct ieee80211_channel *chan),
3329 TP_ARGS(wdev, cookie, chan),
3330 TP_STRUCT__entry(
3331 WDEV_ENTRY
3332 __field(u64, cookie)
3333 CHAN_ENTRY
3334 ),
3335 TP_fast_assign(
3336 WDEV_ASSIGN;
3337 __entry->cookie = cookie;
3338 CHAN_ASSIGN(chan);
3339 ),
3340 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT,
3341 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG)
3342);
3343
3344TRACE_EVENT(cfg80211_new_sta,
3345 TP_PROTO(struct net_device *netdev, const u8 *mac_addr,
3346 struct station_info *sinfo),
3347 TP_ARGS(netdev, mac_addr, sinfo),
3348 TP_STRUCT__entry(
3349 NETDEV_ENTRY
3350 MAC_ENTRY(mac_addr)
3351 SINFO_ENTRY
3352 ),
3353 TP_fast_assign(
3354 NETDEV_ASSIGN;
3355 MAC_ASSIGN(mac_addr, mac_addr);
3356 SINFO_ASSIGN;
3357 ),
3358 TP_printk(NETDEV_PR_FMT ", %pM",
3359 NETDEV_PR_ARG, __entry->mac_addr)
3360);
3361
3362DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta,
3363 TP_PROTO(struct net_device *netdev, const u8 *macaddr),
3364 TP_ARGS(netdev, macaddr)
3365);
3366
3367TRACE_EVENT(cfg80211_rx_mgmt,
3368 TP_PROTO(struct wireless_dev *wdev, struct cfg80211_rx_info *info),
3369 TP_ARGS(wdev, info),
3370 TP_STRUCT__entry(
3371 WDEV_ENTRY
3372 __field(int, freq)
3373 __field(int, sig_dbm)
3374 ),
3375 TP_fast_assign(
3376 WDEV_ASSIGN;
3377 __entry->freq = info->freq;
3378 __entry->sig_dbm = info->sig_dbm;
3379 ),
3380 TP_printk(WDEV_PR_FMT ", freq: "KHZ_F", sig dbm: %d",
3381 WDEV_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm)
3382);
3383
3384TRACE_EVENT(cfg80211_mgmt_tx_status,
3385 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack),
3386 TP_ARGS(wdev, cookie, ack),
3387 TP_STRUCT__entry(
3388 WDEV_ENTRY
3389 __field(u64, cookie)
3390 __field(bool, ack)
3391 ),
3392 TP_fast_assign(
3393 WDEV_ASSIGN;
3394 __entry->cookie = cookie;
3395 __entry->ack = ack;
3396 ),
3397 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s",
3398 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack))
3399);
3400
3401TRACE_EVENT(cfg80211_control_port_tx_status,
3402 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack),
3403 TP_ARGS(wdev, cookie, ack),
3404 TP_STRUCT__entry(
3405 WDEV_ENTRY
3406 __field(u64, cookie)
3407 __field(bool, ack)
3408 ),
3409 TP_fast_assign(
3410 WDEV_ASSIGN;
3411 __entry->cookie = cookie;
3412 __entry->ack = ack;
3413 ),
3414 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s",
3415 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack))
3416);
3417
3418TRACE_EVENT(cfg80211_rx_control_port,
3419 TP_PROTO(struct net_device *netdev, struct sk_buff *skb,
3420 bool unencrypted, int link_id),
3421 TP_ARGS(netdev, skb, unencrypted, link_id),
3422 TP_STRUCT__entry(
3423 NETDEV_ENTRY
3424 __field(int, len)
3425 MAC_ENTRY(from)
3426 __field(u16, proto)
3427 __field(bool, unencrypted)
3428 __field(int, link_id)
3429 ),
3430 TP_fast_assign(
3431 NETDEV_ASSIGN;
3432 __entry->len = skb->len;
3433 MAC_ASSIGN(from, eth_hdr(skb)->h_source);
3434 __entry->proto = be16_to_cpu(skb->protocol);
3435 __entry->unencrypted = unencrypted;
3436 __entry->link_id = link_id;
3437 ),
3438 TP_printk(NETDEV_PR_FMT ", len=%d, %pM, proto: 0x%x, unencrypted: %s, link: %d",
3439 NETDEV_PR_ARG, __entry->len, __entry->from,
3440 __entry->proto, BOOL_TO_STR(__entry->unencrypted),
3441 __entry->link_id)
3442);
3443
3444TRACE_EVENT(cfg80211_cqm_rssi_notify,
3445 TP_PROTO(struct net_device *netdev,
3446 enum nl80211_cqm_rssi_threshold_event rssi_event,
3447 s32 rssi_level),
3448 TP_ARGS(netdev, rssi_event, rssi_level),
3449 TP_STRUCT__entry(
3450 NETDEV_ENTRY
3451 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event)
3452 __field(s32, rssi_level)
3453 ),
3454 TP_fast_assign(
3455 NETDEV_ASSIGN;
3456 __entry->rssi_event = rssi_event;
3457 __entry->rssi_level = rssi_level;
3458 ),
3459 TP_printk(NETDEV_PR_FMT ", rssi event: %d, level: %d",
3460 NETDEV_PR_ARG, __entry->rssi_event, __entry->rssi_level)
3461);
3462
3463TRACE_EVENT(cfg80211_reg_can_beacon,
3464 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef,
3465 enum nl80211_iftype iftype, u32 prohibited_flags,
3466 u32 permitting_flags),
3467 TP_ARGS(wiphy, chandef, iftype, prohibited_flags, permitting_flags),
3468 TP_STRUCT__entry(
3469 WIPHY_ENTRY
3470 CHAN_DEF_ENTRY
3471 __field(enum nl80211_iftype, iftype)
3472 __field(u32, prohibited_flags)
3473 __field(u32, permitting_flags)
3474 ),
3475 TP_fast_assign(
3476 WIPHY_ASSIGN;
3477 CHAN_DEF_ASSIGN(chandef);
3478 __entry->iftype = iftype;
3479 __entry->prohibited_flags = prohibited_flags;
3480 __entry->permitting_flags = permitting_flags;
3481 ),
3482 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d prohibited_flags=0x%x permitting_flags=0x%x",
3483 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype,
3484 __entry->prohibited_flags, __entry->permitting_flags)
3485);
3486
3487TRACE_EVENT(cfg80211_ch_switch_notify,
3488 TP_PROTO(struct net_device *netdev,
3489 struct cfg80211_chan_def *chandef,
3490 unsigned int link_id),
3491 TP_ARGS(netdev, chandef, link_id),
3492 TP_STRUCT__entry(
3493 NETDEV_ENTRY
3494 CHAN_DEF_ENTRY
3495 __field(unsigned int, link_id)
3496 ),
3497 TP_fast_assign(
3498 NETDEV_ASSIGN;
3499 CHAN_DEF_ASSIGN(chandef);
3500 __entry->link_id = link_id;
3501 ),
3502 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d",
3503 NETDEV_PR_ARG, CHAN_DEF_PR_ARG, __entry->link_id)
3504);
3505
3506TRACE_EVENT(cfg80211_ch_switch_started_notify,
3507 TP_PROTO(struct net_device *netdev,
3508 struct cfg80211_chan_def *chandef,
3509 unsigned int link_id),
3510 TP_ARGS(netdev, chandef, link_id),
3511 TP_STRUCT__entry(
3512 NETDEV_ENTRY
3513 CHAN_DEF_ENTRY
3514 __field(unsigned int, link_id)
3515 ),
3516 TP_fast_assign(
3517 NETDEV_ASSIGN;
3518 CHAN_DEF_ASSIGN(chandef);
3519 __entry->link_id = link_id;
3520 ),
3521 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d",
3522 NETDEV_PR_ARG, CHAN_DEF_PR_ARG, __entry->link_id)
3523);
3524
3525TRACE_EVENT(cfg80211_radar_event,
3526 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef,
3527 bool offchan),
3528 TP_ARGS(wiphy, chandef, offchan),
3529 TP_STRUCT__entry(
3530 WIPHY_ENTRY
3531 CHAN_DEF_ENTRY
3532 __field(bool, offchan)
3533 ),
3534 TP_fast_assign(
3535 WIPHY_ASSIGN;
3536 CHAN_DEF_ASSIGN(chandef);
3537 __entry->offchan = offchan;
3538 ),
3539 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", offchan %d",
3540 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->offchan)
3541);
3542
3543TRACE_EVENT(cfg80211_cac_event,
3544 TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt,
3545 unsigned int link_id),
3546 TP_ARGS(netdev, evt, link_id),
3547 TP_STRUCT__entry(
3548 NETDEV_ENTRY
3549 __field(enum nl80211_radar_event, evt)
3550 __field(unsigned int, link_id)
3551 ),
3552 TP_fast_assign(
3553 NETDEV_ASSIGN;
3554 __entry->evt = evt;
3555 __entry->link_id = link_id;
3556 ),
3557 TP_printk(NETDEV_PR_FMT ", event: %d, link_id=%u",
3558 NETDEV_PR_ARG, __entry->evt, __entry->link_id)
3559);
3560
3561DECLARE_EVENT_CLASS(cfg80211_rx_evt,
3562 TP_PROTO(struct net_device *netdev, const u8 *addr, int link_id),
3563 TP_ARGS(netdev, addr, link_id),
3564 TP_STRUCT__entry(
3565 NETDEV_ENTRY
3566 MAC_ENTRY(addr)
3567 __field(int, link_id)
3568 ),
3569 TP_fast_assign(
3570 NETDEV_ASSIGN;
3571 MAC_ASSIGN(addr, addr);
3572 __entry->link_id = link_id;
3573 ),
3574 TP_printk(NETDEV_PR_FMT ", %pM, link_id:%d", NETDEV_PR_ARG,
3575 __entry->addr, __entry->link_id)
3576);
3577
3578DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame,
3579 TP_PROTO(struct net_device *netdev, const u8 *addr, int link_id),
3580 TP_ARGS(netdev, addr, link_id)
3581);
3582
3583DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame,
3584 TP_PROTO(struct net_device *netdev, const u8 *addr, int link_id),
3585 TP_ARGS(netdev, addr, link_id)
3586);
3587
3588TRACE_EVENT(cfg80211_ibss_joined,
3589 TP_PROTO(struct net_device *netdev, const u8 *bssid,
3590 struct ieee80211_channel *channel),
3591 TP_ARGS(netdev, bssid, channel),
3592 TP_STRUCT__entry(
3593 NETDEV_ENTRY
3594 MAC_ENTRY(bssid)
3595 CHAN_ENTRY
3596 ),
3597 TP_fast_assign(
3598 NETDEV_ASSIGN;
3599 MAC_ASSIGN(bssid, bssid);
3600 CHAN_ASSIGN(channel);
3601 ),
3602 TP_printk(NETDEV_PR_FMT ", bssid: %pM, " CHAN_PR_FMT,
3603 NETDEV_PR_ARG, __entry->bssid, CHAN_PR_ARG)
3604);
3605
3606TRACE_EVENT(cfg80211_probe_status,
3607 TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie,
3608 bool acked),
3609 TP_ARGS(netdev, addr, cookie, acked),
3610 TP_STRUCT__entry(
3611 NETDEV_ENTRY
3612 MAC_ENTRY(addr)
3613 __field(u64, cookie)
3614 __field(bool, acked)
3615 ),
3616 TP_fast_assign(
3617 NETDEV_ASSIGN;
3618 MAC_ASSIGN(addr, addr);
3619 __entry->cookie = cookie;
3620 __entry->acked = acked;
3621 ),
3622 TP_printk(NETDEV_PR_FMT " addr:%pM, cookie: %llu, acked: %s",
3623 NETDEV_PR_ARG, __entry->addr, __entry->cookie,
3624 BOOL_TO_STR(__entry->acked))
3625);
3626
3627TRACE_EVENT(cfg80211_cqm_pktloss_notify,
3628 TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets),
3629 TP_ARGS(netdev, peer, num_packets),
3630 TP_STRUCT__entry(
3631 NETDEV_ENTRY
3632 MAC_ENTRY(peer)
3633 __field(u32, num_packets)
3634 ),
3635 TP_fast_assign(
3636 NETDEV_ASSIGN;
3637 MAC_ASSIGN(peer, peer);
3638 __entry->num_packets = num_packets;
3639 ),
3640 TP_printk(NETDEV_PR_FMT ", peer: %pM, num of lost packets: %u",
3641 NETDEV_PR_ARG, __entry->peer, __entry->num_packets)
3642);
3643
3644DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify,
3645 TP_PROTO(struct net_device *netdev, const u8 *macaddr),
3646 TP_ARGS(netdev, macaddr)
3647);
3648
3649TRACE_EVENT(cfg80211_pmksa_candidate_notify,
3650 TP_PROTO(struct net_device *netdev, int index, const u8 *bssid,
3651 bool preauth),
3652 TP_ARGS(netdev, index, bssid, preauth),
3653 TP_STRUCT__entry(
3654 NETDEV_ENTRY
3655 __field(int, index)
3656 MAC_ENTRY(bssid)
3657 __field(bool, preauth)
3658 ),
3659 TP_fast_assign(
3660 NETDEV_ASSIGN;
3661 __entry->index = index;
3662 MAC_ASSIGN(bssid, bssid);
3663 __entry->preauth = preauth;
3664 ),
3665 TP_printk(NETDEV_PR_FMT ", index:%d, bssid: %pM, pre auth: %s",
3666 NETDEV_PR_ARG, __entry->index, __entry->bssid,
3667 BOOL_TO_STR(__entry->preauth))
3668);
3669
3670TRACE_EVENT(cfg80211_report_obss_beacon,
3671 TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len,
3672 int freq, int sig_dbm),
3673 TP_ARGS(wiphy, frame, len, freq, sig_dbm),
3674 TP_STRUCT__entry(
3675 WIPHY_ENTRY
3676 __field(int, freq)
3677 __field(int, sig_dbm)
3678 ),
3679 TP_fast_assign(
3680 WIPHY_ASSIGN;
3681 __entry->freq = freq;
3682 __entry->sig_dbm = sig_dbm;
3683 ),
3684 TP_printk(WIPHY_PR_FMT ", freq: "KHZ_F", sig_dbm: %d",
3685 WIPHY_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm)
3686);
3687
3688TRACE_EVENT(cfg80211_tdls_oper_request,
3689 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer,
3690 enum nl80211_tdls_operation oper, u16 reason_code),
3691 TP_ARGS(wiphy, netdev, peer, oper, reason_code),
3692 TP_STRUCT__entry(
3693 WIPHY_ENTRY
3694 NETDEV_ENTRY
3695 MAC_ENTRY(peer)
3696 __field(enum nl80211_tdls_operation, oper)
3697 __field(u16, reason_code)
3698 ),
3699 TP_fast_assign(
3700 WIPHY_ASSIGN;
3701 NETDEV_ASSIGN;
3702 MAC_ASSIGN(peer, peer);
3703 __entry->oper = oper;
3704 __entry->reason_code = reason_code;
3705 ),
3706 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM, oper: %d, reason_code %u",
3707 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper,
3708 __entry->reason_code)
3709 );
3710
3711TRACE_EVENT(cfg80211_scan_done,
3712 TP_PROTO(struct cfg80211_scan_request_int *request,
3713 struct cfg80211_scan_info *info),
3714 TP_ARGS(request, info),
3715 TP_STRUCT__entry(
3716 __field(u32, n_channels)
3717 __dynamic_array(u8, ie, request ? request->req.ie_len : 0)
3718 __array(u32, rates, NUM_NL80211_BANDS)
3719 __field(u32, wdev_id)
3720 MAC_ENTRY(wiphy_mac)
3721 __field(bool, no_cck)
3722 __field(bool, aborted)
3723 __field(u64, scan_start_tsf)
3724 MAC_ENTRY(tsf_bssid)
3725 ),
3726 TP_fast_assign(
3727 if (request) {
3728 memcpy(__get_dynamic_array(ie), request->req.ie,
3729 request->req.ie_len);
3730 memcpy(__entry->rates, request->req.rates,
3731 NUM_NL80211_BANDS);
3732 __entry->wdev_id = request->req.wdev ?
3733 request->req.wdev->identifier : 0;
3734 if (request->req.wiphy)
3735 MAC_ASSIGN(wiphy_mac,
3736 request->req.wiphy->perm_addr);
3737 __entry->no_cck = request->req.no_cck;
3738 }
3739 if (info) {
3740 __entry->aborted = info->aborted;
3741 __entry->scan_start_tsf = info->scan_start_tsf;
3742 MAC_ASSIGN(tsf_bssid, info->tsf_bssid);
3743 }
3744 ),
3745 TP_printk("aborted: %s, scan start (TSF): %llu, tsf_bssid: %pM",
3746 BOOL_TO_STR(__entry->aborted),
3747 (unsigned long long)__entry->scan_start_tsf,
3748 __entry->tsf_bssid)
3749);
3750
3751DECLARE_EVENT_CLASS(wiphy_id_evt,
3752 TP_PROTO(struct wiphy *wiphy, u64 id),
3753 TP_ARGS(wiphy, id),
3754 TP_STRUCT__entry(
3755 WIPHY_ENTRY
3756 __field(u64, id)
3757 ),
3758 TP_fast_assign(
3759 WIPHY_ASSIGN;
3760 __entry->id = id;
3761 ),
3762 TP_printk(WIPHY_PR_FMT ", id: %llu", WIPHY_PR_ARG, __entry->id)
3763);
3764
3765DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped,
3766 TP_PROTO(struct wiphy *wiphy, u64 id),
3767 TP_ARGS(wiphy, id)
3768);
3769
3770DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results,
3771 TP_PROTO(struct wiphy *wiphy, u64 id),
3772 TP_ARGS(wiphy, id)
3773);
3774
3775TRACE_EVENT(cfg80211_get_bss,
3776 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
3777 const u8 *bssid, const u8 *ssid, size_t ssid_len,
3778 enum ieee80211_bss_type bss_type,
3779 enum ieee80211_privacy privacy),
3780 TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy),
3781 TP_STRUCT__entry(
3782 WIPHY_ENTRY
3783 CHAN_ENTRY
3784 MAC_ENTRY(bssid)
3785 __dynamic_array(u8, ssid, ssid_len)
3786 __field(enum ieee80211_bss_type, bss_type)
3787 __field(enum ieee80211_privacy, privacy)
3788 ),
3789 TP_fast_assign(
3790 WIPHY_ASSIGN;
3791 CHAN_ASSIGN(channel);
3792 MAC_ASSIGN(bssid, bssid);
3793 memcpy(__get_dynamic_array(ssid), ssid, ssid_len);
3794 __entry->bss_type = bss_type;
3795 __entry->privacy = privacy;
3796 ),
3797 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", %pM"
3798 ", buf: %#.2x, bss_type: %d, privacy: %d",
3799 WIPHY_PR_ARG, CHAN_PR_ARG, __entry->bssid,
3800 ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type,
3801 __entry->privacy)
3802);
3803
3804TRACE_EVENT(cfg80211_inform_bss_frame,
3805 TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data,
3806 struct ieee80211_mgmt *mgmt, size_t len),
3807 TP_ARGS(wiphy, data, mgmt, len),
3808 TP_STRUCT__entry(
3809 WIPHY_ENTRY
3810 CHAN_ENTRY
3811 __dynamic_array(u8, mgmt, len)
3812 __field(s32, signal)
3813 __field(u64, ts_boottime)
3814 __field(u64, parent_tsf)
3815 MAC_ENTRY(parent_bssid)
3816 ),
3817 TP_fast_assign(
3818 WIPHY_ASSIGN;
3819 CHAN_ASSIGN(data->chan);
3820 if (mgmt)
3821 memcpy(__get_dynamic_array(mgmt), mgmt, len);
3822 __entry->signal = data->signal;
3823 __entry->ts_boottime = data->boottime_ns;
3824 __entry->parent_tsf = data->parent_tsf;
3825 MAC_ASSIGN(parent_bssid, data->parent_bssid);
3826 ),
3827 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT
3828 "signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: %pM",
3829 WIPHY_PR_ARG, CHAN_PR_ARG,
3830 __entry->signal, (unsigned long long)__entry->ts_boottime,
3831 (unsigned long long)__entry->parent_tsf,
3832 __entry->parent_bssid)
3833);
3834
3835DECLARE_EVENT_CLASS(cfg80211_bss_evt,
3836 TP_PROTO(struct cfg80211_bss *pub),
3837 TP_ARGS(pub),
3838 TP_STRUCT__entry(
3839 MAC_ENTRY(bssid)
3840 CHAN_ENTRY
3841 ),
3842 TP_fast_assign(
3843 MAC_ASSIGN(bssid, pub->bssid);
3844 CHAN_ASSIGN(pub->channel);
3845 ),
3846 TP_printk("%pM, " CHAN_PR_FMT, __entry->bssid, CHAN_PR_ARG)
3847);
3848
3849DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss,
3850 TP_PROTO(struct cfg80211_bss *pub),
3851 TP_ARGS(pub)
3852);
3853
3854TRACE_EVENT(cfg80211_report_wowlan_wakeup,
3855 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3856 struct cfg80211_wowlan_wakeup *wakeup),
3857 TP_ARGS(wiphy, wdev, wakeup),
3858 TP_STRUCT__entry(
3859 WIPHY_ENTRY
3860 WDEV_ENTRY
3861 __field(bool, non_wireless)
3862 __field(bool, disconnect)
3863 __field(bool, magic_pkt)
3864 __field(bool, gtk_rekey_failure)
3865 __field(bool, eap_identity_req)
3866 __field(bool, four_way_handshake)
3867 __field(bool, rfkill_release)
3868 __field(s32, pattern_idx)
3869 __field(u32, packet_len)
3870 __dynamic_array(u8, packet,
3871 wakeup ? wakeup->packet_present_len : 0)
3872 ),
3873 TP_fast_assign(
3874 WIPHY_ASSIGN;
3875 WDEV_ASSIGN;
3876 __entry->non_wireless = !wakeup;
3877 __entry->disconnect = wakeup ? wakeup->disconnect : false;
3878 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false;
3879 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false;
3880 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false;
3881 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false;
3882 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false;
3883 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false;
3884 __entry->packet_len = wakeup ? wakeup->packet_len : false;
3885 if (wakeup && wakeup->packet && wakeup->packet_present_len)
3886 memcpy(__get_dynamic_array(packet), wakeup->packet,
3887 wakeup->packet_present_len);
3888 ),
3889 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
3890);
3891
3892TRACE_EVENT(cfg80211_ft_event,
3893 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3894 struct cfg80211_ft_event_params *ft_event),
3895 TP_ARGS(wiphy, netdev, ft_event),
3896 TP_STRUCT__entry(
3897 WIPHY_ENTRY
3898 NETDEV_ENTRY
3899 __dynamic_array(u8, ies, ft_event->ies_len)
3900 MAC_ENTRY(target_ap)
3901 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len)
3902 ),
3903 TP_fast_assign(
3904 WIPHY_ASSIGN;
3905 NETDEV_ASSIGN;
3906 if (ft_event->ies)
3907 memcpy(__get_dynamic_array(ies), ft_event->ies,
3908 ft_event->ies_len);
3909 MAC_ASSIGN(target_ap, ft_event->target_ap);
3910 if (ft_event->ric_ies)
3911 memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies,
3912 ft_event->ric_ies_len);
3913 ),
3914 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: %pM",
3915 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->target_ap)
3916);
3917
3918TRACE_EVENT(cfg80211_stop_iface,
3919 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
3920 TP_ARGS(wiphy, wdev),
3921 TP_STRUCT__entry(
3922 WIPHY_ENTRY
3923 WDEV_ENTRY
3924 ),
3925 TP_fast_assign(
3926 WIPHY_ASSIGN;
3927 WDEV_ASSIGN;
3928 ),
3929 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
3930 WIPHY_PR_ARG, WDEV_PR_ARG)
3931);
3932
3933TRACE_EVENT(cfg80211_pmsr_report,
3934 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
3935 u64 cookie, const u8 *addr),
3936 TP_ARGS(wiphy, wdev, cookie, addr),
3937 TP_STRUCT__entry(
3938 WIPHY_ENTRY
3939 WDEV_ENTRY
3940 __field(u64, cookie)
3941 MAC_ENTRY(addr)
3942 ),
3943 TP_fast_assign(
3944 WIPHY_ASSIGN;
3945 WDEV_ASSIGN;
3946 __entry->cookie = cookie;
3947 MAC_ASSIGN(addr, addr);
3948 ),
3949 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld, %pM",
3950 WIPHY_PR_ARG, WDEV_PR_ARG,
3951 (unsigned long long)__entry->cookie,
3952 __entry->addr)
3953);
3954
3955TRACE_EVENT(cfg80211_pmsr_complete,
3956 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
3957 TP_ARGS(wiphy, wdev, cookie),
3958 TP_STRUCT__entry(
3959 WIPHY_ENTRY
3960 WDEV_ENTRY
3961 __field(u64, cookie)
3962 ),
3963 TP_fast_assign(
3964 WIPHY_ASSIGN;
3965 WDEV_ASSIGN;
3966 __entry->cookie = cookie;
3967 ),
3968 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld",
3969 WIPHY_PR_ARG, WDEV_PR_ARG,
3970 (unsigned long long)__entry->cookie)
3971);
3972
3973TRACE_EVENT(cfg80211_update_owe_info_event,
3974 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
3975 struct cfg80211_update_owe_info *owe_info),
3976 TP_ARGS(wiphy, netdev, owe_info),
3977 TP_STRUCT__entry(
3978 WIPHY_ENTRY
3979 NETDEV_ENTRY
3980 MAC_ENTRY(peer)
3981 __dynamic_array(u8, ie, owe_info->ie_len)
3982 __field(int, assoc_link_id)
3983 MAC_ENTRY(peer_mld_addr)
3984 ),
3985 TP_fast_assign(
3986 WIPHY_ASSIGN;
3987 NETDEV_ASSIGN;
3988 MAC_ASSIGN(peer, owe_info->peer);
3989 memcpy(__get_dynamic_array(ie), owe_info->ie,
3990 owe_info->ie_len);
3991 __entry->assoc_link_id = owe_info->assoc_link_id;
3992 MAC_ASSIGN(peer_mld_addr, owe_info->peer_mld_addr);
3993 ),
3994 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM,"
3995 " assoc_link_id: %d, peer_mld_addr: %pM",
3996 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer,
3997 __entry->assoc_link_id, __entry->peer_mld_addr)
3998);
3999
4000TRACE_EVENT(cfg80211_bss_color_notify,
4001 TP_PROTO(struct net_device *netdev,
4002 enum nl80211_commands cmd,
4003 u8 count, u64 color_bitmap),
4004 TP_ARGS(netdev, cmd, count, color_bitmap),
4005 TP_STRUCT__entry(
4006 NETDEV_ENTRY
4007 __field(u32, cmd)
4008 __field(u8, count)
4009 __field(u64, color_bitmap)
4010 ),
4011 TP_fast_assign(
4012 NETDEV_ASSIGN;
4013 __entry->cmd = cmd;
4014 __entry->count = count;
4015 __entry->color_bitmap = color_bitmap;
4016 ),
4017 TP_printk(NETDEV_PR_FMT ", cmd: %x, count: %u, bitmap: %llx",
4018 NETDEV_PR_ARG, __entry->cmd, __entry->count,
4019 __entry->color_bitmap)
4020);
4021
4022TRACE_EVENT(cfg80211_assoc_comeback,
4023 TP_PROTO(struct wireless_dev *wdev, const u8 *ap_addr, u32 timeout),
4024 TP_ARGS(wdev, ap_addr, timeout),
4025 TP_STRUCT__entry(
4026 WDEV_ENTRY
4027 MAC_ENTRY(ap_addr)
4028 __field(u32, timeout)
4029 ),
4030 TP_fast_assign(
4031 WDEV_ASSIGN;
4032 MAC_ASSIGN(ap_addr, ap_addr);
4033 __entry->timeout = timeout;
4034 ),
4035 TP_printk(WDEV_PR_FMT ", %pM, timeout: %u TUs",
4036 WDEV_PR_ARG, __entry->ap_addr, __entry->timeout)
4037);
4038
4039DECLARE_EVENT_CLASS(link_station_add_mod,
4040 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
4041 struct link_station_parameters *params),
4042 TP_ARGS(wiphy, netdev, params),
4043 TP_STRUCT__entry(
4044 WIPHY_ENTRY
4045 NETDEV_ENTRY
4046 __array(u8, mld_mac, 6)
4047 __array(u8, link_mac, 6)
4048 __field(u32, link_id)
4049 __dynamic_array(u8, supported_rates,
4050 params->supported_rates_len)
4051 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
4052 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap))
4053 __field(u8, opmode_notif)
4054 __field(bool, opmode_notif_used)
4055 __dynamic_array(u8, he_capa, params->he_capa_len)
4056 __array(u8, he_6ghz_capa, (int)sizeof(struct ieee80211_he_6ghz_capa))
4057 __dynamic_array(u8, eht_capa, params->eht_capa_len)
4058 ),
4059 TP_fast_assign(
4060 WIPHY_ASSIGN;
4061 NETDEV_ASSIGN;
4062 memset(__entry->mld_mac, 0, 6);
4063 memset(__entry->link_mac, 0, 6);
4064 if (params->mld_mac)
4065 memcpy(__entry->mld_mac, params->mld_mac, 6);
4066 if (params->link_mac)
4067 memcpy(__entry->link_mac, params->link_mac, 6);
4068 __entry->link_id = params->link_id;
4069 if (params->supported_rates && params->supported_rates_len)
4070 memcpy(__get_dynamic_array(supported_rates),
4071 params->supported_rates,
4072 params->supported_rates_len);
4073 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
4074 if (params->ht_capa)
4075 memcpy(__entry->ht_capa, params->ht_capa,
4076 sizeof(struct ieee80211_ht_cap));
4077 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap));
4078 if (params->vht_capa)
4079 memcpy(__entry->vht_capa, params->vht_capa,
4080 sizeof(struct ieee80211_vht_cap));
4081 __entry->opmode_notif = params->opmode_notif;
4082 __entry->opmode_notif_used = params->opmode_notif_used;
4083 if (params->he_capa && params->he_capa_len)
4084 memcpy(__get_dynamic_array(he_capa), params->he_capa,
4085 params->he_capa_len);
4086 memset(__entry->he_6ghz_capa, 0, sizeof(struct ieee80211_he_6ghz_capa));
4087 if (params->he_6ghz_capa)
4088 memcpy(__entry->he_6ghz_capa, params->he_6ghz_capa,
4089 sizeof(struct ieee80211_he_6ghz_capa));
4090 if (params->eht_capa && params->eht_capa_len)
4091 memcpy(__get_dynamic_array(eht_capa), params->eht_capa,
4092 params->eht_capa_len);
4093 ),
4094 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM"
4095 ", link mac: %pM, link id: %u",
4096 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac,
4097 __entry->link_mac, __entry->link_id)
4098);
4099
4100DEFINE_EVENT(link_station_add_mod, rdev_add_link_station,
4101 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
4102 struct link_station_parameters *params),
4103 TP_ARGS(wiphy, netdev, params)
4104);
4105
4106DEFINE_EVENT(link_station_add_mod, rdev_mod_link_station,
4107 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
4108 struct link_station_parameters *params),
4109 TP_ARGS(wiphy, netdev, params)
4110);
4111
4112TRACE_EVENT(cfg80211_links_removed,
4113 TP_PROTO(struct net_device *netdev, u16 link_mask),
4114 TP_ARGS(netdev, link_mask),
4115 TP_STRUCT__entry(
4116 NETDEV_ENTRY
4117 __field(u16, link_mask)
4118 ),
4119 TP_fast_assign(
4120 NETDEV_ASSIGN;
4121 __entry->link_mask = link_mask;
4122 ),
4123 TP_printk(NETDEV_PR_FMT ", link_mask:0x%x", NETDEV_PR_ARG,
4124 __entry->link_mask)
4125);
4126
4127TRACE_EVENT(cfg80211_mlo_reconf_add_done,
4128 TP_PROTO(struct net_device *netdev, u16 link_mask,
4129 const u8 *buf, size_t len, bool driver_initiated),
4130 TP_ARGS(netdev, link_mask, buf, len, driver_initiated),
4131 TP_STRUCT__entry(
4132 NETDEV_ENTRY
4133 __field(u16, link_mask)
4134 __dynamic_array(u8, buf, len)
4135 __field(bool, driver_initiated)
4136 ),
4137 TP_fast_assign(
4138 NETDEV_ASSIGN;
4139 __entry->link_mask = link_mask;
4140 memcpy(__get_dynamic_array(buf), buf, len);
4141 __entry->driver_initiated = driver_initiated;
4142 ),
4143 TP_printk(NETDEV_PR_FMT ", link_mask:0x%x, driver_initiated:%d",
4144 NETDEV_PR_ARG, __entry->link_mask, __entry->driver_initiated)
4145);
4146
4147TRACE_EVENT(rdev_assoc_ml_reconf,
4148 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
4149 struct cfg80211_ml_reconf_req *req),
4150 TP_ARGS(wiphy, netdev, req),
4151 TP_STRUCT__entry(
4152 WIPHY_ENTRY
4153 NETDEV_ENTRY
4154 __field(u16, add_links)
4155 __field(u16, rem_links)
4156 __field(u16, ext_mld_capa_ops)
4157 ),
4158 TP_fast_assign(
4159 WIPHY_ASSIGN;
4160 NETDEV_ASSIGN;
4161 u32 i;
4162
4163 __entry->add_links = 0;
4164 __entry->rem_links = req->rem_links;
4165 for (i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++)
4166 if (req->add_links[i].bss)
4167 __entry->add_links |= BIT(i);
4168 __entry->ext_mld_capa_ops = req->ext_mld_capa_ops;
4169 ),
4170 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", add_links=0x%x, rem_links=0x%x",
4171 WIPHY_PR_ARG, NETDEV_PR_ARG,
4172 __entry->add_links, __entry->rem_links)
4173);
4174
4175TRACE_EVENT(cfg80211_epcs_changed,
4176 TP_PROTO(struct wireless_dev *wdev, bool enabled),
4177 TP_ARGS(wdev, enabled),
4178 TP_STRUCT__entry(
4179 WDEV_ENTRY
4180 __field(u32, enabled)
4181 ),
4182 TP_fast_assign(
4183 WDEV_ASSIGN;
4184 __entry->enabled = enabled;
4185 ),
4186 TP_printk(WDEV_PR_FMT ", enabled=%u",
4187 WDEV_PR_ARG, __entry->enabled)
4188);
4189
4190TRACE_EVENT(cfg80211_next_nan_dw_notif,
4191 TP_PROTO(struct wireless_dev *wdev,
4192 struct ieee80211_channel *chan),
4193 TP_ARGS(wdev, chan),
4194 TP_STRUCT__entry(
4195 WDEV_ENTRY
4196 CHAN_ENTRY
4197 ),
4198 TP_fast_assign(
4199 WDEV_ASSIGN;
4200 CHAN_ASSIGN(chan);
4201 ),
4202 TP_printk(WDEV_PR_FMT " " CHAN_PR_FMT,
4203 WDEV_PR_ARG, CHAN_PR_ARG)
4204);
4205
4206TRACE_EVENT(cfg80211_nan_cluster_joined,
4207 TP_PROTO(struct wireless_dev *wdev,
4208 const u8 *cluster_id,
4209 bool new_cluster),
4210 TP_ARGS(wdev, cluster_id, new_cluster),
4211 TP_STRUCT__entry(
4212 WDEV_ENTRY
4213 MAC_ENTRY(cluster_id)
4214 __field(bool, new_cluster)
4215 ),
4216 TP_fast_assign(
4217 WDEV_ASSIGN;
4218 MAC_ASSIGN(cluster_id, cluster_id);
4219 __entry->new_cluster = new_cluster;
4220 ),
4221 TP_printk(WDEV_PR_FMT " cluster_id %pMF%s",
4222 WDEV_PR_ARG, __entry->cluster_id,
4223 __entry->new_cluster ? " [new]" : "")
4224);
4225#endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */
4226
4227#undef TRACE_INCLUDE_PATH
4228#define TRACE_INCLUDE_PATH .
4229#undef TRACE_INCLUDE_FILE
4230#define TRACE_INCLUDE_FILE trace
4231#include <trace/define_trace.h>
4232

source code of linux/net/wireless/trace.h