~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/wireless/trace.h

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 #undef TRACE_SYSTEM
  2 #define TRACE_SYSTEM cfg80211
  3 
  4 #if !defined(__RDEV_OPS_TRACE) || defined(TRACE_HEADER_MULTI_READ)
  5 #define __RDEV_OPS_TRACE
  6 
  7 #include <linux/tracepoint.h>
  8 
  9 #include <linux/rtnetlink.h>
 10 #include <linux/etherdevice.h>
 11 #include <net/cfg80211.h>
 12 #include "core.h"
 13 
 14 #define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN)
 15 #define MAC_ASSIGN(entry_mac, given_mac) do {                        \
 16         if (given_mac)                                               \
 17                 memcpy(__entry->entry_mac, given_mac, ETH_ALEN);     \
 18         else                                                         \
 19                 eth_zero_addr(__entry->entry_mac);                   \
 20         } while (0)
 21 #define MAC_PR_FMT "%pM"
 22 #define MAC_PR_ARG(entry_mac) (__entry->entry_mac)
 23 
 24 #define MAXNAME         32
 25 #define WIPHY_ENTRY     __array(char, wiphy_name, 32)
 26 #define WIPHY_ASSIGN    strlcpy(__entry->wiphy_name, wiphy_name(wiphy), MAXNAME)
 27 #define WIPHY_PR_FMT    "%s"
 28 #define WIPHY_PR_ARG    __entry->wiphy_name
 29 
 30 #define WDEV_ENTRY      __field(u32, id)
 31 #define WDEV_ASSIGN     (__entry->id) = (!IS_ERR_OR_NULL(wdev)  \
 32                                          ? wdev->identifier : 0)
 33 #define WDEV_PR_FMT     "wdev(%u)"
 34 #define WDEV_PR_ARG     (__entry->id)
 35 
 36 #define NETDEV_ENTRY    __array(char, name, IFNAMSIZ) \
 37                         __field(int, ifindex)
 38 #define NETDEV_ASSIGN                                          \
 39         do {                                                   \
 40                 memcpy(__entry->name, netdev->name, IFNAMSIZ); \
 41                 (__entry->ifindex) = (netdev->ifindex);        \
 42         } while (0)
 43 #define NETDEV_PR_FMT   "netdev:%s(%d)"
 44 #define NETDEV_PR_ARG   __entry->name, __entry->ifindex
 45 
 46 #define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout)                 \
 47                        __field(u16, dot11MeshConfirmTimeout)               \
 48                        __field(u16, dot11MeshHoldingTimeout)               \
 49                        __field(u16, dot11MeshMaxPeerLinks)                 \
 50                        __field(u8, dot11MeshMaxRetries)                    \
 51                        __field(u8, dot11MeshTTL)                           \
 52                        __field(u8, element_ttl)                            \
 53                        __field(bool, auto_open_plinks)                     \
 54                        __field(u32, dot11MeshNbrOffsetMaxNeighbor)         \
 55                        __field(u8, dot11MeshHWMPmaxPREQretries)            \
 56                        __field(u32, path_refresh_time)                     \
 57                        __field(u32, dot11MeshHWMPactivePathTimeout)        \
 58                        __field(u16, min_discovery_timeout)                 \
 59                        __field(u16, dot11MeshHWMPpreqMinInterval)          \
 60                        __field(u16, dot11MeshHWMPperrMinInterval)          \
 61                        __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \
 62                        __field(u8, dot11MeshHWMPRootMode)                  \
 63                        __field(u16, dot11MeshHWMPRannInterval)             \
 64                        __field(bool, dot11MeshGateAnnouncementProtocol)    \
 65                        __field(bool, dot11MeshForwarding)                  \
 66                        __field(s32, rssi_threshold)                        \
 67                        __field(u16, ht_opmode)                             \
 68                        __field(u32, dot11MeshHWMPactivePathToRootTimeout)  \
 69                        __field(u16, dot11MeshHWMProotInterval)             \
 70                        __field(u16, dot11MeshHWMPconfirmationInterval)
 71 #define MESH_CFG_ASSIGN                                                       \
 72         do {                                                                  \
 73                 __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \
 74                 __entry->dot11MeshConfirmTimeout =                            \
 75                                 conf->dot11MeshConfirmTimeout;                \
 76                 __entry->dot11MeshHoldingTimeout =                            \
 77                                 conf->dot11MeshHoldingTimeout;                \
 78                 __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \
 79                 __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries;     \
 80                 __entry->dot11MeshTTL = conf->dot11MeshTTL;                   \
 81                 __entry->element_ttl = conf->element_ttl;                     \
 82                 __entry->auto_open_plinks = conf->auto_open_plinks;           \
 83                 __entry->dot11MeshNbrOffsetMaxNeighbor =                      \
 84                                 conf->dot11MeshNbrOffsetMaxNeighbor;          \
 85                 __entry->dot11MeshHWMPmaxPREQretries =                        \
 86                                 conf->dot11MeshHWMPmaxPREQretries;            \
 87                 __entry->path_refresh_time = conf->path_refresh_time;         \
 88                 __entry->dot11MeshHWMPactivePathTimeout =                     \
 89                                 conf->dot11MeshHWMPactivePathTimeout;         \
 90                 __entry->min_discovery_timeout = conf->min_discovery_timeout; \
 91                 __entry->dot11MeshHWMPpreqMinInterval =                       \
 92                                 conf->dot11MeshHWMPpreqMinInterval;           \
 93                 __entry->dot11MeshHWMPperrMinInterval =                       \
 94                                 conf->dot11MeshHWMPperrMinInterval;           \
 95                 __entry->dot11MeshHWMPnetDiameterTraversalTime =              \
 96                                 conf->dot11MeshHWMPnetDiameterTraversalTime;  \
 97                 __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \
 98                 __entry->dot11MeshHWMPRannInterval =                          \
 99                                 conf->dot11MeshHWMPRannInterval;              \
100                 __entry->dot11MeshGateAnnouncementProtocol =                  \
101                                 conf->dot11MeshGateAnnouncementProtocol;      \
102                 __entry->dot11MeshForwarding = conf->dot11MeshForwarding;     \
103                 __entry->rssi_threshold = conf->rssi_threshold;               \
104                 __entry->ht_opmode = conf->ht_opmode;                         \
105                 __entry->dot11MeshHWMPactivePathToRootTimeout =               \
106                                 conf->dot11MeshHWMPactivePathToRootTimeout;   \
107                 __entry->dot11MeshHWMProotInterval =                          \
108                                 conf->dot11MeshHWMProotInterval;              \
109                 __entry->dot11MeshHWMPconfirmationInterval =                  \
110                                 conf->dot11MeshHWMPconfirmationInterval;      \
111         } while (0)
112 
113 #define CHAN_ENTRY __field(enum ieee80211_band, band) \
114                    __field(u16, center_freq)
115 #define CHAN_ASSIGN(chan)                                         \
116         do {                                                      \
117                 if (chan) {                                       \
118                         __entry->band = chan->band;               \
119                         __entry->center_freq = chan->center_freq; \
120                 } else {                                          \
121                         __entry->band = 0;                        \
122                         __entry->center_freq = 0;                 \
123                 }                                                 \
124         } while (0)
125 #define CHAN_PR_FMT "band: %d, freq: %u"
126 #define CHAN_PR_ARG __entry->band, __entry->center_freq
127 
128 #define CHAN_DEF_ENTRY __field(enum ieee80211_band, band)               \
129                        __field(u32, control_freq)                       \
130                        __field(u32, width)                              \
131                        __field(u32, center_freq1)                       \
132                        __field(u32, center_freq2)
133 #define CHAN_DEF_ASSIGN(chandef)                                        \
134         do {                                                            \
135                 if ((chandef) && (chandef)->chan) {                     \
136                         __entry->band = (chandef)->chan->band;          \
137                         __entry->control_freq =                         \
138                                 (chandef)->chan->center_freq;           \
139                         __entry->width = (chandef)->width;              \
140                         __entry->center_freq1 = (chandef)->center_freq1;\
141                         __entry->center_freq2 = (chandef)->center_freq2;\
142                 } else {                                                \
143                         __entry->band = 0;                              \
144                         __entry->control_freq = 0;                      \
145                         __entry->width = 0;                             \
146                         __entry->center_freq1 = 0;                      \
147                         __entry->center_freq2 = 0;                      \
148                 }                                                       \
149         } while (0)
150 #define CHAN_DEF_PR_FMT                                                 \
151         "band: %d, control freq: %u, width: %d, cf1: %u, cf2: %u"
152 #define CHAN_DEF_PR_ARG __entry->band, __entry->control_freq,           \
153                         __entry->width, __entry->center_freq1,          \
154                         __entry->center_freq2
155 
156 #define SINFO_ENTRY __field(int, generation)        \
157                     __field(u32, connected_time)    \
158                     __field(u32, inactive_time)     \
159                     __field(u32, rx_bytes)          \
160                     __field(u32, tx_bytes)          \
161                     __field(u32, rx_packets)        \
162                     __field(u32, tx_packets)        \
163                     __field(u32, tx_retries)        \
164                     __field(u32, tx_failed)         \
165                     __field(u32, rx_dropped_misc)   \
166                     __field(u32, beacon_loss_count) \
167                     __field(u16, llid)              \
168                     __field(u16, plid)              \
169                     __field(u8, plink_state)
170 #define SINFO_ASSIGN                                                   \
171         do {                                                           \
172                 __entry->generation = sinfo->generation;               \
173                 __entry->connected_time = sinfo->connected_time;       \
174                 __entry->inactive_time = sinfo->inactive_time;         \
175                 __entry->rx_bytes = sinfo->rx_bytes;                   \
176                 __entry->tx_bytes = sinfo->tx_bytes;                   \
177                 __entry->rx_packets = sinfo->rx_packets;               \
178                 __entry->tx_packets = sinfo->tx_packets;               \
179                 __entry->tx_retries = sinfo->tx_retries;               \
180                 __entry->tx_failed = sinfo->tx_failed;                 \
181                 __entry->rx_dropped_misc = sinfo->rx_dropped_misc;     \
182                 __entry->beacon_loss_count = sinfo->beacon_loss_count; \
183                 __entry->llid = sinfo->llid;                           \
184                 __entry->plid = sinfo->plid;                           \
185                 __entry->plink_state = sinfo->plink_state;             \
186         } while (0)
187 
188 #define BOOL_TO_STR(bo) (bo) ? "true" : "false"
189 
190 #define QOS_MAP_ENTRY __field(u8, num_des)                      \
191                       __array(u8, dscp_exception,               \
192                               2 * IEEE80211_QOS_MAP_MAX_EX)     \
193                       __array(u8, up, IEEE80211_QOS_MAP_LEN_MIN)
194 #define QOS_MAP_ASSIGN(qos_map)                                 \
195         do {                                                    \
196                 if ((qos_map)) {                                \
197                         __entry->num_des = (qos_map)->num_des;  \
198                         memcpy(__entry->dscp_exception,         \
199                                &(qos_map)->dscp_exception,      \
200                                2 * IEEE80211_QOS_MAP_MAX_EX);   \
201                         memcpy(__entry->up, &(qos_map)->up,     \
202                                IEEE80211_QOS_MAP_LEN_MIN);      \
203                 } else {                                        \
204                         __entry->num_des = 0;                   \
205                         memset(__entry->dscp_exception, 0,      \
206                                2 * IEEE80211_QOS_MAP_MAX_EX);   \
207                         memset(__entry->up, 0,                  \
208                                IEEE80211_QOS_MAP_LEN_MIN);      \
209                 }                                               \
210         } while (0)
211 
212 /*************************************************************
213  *                      rdev->ops traces                     *
214  *************************************************************/
215 
216 TRACE_EVENT(rdev_suspend,
217         TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow),
218         TP_ARGS(wiphy, wow),
219         TP_STRUCT__entry(
220                 WIPHY_ENTRY
221                 __field(bool, any)
222                 __field(bool, disconnect)
223                 __field(bool, magic_pkt)
224                 __field(bool, gtk_rekey_failure)
225                 __field(bool, eap_identity_req)
226                 __field(bool, four_way_handshake)
227                 __field(bool, rfkill_release)
228                 __field(bool, valid_wow)
229         ),
230         TP_fast_assign(
231                 WIPHY_ASSIGN;
232                 if (wow) {
233                         __entry->any = wow->any;
234                         __entry->disconnect = wow->disconnect;
235                         __entry->magic_pkt = wow->magic_pkt;
236                         __entry->gtk_rekey_failure = wow->gtk_rekey_failure;
237                         __entry->eap_identity_req = wow->eap_identity_req;
238                         __entry->four_way_handshake = wow->four_way_handshake;
239                         __entry->rfkill_release = wow->rfkill_release;
240                         __entry->valid_wow = true;
241                 } else {
242                         __entry->valid_wow = false;
243                 }
244         ),
245         TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, "
246                   "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, "
247                   "four way handshake: %d, rfkill release: %d.",
248                   WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)",
249                   __entry->any, __entry->disconnect, __entry->magic_pkt,
250                   __entry->gtk_rekey_failure, __entry->eap_identity_req,
251                   __entry->four_way_handshake, __entry->rfkill_release)
252 );
253 
254 TRACE_EVENT(rdev_return_int,
255         TP_PROTO(struct wiphy *wiphy, int ret),
256         TP_ARGS(wiphy, ret),
257         TP_STRUCT__entry(
258                 WIPHY_ENTRY
259                 __field(int, ret)
260         ),
261         TP_fast_assign(
262                 WIPHY_ASSIGN;
263                 __entry->ret = ret;
264         ),
265         TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret)
266 );
267 
268 TRACE_EVENT(rdev_scan,
269         TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request),
270         TP_ARGS(wiphy, request),
271         TP_STRUCT__entry(
272                 WIPHY_ENTRY
273         ),
274         TP_fast_assign(
275                 WIPHY_ASSIGN;
276         ),
277         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
278 );
279 
280 DECLARE_EVENT_CLASS(wiphy_only_evt,
281         TP_PROTO(struct wiphy *wiphy),
282         TP_ARGS(wiphy),
283         TP_STRUCT__entry(
284                 WIPHY_ENTRY
285         ),
286         TP_fast_assign(
287                 WIPHY_ASSIGN;
288         ),
289         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
290 );
291 
292 DEFINE_EVENT(wiphy_only_evt, rdev_resume,
293         TP_PROTO(struct wiphy *wiphy),
294         TP_ARGS(wiphy)
295 );
296 
297 DEFINE_EVENT(wiphy_only_evt, rdev_return_void,
298         TP_PROTO(struct wiphy *wiphy),
299         TP_ARGS(wiphy)
300 );
301 
302 DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna,
303         TP_PROTO(struct wiphy *wiphy),
304         TP_ARGS(wiphy)
305 );
306 
307 DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll,
308         TP_PROTO(struct wiphy *wiphy),
309         TP_ARGS(wiphy)
310 );
311 
312 DECLARE_EVENT_CLASS(wiphy_enabled_evt,
313         TP_PROTO(struct wiphy *wiphy, bool enabled),
314         TP_ARGS(wiphy, enabled),
315         TP_STRUCT__entry(
316                 WIPHY_ENTRY
317                 __field(bool, enabled)
318         ),
319         TP_fast_assign(
320                 WIPHY_ASSIGN;
321                 __entry->enabled = enabled;
322         ),
323         TP_printk(WIPHY_PR_FMT ", %senabled ",
324                   WIPHY_PR_ARG, __entry->enabled ? "" : "not ")
325 );
326 
327 DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup,
328         TP_PROTO(struct wiphy *wiphy, bool enabled),
329         TP_ARGS(wiphy, enabled)
330 );
331 
332 TRACE_EVENT(rdev_add_virtual_intf,
333         TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type),
334         TP_ARGS(wiphy, name, type),
335         TP_STRUCT__entry(
336                 WIPHY_ENTRY
337                 __string(vir_intf_name, name ? name : "<noname>")
338                 __field(enum nl80211_iftype, type)
339         ),
340         TP_fast_assign(
341                 WIPHY_ASSIGN;
342                 __assign_str(vir_intf_name, name ? name : "<noname>");
343                 __entry->type = type;
344         ),
345         TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d",
346                   WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type)
347 );
348 
349 DECLARE_EVENT_CLASS(wiphy_wdev_evt,
350         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
351         TP_ARGS(wiphy, wdev),
352         TP_STRUCT__entry(
353                 WIPHY_ENTRY
354                 WDEV_ENTRY
355         ),
356         TP_fast_assign(
357                 WIPHY_ASSIGN;
358                 WDEV_ASSIGN;
359         ),
360         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
361 );
362 
363 DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev,
364         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
365         TP_ARGS(wiphy, wdev)
366 );
367 
368 DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf,
369         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
370         TP_ARGS(wiphy, wdev)
371 );
372 
373 TRACE_EVENT(rdev_change_virtual_intf,
374         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
375                  enum nl80211_iftype type),
376         TP_ARGS(wiphy, netdev, type),
377         TP_STRUCT__entry(
378                 WIPHY_ENTRY
379                 NETDEV_ENTRY
380                 __field(enum nl80211_iftype, type)
381         ),
382         TP_fast_assign(
383                 WIPHY_ASSIGN;
384                 NETDEV_ASSIGN;
385                 __entry->type = type;
386         ),
387         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", type: %d",
388                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type)
389 );
390 
391 DECLARE_EVENT_CLASS(key_handle,
392         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
393                  bool pairwise, const u8 *mac_addr),
394         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr),
395         TP_STRUCT__entry(
396                 WIPHY_ENTRY
397                 NETDEV_ENTRY
398                 MAC_ENTRY(mac_addr)
399                 __field(u8, key_index)
400                 __field(bool, pairwise)
401         ),
402         TP_fast_assign(
403                 WIPHY_ASSIGN;
404                 NETDEV_ASSIGN;
405                 MAC_ASSIGN(mac_addr, mac_addr);
406                 __entry->key_index = key_index;
407                 __entry->pairwise = pairwise;
408         ),
409         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key_index: %u, pairwise: %s, mac addr: " MAC_PR_FMT,
410                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
411                   BOOL_TO_STR(__entry->pairwise), MAC_PR_ARG(mac_addr))
412 );
413 
414 DEFINE_EVENT(key_handle, rdev_add_key,
415         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
416                  bool pairwise, const u8 *mac_addr),
417         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
418 );
419 
420 DEFINE_EVENT(key_handle, rdev_get_key,
421         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
422                  bool pairwise, const u8 *mac_addr),
423         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
424 );
425 
426 DEFINE_EVENT(key_handle, rdev_del_key,
427         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
428                  bool pairwise, const u8 *mac_addr),
429         TP_ARGS(wiphy, netdev, key_index, pairwise, mac_addr)
430 );
431 
432 TRACE_EVENT(rdev_set_default_key,
433         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index,
434                  bool unicast, bool multicast),
435         TP_ARGS(wiphy, netdev, key_index, unicast, multicast),
436         TP_STRUCT__entry(
437                 WIPHY_ENTRY
438                 NETDEV_ENTRY
439                 __field(u8, key_index)
440                 __field(bool, unicast)
441                 __field(bool, multicast)
442         ),
443         TP_fast_assign(
444                 WIPHY_ASSIGN;
445                 NETDEV_ASSIGN;
446                 __entry->key_index = key_index;
447                 __entry->unicast = unicast;
448                 __entry->multicast = multicast;
449         ),
450         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key index: %u, unicast: %s, multicast: %s",
451                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index,
452                   BOOL_TO_STR(__entry->unicast),
453                   BOOL_TO_STR(__entry->multicast))
454 );
455 
456 TRACE_EVENT(rdev_set_default_mgmt_key,
457         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 key_index),
458         TP_ARGS(wiphy, netdev, key_index),
459         TP_STRUCT__entry(
460                 WIPHY_ENTRY
461                 NETDEV_ENTRY
462                 __field(u8, key_index)
463         ),
464         TP_fast_assign(
465                 WIPHY_ASSIGN;
466                 NETDEV_ASSIGN;
467                 __entry->key_index = key_index;
468         ),
469         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", key index: %u",
470                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->key_index)
471 );
472 
473 TRACE_EVENT(rdev_start_ap,
474         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
475                  struct cfg80211_ap_settings *settings),
476         TP_ARGS(wiphy, netdev, settings),
477         TP_STRUCT__entry(
478                 WIPHY_ENTRY
479                 NETDEV_ENTRY
480                 CHAN_DEF_ENTRY
481                 __field(int, beacon_interval)
482                 __field(int, dtim_period)
483                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
484                 __field(enum nl80211_hidden_ssid, hidden_ssid)
485                 __field(u32, wpa_ver)
486                 __field(bool, privacy)
487                 __field(enum nl80211_auth_type, auth_type)
488                 __field(int, inactivity_timeout)
489         ),
490         TP_fast_assign(
491                 WIPHY_ASSIGN;
492                 NETDEV_ASSIGN;
493                 CHAN_DEF_ASSIGN(&settings->chandef);
494                 __entry->beacon_interval = settings->beacon_interval;
495                 __entry->dtim_period = settings->dtim_period;
496                 __entry->hidden_ssid = settings->hidden_ssid;
497                 __entry->wpa_ver = settings->crypto.wpa_versions;
498                 __entry->privacy = settings->privacy;
499                 __entry->auth_type = settings->auth_type;
500                 __entry->inactivity_timeout = settings->inactivity_timeout;
501                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
502                 memcpy(__entry->ssid, settings->ssid, settings->ssid_len);
503         ),
504         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", AP settings - ssid: %s, "
505                   CHAN_DEF_PR_FMT ", beacon interval: %d, dtim period: %d, "
506                   "hidden ssid: %d, wpa versions: %u, privacy: %s, "
507                   "auth type: %d, inactivity timeout: %d",
508                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_DEF_PR_ARG,
509                   __entry->beacon_interval, __entry->dtim_period,
510                   __entry->hidden_ssid, __entry->wpa_ver,
511                   BOOL_TO_STR(__entry->privacy), __entry->auth_type,
512                   __entry->inactivity_timeout)
513 );
514 
515 TRACE_EVENT(rdev_change_beacon,
516         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
517                  struct cfg80211_beacon_data *info),
518         TP_ARGS(wiphy, netdev, info),
519         TP_STRUCT__entry(
520                 WIPHY_ENTRY
521                 NETDEV_ENTRY
522                 __dynamic_array(u8, head, info ? info->head_len : 0)
523                 __dynamic_array(u8, tail, info ? info->tail_len : 0)
524                 __dynamic_array(u8, beacon_ies, info ? info->beacon_ies_len : 0)
525                 __dynamic_array(u8, proberesp_ies,
526                                 info ? info->proberesp_ies_len : 0)
527                 __dynamic_array(u8, assocresp_ies,
528                                 info ? info->assocresp_ies_len : 0)
529                 __dynamic_array(u8, probe_resp, info ? info->probe_resp_len : 0)
530         ),
531         TP_fast_assign(
532                 WIPHY_ASSIGN;
533                 NETDEV_ASSIGN;
534                 if (info) {
535                         if (info->head)
536                                 memcpy(__get_dynamic_array(head), info->head,
537                                        info->head_len);
538                         if (info->tail)
539                                 memcpy(__get_dynamic_array(tail), info->tail,
540                                        info->tail_len);
541                         if (info->beacon_ies)
542                                 memcpy(__get_dynamic_array(beacon_ies),
543                                        info->beacon_ies, info->beacon_ies_len);
544                         if (info->proberesp_ies)
545                                 memcpy(__get_dynamic_array(proberesp_ies),
546                                        info->proberesp_ies,
547                                        info->proberesp_ies_len);
548                         if (info->assocresp_ies)
549                                 memcpy(__get_dynamic_array(assocresp_ies),
550                                        info->assocresp_ies,
551                                        info->assocresp_ies_len);
552                         if (info->probe_resp)
553                                 memcpy(__get_dynamic_array(probe_resp),
554                                        info->probe_resp, info->probe_resp_len);
555                 }
556         ),
557         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
558 );
559 
560 DECLARE_EVENT_CLASS(wiphy_netdev_evt,
561         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
562         TP_ARGS(wiphy, netdev),
563         TP_STRUCT__entry(
564                 WIPHY_ENTRY
565                 NETDEV_ENTRY
566         ),
567         TP_fast_assign(
568                 WIPHY_ASSIGN;
569                 NETDEV_ASSIGN;
570         ),
571         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG)
572 );
573 
574 DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap,
575         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
576         TP_ARGS(wiphy, netdev)
577 );
578 
579 DEFINE_EVENT(wiphy_netdev_evt, rdev_sched_scan_stop,
580         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
581         TP_ARGS(wiphy, netdev)
582 );
583 
584 DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data,
585         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
586         TP_ARGS(wiphy, netdev)
587 );
588 
589 DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config,
590         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
591         TP_ARGS(wiphy, netdev)
592 );
593 
594 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh,
595         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
596         TP_ARGS(wiphy, netdev)
597 );
598 
599 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss,
600         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
601         TP_ARGS(wiphy, netdev)
602 );
603 
604 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb,
605         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
606         TP_ARGS(wiphy, netdev)
607 );
608 
609 DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa,
610         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev),
611         TP_ARGS(wiphy, netdev)
612 );
613 
614 DECLARE_EVENT_CLASS(station_add_change,
615         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
616                  struct station_parameters *params),
617         TP_ARGS(wiphy, netdev, mac, params),
618         TP_STRUCT__entry(
619                 WIPHY_ENTRY
620                 NETDEV_ENTRY
621                 MAC_ENTRY(sta_mac)
622                 __field(u32, sta_flags_mask)
623                 __field(u32, sta_flags_set)
624                 __field(u32, sta_modify_mask)
625                 __field(int, listen_interval)
626                 __field(u16, aid)
627                 __field(u8, plink_action)
628                 __field(u8, plink_state)
629                 __field(u8, uapsd_queues)
630                 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap))
631                 __array(char, vlan, IFNAMSIZ)
632         ),
633         TP_fast_assign(
634                 WIPHY_ASSIGN;
635                 NETDEV_ASSIGN;
636                 MAC_ASSIGN(sta_mac, mac);
637                 __entry->sta_flags_mask = params->sta_flags_mask;
638                 __entry->sta_flags_set = params->sta_flags_set;
639                 __entry->sta_modify_mask = params->sta_modify_mask;
640                 __entry->listen_interval = params->listen_interval;
641                 __entry->aid = params->aid;
642                 __entry->plink_action = params->plink_action;
643                 __entry->plink_state = params->plink_state;
644                 __entry->uapsd_queues = params->uapsd_queues;
645                 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap));
646                 if (params->ht_capa)
647                         memcpy(__entry->ht_capa, params->ht_capa,
648                                sizeof(struct ieee80211_ht_cap));
649                 memset(__entry->vlan, 0, sizeof(__entry->vlan));
650                 if (params->vlan)
651                         memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ);
652         ),
653         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT
654                   ", station flags mask: %u, station flags set: %u, "
655                   "station modify mask: %u, listen interval: %d, aid: %u, "
656                   "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s",
657                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
658                   __entry->sta_flags_mask, __entry->sta_flags_set,
659                   __entry->sta_modify_mask, __entry->listen_interval,
660                   __entry->aid, __entry->plink_action, __entry->plink_state,
661                   __entry->uapsd_queues, __entry->vlan)
662 );
663 
664 DEFINE_EVENT(station_add_change, rdev_add_station,
665         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
666                  struct station_parameters *params),
667         TP_ARGS(wiphy, netdev, mac, params)
668 );
669 
670 DEFINE_EVENT(station_add_change, rdev_change_station,
671         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac,
672                  struct station_parameters *params),
673         TP_ARGS(wiphy, netdev, mac, params)
674 );
675 
676 DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt,
677         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
678         TP_ARGS(wiphy, netdev, mac),
679         TP_STRUCT__entry(
680                 WIPHY_ENTRY
681                 NETDEV_ENTRY
682                 MAC_ENTRY(sta_mac)
683         ),
684         TP_fast_assign(
685                 WIPHY_ASSIGN;
686                 NETDEV_ASSIGN;
687                 MAC_ASSIGN(sta_mac, mac);
688         ),
689         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
690                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac))
691 );
692 
693 DECLARE_EVENT_CLASS(station_del,
694         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
695                  struct station_del_parameters *params),
696         TP_ARGS(wiphy, netdev, params),
697         TP_STRUCT__entry(
698                 WIPHY_ENTRY
699                 NETDEV_ENTRY
700                 MAC_ENTRY(sta_mac)
701                 __field(u8, subtype)
702                 __field(u16, reason_code)
703         ),
704         TP_fast_assign(
705                 WIPHY_ASSIGN;
706                 NETDEV_ASSIGN;
707                 MAC_ASSIGN(sta_mac, params->mac);
708                 __entry->subtype = params->subtype;
709                 __entry->reason_code = params->reason_code;
710         ),
711         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT
712                   ", subtype: %u, reason_code: %u",
713                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
714                   __entry->subtype, __entry->reason_code)
715 );
716 
717 DEFINE_EVENT(station_del, rdev_del_station,
718         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
719                  struct station_del_parameters *params),
720         TP_ARGS(wiphy, netdev, params)
721 );
722 
723 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station,
724         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
725         TP_ARGS(wiphy, netdev, mac)
726 );
727 
728 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath,
729         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
730         TP_ARGS(wiphy, netdev, mac)
731 );
732 
733 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_set_wds_peer,
734         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac),
735         TP_ARGS(wiphy, netdev, mac)
736 );
737 
738 TRACE_EVENT(rdev_dump_station,
739         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
740                  u8 *mac),
741         TP_ARGS(wiphy, netdev, idx, mac),
742         TP_STRUCT__entry(
743                 WIPHY_ENTRY
744                 NETDEV_ENTRY
745                 MAC_ENTRY(sta_mac)
746                 __field(int, idx)
747         ),
748         TP_fast_assign(
749                 WIPHY_ASSIGN;
750                 NETDEV_ASSIGN;
751                 MAC_ASSIGN(sta_mac, mac);
752                 __entry->idx = idx;
753         ),
754         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: " MAC_PR_FMT ", idx: %d",
755                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(sta_mac),
756                   __entry->idx)
757 );
758 
759 TRACE_EVENT(rdev_return_int_station_info,
760         TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo),
761         TP_ARGS(wiphy, ret, sinfo),
762         TP_STRUCT__entry(
763                 WIPHY_ENTRY
764                 __field(int, ret)
765                 SINFO_ENTRY
766         ),
767         TP_fast_assign(
768                 WIPHY_ASSIGN;
769                 __entry->ret = ret;
770                 SINFO_ASSIGN;
771         ),
772         TP_printk(WIPHY_PR_FMT ", returned %d" ,
773                   WIPHY_PR_ARG, __entry->ret)
774 );
775 
776 DECLARE_EVENT_CLASS(mpath_evt,
777         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
778                  u8 *next_hop),
779         TP_ARGS(wiphy, netdev, dst, next_hop),
780         TP_STRUCT__entry(
781                 WIPHY_ENTRY
782                 NETDEV_ENTRY
783                 MAC_ENTRY(dst)
784                 MAC_ENTRY(next_hop)
785         ),
786         TP_fast_assign(
787                 WIPHY_ASSIGN;
788                 NETDEV_ASSIGN;
789                 MAC_ASSIGN(dst, dst);
790                 MAC_ASSIGN(next_hop, next_hop);
791         ),
792         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: " MAC_PR_FMT ", next hop: " MAC_PR_FMT,
793                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dst),
794                   MAC_PR_ARG(next_hop))
795 );
796 
797 DEFINE_EVENT(mpath_evt, rdev_add_mpath,
798         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
799                  u8 *next_hop),
800         TP_ARGS(wiphy, netdev, dst, next_hop)
801 );
802 
803 DEFINE_EVENT(mpath_evt, rdev_change_mpath,
804         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
805                  u8 *next_hop),
806         TP_ARGS(wiphy, netdev, dst, next_hop)
807 );
808 
809 DEFINE_EVENT(mpath_evt, rdev_get_mpath,
810         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst,
811                  u8 *next_hop),
812         TP_ARGS(wiphy, netdev, dst, next_hop)
813 );
814 
815 TRACE_EVENT(rdev_dump_mpath,
816         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
817                  u8 *dst, u8 *next_hop),
818         TP_ARGS(wiphy, netdev, idx, dst, next_hop),
819         TP_STRUCT__entry(
820                 WIPHY_ENTRY
821                 NETDEV_ENTRY
822                 MAC_ENTRY(dst)
823                 MAC_ENTRY(next_hop)
824                 __field(int, idx)
825         ),
826         TP_fast_assign(
827                 WIPHY_ASSIGN;
828                 NETDEV_ASSIGN;
829                 MAC_ASSIGN(dst, dst);
830                 MAC_ASSIGN(next_hop, next_hop);
831                 __entry->idx = idx;
832         ),
833         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: "
834                   MAC_PR_FMT ", next hop: " MAC_PR_FMT,
835                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, MAC_PR_ARG(dst),
836                   MAC_PR_ARG(next_hop))
837 );
838 
839 TRACE_EVENT(rdev_get_mpp,
840         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
841                  u8 *dst, u8 *mpp),
842         TP_ARGS(wiphy, netdev, dst, mpp),
843         TP_STRUCT__entry(
844                 WIPHY_ENTRY
845                 NETDEV_ENTRY
846                 MAC_ENTRY(dst)
847                 MAC_ENTRY(mpp)
848         ),
849         TP_fast_assign(
850                 WIPHY_ASSIGN;
851                 NETDEV_ASSIGN;
852                 MAC_ASSIGN(dst, dst);
853                 MAC_ASSIGN(mpp, mpp);
854         ),
855         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: " MAC_PR_FMT
856                   ", mpp: " MAC_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG,
857                   MAC_PR_ARG(dst), MAC_PR_ARG(mpp))
858 );
859 
860 TRACE_EVENT(rdev_dump_mpp,
861         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx,
862                  u8 *dst, u8 *mpp),
863         TP_ARGS(wiphy, netdev, idx, mpp, dst),
864         TP_STRUCT__entry(
865                 WIPHY_ENTRY
866                 NETDEV_ENTRY
867                 MAC_ENTRY(dst)
868                 MAC_ENTRY(mpp)
869                 __field(int, idx)
870         ),
871         TP_fast_assign(
872                 WIPHY_ASSIGN;
873                 NETDEV_ASSIGN;
874                 MAC_ASSIGN(dst, dst);
875                 MAC_ASSIGN(mpp, mpp);
876                 __entry->idx = idx;
877         ),
878         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: "
879                   MAC_PR_FMT ", mpp: " MAC_PR_FMT,
880                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, MAC_PR_ARG(dst),
881                   MAC_PR_ARG(mpp))
882 );
883 
884 TRACE_EVENT(rdev_return_int_mpath_info,
885         TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo),
886         TP_ARGS(wiphy, ret, pinfo),
887         TP_STRUCT__entry(
888                 WIPHY_ENTRY
889                 __field(int, ret)
890                 __field(int, generation)
891                 __field(u32, filled)
892                 __field(u32, frame_qlen)
893                 __field(u32, sn)
894                 __field(u32, metric)
895                 __field(u32, exptime)
896                 __field(u32, discovery_timeout)
897                 __field(u8, discovery_retries)
898                 __field(u8, flags)
899         ),
900         TP_fast_assign(
901                 WIPHY_ASSIGN;
902                 __entry->ret = ret;
903                 __entry->generation = pinfo->generation;
904                 __entry->filled = pinfo->filled;
905                 __entry->frame_qlen = pinfo->frame_qlen;
906                 __entry->sn = pinfo->sn;
907                 __entry->metric = pinfo->metric;
908                 __entry->exptime = pinfo->exptime;
909                 __entry->discovery_timeout = pinfo->discovery_timeout;
910                 __entry->discovery_retries = pinfo->discovery_retries;
911                 __entry->flags = pinfo->flags;
912         ),
913         TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, "
914                   "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u,"
915                   " discovery timeout: %u, discovery retries: %u, flags: %u",
916                   WIPHY_PR_ARG, __entry->ret, __entry->generation,
917                   __entry->filled, __entry->frame_qlen, __entry->sn,
918                   __entry->metric, __entry->exptime, __entry->discovery_timeout,
919                   __entry->discovery_retries, __entry->flags)
920 );
921 
922 TRACE_EVENT(rdev_return_int_mesh_config,
923         TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf),
924         TP_ARGS(wiphy, ret, conf),
925         TP_STRUCT__entry(
926                 WIPHY_ENTRY
927                 MESH_CFG_ENTRY
928                 __field(int, ret)
929         ),
930         TP_fast_assign(
931                 WIPHY_ASSIGN;
932                 MESH_CFG_ASSIGN;
933                 __entry->ret = ret;
934         ),
935         TP_printk(WIPHY_PR_FMT ", returned: %d",
936                   WIPHY_PR_ARG, __entry->ret)
937 );
938 
939 TRACE_EVENT(rdev_update_mesh_config,
940         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask,
941                  const struct mesh_config *conf),
942         TP_ARGS(wiphy, netdev, mask, conf),
943         TP_STRUCT__entry(
944                 WIPHY_ENTRY
945                 NETDEV_ENTRY
946                 MESH_CFG_ENTRY
947                 __field(u32, mask)
948         ),
949         TP_fast_assign(
950                 WIPHY_ASSIGN;
951                 NETDEV_ASSIGN;
952                 MESH_CFG_ASSIGN;
953                 __entry->mask = mask;
954         ),
955         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u",
956                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask)
957 );
958 
959 TRACE_EVENT(rdev_join_mesh,
960         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
961                  const struct mesh_config *conf,
962                  const struct mesh_setup *setup),
963         TP_ARGS(wiphy, netdev, conf, setup),
964         TP_STRUCT__entry(
965                 WIPHY_ENTRY
966                 NETDEV_ENTRY
967                 MESH_CFG_ENTRY
968         ),
969         TP_fast_assign(
970                 WIPHY_ASSIGN;
971                 NETDEV_ASSIGN;
972                 MESH_CFG_ASSIGN;
973         ),
974         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
975                   WIPHY_PR_ARG, NETDEV_PR_ARG)
976 );
977 
978 TRACE_EVENT(rdev_change_bss,
979         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
980                  struct bss_parameters *params),
981         TP_ARGS(wiphy, netdev, params),
982         TP_STRUCT__entry(
983                 WIPHY_ENTRY
984                 NETDEV_ENTRY
985                 __field(int, use_cts_prot)
986                 __field(int, use_short_preamble)
987                 __field(int, use_short_slot_time)
988                 __field(int, ap_isolate)
989                 __field(int, ht_opmode)
990         ),
991         TP_fast_assign(
992                 WIPHY_ASSIGN;
993                 NETDEV_ASSIGN;
994                 __entry->use_cts_prot = params->use_cts_prot;
995                 __entry->use_short_preamble = params->use_short_preamble;
996                 __entry->use_short_slot_time = params->use_short_slot_time;
997                 __entry->ap_isolate = params->ap_isolate;
998                 __entry->ht_opmode = params->ht_opmode;
999         ),
1000         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, "
1001                   "use short preamble: %d, use short slot time: %d, "
1002                   "ap isolate: %d, ht opmode: %d",
1003                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot,
1004                   __entry->use_short_preamble, __entry->use_short_slot_time,
1005                   __entry->ap_isolate, __entry->ht_opmode)
1006 );
1007 
1008 TRACE_EVENT(rdev_set_txq_params,
1009         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1010                  struct ieee80211_txq_params *params),
1011         TP_ARGS(wiphy, netdev, params),
1012         TP_STRUCT__entry(
1013                 WIPHY_ENTRY
1014                 NETDEV_ENTRY
1015                 __field(enum nl80211_ac, ac)
1016                 __field(u16, txop)
1017                 __field(u16, cwmin)
1018                 __field(u16, cwmax)
1019                 __field(u8, aifs)
1020         ),
1021         TP_fast_assign(
1022                 WIPHY_ASSIGN;
1023                 NETDEV_ASSIGN;
1024                 __entry->ac = params->ac;
1025                 __entry->txop = params->txop;
1026                 __entry->cwmin = params->cwmin;
1027                 __entry->cwmax = params->cwmax;
1028                 __entry->aifs = params->aifs;
1029         ),
1030         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u",
1031                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop,
1032                   __entry->cwmin, __entry->cwmax, __entry->aifs)
1033 );
1034 
1035 TRACE_EVENT(rdev_libertas_set_mesh_channel,
1036         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1037                  struct ieee80211_channel *chan),
1038         TP_ARGS(wiphy, netdev, chan),
1039         TP_STRUCT__entry(
1040                 WIPHY_ENTRY
1041                 NETDEV_ENTRY
1042                 CHAN_ENTRY
1043         ),
1044         TP_fast_assign(
1045                 WIPHY_ASSIGN;
1046                 NETDEV_ASSIGN;
1047                 CHAN_ASSIGN(chan);
1048         ),
1049         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG,
1050                   NETDEV_PR_ARG, CHAN_PR_ARG)
1051 );
1052 
1053 TRACE_EVENT(rdev_set_monitor_channel,
1054         TP_PROTO(struct wiphy *wiphy,
1055                  struct cfg80211_chan_def *chandef),
1056         TP_ARGS(wiphy, chandef),
1057         TP_STRUCT__entry(
1058                 WIPHY_ENTRY
1059                 CHAN_DEF_ENTRY
1060         ),
1061         TP_fast_assign(
1062                 WIPHY_ASSIGN;
1063                 CHAN_DEF_ASSIGN(chandef);
1064         ),
1065         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
1066                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
1067 );
1068 
1069 TRACE_EVENT(rdev_auth,
1070         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1071                  struct cfg80211_auth_request *req),
1072         TP_ARGS(wiphy, netdev, req),
1073         TP_STRUCT__entry(
1074                 WIPHY_ENTRY
1075                 NETDEV_ENTRY
1076                 MAC_ENTRY(bssid)
1077                 __field(enum nl80211_auth_type, auth_type)
1078         ),
1079         TP_fast_assign(
1080                 WIPHY_ASSIGN;
1081                 NETDEV_ASSIGN;
1082                 if (req->bss)
1083                         MAC_ASSIGN(bssid, req->bss->bssid);
1084                 else
1085                         eth_zero_addr(__entry->bssid);
1086                 __entry->auth_type = req->auth_type;
1087         ),
1088         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: " MAC_PR_FMT,
1089                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type,
1090                   MAC_PR_ARG(bssid))
1091 );
1092 
1093 TRACE_EVENT(rdev_assoc,
1094         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1095                  struct cfg80211_assoc_request *req),
1096         TP_ARGS(wiphy, netdev, req),
1097         TP_STRUCT__entry(
1098                 WIPHY_ENTRY
1099                 NETDEV_ENTRY
1100                 MAC_ENTRY(bssid)
1101                 MAC_ENTRY(prev_bssid)
1102                 __field(bool, use_mfp)
1103                 __field(u32, flags)
1104         ),
1105         TP_fast_assign(
1106                 WIPHY_ASSIGN;
1107                 NETDEV_ASSIGN;
1108                 if (req->bss)
1109                         MAC_ASSIGN(bssid, req->bss->bssid);
1110                 else
1111                         eth_zero_addr(__entry->bssid);
1112                 MAC_ASSIGN(prev_bssid, req->prev_bssid);
1113                 __entry->use_mfp = req->use_mfp;
1114                 __entry->flags = req->flags;
1115         ),
1116         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1117                   ", previous bssid: " MAC_PR_FMT ", use mfp: %s, flags: %u",
1118                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1119                   MAC_PR_ARG(prev_bssid), BOOL_TO_STR(__entry->use_mfp),
1120                   __entry->flags)
1121 );
1122 
1123 TRACE_EVENT(rdev_deauth,
1124         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1125                  struct cfg80211_deauth_request *req),
1126         TP_ARGS(wiphy, netdev, req),
1127         TP_STRUCT__entry(
1128                 WIPHY_ENTRY
1129                 NETDEV_ENTRY
1130                 MAC_ENTRY(bssid)
1131                 __field(u16, reason_code)
1132         ),
1133         TP_fast_assign(
1134                 WIPHY_ASSIGN;
1135                 NETDEV_ASSIGN;
1136                 MAC_ASSIGN(bssid, req->bssid);
1137                 __entry->reason_code = req->reason_code;
1138         ),
1139         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", reason: %u",
1140                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1141                   __entry->reason_code)
1142 );
1143 
1144 TRACE_EVENT(rdev_disassoc,
1145         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1146                  struct cfg80211_disassoc_request *req),
1147         TP_ARGS(wiphy, netdev, req),
1148         TP_STRUCT__entry(
1149                 WIPHY_ENTRY
1150                 NETDEV_ENTRY
1151                 MAC_ENTRY(bssid)
1152                 __field(u16, reason_code)
1153                 __field(bool, local_state_change)
1154         ),
1155         TP_fast_assign(
1156                 WIPHY_ASSIGN;
1157                 NETDEV_ASSIGN;
1158                 if (req->bss)
1159                         MAC_ASSIGN(bssid, req->bss->bssid);
1160                 else
1161                         eth_zero_addr(__entry->bssid);
1162                 __entry->reason_code = req->reason_code;
1163                 __entry->local_state_change = req->local_state_change;
1164         ),
1165         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1166                   ", reason: %u, local state change: %s",
1167                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid),
1168                   __entry->reason_code,
1169                   BOOL_TO_STR(__entry->local_state_change))
1170 );
1171 
1172 TRACE_EVENT(rdev_mgmt_tx_cancel_wait,
1173         TP_PROTO(struct wiphy *wiphy,
1174                  struct wireless_dev *wdev, u64 cookie),
1175         TP_ARGS(wiphy, wdev, cookie),
1176         TP_STRUCT__entry(
1177                 WIPHY_ENTRY
1178                 WDEV_ENTRY
1179                 __field(u64, cookie)
1180         ),
1181         TP_fast_assign(
1182                 WIPHY_ASSIGN;
1183                 WDEV_ASSIGN;
1184                 __entry->cookie = cookie;
1185         ),
1186         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ",
1187                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
1188 );
1189 
1190 TRACE_EVENT(rdev_set_power_mgmt,
1191         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1192                  bool enabled, int timeout),
1193         TP_ARGS(wiphy, netdev, enabled, timeout),
1194         TP_STRUCT__entry(
1195                 WIPHY_ENTRY
1196                 NETDEV_ENTRY
1197                 __field(bool, enabled)
1198                 __field(int, timeout)
1199         ),
1200         TP_fast_assign(
1201                 WIPHY_ASSIGN;
1202                 NETDEV_ASSIGN;
1203                 __entry->enabled = enabled;
1204                 __entry->timeout = timeout;
1205         ),
1206         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ",
1207                   WIPHY_PR_ARG, NETDEV_PR_ARG,
1208                   __entry->enabled ? "" : "not ", __entry->timeout)
1209 );
1210 
1211 TRACE_EVENT(rdev_connect,
1212         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1213                  struct cfg80211_connect_params *sme),
1214         TP_ARGS(wiphy, netdev, sme),
1215         TP_STRUCT__entry(
1216                 WIPHY_ENTRY
1217                 NETDEV_ENTRY
1218                 MAC_ENTRY(bssid)
1219                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1220                 __field(enum nl80211_auth_type, auth_type)
1221                 __field(bool, privacy)
1222                 __field(u32, wpa_versions)
1223                 __field(u32, flags)
1224         ),
1225         TP_fast_assign(
1226                 WIPHY_ASSIGN;
1227                 NETDEV_ASSIGN;
1228                 MAC_ASSIGN(bssid, sme->bssid);
1229                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1230                 memcpy(__entry->ssid, sme->ssid, sme->ssid_len);
1231                 __entry->auth_type = sme->auth_type;
1232                 __entry->privacy = sme->privacy;
1233                 __entry->wpa_versions = sme->crypto.wpa_versions;
1234                 __entry->flags = sme->flags;
1235         ),
1236         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT
1237                   ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, "
1238                   "flags: %u",
1239                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid,
1240                   __entry->auth_type, BOOL_TO_STR(__entry->privacy),
1241                   __entry->wpa_versions, __entry->flags)
1242 );
1243 
1244 TRACE_EVENT(rdev_set_cqm_rssi_config,
1245         TP_PROTO(struct wiphy *wiphy,
1246                  struct net_device *netdev, s32 rssi_thold,
1247                  u32 rssi_hyst),
1248         TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst),
1249         TP_STRUCT__entry(
1250                 WIPHY_ENTRY
1251                 NETDEV_ENTRY
1252                 __field(s32, rssi_thold)
1253                 __field(u32, rssi_hyst)
1254         ),
1255         TP_fast_assign(
1256                 WIPHY_ASSIGN;
1257                 NETDEV_ASSIGN;
1258                 __entry->rssi_thold = rssi_thold;
1259                 __entry->rssi_hyst = rssi_hyst;
1260         ),
1261         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT
1262                   ", rssi_thold: %d, rssi_hyst: %u ",
1263                   WIPHY_PR_ARG, NETDEV_PR_ARG,
1264                  __entry->rssi_thold, __entry->rssi_hyst)
1265 );
1266 
1267 TRACE_EVENT(rdev_set_cqm_txe_config,
1268         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate,
1269                  u32 pkts, u32 intvl),
1270         TP_ARGS(wiphy, netdev, rate, pkts, intvl),
1271         TP_STRUCT__entry(
1272                 WIPHY_ENTRY
1273                 NETDEV_ENTRY
1274                 __field(u32, rate)
1275                 __field(u32, pkts)
1276                 __field(u32, intvl)
1277         ),
1278         TP_fast_assign(
1279                 WIPHY_ASSIGN;
1280                 NETDEV_ASSIGN;
1281                 __entry->rate = rate;
1282                 __entry->pkts = pkts;
1283                 __entry->intvl = intvl;
1284         ),
1285         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u",
1286                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts,
1287                   __entry->intvl)
1288 );
1289 
1290 TRACE_EVENT(rdev_disconnect,
1291         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1292                  u16 reason_code),
1293         TP_ARGS(wiphy, netdev, reason_code),
1294         TP_STRUCT__entry(
1295                 WIPHY_ENTRY
1296                 NETDEV_ENTRY
1297                 __field(u16, reason_code)
1298         ),
1299         TP_fast_assign(
1300                 WIPHY_ASSIGN;
1301                 NETDEV_ASSIGN;
1302                 __entry->reason_code = reason_code;
1303         ),
1304         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG,
1305                   NETDEV_PR_ARG, __entry->reason_code)
1306 );
1307 
1308 TRACE_EVENT(rdev_join_ibss,
1309         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1310                  struct cfg80211_ibss_params *params),
1311         TP_ARGS(wiphy, netdev, params),
1312         TP_STRUCT__entry(
1313                 WIPHY_ENTRY
1314                 NETDEV_ENTRY
1315                 MAC_ENTRY(bssid)
1316                 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1)
1317         ),
1318         TP_fast_assign(
1319                 WIPHY_ASSIGN;
1320                 NETDEV_ASSIGN;
1321                 MAC_ASSIGN(bssid, params->bssid);
1322                 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1);
1323                 memcpy(__entry->ssid, params->ssid, params->ssid_len);
1324         ),
1325         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", ssid: %s",
1326                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid)
1327 );
1328 
1329 TRACE_EVENT(rdev_join_ocb,
1330         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1331                  const struct ocb_setup *setup),
1332         TP_ARGS(wiphy, netdev, setup),
1333         TP_STRUCT__entry(
1334                 WIPHY_ENTRY
1335                 NETDEV_ENTRY
1336         ),
1337         TP_fast_assign(
1338                 WIPHY_ASSIGN;
1339                 NETDEV_ASSIGN;
1340         ),
1341         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
1342                   WIPHY_PR_ARG, NETDEV_PR_ARG)
1343 );
1344 
1345 TRACE_EVENT(rdev_set_wiphy_params,
1346         TP_PROTO(struct wiphy *wiphy, u32 changed),
1347         TP_ARGS(wiphy, changed),
1348         TP_STRUCT__entry(
1349                 WIPHY_ENTRY
1350                 __field(u32, changed)
1351         ),
1352         TP_fast_assign(
1353                 WIPHY_ASSIGN;
1354                 __entry->changed = changed;
1355         ),
1356         TP_printk(WIPHY_PR_FMT ", changed: %u",
1357                   WIPHY_PR_ARG, __entry->changed)
1358 );
1359 
1360 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power,
1361         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1362         TP_ARGS(wiphy, wdev)
1363 );
1364 
1365 TRACE_EVENT(rdev_set_tx_power,
1366         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1367                  enum nl80211_tx_power_setting type, int mbm),
1368         TP_ARGS(wiphy, wdev, type, mbm),
1369         TP_STRUCT__entry(
1370                 WIPHY_ENTRY
1371                 WDEV_ENTRY
1372                 __field(enum nl80211_tx_power_setting, type)
1373                 __field(int, mbm)
1374         ),
1375         TP_fast_assign(
1376                 WIPHY_ASSIGN;
1377                 WDEV_ASSIGN;
1378                 __entry->type = type;
1379                 __entry->mbm = mbm;
1380         ),
1381         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type: %u, mbm: %d",
1382                   WIPHY_PR_ARG, WDEV_PR_ARG,__entry->type, __entry->mbm)
1383 );
1384 
1385 TRACE_EVENT(rdev_return_int_int,
1386         TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill),
1387         TP_ARGS(wiphy, func_ret, func_fill),
1388         TP_STRUCT__entry(
1389                 WIPHY_ENTRY
1390                 __field(int, func_ret)
1391                 __field(int, func_fill)
1392         ),
1393         TP_fast_assign(
1394                 WIPHY_ASSIGN;
1395                 __entry->func_ret = func_ret;
1396                 __entry->func_fill = func_fill;
1397         ),
1398         TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d",
1399                   WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill)
1400 );
1401 
1402 #ifdef CONFIG_NL80211_TESTMODE
1403 TRACE_EVENT(rdev_testmode_cmd,
1404         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1405         TP_ARGS(wiphy, wdev),
1406         TP_STRUCT__entry(
1407                 WIPHY_ENTRY
1408                 WDEV_ENTRY
1409         ),
1410         TP_fast_assign(
1411                 WIPHY_ASSIGN;
1412                 WDEV_ASSIGN;
1413         ),
1414         TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
1415 );
1416 
1417 TRACE_EVENT(rdev_testmode_dump,
1418         TP_PROTO(struct wiphy *wiphy),
1419         TP_ARGS(wiphy),
1420         TP_STRUCT__entry(
1421                 WIPHY_ENTRY
1422         ),
1423         TP_fast_assign(
1424                 WIPHY_ASSIGN;
1425         ),
1426         TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG)
1427 );
1428 #endif /* CONFIG_NL80211_TESTMODE */
1429 
1430 TRACE_EVENT(rdev_set_bitrate_mask,
1431         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1432                  const u8 *peer, const struct cfg80211_bitrate_mask *mask),
1433         TP_ARGS(wiphy, netdev, peer, mask),
1434         TP_STRUCT__entry(
1435                 WIPHY_ENTRY
1436                 NETDEV_ENTRY
1437                 MAC_ENTRY(peer)
1438         ),
1439         TP_fast_assign(
1440                 WIPHY_ASSIGN;
1441                 NETDEV_ASSIGN;
1442                 MAC_ASSIGN(peer, peer);
1443         ),
1444         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT,
1445                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
1446 );
1447 
1448 TRACE_EVENT(rdev_mgmt_frame_register,
1449         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1450                  u16 frame_type, bool reg),
1451         TP_ARGS(wiphy, wdev, frame_type, reg),
1452         TP_STRUCT__entry(
1453                 WIPHY_ENTRY
1454                 WDEV_ENTRY
1455                 __field(u16, frame_type)
1456                 __field(bool, reg)
1457         ),
1458         TP_fast_assign(
1459                 WIPHY_ASSIGN;
1460                 WDEV_ASSIGN;
1461                 __entry->frame_type = frame_type;
1462                 __entry->reg = reg;
1463         ),
1464         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", frame_type: 0x%.2x, reg: %s ",
1465                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->frame_type,
1466                   __entry->reg ? "true" : "false")
1467 );
1468 
1469 TRACE_EVENT(rdev_return_int_tx_rx,
1470         TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx),
1471         TP_ARGS(wiphy, ret, tx, rx),
1472         TP_STRUCT__entry(
1473                 WIPHY_ENTRY
1474                 __field(int, ret)
1475                 __field(u32, tx)
1476                 __field(u32, rx)
1477         ),
1478         TP_fast_assign(
1479                 WIPHY_ASSIGN;
1480                 __entry->ret = ret;
1481                 __entry->tx = tx;
1482                 __entry->rx = rx;
1483         ),
1484         TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u",
1485                   WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx)
1486 );
1487 
1488 TRACE_EVENT(rdev_return_void_tx_rx,
1489         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max,
1490                  u32 rx, u32 rx_max),
1491         TP_ARGS(wiphy, tx, tx_max, rx, rx_max),
1492         TP_STRUCT__entry(
1493                 WIPHY_ENTRY
1494                 __field(u32, tx)
1495                 __field(u32, tx_max)
1496                 __field(u32, rx)
1497                 __field(u32, rx_max)
1498         ),
1499         TP_fast_assign(
1500                 WIPHY_ASSIGN;
1501                 __entry->tx = tx;
1502                 __entry->tx_max = tx_max;
1503                 __entry->rx = rx;
1504                 __entry->rx_max = rx_max;
1505         ),
1506         TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ",
1507                   WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx,
1508                   __entry->rx_max)
1509 );
1510 
1511 DECLARE_EVENT_CLASS(tx_rx_evt,
1512         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
1513         TP_ARGS(wiphy, rx, tx),
1514         TP_STRUCT__entry(
1515                 WIPHY_ENTRY
1516                 __field(u32, tx)
1517                 __field(u32, rx)
1518         ),
1519         TP_fast_assign(
1520                 WIPHY_ASSIGN;
1521                 __entry->tx = tx;
1522                 __entry->rx = rx;
1523         ),
1524         TP_printk(WIPHY_PR_FMT ", tx: %u, rx: %u ",
1525                   WIPHY_PR_ARG, __entry->tx, __entry->rx)
1526 );
1527 
1528 DEFINE_EVENT(tx_rx_evt, rdev_set_antenna,
1529         TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx),
1530         TP_ARGS(wiphy, rx, tx)
1531 );
1532 
1533 TRACE_EVENT(rdev_sched_scan_start,
1534         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1535                  struct cfg80211_sched_scan_request *request),
1536         TP_ARGS(wiphy, netdev, request),
1537         TP_STRUCT__entry(
1538                 WIPHY_ENTRY
1539                 NETDEV_ENTRY
1540         ),
1541         TP_fast_assign(
1542                 WIPHY_ASSIGN;
1543                 NETDEV_ASSIGN;
1544         ),
1545         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT,
1546                   WIPHY_PR_ARG, NETDEV_PR_ARG)
1547 );
1548 
1549 TRACE_EVENT(rdev_tdls_mgmt,
1550         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1551                  u8 *peer, u8 action_code, u8 dialog_token,
1552                  u16 status_code, u32 peer_capability,
1553                  bool initiator, const u8 *buf, size_t len),
1554         TP_ARGS(wiphy, netdev, peer, action_code, dialog_token, status_code,
1555                 peer_capability, initiator, buf, len),
1556         TP_STRUCT__entry(
1557                 WIPHY_ENTRY
1558                 NETDEV_ENTRY
1559                 MAC_ENTRY(peer)
1560                 __field(u8, action_code)
1561                 __field(u8, dialog_token)
1562                 __field(u16, status_code)
1563                 __field(u32, peer_capability)
1564                 __field(bool, initiator)
1565                 __dynamic_array(u8, buf, len)
1566         ),
1567         TP_fast_assign(
1568                 WIPHY_ASSIGN;
1569                 NETDEV_ASSIGN;
1570                 MAC_ASSIGN(peer, peer);
1571                 __entry->action_code = action_code;
1572                 __entry->dialog_token = dialog_token;
1573                 __entry->status_code = status_code;
1574                 __entry->peer_capability = peer_capability;
1575                 __entry->initiator = initiator;
1576                 memcpy(__get_dynamic_array(buf), buf, len);
1577         ),
1578         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", action_code: %u, "
1579                   "dialog_token: %u, status_code: %u, peer_capability: %u "
1580                   "initiator: %s buf: %#.2x ",
1581                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
1582                   __entry->action_code, __entry->dialog_token,
1583                   __entry->status_code, __entry->peer_capability,
1584                   BOOL_TO_STR(__entry->initiator),
1585                   ((u8 *)__get_dynamic_array(buf))[0])
1586 );
1587 
1588 TRACE_EVENT(rdev_dump_survey,
1589         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx),
1590         TP_ARGS(wiphy, netdev, idx),
1591         TP_STRUCT__entry(
1592                 WIPHY_ENTRY
1593                 NETDEV_ENTRY
1594                 __field(int, idx)
1595         ),
1596         TP_fast_assign(
1597                 WIPHY_ASSIGN;
1598                 NETDEV_ASSIGN;
1599                 __entry->idx = idx;
1600         ),
1601         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d",
1602                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx)
1603 );
1604 
1605 TRACE_EVENT(rdev_return_int_survey_info,
1606         TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info),
1607         TP_ARGS(wiphy, ret, info),
1608         TP_STRUCT__entry(
1609                 WIPHY_ENTRY
1610                 CHAN_ENTRY
1611                 __field(int, ret)
1612                 __field(u64, time)
1613                 __field(u64, time_busy)
1614                 __field(u64, time_ext_busy)
1615                 __field(u64, time_rx)
1616                 __field(u64, time_tx)
1617                 __field(u64, time_scan)
1618                 __field(u32, filled)
1619                 __field(s8, noise)
1620         ),
1621         TP_fast_assign(
1622                 WIPHY_ASSIGN;
1623                 CHAN_ASSIGN(info->channel);
1624                 __entry->ret = ret;
1625                 __entry->time = info->time;
1626                 __entry->time_busy = info->time_busy;
1627                 __entry->time_ext_busy = info->time_ext_busy;
1628                 __entry->time_rx = info->time_rx;
1629                 __entry->time_tx = info->time_tx;
1630                 __entry->time_scan = info->time_scan;
1631                 __entry->filled = info->filled;
1632                 __entry->noise = info->noise;
1633         ),
1634         TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT
1635                   ", channel time: %llu, channel time busy: %llu, "
1636                   "channel time extension busy: %llu, channel time rx: %llu, "
1637                   "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d",
1638                   WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG,
1639                   __entry->time, __entry->time_busy,
1640                   __entry->time_ext_busy, __entry->time_rx,
1641                   __entry->time_tx, __entry->time_scan,
1642                   __entry->filled, __entry->noise)
1643 );
1644 
1645 TRACE_EVENT(rdev_tdls_oper,
1646         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1647                  u8 *peer, enum nl80211_tdls_operation oper),
1648         TP_ARGS(wiphy, netdev, peer, oper),
1649         TP_STRUCT__entry(
1650                 WIPHY_ENTRY
1651                 NETDEV_ENTRY
1652                 MAC_ENTRY(peer)
1653                 __field(enum nl80211_tdls_operation, oper)
1654         ),
1655         TP_fast_assign(
1656                 WIPHY_ASSIGN;
1657                 NETDEV_ASSIGN;
1658                 MAC_ASSIGN(peer, peer);
1659                 __entry->oper = oper;
1660         ),
1661         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", oper: %d",
1662                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper)
1663 );
1664 
1665 DECLARE_EVENT_CLASS(rdev_pmksa,
1666         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1667                  struct cfg80211_pmksa *pmksa),
1668         TP_ARGS(wiphy, netdev, pmksa),
1669         TP_STRUCT__entry(
1670                 WIPHY_ENTRY
1671                 NETDEV_ENTRY
1672                 MAC_ENTRY(bssid)
1673         ),
1674         TP_fast_assign(
1675                 WIPHY_ASSIGN;
1676                 NETDEV_ASSIGN;
1677                 MAC_ASSIGN(bssid, pmksa->bssid);
1678         ),
1679         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT,
1680                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid))
1681 );
1682 
1683 TRACE_EVENT(rdev_probe_client,
1684         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1685                  const u8 *peer),
1686         TP_ARGS(wiphy, netdev, peer),
1687         TP_STRUCT__entry(
1688                 WIPHY_ENTRY
1689                 NETDEV_ENTRY
1690                 MAC_ENTRY(peer)
1691         ),
1692         TP_fast_assign(
1693                 WIPHY_ASSIGN;
1694                 NETDEV_ASSIGN;
1695                 MAC_ASSIGN(peer, peer);
1696         ),
1697         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
1698                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer))
1699 );
1700 
1701 DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa,
1702         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1703                  struct cfg80211_pmksa *pmksa),
1704         TP_ARGS(wiphy, netdev, pmksa)
1705 );
1706 
1707 DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa,
1708         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1709                  struct cfg80211_pmksa *pmksa),
1710         TP_ARGS(wiphy, netdev, pmksa)
1711 );
1712 
1713 TRACE_EVENT(rdev_remain_on_channel,
1714         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1715                  struct ieee80211_channel *chan,
1716                  unsigned int duration),
1717         TP_ARGS(wiphy, wdev, chan, duration),
1718         TP_STRUCT__entry(
1719                 WIPHY_ENTRY
1720                 WDEV_ENTRY
1721                 CHAN_ENTRY
1722                 __field(unsigned int, duration)
1723         ),
1724         TP_fast_assign(
1725                 WIPHY_ASSIGN;
1726                 WDEV_ASSIGN;
1727                 CHAN_ASSIGN(chan);
1728                 __entry->duration = duration;
1729         ),
1730         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u",
1731                   WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration)
1732 );
1733 
1734 TRACE_EVENT(rdev_return_int_cookie,
1735         TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie),
1736         TP_ARGS(wiphy, ret, cookie),
1737         TP_STRUCT__entry(
1738                 WIPHY_ENTRY
1739                 __field(int, ret)
1740                 __field(u64, cookie)
1741         ),
1742         TP_fast_assign(
1743                 WIPHY_ASSIGN;
1744                 __entry->ret = ret;
1745                 __entry->cookie = cookie;
1746         ),
1747         TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu",
1748                   WIPHY_PR_ARG, __entry->ret, __entry->cookie)
1749 );
1750 
1751 TRACE_EVENT(rdev_cancel_remain_on_channel,
1752         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie),
1753         TP_ARGS(wiphy, wdev, cookie),
1754         TP_STRUCT__entry(
1755                 WIPHY_ENTRY
1756                 WDEV_ENTRY
1757                 __field(u64, cookie)
1758         ),
1759         TP_fast_assign(
1760                 WIPHY_ASSIGN;
1761                 WDEV_ASSIGN;
1762                 __entry->cookie = cookie;
1763         ),
1764         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu",
1765                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie)
1766 );
1767 
1768 TRACE_EVENT(rdev_mgmt_tx,
1769         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1770                  struct cfg80211_mgmt_tx_params *params),
1771         TP_ARGS(wiphy, wdev, params),
1772         TP_STRUCT__entry(
1773                 WIPHY_ENTRY
1774                 WDEV_ENTRY
1775                 CHAN_ENTRY
1776                 __field(bool, offchan)
1777                 __field(unsigned int, wait)
1778                 __field(bool, no_cck)
1779                 __field(bool, dont_wait_for_ack)
1780         ),
1781         TP_fast_assign(
1782                 WIPHY_ASSIGN;
1783                 WDEV_ASSIGN;
1784                 CHAN_ASSIGN(params->chan);
1785                 __entry->offchan = params->offchan;
1786                 __entry->wait = params->wait;
1787                 __entry->no_cck = params->no_cck;
1788                 __entry->dont_wait_for_ack = params->dont_wait_for_ack;
1789         ),
1790         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s,"
1791                   " wait: %u, no cck: %s, dont wait for ack: %s",
1792                   WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG,
1793                   BOOL_TO_STR(__entry->offchan), __entry->wait,
1794                   BOOL_TO_STR(__entry->no_cck),
1795                   BOOL_TO_STR(__entry->dont_wait_for_ack))
1796 );
1797 
1798 TRACE_EVENT(rdev_set_noack_map,
1799         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1800                  u16 noack_map),
1801         TP_ARGS(wiphy, netdev, noack_map),
1802         TP_STRUCT__entry(
1803                 WIPHY_ENTRY
1804                 NETDEV_ENTRY
1805                 __field(u16, noack_map)
1806         ),
1807         TP_fast_assign(
1808                 WIPHY_ASSIGN;
1809                 NETDEV_ASSIGN;
1810                 __entry->noack_map = noack_map;
1811         ),
1812         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u",
1813                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map)
1814 );
1815 
1816 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel,
1817         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1818         TP_ARGS(wiphy, wdev)
1819 );
1820 
1821 TRACE_EVENT(rdev_return_chandef,
1822         TP_PROTO(struct wiphy *wiphy, int ret,
1823                  struct cfg80211_chan_def *chandef),
1824         TP_ARGS(wiphy, ret, chandef),
1825         TP_STRUCT__entry(
1826                 WIPHY_ENTRY
1827                 __field(int, ret)
1828                 CHAN_DEF_ENTRY
1829         ),
1830         TP_fast_assign(
1831                 WIPHY_ASSIGN;
1832                 if (ret == 0)
1833                         CHAN_DEF_ASSIGN(chandef);
1834                 else
1835                         CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL);
1836                 __entry->ret = ret;
1837         ),
1838         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d",
1839                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret)
1840 );
1841 
1842 DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device,
1843         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1844         TP_ARGS(wiphy, wdev)
1845 );
1846 
1847 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device,
1848         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1849         TP_ARGS(wiphy, wdev)
1850 );
1851 
1852 TRACE_EVENT(rdev_set_mac_acl,
1853         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1854                  struct cfg80211_acl_data *params),
1855         TP_ARGS(wiphy, netdev, params),
1856         TP_STRUCT__entry(
1857                 WIPHY_ENTRY
1858                 NETDEV_ENTRY
1859                 __field(u32, acl_policy)
1860         ),
1861         TP_fast_assign(
1862                 WIPHY_ASSIGN;
1863                 NETDEV_ASSIGN;
1864                 __entry->acl_policy = params->acl_policy;
1865         ),
1866         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d",
1867                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy)
1868 );
1869 
1870 TRACE_EVENT(rdev_update_ft_ies,
1871         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1872                  struct cfg80211_update_ft_ies_params *ftie),
1873         TP_ARGS(wiphy, netdev, ftie),
1874         TP_STRUCT__entry(
1875                 WIPHY_ENTRY
1876                 NETDEV_ENTRY
1877                 __field(u16, md)
1878                 __dynamic_array(u8, ie, ftie->ie_len)
1879         ),
1880         TP_fast_assign(
1881                 WIPHY_ASSIGN;
1882                 NETDEV_ASSIGN;
1883                 __entry->md = ftie->md;
1884                 memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len);
1885         ),
1886         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x",
1887                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md)
1888 );
1889 
1890 TRACE_EVENT(rdev_crit_proto_start,
1891         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
1892                  enum nl80211_crit_proto_id protocol, u16 duration),
1893         TP_ARGS(wiphy, wdev, protocol, duration),
1894         TP_STRUCT__entry(
1895                 WIPHY_ENTRY
1896                 WDEV_ENTRY
1897                 __field(u16, proto)
1898                 __field(u16, duration)
1899         ),
1900         TP_fast_assign(
1901                 WIPHY_ASSIGN;
1902                 WDEV_ASSIGN;
1903                 __entry->proto = protocol;
1904                 __entry->duration = duration;
1905         ),
1906         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u",
1907                   WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration)
1908 );
1909 
1910 TRACE_EVENT(rdev_crit_proto_stop,
1911         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
1912         TP_ARGS(wiphy, wdev),
1913         TP_STRUCT__entry(
1914                 WIPHY_ENTRY
1915                 WDEV_ENTRY
1916         ),
1917         TP_fast_assign(
1918                 WIPHY_ASSIGN;
1919                 WDEV_ASSIGN;
1920         ),
1921         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
1922                   WIPHY_PR_ARG, WDEV_PR_ARG)
1923 );
1924 
1925 TRACE_EVENT(rdev_channel_switch,
1926         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1927                  struct cfg80211_csa_settings *params),
1928         TP_ARGS(wiphy, netdev, params),
1929         TP_STRUCT__entry(
1930                 WIPHY_ENTRY
1931                 NETDEV_ENTRY
1932                 CHAN_DEF_ENTRY
1933                 __field(bool, radar_required)
1934                 __field(bool, block_tx)
1935                 __field(u8, count)
1936                 __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon)
1937                 __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp)
1938         ),
1939         TP_fast_assign(
1940                 WIPHY_ASSIGN;
1941                 NETDEV_ASSIGN;
1942                 CHAN_DEF_ASSIGN(&params->chandef);
1943                 __entry->radar_required = params->radar_required;
1944                 __entry->block_tx = params->block_tx;
1945                 __entry->count = params->count;
1946                 memcpy(__get_dynamic_array(bcn_ofs),
1947                        params->counter_offsets_beacon,
1948                        params->n_counter_offsets_beacon * sizeof(u16));
1949 
1950                 /* probe response offsets are optional */
1951                 if (params->n_counter_offsets_presp)
1952                         memcpy(__get_dynamic_array(pres_ofs),
1953                                params->counter_offsets_presp,
1954                                params->n_counter_offsets_presp * sizeof(u16));
1955         ),
1956         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT
1957                   ", block_tx: %d, count: %u, radar_required: %d",
1958                   WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG,
1959                   __entry->block_tx, __entry->count, __entry->radar_required)
1960 );
1961 
1962 TRACE_EVENT(rdev_set_qos_map,
1963         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1964                  struct cfg80211_qos_map *qos_map),
1965         TP_ARGS(wiphy, netdev, qos_map),
1966         TP_STRUCT__entry(
1967                 WIPHY_ENTRY
1968                 NETDEV_ENTRY
1969                 QOS_MAP_ENTRY
1970         ),
1971         TP_fast_assign(
1972                 WIPHY_ASSIGN;
1973                 NETDEV_ASSIGN;
1974                 QOS_MAP_ASSIGN(qos_map);
1975         ),
1976         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u",
1977                   WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des)
1978 );
1979 
1980 TRACE_EVENT(rdev_set_ap_chanwidth,
1981         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
1982                  struct cfg80211_chan_def *chandef),
1983         TP_ARGS(wiphy, netdev, chandef),
1984         TP_STRUCT__entry(
1985                 WIPHY_ENTRY
1986                 NETDEV_ENTRY
1987                 CHAN_DEF_ENTRY
1988         ),
1989         TP_fast_assign(
1990                 WIPHY_ASSIGN;
1991                 NETDEV_ASSIGN;
1992                 CHAN_DEF_ASSIGN(chandef);
1993         ),
1994         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
1995                   WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
1996 );
1997 
1998 TRACE_EVENT(rdev_add_tx_ts,
1999         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2000                  u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time),
2001         TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time),
2002         TP_STRUCT__entry(
2003                 WIPHY_ENTRY
2004                 NETDEV_ENTRY
2005                 MAC_ENTRY(peer)
2006                 __field(u8, tsid)
2007                 __field(u8, user_prio)
2008                 __field(u16, admitted_time)
2009         ),
2010         TP_fast_assign(
2011                 WIPHY_ASSIGN;
2012                 NETDEV_ASSIGN;
2013                 MAC_ASSIGN(peer, peer);
2014                 __entry->tsid = tsid;
2015                 __entry->user_prio = user_prio;
2016                 __entry->admitted_time = admitted_time;
2017         ),
2018         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d, UP %d, time %d",
2019                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer),
2020                   __entry->tsid, __entry->user_prio, __entry->admitted_time)
2021 );
2022 
2023 TRACE_EVENT(rdev_del_tx_ts,
2024         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2025                  u8 tsid, const u8 *peer),
2026         TP_ARGS(wiphy, netdev, tsid, peer),
2027         TP_STRUCT__entry(
2028                 WIPHY_ENTRY
2029                 NETDEV_ENTRY
2030                 MAC_ENTRY(peer)
2031                 __field(u8, tsid)
2032         ),
2033         TP_fast_assign(
2034                 WIPHY_ASSIGN;
2035                 NETDEV_ASSIGN;
2036                 MAC_ASSIGN(peer, peer);
2037                 __entry->tsid = tsid;
2038         ),
2039         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d",
2040                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->tsid)
2041 );
2042 
2043 TRACE_EVENT(rdev_tdls_channel_switch,
2044         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2045                  const u8 *addr, u8 oper_class,
2046                  struct cfg80211_chan_def *chandef),
2047         TP_ARGS(wiphy, netdev, addr, oper_class, chandef),
2048         TP_STRUCT__entry(
2049                 WIPHY_ENTRY
2050                 NETDEV_ENTRY
2051                 MAC_ENTRY(addr)
2052                 __field(u8, oper_class)
2053                 CHAN_DEF_ENTRY
2054         ),
2055         TP_fast_assign(
2056                 WIPHY_ASSIGN;
2057                 NETDEV_ASSIGN;
2058                 MAC_ASSIGN(addr, addr);
2059                 CHAN_DEF_ASSIGN(chandef);
2060         ),
2061         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT
2062                   " oper class %d, " CHAN_DEF_PR_FMT,
2063                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr),
2064                   __entry->oper_class, CHAN_DEF_PR_ARG)
2065 );
2066 
2067 TRACE_EVENT(rdev_tdls_cancel_channel_switch,
2068         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2069                  const u8 *addr),
2070         TP_ARGS(wiphy, netdev, addr),
2071         TP_STRUCT__entry(
2072                 WIPHY_ENTRY
2073                 NETDEV_ENTRY
2074                 MAC_ENTRY(addr)
2075         ),
2076         TP_fast_assign(
2077                 WIPHY_ASSIGN;
2078                 NETDEV_ASSIGN;
2079                 MAC_ASSIGN(addr, addr);
2080         ),
2081         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT,
2082                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr))
2083 );
2084 
2085 /*************************************************************
2086  *           cfg80211 exported functions traces              *
2087  *************************************************************/
2088 
2089 TRACE_EVENT(cfg80211_return_bool,
2090         TP_PROTO(bool ret),
2091         TP_ARGS(ret),
2092         TP_STRUCT__entry(
2093                 __field(bool, ret)
2094         ),
2095         TP_fast_assign(
2096                 __entry->ret = ret;
2097         ),
2098         TP_printk("returned %s", BOOL_TO_STR(__entry->ret))
2099 );
2100 
2101 DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt,
2102         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2103         TP_ARGS(netdev, macaddr),
2104         TP_STRUCT__entry(
2105                 NETDEV_ENTRY
2106                 MAC_ENTRY(macaddr)
2107         ),
2108         TP_fast_assign(
2109                 NETDEV_ASSIGN;
2110                 MAC_ASSIGN(macaddr, macaddr);
2111         ),
2112         TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
2113                   NETDEV_PR_ARG, MAC_PR_ARG(macaddr))
2114 );
2115 
2116 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate,
2117         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2118         TP_ARGS(netdev, macaddr)
2119 );
2120 
2121 DECLARE_EVENT_CLASS(netdev_evt_only,
2122         TP_PROTO(struct net_device *netdev),
2123         TP_ARGS(netdev),
2124         TP_STRUCT__entry(
2125                 NETDEV_ENTRY
2126         ),
2127         TP_fast_assign(
2128                 NETDEV_ASSIGN;
2129         ),
2130         TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG)
2131 );
2132 
2133 DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth,
2134         TP_PROTO(struct net_device *netdev),
2135         TP_ARGS(netdev)
2136 );
2137 
2138 TRACE_EVENT(cfg80211_send_rx_assoc,
2139         TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss),
2140         TP_ARGS(netdev, bss),
2141         TP_STRUCT__entry(
2142                 NETDEV_ENTRY
2143                 MAC_ENTRY(bssid)
2144                 CHAN_ENTRY
2145         ),
2146         TP_fast_assign(
2147                 NETDEV_ASSIGN;
2148                 MAC_ASSIGN(bssid, bss->bssid);
2149                 CHAN_ASSIGN(bss->channel);
2150         ),
2151         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", " CHAN_PR_FMT,
2152                   NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
2153 );
2154 
2155 DECLARE_EVENT_CLASS(netdev_frame_event,
2156         TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
2157         TP_ARGS(netdev, buf, len),
2158         TP_STRUCT__entry(
2159                 NETDEV_ENTRY
2160                 __dynamic_array(u8, frame, len)
2161         ),
2162         TP_fast_assign(
2163                 NETDEV_ASSIGN;
2164                 memcpy(__get_dynamic_array(frame), buf, len);
2165         ),
2166         TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x",
2167                   NETDEV_PR_ARG,
2168                   le16_to_cpup((__le16 *)__get_dynamic_array(frame)))
2169 );
2170 
2171 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt,
2172         TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
2173         TP_ARGS(netdev, buf, len)
2174 );
2175 
2176 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt,
2177         TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
2178         TP_ARGS(netdev, buf, len)
2179 );
2180 
2181 TRACE_EVENT(cfg80211_tx_mlme_mgmt,
2182         TP_PROTO(struct net_device *netdev, const u8 *buf, int len),
2183         TP_ARGS(netdev, buf, len),
2184         TP_STRUCT__entry(
2185                 NETDEV_ENTRY
2186                 __dynamic_array(u8, frame, len)
2187         ),
2188         TP_fast_assign(
2189                 NETDEV_ASSIGN;
2190                 memcpy(__get_dynamic_array(frame), buf, len);
2191         ),
2192         TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x",
2193                   NETDEV_PR_ARG,
2194                   le16_to_cpup((__le16 *)__get_dynamic_array(frame)))
2195 );
2196 
2197 DECLARE_EVENT_CLASS(netdev_mac_evt,
2198         TP_PROTO(struct net_device *netdev, const u8 *mac),
2199         TP_ARGS(netdev, mac),
2200         TP_STRUCT__entry(
2201                 NETDEV_ENTRY
2202                 MAC_ENTRY(mac)
2203         ),
2204         TP_fast_assign(
2205                 NETDEV_ASSIGN;
2206                 MAC_ASSIGN(mac, mac)
2207         ),
2208         TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT,
2209                   NETDEV_PR_ARG, MAC_PR_ARG(mac))
2210 );
2211 
2212 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout,
2213         TP_PROTO(struct net_device *netdev, const u8 *mac),
2214         TP_ARGS(netdev, mac)
2215 );
2216 
2217 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout,
2218         TP_PROTO(struct net_device *netdev, const u8 *mac),
2219         TP_ARGS(netdev, mac)
2220 );
2221 
2222 TRACE_EVENT(cfg80211_michael_mic_failure,
2223         TP_PROTO(struct net_device *netdev, const u8 *addr,
2224                  enum nl80211_key_type key_type, int key_id, const u8 *tsc),
2225         TP_ARGS(netdev, addr, key_type, key_id, tsc),
2226         TP_STRUCT__entry(
2227                 NETDEV_ENTRY
2228                 MAC_ENTRY(addr)
2229                 __field(enum nl80211_key_type, key_type)
2230                 __field(int, key_id)
2231                 __array(u8, tsc, 6)
2232         ),
2233         TP_fast_assign(
2234                 NETDEV_ASSIGN;
2235                 MAC_ASSIGN(addr, addr);
2236                 __entry->key_type = key_type;
2237                 __entry->key_id = key_id;
2238                 if (tsc)
2239                         memcpy(__entry->tsc, tsc, 6);
2240         ),
2241         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", key type: %d, key id: %d, tsc: %pm",
2242                   NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->key_type,
2243                   __entry->key_id, __entry->tsc)
2244 );
2245 
2246 TRACE_EVENT(cfg80211_ready_on_channel,
2247         TP_PROTO(struct wireless_dev *wdev, u64 cookie,
2248                  struct ieee80211_channel *chan,
2249                  unsigned int duration),
2250         TP_ARGS(wdev, cookie, chan, duration),
2251         TP_STRUCT__entry(
2252                 WDEV_ENTRY
2253                 __field(u64, cookie)
2254                 CHAN_ENTRY
2255                 __field(unsigned int, duration)
2256         ),
2257         TP_fast_assign(
2258                 WDEV_ASSIGN;
2259                 __entry->cookie = cookie;
2260                 CHAN_ASSIGN(chan);
2261                 __entry->duration = duration;
2262         ),
2263         TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u",
2264                   WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG,
2265                   __entry->duration)
2266 );
2267 
2268 TRACE_EVENT(cfg80211_ready_on_channel_expired,
2269         TP_PROTO(struct wireless_dev *wdev, u64 cookie,
2270                  struct ieee80211_channel *chan),
2271         TP_ARGS(wdev, cookie, chan),
2272         TP_STRUCT__entry(
2273                 WDEV_ENTRY
2274                 __field(u64, cookie)
2275                 CHAN_ENTRY
2276         ),
2277         TP_fast_assign(
2278                 WDEV_ASSIGN;
2279                 __entry->cookie = cookie;
2280                 CHAN_ASSIGN(chan);
2281         ),
2282         TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT,
2283                   WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG)
2284 );
2285 
2286 TRACE_EVENT(cfg80211_new_sta,
2287         TP_PROTO(struct net_device *netdev, const u8 *mac_addr,
2288                  struct station_info *sinfo),
2289         TP_ARGS(netdev, mac_addr, sinfo),
2290         TP_STRUCT__entry(
2291                 NETDEV_ENTRY
2292                 MAC_ENTRY(mac_addr)
2293                 SINFO_ENTRY
2294         ),
2295         TP_fast_assign(
2296                 NETDEV_ASSIGN;
2297                 MAC_ASSIGN(mac_addr, mac_addr);
2298                 SINFO_ASSIGN;
2299         ),
2300         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT,
2301                   NETDEV_PR_ARG, MAC_PR_ARG(mac_addr))
2302 );
2303 
2304 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta,
2305         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2306         TP_ARGS(netdev, macaddr)
2307 );
2308 
2309 TRACE_EVENT(cfg80211_rx_mgmt,
2310         TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm),
2311         TP_ARGS(wdev, freq, sig_mbm),
2312         TP_STRUCT__entry(
2313                 WDEV_ENTRY
2314                 __field(int, freq)
2315                 __field(int, sig_mbm)
2316         ),
2317         TP_fast_assign(
2318                 WDEV_ASSIGN;
2319                 __entry->freq = freq;
2320                 __entry->sig_mbm = sig_mbm;
2321         ),
2322         TP_printk(WDEV_PR_FMT ", freq: %d, sig mbm: %d",
2323                   WDEV_PR_ARG, __entry->freq, __entry->sig_mbm)
2324 );
2325 
2326 TRACE_EVENT(cfg80211_mgmt_tx_status,
2327         TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack),
2328         TP_ARGS(wdev, cookie, ack),
2329         TP_STRUCT__entry(
2330                 WDEV_ENTRY
2331                 __field(u64, cookie)
2332                 __field(bool, ack)
2333         ),
2334         TP_fast_assign(
2335                 WDEV_ASSIGN;
2336                 __entry->cookie = cookie;
2337                 __entry->ack = ack;
2338         ),
2339         TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s",
2340                   WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack))
2341 );
2342 
2343 TRACE_EVENT(cfg80211_cqm_rssi_notify,
2344         TP_PROTO(struct net_device *netdev,
2345                  enum nl80211_cqm_rssi_threshold_event rssi_event),
2346         TP_ARGS(netdev, rssi_event),
2347         TP_STRUCT__entry(
2348                 NETDEV_ENTRY
2349                 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event)
2350         ),
2351         TP_fast_assign(
2352                 NETDEV_ASSIGN;
2353                 __entry->rssi_event = rssi_event;
2354         ),
2355         TP_printk(NETDEV_PR_FMT ", rssi event: %d",
2356                   NETDEV_PR_ARG, __entry->rssi_event)
2357 );
2358 
2359 TRACE_EVENT(cfg80211_reg_can_beacon,
2360         TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef,
2361                  enum nl80211_iftype iftype, bool check_no_ir),
2362         TP_ARGS(wiphy, chandef, iftype, check_no_ir),
2363         TP_STRUCT__entry(
2364                 WIPHY_ENTRY
2365                 CHAN_DEF_ENTRY
2366                 __field(enum nl80211_iftype, iftype)
2367                 __field(bool, check_no_ir)
2368         ),
2369         TP_fast_assign(
2370                 WIPHY_ASSIGN;
2371                 CHAN_DEF_ASSIGN(chandef);
2372                 __entry->iftype = iftype;
2373                 __entry->check_no_ir = check_no_ir;
2374         ),
2375         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d check_no_ir=%s",
2376                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype,
2377                   BOOL_TO_STR(__entry->check_no_ir))
2378 );
2379 
2380 TRACE_EVENT(cfg80211_chandef_dfs_required,
2381         TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef),
2382         TP_ARGS(wiphy, chandef),
2383         TP_STRUCT__entry(
2384                 WIPHY_ENTRY
2385                 CHAN_DEF_ENTRY
2386         ),
2387         TP_fast_assign(
2388                 WIPHY_ASSIGN;
2389                 CHAN_DEF_ASSIGN(chandef);
2390         ),
2391         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
2392                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
2393 );
2394 
2395 TRACE_EVENT(cfg80211_ch_switch_notify,
2396         TP_PROTO(struct net_device *netdev,
2397                  struct cfg80211_chan_def *chandef),
2398         TP_ARGS(netdev, chandef),
2399         TP_STRUCT__entry(
2400                 NETDEV_ENTRY
2401                 CHAN_DEF_ENTRY
2402         ),
2403         TP_fast_assign(
2404                 NETDEV_ASSIGN;
2405                 CHAN_DEF_ASSIGN(chandef);
2406         ),
2407         TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
2408                   NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
2409 );
2410 
2411 TRACE_EVENT(cfg80211_ch_switch_started_notify,
2412         TP_PROTO(struct net_device *netdev,
2413                  struct cfg80211_chan_def *chandef),
2414         TP_ARGS(netdev, chandef),
2415         TP_STRUCT__entry(
2416                 NETDEV_ENTRY
2417                 CHAN_DEF_ENTRY
2418         ),
2419         TP_fast_assign(
2420                 NETDEV_ASSIGN;
2421                 CHAN_DEF_ASSIGN(chandef);
2422         ),
2423         TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT,
2424                   NETDEV_PR_ARG, CHAN_DEF_PR_ARG)
2425 );
2426 
2427 TRACE_EVENT(cfg80211_radar_event,
2428         TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef),
2429         TP_ARGS(wiphy, chandef),
2430         TP_STRUCT__entry(
2431                 WIPHY_ENTRY
2432                 CHAN_DEF_ENTRY
2433         ),
2434         TP_fast_assign(
2435                 WIPHY_ASSIGN;
2436                 CHAN_DEF_ASSIGN(chandef);
2437         ),
2438         TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT,
2439                   WIPHY_PR_ARG, CHAN_DEF_PR_ARG)
2440 );
2441 
2442 TRACE_EVENT(cfg80211_cac_event,
2443         TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt),
2444         TP_ARGS(netdev, evt),
2445         TP_STRUCT__entry(
2446                 NETDEV_ENTRY
2447                 __field(enum nl80211_radar_event, evt)
2448         ),
2449         TP_fast_assign(
2450                 NETDEV_ASSIGN;
2451                 __entry->evt = evt;
2452         ),
2453         TP_printk(NETDEV_PR_FMT ",  event: %d",
2454                   NETDEV_PR_ARG, __entry->evt)
2455 );
2456 
2457 DECLARE_EVENT_CLASS(cfg80211_rx_evt,
2458         TP_PROTO(struct net_device *netdev, const u8 *addr),
2459         TP_ARGS(netdev, addr),
2460         TP_STRUCT__entry(
2461                 NETDEV_ENTRY
2462                 MAC_ENTRY(addr)
2463         ),
2464         TP_fast_assign(
2465                 NETDEV_ASSIGN;
2466                 MAC_ASSIGN(addr, addr);
2467         ),
2468         TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr))
2469 );
2470 
2471 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame,
2472         TP_PROTO(struct net_device *netdev, const u8 *addr),
2473         TP_ARGS(netdev, addr)
2474 );
2475 
2476 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame,
2477         TP_PROTO(struct net_device *netdev, const u8 *addr),
2478         TP_ARGS(netdev, addr)
2479 );
2480 
2481 TRACE_EVENT(cfg80211_ibss_joined,
2482         TP_PROTO(struct net_device *netdev, const u8 *bssid,
2483                  struct ieee80211_channel *channel),
2484         TP_ARGS(netdev, bssid, channel),
2485         TP_STRUCT__entry(
2486                 NETDEV_ENTRY
2487                 MAC_ENTRY(bssid)
2488                 CHAN_ENTRY
2489         ),
2490         TP_fast_assign(
2491                 NETDEV_ASSIGN;
2492                 MAC_ASSIGN(bssid, bssid);
2493                 CHAN_ASSIGN(channel);
2494         ),
2495         TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT,
2496                   NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG)
2497 );
2498 
2499 TRACE_EVENT(cfg80211_probe_status,
2500         TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie,
2501                  bool acked),
2502         TP_ARGS(netdev, addr, cookie, acked),
2503         TP_STRUCT__entry(
2504                 NETDEV_ENTRY
2505                 MAC_ENTRY(addr)
2506                 __field(u64, cookie)
2507                 __field(bool, acked)
2508         ),
2509         TP_fast_assign(
2510                 NETDEV_ASSIGN;
2511                 MAC_ASSIGN(addr, addr);
2512                 __entry->cookie = cookie;
2513                 __entry->acked = acked;
2514         ),
2515         TP_printk(NETDEV_PR_FMT " addr:" MAC_PR_FMT ", cookie: %llu, acked: %s",
2516                   NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie,
2517                   BOOL_TO_STR(__entry->acked))
2518 );
2519 
2520 TRACE_EVENT(cfg80211_cqm_pktloss_notify,
2521         TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets),
2522         TP_ARGS(netdev, peer, num_packets),
2523         TP_STRUCT__entry(
2524                 NETDEV_ENTRY
2525                 MAC_ENTRY(peer)
2526                 __field(u32, num_packets)
2527         ),
2528         TP_fast_assign(
2529                 NETDEV_ASSIGN;
2530                 MAC_ASSIGN(peer, peer);
2531                 __entry->num_packets = num_packets;
2532         ),
2533         TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u",
2534                   NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets)
2535 );
2536 
2537 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify,
2538         TP_PROTO(struct net_device *netdev, const u8 *macaddr),
2539         TP_ARGS(netdev, macaddr)
2540 );
2541 
2542 TRACE_EVENT(cfg80211_pmksa_candidate_notify,
2543         TP_PROTO(struct net_device *netdev, int index, const u8 *bssid,
2544                  bool preauth),
2545         TP_ARGS(netdev, index, bssid, preauth),
2546         TP_STRUCT__entry(
2547                 NETDEV_ENTRY
2548                 __field(int, index)
2549                 MAC_ENTRY(bssid)
2550                 __field(bool, preauth)
2551         ),
2552         TP_fast_assign(
2553                 NETDEV_ASSIGN;
2554                 __entry->index = index;
2555                 MAC_ASSIGN(bssid, bssid);
2556                 __entry->preauth = preauth;
2557         ),
2558         TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s",
2559                   NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid),
2560                   BOOL_TO_STR(__entry->preauth))
2561 );
2562 
2563 TRACE_EVENT(cfg80211_report_obss_beacon,
2564         TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len,
2565                  int freq, int sig_dbm),
2566         TP_ARGS(wiphy, frame, len, freq, sig_dbm),
2567         TP_STRUCT__entry(
2568                 WIPHY_ENTRY
2569                 __field(int, freq)
2570                 __field(int, sig_dbm)
2571         ),
2572         TP_fast_assign(
2573                 WIPHY_ASSIGN;
2574                 __entry->freq = freq;
2575                 __entry->sig_dbm = sig_dbm;
2576         ),
2577         TP_printk(WIPHY_PR_FMT ", freq: %d, sig_dbm: %d",
2578                   WIPHY_PR_ARG, __entry->freq, __entry->sig_dbm)
2579 );
2580 
2581 TRACE_EVENT(cfg80211_tdls_oper_request,
2582         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer,
2583                  enum nl80211_tdls_operation oper, u16 reason_code),
2584         TP_ARGS(wiphy, netdev, peer, oper, reason_code),
2585         TP_STRUCT__entry(
2586                 WIPHY_ENTRY
2587                 NETDEV_ENTRY
2588                 MAC_ENTRY(peer)
2589                 __field(enum nl80211_tdls_operation, oper)
2590                 __field(u16, reason_code)
2591         ),
2592         TP_fast_assign(
2593                 WIPHY_ASSIGN;
2594                 NETDEV_ASSIGN;
2595                 MAC_ASSIGN(peer, peer);
2596                 __entry->oper = oper;
2597                 __entry->reason_code = reason_code;
2598         ),
2599         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", oper: %d, reason_code %u",
2600                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper,
2601                   __entry->reason_code)
2602         );
2603 
2604 TRACE_EVENT(cfg80211_scan_done,
2605         TP_PROTO(struct cfg80211_scan_request *request, bool aborted),
2606         TP_ARGS(request, aborted),
2607         TP_STRUCT__entry(
2608                 __field(u32, n_channels)
2609                 __dynamic_array(u8, ie, request ? request->ie_len : 0)
2610                 __array(u32, rates, IEEE80211_NUM_BANDS)
2611                 __field(u32, wdev_id)
2612                 MAC_ENTRY(wiphy_mac)
2613                 __field(bool, no_cck)
2614                 __field(bool, aborted)
2615         ),
2616         TP_fast_assign(
2617                 if (request) {
2618                         memcpy(__get_dynamic_array(ie), request->ie,
2619                                request->ie_len);
2620                         memcpy(__entry->rates, request->rates,
2621                                IEEE80211_NUM_BANDS);
2622                         __entry->wdev_id = request->wdev ?
2623                                         request->wdev->identifier : 0;
2624                         if (request->wiphy)
2625                                 MAC_ASSIGN(wiphy_mac,
2626                                            request->wiphy->perm_addr);
2627                         __entry->no_cck = request->no_cck;
2628                 }
2629                 __entry->aborted = aborted;
2630         ),
2631         TP_printk("aborted: %s", BOOL_TO_STR(__entry->aborted))
2632 );
2633 
2634 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_results,
2635         TP_PROTO(struct wiphy *wiphy),
2636         TP_ARGS(wiphy)
2637 );
2638 
2639 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_stopped,
2640         TP_PROTO(struct wiphy *wiphy),
2641         TP_ARGS(wiphy)
2642 );
2643 
2644 TRACE_EVENT(cfg80211_get_bss,
2645         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
2646                  const u8 *bssid, const u8 *ssid, size_t ssid_len,
2647                  enum ieee80211_bss_type bss_type,
2648                  enum ieee80211_privacy privacy),
2649         TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy),
2650         TP_STRUCT__entry(
2651                 WIPHY_ENTRY
2652                 CHAN_ENTRY
2653                 MAC_ENTRY(bssid)
2654                 __dynamic_array(u8, ssid, ssid_len)
2655                 __field(enum ieee80211_bss_type, bss_type)
2656                 __field(enum ieee80211_privacy, privacy)
2657         ),
2658         TP_fast_assign(
2659                 WIPHY_ASSIGN;
2660                 CHAN_ASSIGN(channel);
2661                 MAC_ASSIGN(bssid, bssid);
2662                 memcpy(__get_dynamic_array(ssid), ssid, ssid_len);
2663                 __entry->bss_type = bss_type;
2664                 __entry->privacy = privacy;
2665         ),
2666         TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", " MAC_PR_FMT
2667                   ", buf: %#.2x, bss_type: %d, privacy: %d",
2668                   WIPHY_PR_ARG, CHAN_PR_ARG, MAC_PR_ARG(bssid),
2669                   ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type,
2670                   __entry->privacy)
2671 );
2672 
2673 TRACE_EVENT(cfg80211_inform_bss_width_frame,
2674         TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel,
2675                  enum nl80211_bss_scan_width scan_width,
2676                  struct ieee80211_mgmt *mgmt, size_t len,
2677                  s32 signal),
2678         TP_ARGS(wiphy, channel, scan_width, mgmt, len, signal),
2679         TP_STRUCT__entry(
2680                 WIPHY_ENTRY
2681                 CHAN_ENTRY
2682                 __field(enum nl80211_bss_scan_width, scan_width)
2683                 __dynamic_array(u8, mgmt, len)
2684                 __field(s32, signal)
2685         ),
2686         TP_fast_assign(
2687                 WIPHY_ASSIGN;
2688                 CHAN_ASSIGN(channel);
2689                 __entry->scan_width = scan_width;
2690                 if (mgmt)
2691                         memcpy(__get_dynamic_array(mgmt), mgmt, len);
2692                 __entry->signal = signal;
2693         ),
2694         TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT "(scan_width: %d) signal: %d",
2695                   WIPHY_PR_ARG, CHAN_PR_ARG, __entry->scan_width,
2696                   __entry->signal)
2697 );
2698 
2699 DECLARE_EVENT_CLASS(cfg80211_bss_evt,
2700         TP_PROTO(struct cfg80211_bss *pub),
2701         TP_ARGS(pub),
2702         TP_STRUCT__entry(
2703                 MAC_ENTRY(bssid)
2704                 CHAN_ENTRY
2705         ),
2706         TP_fast_assign(
2707                 MAC_ASSIGN(bssid, pub->bssid);
2708                 CHAN_ASSIGN(pub->channel);
2709         ),
2710         TP_printk(MAC_PR_FMT ", " CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG)
2711 );
2712 
2713 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss,
2714         TP_PROTO(struct cfg80211_bss *pub),
2715         TP_ARGS(pub)
2716 );
2717 
2718 TRACE_EVENT(cfg80211_return_uint,
2719         TP_PROTO(unsigned int ret),
2720         TP_ARGS(ret),
2721         TP_STRUCT__entry(
2722                 __field(unsigned int, ret)
2723         ),
2724         TP_fast_assign(
2725                 __entry->ret = ret;
2726         ),
2727         TP_printk("ret: %d", __entry->ret)
2728 );
2729 
2730 TRACE_EVENT(cfg80211_return_u32,
2731         TP_PROTO(u32 ret),
2732         TP_ARGS(ret),
2733         TP_STRUCT__entry(
2734                 __field(u32, ret)
2735         ),
2736         TP_fast_assign(
2737                 __entry->ret = ret;
2738         ),
2739         TP_printk("ret: %u", __entry->ret)
2740 );
2741 
2742 TRACE_EVENT(cfg80211_report_wowlan_wakeup,
2743         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev,
2744                  struct cfg80211_wowlan_wakeup *wakeup),
2745         TP_ARGS(wiphy, wdev, wakeup),
2746         TP_STRUCT__entry(
2747                 WIPHY_ENTRY
2748                 WDEV_ENTRY
2749                 __field(bool, non_wireless)
2750                 __field(bool, disconnect)
2751                 __field(bool, magic_pkt)
2752                 __field(bool, gtk_rekey_failure)
2753                 __field(bool, eap_identity_req)
2754                 __field(bool, four_way_handshake)
2755                 __field(bool, rfkill_release)
2756                 __field(s32, pattern_idx)
2757                 __field(u32, packet_len)
2758                 __dynamic_array(u8, packet,
2759                                 wakeup ? wakeup->packet_present_len : 0)
2760         ),
2761         TP_fast_assign(
2762                 WIPHY_ASSIGN;
2763                 WDEV_ASSIGN;
2764                 __entry->non_wireless = !wakeup;
2765                 __entry->disconnect = wakeup ? wakeup->disconnect : false;
2766                 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false;
2767                 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false;
2768                 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false;
2769                 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false;
2770                 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false;
2771                 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false;
2772                 __entry->packet_len = wakeup ? wakeup->packet_len : false;
2773                 if (wakeup && wakeup->packet && wakeup->packet_present_len)
2774                         memcpy(__get_dynamic_array(packet), wakeup->packet,
2775                                wakeup->packet_present_len);
2776         ),
2777         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG)
2778 );
2779 
2780 TRACE_EVENT(cfg80211_ft_event,
2781         TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
2782                  struct cfg80211_ft_event_params *ft_event),
2783         TP_ARGS(wiphy, netdev, ft_event),
2784         TP_STRUCT__entry(
2785                 WIPHY_ENTRY
2786                 NETDEV_ENTRY
2787                 __dynamic_array(u8, ies, ft_event->ies_len)
2788                 MAC_ENTRY(target_ap)
2789                 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len)
2790         ),
2791         TP_fast_assign(
2792                 WIPHY_ASSIGN;
2793                 NETDEV_ASSIGN;
2794                 if (ft_event->ies)
2795                         memcpy(__get_dynamic_array(ies), ft_event->ies,
2796                                ft_event->ies_len);
2797                 MAC_ASSIGN(target_ap, ft_event->target_ap);
2798                 if (ft_event->ric_ies)
2799                         memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies,
2800                                ft_event->ric_ies_len);
2801         ),
2802         TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: " MAC_PR_FMT,
2803                   WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(target_ap))
2804 );
2805 
2806 TRACE_EVENT(cfg80211_stop_iface,
2807         TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev),
2808         TP_ARGS(wiphy, wdev),
2809         TP_STRUCT__entry(
2810                 WIPHY_ENTRY
2811                 WDEV_ENTRY
2812         ),
2813         TP_fast_assign(
2814                 WIPHY_ASSIGN;
2815                 WDEV_ASSIGN;
2816         ),
2817         TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT,
2818                   WIPHY_PR_ARG, WDEV_PR_ARG)
2819 );
2820 
2821 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */
2822 
2823 #undef TRACE_INCLUDE_PATH
2824 #define TRACE_INCLUDE_PATH .
2825 #undef TRACE_INCLUDE_FILE
2826 #define TRACE_INCLUDE_FILE trace
2827 #include <trace/define_trace.h>
2828 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp