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