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