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 216TRACE_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 254TRACE_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 268TRACE_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 280DECLARE_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 292DEFINE_EVENT(wiphy_only_evt, rdev_resume, 293 TP_PROTO(struct wiphy *wiphy), 294 TP_ARGS(wiphy) 295); 296 297DEFINE_EVENT(wiphy_only_evt, rdev_return_void, 298 TP_PROTO(struct wiphy *wiphy), 299 TP_ARGS(wiphy) 300); 301 302DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, 303 TP_PROTO(struct wiphy *wiphy), 304 TP_ARGS(wiphy) 305); 306 307DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, 308 TP_PROTO(struct wiphy *wiphy), 309 TP_ARGS(wiphy) 310); 311 312DECLARE_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 327DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, 328 TP_PROTO(struct wiphy *wiphy, bool enabled), 329 TP_ARGS(wiphy, enabled) 330); 331 332TRACE_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 349DECLARE_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 363DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, 364 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 365 TP_ARGS(wiphy, wdev) 366); 367 368DEFINE_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 373TRACE_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 391DECLARE_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 414DEFINE_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 420DEFINE_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 426DEFINE_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 432TRACE_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 456TRACE_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 473TRACE_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 515TRACE_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 560DECLARE_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 574DEFINE_EVENT(wiphy_netdev_evt, rdev_stop_ap, 575 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 576 TP_ARGS(wiphy, netdev) 577); 578 579DEFINE_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 584DEFINE_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 589DEFINE_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 594DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, 595 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 596 TP_ARGS(wiphy, netdev) 597); 598 599DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, 600 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 601 TP_ARGS(wiphy, netdev) 602); 603 604DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, 605 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 606 TP_ARGS(wiphy, netdev) 607); 608 609DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, 610 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 611 TP_ARGS(wiphy, netdev) 612); 613 614DECLARE_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 664DEFINE_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 670DEFINE_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 676DECLARE_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 693DECLARE_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 717DEFINE_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 723DEFINE_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 728DEFINE_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 733DEFINE_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 738TRACE_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 759TRACE_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 776DECLARE_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 797DEFINE_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 803DEFINE_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 809DEFINE_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 815TRACE_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 839TRACE_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 860TRACE_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 884TRACE_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 922TRACE_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 939TRACE_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 959TRACE_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 978TRACE_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 1008TRACE_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 1035TRACE_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 1053TRACE_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 1069TRACE_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 1093TRACE_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 1123TRACE_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 1144TRACE_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 1172TRACE_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 1190TRACE_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 1211TRACE_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 1244TRACE_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 1267TRACE_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 1290TRACE_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 1308TRACE_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 1329TRACE_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 1345TRACE_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 1360DEFINE_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 1365TRACE_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 1385TRACE_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 1403TRACE_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 1417TRACE_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 1430TRACE_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 1448TRACE_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 1469TRACE_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 1488TRACE_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 1511DECLARE_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 1528DEFINE_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 1533TRACE_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 1549TRACE_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 1588TRACE_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 1605TRACE_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 1645TRACE_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 1665DECLARE_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 1683TRACE_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 1701DEFINE_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 1707DEFINE_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 1713TRACE_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 1734TRACE_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 1751TRACE_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 1768TRACE_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 1798TRACE_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 1816DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, 1817 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1818 TP_ARGS(wiphy, wdev) 1819); 1820 1821TRACE_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 1842DEFINE_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 1847DEFINE_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 1852TRACE_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 1870TRACE_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 1890TRACE_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 1910TRACE_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 1925TRACE_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(¶ms->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 1962TRACE_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 1980TRACE_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 1998TRACE_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 2023TRACE_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 2043TRACE_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 2067TRACE_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 2089TRACE_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 2101DECLARE_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 2116DEFINE_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 2121DECLARE_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 2133DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, 2134 TP_PROTO(struct net_device *netdev), 2135 TP_ARGS(netdev) 2136); 2137 2138TRACE_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 2155DECLARE_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 2171DEFINE_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 2176DEFINE_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 2181TRACE_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 2197DECLARE_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 2212DEFINE_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 2217DEFINE_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 2222TRACE_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 2246TRACE_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 2268TRACE_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 2286TRACE_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 2304DEFINE_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 2309TRACE_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 2326TRACE_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 2343TRACE_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 2359TRACE_EVENT(cfg80211_reg_can_beacon, 2360 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 2361 enum nl80211_iftype iftype), 2362 TP_ARGS(wiphy, chandef, iftype), 2363 TP_STRUCT__entry( 2364 WIPHY_ENTRY 2365 CHAN_DEF_ENTRY 2366 __field(enum nl80211_iftype, iftype) 2367 ), 2368 TP_fast_assign( 2369 WIPHY_ASSIGN; 2370 CHAN_DEF_ASSIGN(chandef); 2371 __entry->iftype = iftype; 2372 ), 2373 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d", 2374 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype) 2375); 2376 2377TRACE_EVENT(cfg80211_chandef_dfs_required, 2378 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2379 TP_ARGS(wiphy, chandef), 2380 TP_STRUCT__entry( 2381 WIPHY_ENTRY 2382 CHAN_DEF_ENTRY 2383 ), 2384 TP_fast_assign( 2385 WIPHY_ASSIGN; 2386 CHAN_DEF_ASSIGN(chandef); 2387 ), 2388 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2389 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2390); 2391 2392TRACE_EVENT(cfg80211_ch_switch_notify, 2393 TP_PROTO(struct net_device *netdev, 2394 struct cfg80211_chan_def *chandef), 2395 TP_ARGS(netdev, chandef), 2396 TP_STRUCT__entry( 2397 NETDEV_ENTRY 2398 CHAN_DEF_ENTRY 2399 ), 2400 TP_fast_assign( 2401 NETDEV_ASSIGN; 2402 CHAN_DEF_ASSIGN(chandef); 2403 ), 2404 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2405 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2406); 2407 2408TRACE_EVENT(cfg80211_ch_switch_started_notify, 2409 TP_PROTO(struct net_device *netdev, 2410 struct cfg80211_chan_def *chandef), 2411 TP_ARGS(netdev, chandef), 2412 TP_STRUCT__entry( 2413 NETDEV_ENTRY 2414 CHAN_DEF_ENTRY 2415 ), 2416 TP_fast_assign( 2417 NETDEV_ASSIGN; 2418 CHAN_DEF_ASSIGN(chandef); 2419 ), 2420 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2421 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2422); 2423 2424TRACE_EVENT(cfg80211_radar_event, 2425 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2426 TP_ARGS(wiphy, chandef), 2427 TP_STRUCT__entry( 2428 WIPHY_ENTRY 2429 CHAN_DEF_ENTRY 2430 ), 2431 TP_fast_assign( 2432 WIPHY_ASSIGN; 2433 CHAN_DEF_ASSIGN(chandef); 2434 ), 2435 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2436 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2437); 2438 2439TRACE_EVENT(cfg80211_cac_event, 2440 TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), 2441 TP_ARGS(netdev, evt), 2442 TP_STRUCT__entry( 2443 NETDEV_ENTRY 2444 __field(enum nl80211_radar_event, evt) 2445 ), 2446 TP_fast_assign( 2447 NETDEV_ASSIGN; 2448 __entry->evt = evt; 2449 ), 2450 TP_printk(NETDEV_PR_FMT ", event: %d", 2451 NETDEV_PR_ARG, __entry->evt) 2452); 2453 2454DECLARE_EVENT_CLASS(cfg80211_rx_evt, 2455 TP_PROTO(struct net_device *netdev, const u8 *addr), 2456 TP_ARGS(netdev, addr), 2457 TP_STRUCT__entry( 2458 NETDEV_ENTRY 2459 MAC_ENTRY(addr) 2460 ), 2461 TP_fast_assign( 2462 NETDEV_ASSIGN; 2463 MAC_ASSIGN(addr, addr); 2464 ), 2465 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr)) 2466); 2467 2468DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, 2469 TP_PROTO(struct net_device *netdev, const u8 *addr), 2470 TP_ARGS(netdev, addr) 2471); 2472 2473DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, 2474 TP_PROTO(struct net_device *netdev, const u8 *addr), 2475 TP_ARGS(netdev, addr) 2476); 2477 2478TRACE_EVENT(cfg80211_ibss_joined, 2479 TP_PROTO(struct net_device *netdev, const u8 *bssid, 2480 struct ieee80211_channel *channel), 2481 TP_ARGS(netdev, bssid, channel), 2482 TP_STRUCT__entry( 2483 NETDEV_ENTRY 2484 MAC_ENTRY(bssid) 2485 CHAN_ENTRY 2486 ), 2487 TP_fast_assign( 2488 NETDEV_ASSIGN; 2489 MAC_ASSIGN(bssid, bssid); 2490 CHAN_ASSIGN(channel); 2491 ), 2492 TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT, 2493 NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2494); 2495 2496TRACE_EVENT(cfg80211_probe_status, 2497 TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, 2498 bool acked), 2499 TP_ARGS(netdev, addr, cookie, acked), 2500 TP_STRUCT__entry( 2501 NETDEV_ENTRY 2502 MAC_ENTRY(addr) 2503 __field(u64, cookie) 2504 __field(bool, acked) 2505 ), 2506 TP_fast_assign( 2507 NETDEV_ASSIGN; 2508 MAC_ASSIGN(addr, addr); 2509 __entry->cookie = cookie; 2510 __entry->acked = acked; 2511 ), 2512 TP_printk(NETDEV_PR_FMT " addr:" MAC_PR_FMT ", cookie: %llu, acked: %s", 2513 NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie, 2514 BOOL_TO_STR(__entry->acked)) 2515); 2516 2517TRACE_EVENT(cfg80211_cqm_pktloss_notify, 2518 TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), 2519 TP_ARGS(netdev, peer, num_packets), 2520 TP_STRUCT__entry( 2521 NETDEV_ENTRY 2522 MAC_ENTRY(peer) 2523 __field(u32, num_packets) 2524 ), 2525 TP_fast_assign( 2526 NETDEV_ASSIGN; 2527 MAC_ASSIGN(peer, peer); 2528 __entry->num_packets = num_packets; 2529 ), 2530 TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u", 2531 NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets) 2532); 2533 2534DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, 2535 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2536 TP_ARGS(netdev, macaddr) 2537); 2538 2539TRACE_EVENT(cfg80211_pmksa_candidate_notify, 2540 TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, 2541 bool preauth), 2542 TP_ARGS(netdev, index, bssid, preauth), 2543 TP_STRUCT__entry( 2544 NETDEV_ENTRY 2545 __field(int, index) 2546 MAC_ENTRY(bssid) 2547 __field(bool, preauth) 2548 ), 2549 TP_fast_assign( 2550 NETDEV_ASSIGN; 2551 __entry->index = index; 2552 MAC_ASSIGN(bssid, bssid); 2553 __entry->preauth = preauth; 2554 ), 2555 TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s", 2556 NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid), 2557 BOOL_TO_STR(__entry->preauth)) 2558); 2559 2560TRACE_EVENT(cfg80211_report_obss_beacon, 2561 TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, 2562 int freq, int sig_dbm), 2563 TP_ARGS(wiphy, frame, len, freq, sig_dbm), 2564 TP_STRUCT__entry( 2565 WIPHY_ENTRY 2566 __field(int, freq) 2567 __field(int, sig_dbm) 2568 ), 2569 TP_fast_assign( 2570 WIPHY_ASSIGN; 2571 __entry->freq = freq; 2572 __entry->sig_dbm = sig_dbm; 2573 ), 2574 TP_printk(WIPHY_PR_FMT ", freq: %d, sig_dbm: %d", 2575 WIPHY_PR_ARG, __entry->freq, __entry->sig_dbm) 2576); 2577 2578TRACE_EVENT(cfg80211_tdls_oper_request, 2579 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, 2580 enum nl80211_tdls_operation oper, u16 reason_code), 2581 TP_ARGS(wiphy, netdev, peer, oper, reason_code), 2582 TP_STRUCT__entry( 2583 WIPHY_ENTRY 2584 NETDEV_ENTRY 2585 MAC_ENTRY(peer) 2586 __field(enum nl80211_tdls_operation, oper) 2587 __field(u16, reason_code) 2588 ), 2589 TP_fast_assign( 2590 WIPHY_ASSIGN; 2591 NETDEV_ASSIGN; 2592 MAC_ASSIGN(peer, peer); 2593 __entry->oper = oper; 2594 __entry->reason_code = reason_code; 2595 ), 2596 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", oper: %d, reason_code %u", 2597 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper, 2598 __entry->reason_code) 2599 ); 2600 2601TRACE_EVENT(cfg80211_scan_done, 2602 TP_PROTO(struct cfg80211_scan_request *request, bool aborted), 2603 TP_ARGS(request, aborted), 2604 TP_STRUCT__entry( 2605 __field(u32, n_channels) 2606 __dynamic_array(u8, ie, request ? request->ie_len : 0) 2607 __array(u32, rates, IEEE80211_NUM_BANDS) 2608 __field(u32, wdev_id) 2609 MAC_ENTRY(wiphy_mac) 2610 __field(bool, no_cck) 2611 __field(bool, aborted) 2612 ), 2613 TP_fast_assign( 2614 if (request) { 2615 memcpy(__get_dynamic_array(ie), request->ie, 2616 request->ie_len); 2617 memcpy(__entry->rates, request->rates, 2618 IEEE80211_NUM_BANDS); 2619 __entry->wdev_id = request->wdev ? 2620 request->wdev->identifier : 0; 2621 if (request->wiphy) 2622 MAC_ASSIGN(wiphy_mac, 2623 request->wiphy->perm_addr); 2624 __entry->no_cck = request->no_cck; 2625 } 2626 __entry->aborted = aborted; 2627 ), 2628 TP_printk("aborted: %s", BOOL_TO_STR(__entry->aborted)) 2629); 2630 2631DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_results, 2632 TP_PROTO(struct wiphy *wiphy), 2633 TP_ARGS(wiphy) 2634); 2635 2636DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_stopped, 2637 TP_PROTO(struct wiphy *wiphy), 2638 TP_ARGS(wiphy) 2639); 2640 2641TRACE_EVENT(cfg80211_get_bss, 2642 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, 2643 const u8 *bssid, const u8 *ssid, size_t ssid_len, 2644 enum ieee80211_bss_type bss_type, 2645 enum ieee80211_privacy privacy), 2646 TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy), 2647 TP_STRUCT__entry( 2648 WIPHY_ENTRY 2649 CHAN_ENTRY 2650 MAC_ENTRY(bssid) 2651 __dynamic_array(u8, ssid, ssid_len) 2652 __field(enum ieee80211_bss_type, bss_type) 2653 __field(enum ieee80211_privacy, privacy) 2654 ), 2655 TP_fast_assign( 2656 WIPHY_ASSIGN; 2657 CHAN_ASSIGN(channel); 2658 MAC_ASSIGN(bssid, bssid); 2659 memcpy(__get_dynamic_array(ssid), ssid, ssid_len); 2660 __entry->bss_type = bss_type; 2661 __entry->privacy = privacy; 2662 ), 2663 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", " MAC_PR_FMT 2664 ", buf: %#.2x, bss_type: %d, privacy: %d", 2665 WIPHY_PR_ARG, CHAN_PR_ARG, MAC_PR_ARG(bssid), 2666 ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type, 2667 __entry->privacy) 2668); 2669 2670TRACE_EVENT(cfg80211_inform_bss_width_frame, 2671 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, 2672 enum nl80211_bss_scan_width scan_width, 2673 struct ieee80211_mgmt *mgmt, size_t len, 2674 s32 signal), 2675 TP_ARGS(wiphy, channel, scan_width, mgmt, len, signal), 2676 TP_STRUCT__entry( 2677 WIPHY_ENTRY 2678 CHAN_ENTRY 2679 __field(enum nl80211_bss_scan_width, scan_width) 2680 __dynamic_array(u8, mgmt, len) 2681 __field(s32, signal) 2682 ), 2683 TP_fast_assign( 2684 WIPHY_ASSIGN; 2685 CHAN_ASSIGN(channel); 2686 __entry->scan_width = scan_width; 2687 if (mgmt) 2688 memcpy(__get_dynamic_array(mgmt), mgmt, len); 2689 __entry->signal = signal; 2690 ), 2691 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT "(scan_width: %d) signal: %d", 2692 WIPHY_PR_ARG, CHAN_PR_ARG, __entry->scan_width, 2693 __entry->signal) 2694); 2695 2696DECLARE_EVENT_CLASS(cfg80211_bss_evt, 2697 TP_PROTO(struct cfg80211_bss *pub), 2698 TP_ARGS(pub), 2699 TP_STRUCT__entry( 2700 MAC_ENTRY(bssid) 2701 CHAN_ENTRY 2702 ), 2703 TP_fast_assign( 2704 MAC_ASSIGN(bssid, pub->bssid); 2705 CHAN_ASSIGN(pub->channel); 2706 ), 2707 TP_printk(MAC_PR_FMT ", " CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2708); 2709 2710DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, 2711 TP_PROTO(struct cfg80211_bss *pub), 2712 TP_ARGS(pub) 2713); 2714 2715TRACE_EVENT(cfg80211_return_uint, 2716 TP_PROTO(unsigned int ret), 2717 TP_ARGS(ret), 2718 TP_STRUCT__entry( 2719 __field(unsigned int, ret) 2720 ), 2721 TP_fast_assign( 2722 __entry->ret = ret; 2723 ), 2724 TP_printk("ret: %d", __entry->ret) 2725); 2726 2727TRACE_EVENT(cfg80211_return_u32, 2728 TP_PROTO(u32 ret), 2729 TP_ARGS(ret), 2730 TP_STRUCT__entry( 2731 __field(u32, ret) 2732 ), 2733 TP_fast_assign( 2734 __entry->ret = ret; 2735 ), 2736 TP_printk("ret: %u", __entry->ret) 2737); 2738 2739TRACE_EVENT(cfg80211_report_wowlan_wakeup, 2740 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2741 struct cfg80211_wowlan_wakeup *wakeup), 2742 TP_ARGS(wiphy, wdev, wakeup), 2743 TP_STRUCT__entry( 2744 WIPHY_ENTRY 2745 WDEV_ENTRY 2746 __field(bool, non_wireless) 2747 __field(bool, disconnect) 2748 __field(bool, magic_pkt) 2749 __field(bool, gtk_rekey_failure) 2750 __field(bool, eap_identity_req) 2751 __field(bool, four_way_handshake) 2752 __field(bool, rfkill_release) 2753 __field(s32, pattern_idx) 2754 __field(u32, packet_len) 2755 __dynamic_array(u8, packet, 2756 wakeup ? wakeup->packet_present_len : 0) 2757 ), 2758 TP_fast_assign( 2759 WIPHY_ASSIGN; 2760 WDEV_ASSIGN; 2761 __entry->non_wireless = !wakeup; 2762 __entry->disconnect = wakeup ? wakeup->disconnect : false; 2763 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false; 2764 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false; 2765 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false; 2766 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false; 2767 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false; 2768 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false; 2769 __entry->packet_len = wakeup ? wakeup->packet_len : false; 2770 if (wakeup && wakeup->packet && wakeup->packet_present_len) 2771 memcpy(__get_dynamic_array(packet), wakeup->packet, 2772 wakeup->packet_present_len); 2773 ), 2774 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 2775); 2776 2777TRACE_EVENT(cfg80211_ft_event, 2778 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2779 struct cfg80211_ft_event_params *ft_event), 2780 TP_ARGS(wiphy, netdev, ft_event), 2781 TP_STRUCT__entry( 2782 WIPHY_ENTRY 2783 NETDEV_ENTRY 2784 __dynamic_array(u8, ies, ft_event->ies_len) 2785 MAC_ENTRY(target_ap) 2786 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len) 2787 ), 2788 TP_fast_assign( 2789 WIPHY_ASSIGN; 2790 NETDEV_ASSIGN; 2791 if (ft_event->ies) 2792 memcpy(__get_dynamic_array(ies), ft_event->ies, 2793 ft_event->ies_len); 2794 MAC_ASSIGN(target_ap, ft_event->target_ap); 2795 if (ft_event->ric_ies) 2796 memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies, 2797 ft_event->ric_ies_len); 2798 ), 2799 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: " MAC_PR_FMT, 2800 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(target_ap)) 2801); 2802 2803TRACE_EVENT(cfg80211_stop_iface, 2804 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2805 TP_ARGS(wiphy, wdev), 2806 TP_STRUCT__entry( 2807 WIPHY_ENTRY 2808 WDEV_ENTRY 2809 ), 2810 TP_fast_assign( 2811 WIPHY_ASSIGN; 2812 WDEV_ASSIGN; 2813 ), 2814 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 2815 WIPHY_PR_ARG, WDEV_PR_ARG) 2816); 2817 2818#endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */ 2819 2820#undef TRACE_INCLUDE_PATH 2821#define TRACE_INCLUDE_PATH . 2822#undef TRACE_INCLUDE_FILE 2823#define TRACE_INCLUDE_FILE trace 2824#include <trace/define_trace.h> 2825