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