projects/linux·blob master · refs

4414 lines · 120.6 KiB

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