1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Portions of this file 4 * Copyright(c) 2016-2017 Intel Deutschland GmbH 5 * Copyright (C) 2018, 2020-2025 Intel Corporation 6 */ 7 #undef TRACE_SYSTEM 8 #define TRACE_SYSTEM cfg80211 9 10 #if !defined(__RDEV_OPS_TRACE) || defined(TRACE_HEADER_MULTI_READ) 11 #define __RDEV_OPS_TRACE 12 13 #include <linux/tracepoint.h> 14 15 #include <linux/rtnetlink.h> 16 #include <linux/etherdevice.h> 17 #include <net/cfg80211.h> 18 #include "core.h" 19 20 #define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN) 21 #define MAC_ASSIGN(entry_mac, given_mac) do { \ 22 if (given_mac) \ 23 memcpy(__entry->entry_mac, given_mac, ETH_ALEN); \ 24 else \ 25 eth_zero_addr(__entry->entry_mac); \ 26 } while (0) 27 28 #define MAXNAME 32 29 #define WIPHY_ENTRY __array(char, wiphy_name, 32) 30 #define WIPHY_ASSIGN strscpy(__entry->wiphy_name, wiphy_name(wiphy), MAXNAME) 31 #define WIPHY_PR_FMT "%s" 32 #define WIPHY_PR_ARG __entry->wiphy_name 33 34 #define WDEV_ENTRY __field(u32, id) 35 #define WDEV_ASSIGN (__entry->id) = (!IS_ERR_OR_NULL(wdev) \ 36 ? wdev->identifier : 0) 37 #define WDEV_PR_FMT "wdev(%u)" 38 #define WDEV_PR_ARG (__entry->id) 39 40 #define NETDEV_ENTRY __array(char, name, IFNAMSIZ) \ 41 __field(int, ifindex) 42 #define NETDEV_ASSIGN \ 43 do { \ 44 memcpy(__entry->name, netdev->name, IFNAMSIZ); \ 45 (__entry->ifindex) = (netdev->ifindex); \ 46 } while (0) 47 #define NETDEV_PR_FMT "netdev:%s(%d)" 48 #define NETDEV_PR_ARG __entry->name, __entry->ifindex 49 50 #define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout) \ 51 __field(u16, dot11MeshConfirmTimeout) \ 52 __field(u16, dot11MeshHoldingTimeout) \ 53 __field(u16, dot11MeshMaxPeerLinks) \ 54 __field(u8, dot11MeshMaxRetries) \ 55 __field(u8, dot11MeshTTL) \ 56 __field(u8, element_ttl) \ 57 __field(bool, auto_open_plinks) \ 58 __field(u32, dot11MeshNbrOffsetMaxNeighbor) \ 59 __field(u8, dot11MeshHWMPmaxPREQretries) \ 60 __field(u32, path_refresh_time) \ 61 __field(u32, dot11MeshHWMPactivePathTimeout) \ 62 __field(u16, min_discovery_timeout) \ 63 __field(u16, dot11MeshHWMPpreqMinInterval) \ 64 __field(u16, dot11MeshHWMPperrMinInterval) \ 65 __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \ 66 __field(u8, dot11MeshHWMPRootMode) \ 67 __field(u16, dot11MeshHWMPRannInterval) \ 68 __field(bool, dot11MeshGateAnnouncementProtocol) \ 69 __field(bool, dot11MeshForwarding) \ 70 __field(s32, rssi_threshold) \ 71 __field(u16, ht_opmode) \ 72 __field(u32, dot11MeshHWMPactivePathToRootTimeout) \ 73 __field(u16, dot11MeshHWMProotInterval) \ 74 __field(u16, dot11MeshHWMPconfirmationInterval) \ 75 __field(bool, dot11MeshNolearn) 76 #define MESH_CFG_ASSIGN \ 77 do { \ 78 __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \ 79 __entry->dot11MeshConfirmTimeout = \ 80 conf->dot11MeshConfirmTimeout; \ 81 __entry->dot11MeshHoldingTimeout = \ 82 conf->dot11MeshHoldingTimeout; \ 83 __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \ 84 __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries; \ 85 __entry->dot11MeshTTL = conf->dot11MeshTTL; \ 86 __entry->element_ttl = conf->element_ttl; \ 87 __entry->auto_open_plinks = conf->auto_open_plinks; \ 88 __entry->dot11MeshNbrOffsetMaxNeighbor = \ 89 conf->dot11MeshNbrOffsetMaxNeighbor; \ 90 __entry->dot11MeshHWMPmaxPREQretries = \ 91 conf->dot11MeshHWMPmaxPREQretries; \ 92 __entry->path_refresh_time = conf->path_refresh_time; \ 93 __entry->dot11MeshHWMPactivePathTimeout = \ 94 conf->dot11MeshHWMPactivePathTimeout; \ 95 __entry->min_discovery_timeout = conf->min_discovery_timeout; \ 96 __entry->dot11MeshHWMPpreqMinInterval = \ 97 conf->dot11MeshHWMPpreqMinInterval; \ 98 __entry->dot11MeshHWMPperrMinInterval = \ 99 conf->dot11MeshHWMPperrMinInterval; \ 100 __entry->dot11MeshHWMPnetDiameterTraversalTime = \ 101 conf->dot11MeshHWMPnetDiameterTraversalTime; \ 102 __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \ 103 __entry->dot11MeshHWMPRannInterval = \ 104 conf->dot11MeshHWMPRannInterval; \ 105 __entry->dot11MeshGateAnnouncementProtocol = \ 106 conf->dot11MeshGateAnnouncementProtocol; \ 107 __entry->dot11MeshForwarding = conf->dot11MeshForwarding; \ 108 __entry->rssi_threshold = conf->rssi_threshold; \ 109 __entry->ht_opmode = conf->ht_opmode; \ 110 __entry->dot11MeshHWMPactivePathToRootTimeout = \ 111 conf->dot11MeshHWMPactivePathToRootTimeout; \ 112 __entry->dot11MeshHWMProotInterval = \ 113 conf->dot11MeshHWMProotInterval; \ 114 __entry->dot11MeshHWMPconfirmationInterval = \ 115 conf->dot11MeshHWMPconfirmationInterval; \ 116 __entry->dot11MeshNolearn = conf->dot11MeshNolearn; \ 117 } while (0) 118 119 #define CHAN_ENTRY __field(enum nl80211_band, band) \ 120 __field(u32, center_freq) \ 121 __field(u16, freq_offset) 122 #define CHAN_ASSIGN(chan) \ 123 do { \ 124 if (chan) { \ 125 __entry->band = chan->band; \ 126 __entry->center_freq = chan->center_freq; \ 127 __entry->freq_offset = chan->freq_offset; \ 128 } else { \ 129 __entry->band = 0; \ 130 __entry->center_freq = 0; \ 131 __entry->freq_offset = 0; \ 132 } \ 133 } while (0) 134 #define CHAN_PR_FMT "band: %d, freq: %u.%03u" 135 #define CHAN_PR_ARG __entry->band, __entry->center_freq, __entry->freq_offset 136 137 #define CHAN_DEF_ENTRY __field(enum nl80211_band, band) \ 138 __field(u32, control_freq) \ 139 __field(u32, freq_offset) \ 140 __field(u32, width) \ 141 __field(u32, center_freq1) \ 142 __field(u32, freq1_offset) \ 143 __field(u32, center_freq2) \ 144 __field(u16, punctured) 145 #define CHAN_DEF_ASSIGN(chandef) \ 146 do { \ 147 if ((chandef) && (chandef)->chan) { \ 148 __entry->band = (chandef)->chan->band; \ 149 __entry->control_freq = \ 150 (chandef)->chan->center_freq; \ 151 __entry->freq_offset = \ 152 (chandef)->chan->freq_offset; \ 153 __entry->width = (chandef)->width; \ 154 __entry->center_freq1 = (chandef)->center_freq1;\ 155 __entry->freq1_offset = (chandef)->freq1_offset;\ 156 __entry->center_freq2 = (chandef)->center_freq2;\ 157 __entry->punctured = (chandef)->punctured; \ 158 } else { \ 159 __entry->band = 0; \ 160 __entry->control_freq = 0; \ 161 __entry->freq_offset = 0; \ 162 __entry->width = 0; \ 163 __entry->center_freq1 = 0; \ 164 __entry->freq1_offset = 0; \ 165 __entry->center_freq2 = 0; \ 166 __entry->punctured = 0; \ 167 } \ 168 } while (0) 169 #define CHAN_DEF_PR_FMT \ 170 "band: %d, control freq: %u.%03u, width: %d, cf1: %u.%03u, cf2: %u, punct: 0x%x" 171 #define CHAN_DEF_PR_ARG __entry->band, __entry->control_freq, \ 172 __entry->freq_offset, __entry->width, \ 173 __entry->center_freq1, __entry->freq1_offset, \ 174 __entry->center_freq2, __entry->punctured 175 176 #define FILS_AAD_ASSIGN(fa) \ 177 do { \ 178 if (fa) { \ 179 ether_addr_copy(__entry->macaddr, fa->macaddr); \ 180 __entry->kek_len = fa->kek_len; \ 181 } else { \ 182 eth_zero_addr(__entry->macaddr); \ 183 __entry->kek_len = 0; \ 184 } \ 185 } while (0) 186 #define FILS_AAD_PR_FMT \ 187 "macaddr: %pM, kek_len: %d" 188 189 #define SINFO_ENTRY __field(int, generation) \ 190 __field(u32, connected_time) \ 191 __field(u32, inactive_time) \ 192 __field(u32, rx_bytes) \ 193 __field(u32, tx_bytes) \ 194 __field(u32, rx_packets) \ 195 __field(u32, tx_packets) \ 196 __field(u32, tx_retries) \ 197 __field(u32, tx_failed) \ 198 __field(u32, rx_dropped_misc) \ 199 __field(u32, beacon_loss_count) \ 200 __field(u16, llid) \ 201 __field(u16, plid) \ 202 __field(u8, plink_state) 203 #define SINFO_ASSIGN \ 204 do { \ 205 __entry->generation = sinfo->generation; \ 206 __entry->connected_time = sinfo->connected_time; \ 207 __entry->inactive_time = sinfo->inactive_time; \ 208 __entry->rx_bytes = sinfo->rx_bytes; \ 209 __entry->tx_bytes = sinfo->tx_bytes; \ 210 __entry->rx_packets = sinfo->rx_packets; \ 211 __entry->tx_packets = sinfo->tx_packets; \ 212 __entry->tx_retries = sinfo->tx_retries; \ 213 __entry->tx_failed = sinfo->tx_failed; \ 214 __entry->rx_dropped_misc = sinfo->rx_dropped_misc; \ 215 __entry->beacon_loss_count = sinfo->beacon_loss_count; \ 216 __entry->llid = sinfo->llid; \ 217 __entry->plid = sinfo->plid; \ 218 __entry->plink_state = sinfo->plink_state; \ 219 } while (0) 220 221 #define BOOL_TO_STR(bo) (bo) ? "true" : "false" 222 223 #define QOS_MAP_ENTRY __field(u8, num_des) \ 224 __array(u8, dscp_exception, \ 225 2 * IEEE80211_QOS_MAP_MAX_EX) \ 226 __array(u8, up, IEEE80211_QOS_MAP_LEN_MIN) 227 #define QOS_MAP_ASSIGN(qos_map) \ 228 do { \ 229 if ((qos_map)) { \ 230 __entry->num_des = (qos_map)->num_des; \ 231 memcpy(__entry->dscp_exception, \ 232 &(qos_map)->dscp_exception, \ 233 2 * IEEE80211_QOS_MAP_MAX_EX); \ 234 memcpy(__entry->up, &(qos_map)->up, \ 235 IEEE80211_QOS_MAP_LEN_MIN); \ 236 } else { \ 237 __entry->num_des = 0; \ 238 memset(__entry->dscp_exception, 0, \ 239 2 * IEEE80211_QOS_MAP_MAX_EX); \ 240 memset(__entry->up, 0, \ 241 IEEE80211_QOS_MAP_LEN_MIN); \ 242 } \ 243 } while (0) 244 245 /************************************************************* 246 * wiphy work traces * 247 *************************************************************/ 248 249 DECLARE_EVENT_CLASS(wiphy_work_event, 250 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), 251 TP_ARGS(wiphy, work), 252 TP_STRUCT__entry( 253 WIPHY_ENTRY 254 __field(void *, instance) 255 __field(void *, func) 256 ), 257 TP_fast_assign( 258 WIPHY_ASSIGN; 259 __entry->instance = work; 260 __entry->func = work ? work->func : NULL; 261 ), 262 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS", 263 WIPHY_PR_ARG, __entry->instance, __entry->func) 264 ); 265 266 DEFINE_EVENT(wiphy_work_event, wiphy_work_queue, 267 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), 268 TP_ARGS(wiphy, work) 269 ); 270 271 DEFINE_EVENT(wiphy_work_event, wiphy_work_run, 272 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), 273 TP_ARGS(wiphy, work) 274 ); 275 276 DEFINE_EVENT(wiphy_work_event, wiphy_work_cancel, 277 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), 278 TP_ARGS(wiphy, work) 279 ); 280 281 DEFINE_EVENT(wiphy_work_event, wiphy_work_flush, 282 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), 283 TP_ARGS(wiphy, work) 284 ); 285 286 TRACE_EVENT(wiphy_delayed_work_queue, 287 TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work, 288 unsigned long delay), 289 TP_ARGS(wiphy, work, delay), 290 TP_STRUCT__entry( 291 WIPHY_ENTRY 292 __field(void *, instance) 293 __field(void *, func) 294 __field(unsigned long, delay) 295 ), 296 TP_fast_assign( 297 WIPHY_ASSIGN; 298 __entry->instance = work; 299 __entry->func = work->func; 300 __entry->delay = delay; 301 ), 302 TP_printk(WIPHY_PR_FMT " instance=%p func=%pS delay=%ld", 303 WIPHY_PR_ARG, __entry->instance, __entry->func, 304 __entry->delay) 305 ); 306 307 TRACE_EVENT(wiphy_work_worker_start, 308 TP_PROTO(struct wiphy *wiphy), 309 TP_ARGS(wiphy), 310 TP_STRUCT__entry( 311 WIPHY_ENTRY 312 ), 313 TP_fast_assign( 314 WIPHY_ASSIGN; 315 ), 316 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) 317 ); 318 319 /************************************************************* 320 * rdev->ops traces * 321 *************************************************************/ 322 323 TRACE_EVENT(rdev_suspend, 324 TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), 325 TP_ARGS(wiphy, wow), 326 TP_STRUCT__entry( 327 WIPHY_ENTRY 328 __field(bool, any) 329 __field(bool, disconnect) 330 __field(bool, magic_pkt) 331 __field(bool, gtk_rekey_failure) 332 __field(bool, eap_identity_req) 333 __field(bool, four_way_handshake) 334 __field(bool, rfkill_release) 335 __field(bool, valid_wow) 336 ), 337 TP_fast_assign( 338 WIPHY_ASSIGN; 339 if (wow) { 340 __entry->any = wow->any; 341 __entry->disconnect = wow->disconnect; 342 __entry->magic_pkt = wow->magic_pkt; 343 __entry->gtk_rekey_failure = wow->gtk_rekey_failure; 344 __entry->eap_identity_req = wow->eap_identity_req; 345 __entry->four_way_handshake = wow->four_way_handshake; 346 __entry->rfkill_release = wow->rfkill_release; 347 __entry->valid_wow = true; 348 } else { 349 __entry->valid_wow = false; 350 } 351 ), 352 TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, " 353 "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, " 354 "four way handshake: %d, rfkill release: %d.", 355 WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)", 356 __entry->any, __entry->disconnect, __entry->magic_pkt, 357 __entry->gtk_rekey_failure, __entry->eap_identity_req, 358 __entry->four_way_handshake, __entry->rfkill_release) 359 ); 360 361 TRACE_EVENT(rdev_return_int, 362 TP_PROTO(struct wiphy *wiphy, int ret), 363 TP_ARGS(wiphy, ret), 364 TP_STRUCT__entry( 365 WIPHY_ENTRY 366 __field(int, ret) 367 ), 368 TP_fast_assign( 369 WIPHY_ASSIGN; 370 __entry->ret = ret; 371 ), 372 TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret) 373 ); 374 375 TRACE_EVENT(rdev_scan, 376 TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), 377 TP_ARGS(wiphy, request), 378 TP_STRUCT__entry( 379 WIPHY_ENTRY 380 ), 381 TP_fast_assign( 382 WIPHY_ASSIGN; 383 ), 384 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) 385 ); 386 387 DECLARE_EVENT_CLASS(wiphy_only_evt, 388 TP_PROTO(struct wiphy *wiphy), 389 TP_ARGS(wiphy), 390 TP_STRUCT__entry( 391 WIPHY_ENTRY 392 ), 393 TP_fast_assign( 394 WIPHY_ASSIGN; 395 ), 396 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) 397 ); 398 399 DEFINE_EVENT(wiphy_only_evt, rdev_resume, 400 TP_PROTO(struct wiphy *wiphy), 401 TP_ARGS(wiphy) 402 ); 403 404 DEFINE_EVENT(wiphy_only_evt, rdev_return_void, 405 TP_PROTO(struct wiphy *wiphy), 406 TP_ARGS(wiphy) 407 ); 408 409 TRACE_EVENT(rdev_get_antenna, 410 TP_PROTO(struct wiphy *wiphy, int radio_idx), 411 TP_ARGS(wiphy, radio_idx), 412 TP_STRUCT__entry( 413 WIPHY_ENTRY 414 __field(int, radio_idx) 415 ), 416 TP_fast_assign( 417 WIPHY_ASSIGN; 418 __entry->radio_idx = radio_idx; 419 ), 420 TP_printk(WIPHY_PR_FMT ", radio_idx: %d", 421 WIPHY_PR_ARG, __entry->radio_idx) 422 ); 423 424 DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, 425 TP_PROTO(struct wiphy *wiphy), 426 TP_ARGS(wiphy) 427 ); 428 429 DECLARE_EVENT_CLASS(wiphy_enabled_evt, 430 TP_PROTO(struct wiphy *wiphy, bool enabled), 431 TP_ARGS(wiphy, enabled), 432 TP_STRUCT__entry( 433 WIPHY_ENTRY 434 __field(bool, enabled) 435 ), 436 TP_fast_assign( 437 WIPHY_ASSIGN; 438 __entry->enabled = enabled; 439 ), 440 TP_printk(WIPHY_PR_FMT ", %senabled ", 441 WIPHY_PR_ARG, __entry->enabled ? "" : "not ") 442 ); 443 444 DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, 445 TP_PROTO(struct wiphy *wiphy, bool enabled), 446 TP_ARGS(wiphy, enabled) 447 ); 448 449 TRACE_EVENT(rdev_add_virtual_intf, 450 TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), 451 TP_ARGS(wiphy, name, type), 452 TP_STRUCT__entry( 453 WIPHY_ENTRY 454 __string(vir_intf_name, name ? name : "<noname>") 455 __field(enum nl80211_iftype, type) 456 ), 457 TP_fast_assign( 458 WIPHY_ASSIGN; 459 __assign_str(vir_intf_name); 460 __entry->type = type; 461 ), 462 TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d", 463 WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type) 464 ); 465 466 DECLARE_EVENT_CLASS(wiphy_wdev_evt, 467 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 468 TP_ARGS(wiphy, wdev), 469 TP_STRUCT__entry( 470 WIPHY_ENTRY 471 WDEV_ENTRY 472 ), 473 TP_fast_assign( 474 WIPHY_ASSIGN; 475 WDEV_ASSIGN; 476 ), 477 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 478 ); 479 480 DECLARE_EVENT_CLASS(wiphy_wdev_cookie_evt, 481 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 482 TP_ARGS(wiphy, wdev, cookie), 483 TP_STRUCT__entry( 484 WIPHY_ENTRY 485 WDEV_ENTRY 486 __field(u64, cookie) 487 ), 488 TP_fast_assign( 489 WIPHY_ASSIGN; 490 WDEV_ASSIGN; 491 __entry->cookie = cookie; 492 ), 493 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %lld", 494 WIPHY_PR_ARG, WDEV_PR_ARG, 495 (unsigned long long)__entry->cookie) 496 ); 497 498 DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, 499 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 500 TP_ARGS(wiphy, wdev) 501 ); 502 503 DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, 504 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 505 TP_ARGS(wiphy, wdev) 506 ); 507 508 TRACE_EVENT(rdev_change_virtual_intf, 509 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 510 enum nl80211_iftype type), 511 TP_ARGS(wiphy, netdev, type), 512 TP_STRUCT__entry( 513 WIPHY_ENTRY 514 NETDEV_ENTRY 515 __field(enum nl80211_iftype, type) 516 ), 517 TP_fast_assign( 518 WIPHY_ASSIGN; 519 NETDEV_ASSIGN; 520 __entry->type = type; 521 ), 522 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", type: %d", 523 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type) 524 ); 525 526 DECLARE_EVENT_CLASS(key_handle, 527 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, 528 u8 key_index, bool pairwise, const u8 *mac_addr), 529 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr), 530 TP_STRUCT__entry( 531 WIPHY_ENTRY 532 NETDEV_ENTRY 533 MAC_ENTRY(mac_addr) 534 __field(int, link_id) 535 __field(u8, key_index) 536 __field(bool, pairwise) 537 ), 538 TP_fast_assign( 539 WIPHY_ASSIGN; 540 NETDEV_ASSIGN; 541 MAC_ASSIGN(mac_addr, mac_addr); 542 __entry->link_id = link_id; 543 __entry->key_index = key_index; 544 __entry->pairwise = pairwise; 545 ), 546 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " 547 "key_index: %u, pairwise: %s, mac addr: %pM", 548 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, 549 __entry->key_index, BOOL_TO_STR(__entry->pairwise), 550 __entry->mac_addr) 551 ); 552 553 DEFINE_EVENT(key_handle, rdev_get_key, 554 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, 555 u8 key_index, bool pairwise, const u8 *mac_addr), 556 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr) 557 ); 558 559 DEFINE_EVENT(key_handle, rdev_del_key, 560 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, 561 u8 key_index, bool pairwise, const u8 *mac_addr), 562 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr) 563 ); 564 565 TRACE_EVENT(rdev_add_key, 566 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, 567 u8 key_index, bool pairwise, const u8 *mac_addr, u8 mode), 568 TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr, mode), 569 TP_STRUCT__entry( 570 WIPHY_ENTRY 571 NETDEV_ENTRY 572 MAC_ENTRY(mac_addr) 573 __field(int, link_id) 574 __field(u8, key_index) 575 __field(bool, pairwise) 576 __field(u8, mode) 577 ), 578 TP_fast_assign( 579 WIPHY_ASSIGN; 580 NETDEV_ASSIGN; 581 MAC_ASSIGN(mac_addr, mac_addr); 582 __entry->link_id = link_id; 583 __entry->key_index = key_index; 584 __entry->pairwise = pairwise; 585 __entry->mode = mode; 586 ), 587 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " 588 "key_index: %u, mode: %u, pairwise: %s, " 589 "mac addr: %pM", 590 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, 591 __entry->key_index, __entry->mode, 592 BOOL_TO_STR(__entry->pairwise), __entry->mac_addr) 593 ); 594 595 TRACE_EVENT(rdev_set_default_key, 596 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, 597 u8 key_index, bool unicast, bool multicast), 598 TP_ARGS(wiphy, netdev, link_id, key_index, unicast, multicast), 599 TP_STRUCT__entry( 600 WIPHY_ENTRY 601 NETDEV_ENTRY 602 __field(int, link_id) 603 __field(u8, key_index) 604 __field(bool, unicast) 605 __field(bool, multicast) 606 ), 607 TP_fast_assign( 608 WIPHY_ASSIGN; 609 NETDEV_ASSIGN; 610 __entry->link_id = link_id; 611 __entry->key_index = key_index; 612 __entry->unicast = unicast; 613 __entry->multicast = multicast; 614 ), 615 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " 616 "key index: %u, unicast: %s, multicast: %s", 617 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, 618 __entry->key_index, BOOL_TO_STR(__entry->unicast), 619 BOOL_TO_STR(__entry->multicast)) 620 ); 621 622 TRACE_EVENT(rdev_set_default_mgmt_key, 623 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, 624 u8 key_index), 625 TP_ARGS(wiphy, netdev, link_id, key_index), 626 TP_STRUCT__entry( 627 WIPHY_ENTRY 628 NETDEV_ENTRY 629 __field(int, link_id) 630 __field(u8, key_index) 631 ), 632 TP_fast_assign( 633 WIPHY_ASSIGN; 634 NETDEV_ASSIGN; 635 __entry->link_id = link_id; 636 __entry->key_index = key_index; 637 ), 638 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " 639 "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG, 640 __entry->link_id, __entry->key_index) 641 ); 642 643 TRACE_EVENT(rdev_set_default_beacon_key, 644 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, 645 u8 key_index), 646 TP_ARGS(wiphy, netdev, link_id, key_index), 647 TP_STRUCT__entry( 648 WIPHY_ENTRY 649 NETDEV_ENTRY 650 __field(int, link_id) 651 __field(u8, key_index) 652 ), 653 TP_fast_assign( 654 WIPHY_ASSIGN; 655 NETDEV_ASSIGN; 656 __entry->link_id = link_id; 657 __entry->key_index = key_index; 658 ), 659 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " 660 "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG, 661 __entry->link_id, __entry->key_index) 662 ); 663 664 TRACE_EVENT(rdev_start_ap, 665 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 666 struct cfg80211_ap_settings *settings), 667 TP_ARGS(wiphy, netdev, settings), 668 TP_STRUCT__entry( 669 WIPHY_ENTRY 670 NETDEV_ENTRY 671 CHAN_DEF_ENTRY 672 __field(int, beacon_interval) 673 __field(int, dtim_period) 674 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) 675 __field(enum nl80211_hidden_ssid, hidden_ssid) 676 __field(u32, wpa_ver) 677 __field(bool, privacy) 678 __field(enum nl80211_auth_type, auth_type) 679 __field(int, inactivity_timeout) 680 __field(unsigned int, link_id) 681 ), 682 TP_fast_assign( 683 WIPHY_ASSIGN; 684 NETDEV_ASSIGN; 685 CHAN_DEF_ASSIGN(&settings->chandef); 686 __entry->beacon_interval = settings->beacon_interval; 687 __entry->dtim_period = settings->dtim_period; 688 __entry->hidden_ssid = settings->hidden_ssid; 689 __entry->wpa_ver = settings->crypto.wpa_versions; 690 __entry->privacy = settings->privacy; 691 __entry->auth_type = settings->auth_type; 692 __entry->inactivity_timeout = settings->inactivity_timeout; 693 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 694 memcpy(__entry->ssid, settings->ssid, settings->ssid_len); 695 __entry->link_id = settings->beacon.link_id; 696 ), 697 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", AP settings - ssid: %s, " 698 CHAN_DEF_PR_FMT ", beacon interval: %d, dtim period: %d, " 699 "hidden ssid: %d, wpa versions: %u, privacy: %s, " 700 "auth type: %d, inactivity timeout: %d, link_id: %d", 701 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_DEF_PR_ARG, 702 __entry->beacon_interval, __entry->dtim_period, 703 __entry->hidden_ssid, __entry->wpa_ver, 704 BOOL_TO_STR(__entry->privacy), __entry->auth_type, 705 __entry->inactivity_timeout, __entry->link_id) 706 ); 707 708 TRACE_EVENT(rdev_change_beacon, 709 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 710 struct cfg80211_ap_update *info), 711 TP_ARGS(wiphy, netdev, info), 712 TP_STRUCT__entry( 713 WIPHY_ENTRY 714 NETDEV_ENTRY 715 __field(int, link_id) 716 __dynamic_array(u8, head, info->beacon.head_len) 717 __dynamic_array(u8, tail, info->beacon.tail_len) 718 __dynamic_array(u8, beacon_ies, info->beacon.beacon_ies_len) 719 __dynamic_array(u8, proberesp_ies, info->beacon.proberesp_ies_len) 720 __dynamic_array(u8, assocresp_ies, info->beacon.assocresp_ies_len) 721 __dynamic_array(u8, probe_resp, info->beacon.probe_resp_len) 722 ), 723 TP_fast_assign( 724 WIPHY_ASSIGN; 725 NETDEV_ASSIGN; 726 __entry->link_id = info->beacon.link_id; 727 if (info->beacon.head) 728 memcpy(__get_dynamic_array(head), 729 info->beacon.head, 730 info->beacon.head_len); 731 if (info->beacon.tail) 732 memcpy(__get_dynamic_array(tail), 733 info->beacon.tail, 734 info->beacon.tail_len); 735 if (info->beacon.beacon_ies) 736 memcpy(__get_dynamic_array(beacon_ies), 737 info->beacon.beacon_ies, 738 info->beacon.beacon_ies_len); 739 if (info->beacon.proberesp_ies) 740 memcpy(__get_dynamic_array(proberesp_ies), 741 info->beacon.proberesp_ies, 742 info->beacon.proberesp_ies_len); 743 if (info->beacon.assocresp_ies) 744 memcpy(__get_dynamic_array(assocresp_ies), 745 info->beacon.assocresp_ies, 746 info->beacon.assocresp_ies_len); 747 if (info->beacon.probe_resp) 748 memcpy(__get_dynamic_array(probe_resp), 749 info->beacon.probe_resp, 750 info->beacon.probe_resp_len); 751 ), 752 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id:%d", 753 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id) 754 ); 755 756 TRACE_EVENT(rdev_stop_ap, 757 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 758 unsigned int link_id), 759 TP_ARGS(wiphy, netdev, link_id), 760 TP_STRUCT__entry( 761 WIPHY_ENTRY 762 NETDEV_ENTRY 763 __field(unsigned int, link_id) 764 ), 765 TP_fast_assign( 766 WIPHY_ASSIGN; 767 NETDEV_ASSIGN; 768 __entry->link_id = link_id; 769 ), 770 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d", 771 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id) 772 ); 773 774 DECLARE_EVENT_CLASS(wiphy_netdev_evt, 775 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 776 TP_ARGS(wiphy, netdev), 777 TP_STRUCT__entry( 778 WIPHY_ENTRY 779 NETDEV_ENTRY 780 ), 781 TP_fast_assign( 782 WIPHY_ASSIGN; 783 NETDEV_ASSIGN; 784 ), 785 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG) 786 ); 787 788 DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, 789 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 790 TP_ARGS(wiphy, netdev) 791 ); 792 793 DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, 794 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 795 TP_ARGS(wiphy, netdev) 796 ); 797 798 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, 799 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 800 TP_ARGS(wiphy, netdev) 801 ); 802 803 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, 804 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 805 TP_ARGS(wiphy, netdev) 806 ); 807 808 DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, 809 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 810 TP_ARGS(wiphy, netdev) 811 ); 812 813 DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, 814 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), 815 TP_ARGS(wiphy, netdev) 816 ); 817 818 TRACE_EVENT(rdev_end_cac, 819 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 820 unsigned int link_id), 821 TP_ARGS(wiphy, netdev, link_id), 822 TP_STRUCT__entry( 823 WIPHY_ENTRY 824 NETDEV_ENTRY 825 __field(unsigned int, link_id) 826 ), 827 TP_fast_assign( 828 WIPHY_ASSIGN; 829 NETDEV_ASSIGN; 830 __entry->link_id = link_id; 831 ), 832 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d", 833 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id) 834 ); 835 836 DECLARE_EVENT_CLASS(station_add_change, 837 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, 838 struct station_parameters *params), 839 TP_ARGS(wiphy, netdev, mac, params), 840 TP_STRUCT__entry( 841 WIPHY_ENTRY 842 NETDEV_ENTRY 843 MAC_ENTRY(sta_mac) 844 __field(u32, sta_flags_mask) 845 __field(u32, sta_flags_set) 846 __field(u32, sta_modify_mask) 847 __field(int, listen_interval) 848 __field(u16, capability) 849 __field(u16, aid) 850 __field(u8, plink_action) 851 __field(u8, plink_state) 852 __field(u8, uapsd_queues) 853 __field(u8, max_sp) 854 __field(u8, opmode_notif) 855 __field(bool, opmode_notif_used) 856 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap)) 857 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap)) 858 __array(char, vlan, IFNAMSIZ) 859 __dynamic_array(u8, supported_rates, 860 params->link_sta_params.supported_rates_len) 861 __dynamic_array(u8, ext_capab, params->ext_capab_len) 862 __dynamic_array(u8, supported_channels, 863 params->supported_channels_len) 864 __dynamic_array(u8, supported_oper_classes, 865 params->supported_oper_classes_len) 866 ), 867 TP_fast_assign( 868 WIPHY_ASSIGN; 869 NETDEV_ASSIGN; 870 MAC_ASSIGN(sta_mac, mac); 871 __entry->sta_flags_mask = params->sta_flags_mask; 872 __entry->sta_flags_set = params->sta_flags_set; 873 __entry->sta_modify_mask = params->sta_modify_mask; 874 __entry->listen_interval = params->listen_interval; 875 __entry->aid = params->aid; 876 __entry->plink_action = params->plink_action; 877 __entry->plink_state = params->plink_state; 878 __entry->uapsd_queues = params->uapsd_queues; 879 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap)); 880 if (params->link_sta_params.ht_capa) 881 memcpy(__entry->ht_capa, 882 params->link_sta_params.ht_capa, 883 sizeof(struct ieee80211_ht_cap)); 884 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap)); 885 if (params->link_sta_params.vht_capa) 886 memcpy(__entry->vht_capa, 887 params->link_sta_params.vht_capa, 888 sizeof(struct ieee80211_vht_cap)); 889 memset(__entry->vlan, 0, sizeof(__entry->vlan)); 890 if (params->vlan) 891 memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ); 892 if (params->link_sta_params.supported_rates && 893 params->link_sta_params.supported_rates_len) 894 memcpy(__get_dynamic_array(supported_rates), 895 params->link_sta_params.supported_rates, 896 params->link_sta_params.supported_rates_len); 897 if (params->ext_capab && params->ext_capab_len) 898 memcpy(__get_dynamic_array(ext_capab), 899 params->ext_capab, 900 params->ext_capab_len); 901 if (params->supported_channels && 902 params->supported_channels_len) 903 memcpy(__get_dynamic_array(supported_channels), 904 params->supported_channels, 905 params->supported_channels_len); 906 if (params->supported_oper_classes && 907 params->supported_oper_classes_len) 908 memcpy(__get_dynamic_array(supported_oper_classes), 909 params->supported_oper_classes, 910 params->supported_oper_classes_len); 911 __entry->max_sp = params->max_sp; 912 __entry->capability = params->capability; 913 __entry->opmode_notif = params->link_sta_params.opmode_notif; 914 __entry->opmode_notif_used = 915 params->link_sta_params.opmode_notif_used; 916 ), 917 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" 918 ", station flags mask: 0x%x, station flags set: 0x%x, " 919 "station modify mask: 0x%x, listen interval: %d, aid: %u, " 920 "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s", 921 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac, 922 __entry->sta_flags_mask, __entry->sta_flags_set, 923 __entry->sta_modify_mask, __entry->listen_interval, 924 __entry->aid, __entry->plink_action, __entry->plink_state, 925 __entry->uapsd_queues, __entry->vlan) 926 ); 927 928 DEFINE_EVENT(station_add_change, rdev_add_station, 929 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, 930 struct station_parameters *params), 931 TP_ARGS(wiphy, netdev, mac, params) 932 ); 933 934 DEFINE_EVENT(station_add_change, rdev_change_station, 935 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, 936 struct station_parameters *params), 937 TP_ARGS(wiphy, netdev, mac, params) 938 ); 939 940 DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, 941 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), 942 TP_ARGS(wiphy, netdev, mac), 943 TP_STRUCT__entry( 944 WIPHY_ENTRY 945 NETDEV_ENTRY 946 MAC_ENTRY(sta_mac) 947 ), 948 TP_fast_assign( 949 WIPHY_ASSIGN; 950 NETDEV_ASSIGN; 951 MAC_ASSIGN(sta_mac, mac); 952 ), 953 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: %pM", 954 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac) 955 ); 956 957 DECLARE_EVENT_CLASS(station_del, 958 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 959 struct station_del_parameters *params), 960 TP_ARGS(wiphy, netdev, params), 961 TP_STRUCT__entry( 962 WIPHY_ENTRY 963 NETDEV_ENTRY 964 MAC_ENTRY(sta_mac) 965 __field(u8, subtype) 966 __field(u16, reason_code) 967 __field(int, link_id) 968 ), 969 TP_fast_assign( 970 WIPHY_ASSIGN; 971 NETDEV_ASSIGN; 972 MAC_ASSIGN(sta_mac, params->mac); 973 __entry->subtype = params->subtype; 974 __entry->reason_code = params->reason_code; 975 __entry->link_id = params->link_id; 976 ), 977 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" 978 ", subtype: %u, reason_code: %u, link_id: %d", 979 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac, 980 __entry->subtype, __entry->reason_code, 981 __entry->link_id) 982 ); 983 984 DEFINE_EVENT(station_del, rdev_del_station, 985 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 986 struct station_del_parameters *params), 987 TP_ARGS(wiphy, netdev, params) 988 ); 989 990 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, 991 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), 992 TP_ARGS(wiphy, netdev, mac) 993 ); 994 995 DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, 996 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), 997 TP_ARGS(wiphy, netdev, mac) 998 ); 999 1000 TRACE_EVENT(rdev_dump_station, 1001 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx, 1002 u8 *mac), 1003 TP_ARGS(wiphy, netdev, _idx, mac), 1004 TP_STRUCT__entry( 1005 WIPHY_ENTRY 1006 NETDEV_ENTRY 1007 MAC_ENTRY(sta_mac) 1008 __field(int, idx) 1009 ), 1010 TP_fast_assign( 1011 WIPHY_ASSIGN; 1012 NETDEV_ASSIGN; 1013 MAC_ASSIGN(sta_mac, mac); 1014 __entry->idx = _idx; 1015 ), 1016 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM, idx: %d", 1017 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac, 1018 __entry->idx) 1019 ); 1020 1021 TRACE_EVENT(rdev_return_int_station_info, 1022 TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), 1023 TP_ARGS(wiphy, ret, sinfo), 1024 TP_STRUCT__entry( 1025 WIPHY_ENTRY 1026 __field(int, ret) 1027 SINFO_ENTRY 1028 ), 1029 TP_fast_assign( 1030 WIPHY_ASSIGN; 1031 __entry->ret = ret; 1032 SINFO_ASSIGN; 1033 ), 1034 TP_printk(WIPHY_PR_FMT ", returned %d" , 1035 WIPHY_PR_ARG, __entry->ret) 1036 ); 1037 1038 DECLARE_EVENT_CLASS(mpath_evt, 1039 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, 1040 u8 *next_hop), 1041 TP_ARGS(wiphy, netdev, dst, next_hop), 1042 TP_STRUCT__entry( 1043 WIPHY_ENTRY 1044 NETDEV_ENTRY 1045 MAC_ENTRY(dst) 1046 MAC_ENTRY(next_hop) 1047 ), 1048 TP_fast_assign( 1049 WIPHY_ASSIGN; 1050 NETDEV_ASSIGN; 1051 MAC_ASSIGN(dst, dst); 1052 MAC_ASSIGN(next_hop, next_hop); 1053 ), 1054 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM, next hop: %pM", 1055 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dst, 1056 __entry->next_hop) 1057 ); 1058 1059 DEFINE_EVENT(mpath_evt, rdev_add_mpath, 1060 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, 1061 u8 *next_hop), 1062 TP_ARGS(wiphy, netdev, dst, next_hop) 1063 ); 1064 1065 DEFINE_EVENT(mpath_evt, rdev_change_mpath, 1066 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, 1067 u8 *next_hop), 1068 TP_ARGS(wiphy, netdev, dst, next_hop) 1069 ); 1070 1071 DEFINE_EVENT(mpath_evt, rdev_get_mpath, 1072 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, 1073 u8 *next_hop), 1074 TP_ARGS(wiphy, netdev, dst, next_hop) 1075 ); 1076 1077 TRACE_EVENT(rdev_dump_mpath, 1078 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx, 1079 u8 *dst, u8 *next_hop), 1080 TP_ARGS(wiphy, netdev, _idx, dst, next_hop), 1081 TP_STRUCT__entry( 1082 WIPHY_ENTRY 1083 NETDEV_ENTRY 1084 MAC_ENTRY(dst) 1085 MAC_ENTRY(next_hop) 1086 __field(int, idx) 1087 ), 1088 TP_fast_assign( 1089 WIPHY_ASSIGN; 1090 NETDEV_ASSIGN; 1091 MAC_ASSIGN(dst, dst); 1092 MAC_ASSIGN(next_hop, next_hop); 1093 __entry->idx = _idx; 1094 ), 1095 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, next hop: %pM", 1096 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst, 1097 __entry->next_hop) 1098 ); 1099 1100 TRACE_EVENT(rdev_get_mpp, 1101 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1102 u8 *dst, u8 *mpp), 1103 TP_ARGS(wiphy, netdev, dst, mpp), 1104 TP_STRUCT__entry( 1105 WIPHY_ENTRY 1106 NETDEV_ENTRY 1107 MAC_ENTRY(dst) 1108 MAC_ENTRY(mpp) 1109 ), 1110 TP_fast_assign( 1111 WIPHY_ASSIGN; 1112 NETDEV_ASSIGN; 1113 MAC_ASSIGN(dst, dst); 1114 MAC_ASSIGN(mpp, mpp); 1115 ), 1116 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM" 1117 ", mpp: %pM", WIPHY_PR_ARG, NETDEV_PR_ARG, 1118 __entry->dst, __entry->mpp) 1119 ); 1120 1121 TRACE_EVENT(rdev_dump_mpp, 1122 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx, 1123 u8 *dst, u8 *mpp), 1124 TP_ARGS(wiphy, netdev, _idx, dst, mpp), 1125 TP_STRUCT__entry( 1126 WIPHY_ENTRY 1127 NETDEV_ENTRY 1128 MAC_ENTRY(dst) 1129 MAC_ENTRY(mpp) 1130 __field(int, idx) 1131 ), 1132 TP_fast_assign( 1133 WIPHY_ASSIGN; 1134 NETDEV_ASSIGN; 1135 MAC_ASSIGN(dst, dst); 1136 MAC_ASSIGN(mpp, mpp); 1137 __entry->idx = _idx; 1138 ), 1139 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, mpp: %pM", 1140 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst, 1141 __entry->mpp) 1142 ); 1143 1144 TRACE_EVENT(rdev_return_int_mpath_info, 1145 TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), 1146 TP_ARGS(wiphy, ret, pinfo), 1147 TP_STRUCT__entry( 1148 WIPHY_ENTRY 1149 __field(int, ret) 1150 __field(int, generation) 1151 __field(u32, filled) 1152 __field(u32, frame_qlen) 1153 __field(u32, sn) 1154 __field(u32, metric) 1155 __field(u32, exptime) 1156 __field(u32, discovery_timeout) 1157 __field(u8, discovery_retries) 1158 __field(u8, flags) 1159 ), 1160 TP_fast_assign( 1161 WIPHY_ASSIGN; 1162 __entry->ret = ret; 1163 __entry->generation = pinfo->generation; 1164 __entry->filled = pinfo->filled; 1165 __entry->frame_qlen = pinfo->frame_qlen; 1166 __entry->sn = pinfo->sn; 1167 __entry->metric = pinfo->metric; 1168 __entry->exptime = pinfo->exptime; 1169 __entry->discovery_timeout = pinfo->discovery_timeout; 1170 __entry->discovery_retries = pinfo->discovery_retries; 1171 __entry->flags = pinfo->flags; 1172 ), 1173 TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, " 1174 "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u," 1175 " discovery timeout: %u, discovery retries: %u, flags: 0x%x", 1176 WIPHY_PR_ARG, __entry->ret, __entry->generation, 1177 __entry->filled, __entry->frame_qlen, __entry->sn, 1178 __entry->metric, __entry->exptime, __entry->discovery_timeout, 1179 __entry->discovery_retries, __entry->flags) 1180 ); 1181 1182 TRACE_EVENT(rdev_return_int_mesh_config, 1183 TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), 1184 TP_ARGS(wiphy, ret, conf), 1185 TP_STRUCT__entry( 1186 WIPHY_ENTRY 1187 MESH_CFG_ENTRY 1188 __field(int, ret) 1189 ), 1190 TP_fast_assign( 1191 WIPHY_ASSIGN; 1192 MESH_CFG_ASSIGN; 1193 __entry->ret = ret; 1194 ), 1195 TP_printk(WIPHY_PR_FMT ", returned: %d", 1196 WIPHY_PR_ARG, __entry->ret) 1197 ); 1198 1199 TRACE_EVENT(rdev_update_mesh_config, 1200 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, 1201 const struct mesh_config *conf), 1202 TP_ARGS(wiphy, netdev, mask, conf), 1203 TP_STRUCT__entry( 1204 WIPHY_ENTRY 1205 NETDEV_ENTRY 1206 MESH_CFG_ENTRY 1207 __field(u32, mask) 1208 ), 1209 TP_fast_assign( 1210 WIPHY_ASSIGN; 1211 NETDEV_ASSIGN; 1212 MESH_CFG_ASSIGN; 1213 __entry->mask = mask; 1214 ), 1215 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u", 1216 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask) 1217 ); 1218 1219 TRACE_EVENT(rdev_join_mesh, 1220 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1221 const struct mesh_config *conf, 1222 const struct mesh_setup *setup), 1223 TP_ARGS(wiphy, netdev, conf, setup), 1224 TP_STRUCT__entry( 1225 WIPHY_ENTRY 1226 NETDEV_ENTRY 1227 MESH_CFG_ENTRY 1228 ), 1229 TP_fast_assign( 1230 WIPHY_ASSIGN; 1231 NETDEV_ASSIGN; 1232 MESH_CFG_ASSIGN; 1233 ), 1234 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, 1235 WIPHY_PR_ARG, NETDEV_PR_ARG) 1236 ); 1237 1238 TRACE_EVENT(rdev_change_bss, 1239 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1240 struct bss_parameters *params), 1241 TP_ARGS(wiphy, netdev, params), 1242 TP_STRUCT__entry( 1243 WIPHY_ENTRY 1244 NETDEV_ENTRY 1245 __field(int, use_cts_prot) 1246 __field(int, use_short_preamble) 1247 __field(int, use_short_slot_time) 1248 __field(int, ap_isolate) 1249 __field(int, ht_opmode) 1250 ), 1251 TP_fast_assign( 1252 WIPHY_ASSIGN; 1253 NETDEV_ASSIGN; 1254 __entry->use_cts_prot = params->use_cts_prot; 1255 __entry->use_short_preamble = params->use_short_preamble; 1256 __entry->use_short_slot_time = params->use_short_slot_time; 1257 __entry->ap_isolate = params->ap_isolate; 1258 __entry->ht_opmode = params->ht_opmode; 1259 ), 1260 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, " 1261 "use short preamble: %d, use short slot time: %d, " 1262 "ap isolate: %d, ht opmode: %d", 1263 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot, 1264 __entry->use_short_preamble, __entry->use_short_slot_time, 1265 __entry->ap_isolate, __entry->ht_opmode) 1266 ); 1267 1268 TRACE_EVENT(rdev_inform_bss, 1269 TP_PROTO(struct wiphy *wiphy, struct cfg80211_bss *bss), 1270 TP_ARGS(wiphy, bss), 1271 TP_STRUCT__entry( 1272 WIPHY_ENTRY 1273 MAC_ENTRY(bssid) 1274 CHAN_ENTRY 1275 ), 1276 TP_fast_assign( 1277 WIPHY_ASSIGN; 1278 MAC_ASSIGN(bssid, bss->bssid); 1279 CHAN_ASSIGN(bss->channel); 1280 ), 1281 TP_printk(WIPHY_PR_FMT ", %pM, " CHAN_PR_FMT, 1282 WIPHY_PR_ARG, __entry->bssid, CHAN_PR_ARG) 1283 ); 1284 1285 TRACE_EVENT(rdev_set_txq_params, 1286 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1287 struct ieee80211_txq_params *params), 1288 TP_ARGS(wiphy, netdev, params), 1289 TP_STRUCT__entry( 1290 WIPHY_ENTRY 1291 NETDEV_ENTRY 1292 __field(enum nl80211_ac, ac) 1293 __field(u16, txop) 1294 __field(u16, cwmin) 1295 __field(u16, cwmax) 1296 __field(u8, aifs) 1297 ), 1298 TP_fast_assign( 1299 WIPHY_ASSIGN; 1300 NETDEV_ASSIGN; 1301 __entry->ac = params->ac; 1302 __entry->txop = params->txop; 1303 __entry->cwmin = params->cwmin; 1304 __entry->cwmax = params->cwmax; 1305 __entry->aifs = params->aifs; 1306 ), 1307 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u", 1308 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop, 1309 __entry->cwmin, __entry->cwmax, __entry->aifs) 1310 ); 1311 1312 TRACE_EVENT(rdev_libertas_set_mesh_channel, 1313 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1314 struct ieee80211_channel *chan), 1315 TP_ARGS(wiphy, netdev, chan), 1316 TP_STRUCT__entry( 1317 WIPHY_ENTRY 1318 NETDEV_ENTRY 1319 CHAN_ENTRY 1320 ), 1321 TP_fast_assign( 1322 WIPHY_ASSIGN; 1323 NETDEV_ASSIGN; 1324 CHAN_ASSIGN(chan); 1325 ), 1326 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG, 1327 NETDEV_PR_ARG, CHAN_PR_ARG) 1328 ); 1329 1330 TRACE_EVENT(rdev_set_monitor_channel, 1331 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1332 struct cfg80211_chan_def *chandef), 1333 TP_ARGS(wiphy, netdev, chandef), 1334 TP_STRUCT__entry( 1335 WIPHY_ENTRY 1336 NETDEV_ENTRY 1337 CHAN_DEF_ENTRY 1338 ), 1339 TP_fast_assign( 1340 WIPHY_ASSIGN; 1341 NETDEV_ASSIGN; 1342 CHAN_DEF_ASSIGN(chandef); 1343 ), 1344 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 1345 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 1346 ); 1347 1348 TRACE_EVENT(rdev_auth, 1349 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1350 struct cfg80211_auth_request *req), 1351 TP_ARGS(wiphy, netdev, req), 1352 TP_STRUCT__entry( 1353 WIPHY_ENTRY 1354 NETDEV_ENTRY 1355 MAC_ENTRY(bssid) 1356 __field(enum nl80211_auth_type, auth_type) 1357 ), 1358 TP_fast_assign( 1359 WIPHY_ASSIGN; 1360 NETDEV_ASSIGN; 1361 if (req->bss) 1362 MAC_ASSIGN(bssid, req->bss->bssid); 1363 else 1364 eth_zero_addr(__entry->bssid); 1365 __entry->auth_type = req->auth_type; 1366 ), 1367 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: %pM", 1368 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type, 1369 __entry->bssid) 1370 ); 1371 1372 TRACE_EVENT(rdev_assoc, 1373 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1374 struct cfg80211_assoc_request *req), 1375 TP_ARGS(wiphy, netdev, req), 1376 TP_STRUCT__entry( 1377 WIPHY_ENTRY 1378 NETDEV_ENTRY 1379 MAC_ENTRY(bssid) 1380 MAC_ENTRY(prev_bssid) 1381 __field(bool, use_mfp) 1382 __field(u32, flags) 1383 __dynamic_array(u8, elements, req->ie_len) 1384 __array(u8, ht_capa, sizeof(struct ieee80211_ht_cap)) 1385 __array(u8, ht_capa_mask, sizeof(struct ieee80211_ht_cap)) 1386 __array(u8, vht_capa, sizeof(struct ieee80211_vht_cap)) 1387 __array(u8, vht_capa_mask, sizeof(struct ieee80211_vht_cap)) 1388 __dynamic_array(u8, fils_kek, req->fils_kek_len) 1389 __dynamic_array(u8, fils_nonces, 1390 req->fils_nonces ? 2 * FILS_NONCE_LEN : 0) 1391 __field(u16, ext_mld_capa_ops) 1392 ), 1393 TP_fast_assign( 1394 WIPHY_ASSIGN; 1395 NETDEV_ASSIGN; 1396 if (req->bss) 1397 MAC_ASSIGN(bssid, req->bss->bssid); 1398 else 1399 eth_zero_addr(__entry->bssid); 1400 MAC_ASSIGN(prev_bssid, req->prev_bssid); 1401 __entry->use_mfp = req->use_mfp; 1402 __entry->flags = req->flags; 1403 if (req->ie) 1404 memcpy(__get_dynamic_array(elements), 1405 req->ie, req->ie_len); 1406 memcpy(__entry->ht_capa, &req->ht_capa, sizeof(req->ht_capa)); 1407 memcpy(__entry->ht_capa_mask, &req->ht_capa_mask, 1408 sizeof(req->ht_capa_mask)); 1409 memcpy(__entry->vht_capa, &req->vht_capa, sizeof(req->vht_capa)); 1410 memcpy(__entry->vht_capa_mask, &req->vht_capa_mask, 1411 sizeof(req->vht_capa_mask)); 1412 if (req->fils_kek) 1413 memcpy(__get_dynamic_array(fils_kek), 1414 req->fils_kek, req->fils_kek_len); 1415 if (req->fils_nonces) 1416 memcpy(__get_dynamic_array(fils_nonces), 1417 req->fils_nonces, 2 * FILS_NONCE_LEN); 1418 __entry->ext_mld_capa_ops = req->ext_mld_capa_ops; 1419 ), 1420 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 1421 ", previous bssid: %pM, use mfp: %s, flags: 0x%x", 1422 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 1423 __entry->prev_bssid, BOOL_TO_STR(__entry->use_mfp), 1424 __entry->flags) 1425 ); 1426 1427 TRACE_EVENT(rdev_deauth, 1428 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1429 struct cfg80211_deauth_request *req), 1430 TP_ARGS(wiphy, netdev, req), 1431 TP_STRUCT__entry( 1432 WIPHY_ENTRY 1433 NETDEV_ENTRY 1434 MAC_ENTRY(bssid) 1435 __field(u16, reason_code) 1436 __field(bool, local_state_change) 1437 ), 1438 TP_fast_assign( 1439 WIPHY_ASSIGN; 1440 NETDEV_ASSIGN; 1441 MAC_ASSIGN(bssid, req->bssid); 1442 __entry->reason_code = req->reason_code; 1443 __entry->local_state_change = req->local_state_change; 1444 ), 1445 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, reason: %u, local_state_change:%d", 1446 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 1447 __entry->reason_code, __entry->local_state_change) 1448 ); 1449 1450 TRACE_EVENT(rdev_disassoc, 1451 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1452 struct cfg80211_disassoc_request *req), 1453 TP_ARGS(wiphy, netdev, req), 1454 TP_STRUCT__entry( 1455 WIPHY_ENTRY 1456 NETDEV_ENTRY 1457 MAC_ENTRY(bssid) 1458 __field(u16, reason_code) 1459 __field(bool, local_state_change) 1460 ), 1461 TP_fast_assign( 1462 WIPHY_ASSIGN; 1463 NETDEV_ASSIGN; 1464 MAC_ASSIGN(bssid, req->ap_addr); 1465 __entry->reason_code = req->reason_code; 1466 __entry->local_state_change = req->local_state_change; 1467 ), 1468 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 1469 ", reason: %u, local state change: %s", 1470 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 1471 __entry->reason_code, 1472 BOOL_TO_STR(__entry->local_state_change)) 1473 ); 1474 1475 TRACE_EVENT(rdev_mgmt_tx_cancel_wait, 1476 TP_PROTO(struct wiphy *wiphy, 1477 struct wireless_dev *wdev, u64 cookie), 1478 TP_ARGS(wiphy, wdev, cookie), 1479 TP_STRUCT__entry( 1480 WIPHY_ENTRY 1481 WDEV_ENTRY 1482 __field(u64, cookie) 1483 ), 1484 TP_fast_assign( 1485 WIPHY_ASSIGN; 1486 WDEV_ASSIGN; 1487 __entry->cookie = cookie; 1488 ), 1489 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ", 1490 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 1491 ); 1492 1493 TRACE_EVENT(rdev_set_power_mgmt, 1494 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1495 bool enabled, int timeout), 1496 TP_ARGS(wiphy, netdev, enabled, timeout), 1497 TP_STRUCT__entry( 1498 WIPHY_ENTRY 1499 NETDEV_ENTRY 1500 __field(bool, enabled) 1501 __field(int, timeout) 1502 ), 1503 TP_fast_assign( 1504 WIPHY_ASSIGN; 1505 NETDEV_ASSIGN; 1506 __entry->enabled = enabled; 1507 __entry->timeout = timeout; 1508 ), 1509 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ", 1510 WIPHY_PR_ARG, NETDEV_PR_ARG, 1511 __entry->enabled ? "" : "not ", __entry->timeout) 1512 ); 1513 1514 TRACE_EVENT(rdev_connect, 1515 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1516 struct cfg80211_connect_params *sme), 1517 TP_ARGS(wiphy, netdev, sme), 1518 TP_STRUCT__entry( 1519 WIPHY_ENTRY 1520 NETDEV_ENTRY 1521 MAC_ENTRY(bssid) 1522 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) 1523 __field(enum nl80211_auth_type, auth_type) 1524 __field(bool, privacy) 1525 __field(u32, wpa_versions) 1526 __field(u32, flags) 1527 MAC_ENTRY(prev_bssid) 1528 ), 1529 TP_fast_assign( 1530 WIPHY_ASSIGN; 1531 NETDEV_ASSIGN; 1532 MAC_ASSIGN(bssid, sme->bssid); 1533 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 1534 memcpy(__entry->ssid, sme->ssid, sme->ssid_len); 1535 __entry->auth_type = sme->auth_type; 1536 __entry->privacy = sme->privacy; 1537 __entry->wpa_versions = sme->crypto.wpa_versions; 1538 __entry->flags = sme->flags; 1539 MAC_ASSIGN(prev_bssid, sme->prev_bssid); 1540 ), 1541 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 1542 ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, " 1543 "flags: 0x%x, previous bssid: %pM", 1544 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid, 1545 __entry->auth_type, BOOL_TO_STR(__entry->privacy), 1546 __entry->wpa_versions, __entry->flags, __entry->prev_bssid) 1547 ); 1548 1549 TRACE_EVENT(rdev_update_connect_params, 1550 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1551 struct cfg80211_connect_params *sme, u32 changed), 1552 TP_ARGS(wiphy, netdev, sme, changed), 1553 TP_STRUCT__entry( 1554 WIPHY_ENTRY 1555 NETDEV_ENTRY 1556 __field(u32, changed) 1557 ), 1558 TP_fast_assign( 1559 WIPHY_ASSIGN; 1560 NETDEV_ASSIGN; 1561 __entry->changed = changed; 1562 ), 1563 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", parameters changed: %u", 1564 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->changed) 1565 ); 1566 1567 TRACE_EVENT(rdev_set_cqm_rssi_config, 1568 TP_PROTO(struct wiphy *wiphy, 1569 struct net_device *netdev, s32 rssi_thold, 1570 u32 rssi_hyst), 1571 TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst), 1572 TP_STRUCT__entry( 1573 WIPHY_ENTRY 1574 NETDEV_ENTRY 1575 __field(s32, rssi_thold) 1576 __field(u32, rssi_hyst) 1577 ), 1578 TP_fast_assign( 1579 WIPHY_ASSIGN; 1580 NETDEV_ASSIGN; 1581 __entry->rssi_thold = rssi_thold; 1582 __entry->rssi_hyst = rssi_hyst; 1583 ), 1584 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT 1585 ", rssi_thold: %d, rssi_hyst: %u ", 1586 WIPHY_PR_ARG, NETDEV_PR_ARG, 1587 __entry->rssi_thold, __entry->rssi_hyst) 1588 ); 1589 1590 TRACE_EVENT(rdev_set_cqm_rssi_range_config, 1591 TP_PROTO(struct wiphy *wiphy, 1592 struct net_device *netdev, s32 low, s32 high), 1593 TP_ARGS(wiphy, netdev, low, high), 1594 TP_STRUCT__entry( 1595 WIPHY_ENTRY 1596 NETDEV_ENTRY 1597 __field(s32, rssi_low) 1598 __field(s32, rssi_high) 1599 ), 1600 TP_fast_assign( 1601 WIPHY_ASSIGN; 1602 NETDEV_ASSIGN; 1603 __entry->rssi_low = low; 1604 __entry->rssi_high = high; 1605 ), 1606 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT 1607 ", range: %d - %d ", 1608 WIPHY_PR_ARG, NETDEV_PR_ARG, 1609 __entry->rssi_low, __entry->rssi_high) 1610 ); 1611 1612 TRACE_EVENT(rdev_set_cqm_txe_config, 1613 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, 1614 u32 pkts, u32 intvl), 1615 TP_ARGS(wiphy, netdev, rate, pkts, intvl), 1616 TP_STRUCT__entry( 1617 WIPHY_ENTRY 1618 NETDEV_ENTRY 1619 __field(u32, rate) 1620 __field(u32, pkts) 1621 __field(u32, intvl) 1622 ), 1623 TP_fast_assign( 1624 WIPHY_ASSIGN; 1625 NETDEV_ASSIGN; 1626 __entry->rate = rate; 1627 __entry->pkts = pkts; 1628 __entry->intvl = intvl; 1629 ), 1630 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u", 1631 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts, 1632 __entry->intvl) 1633 ); 1634 1635 TRACE_EVENT(rdev_disconnect, 1636 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1637 u16 reason_code), 1638 TP_ARGS(wiphy, netdev, reason_code), 1639 TP_STRUCT__entry( 1640 WIPHY_ENTRY 1641 NETDEV_ENTRY 1642 __field(u16, reason_code) 1643 ), 1644 TP_fast_assign( 1645 WIPHY_ASSIGN; 1646 NETDEV_ASSIGN; 1647 __entry->reason_code = reason_code; 1648 ), 1649 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG, 1650 NETDEV_PR_ARG, __entry->reason_code) 1651 ); 1652 1653 TRACE_EVENT(rdev_join_ibss, 1654 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1655 struct cfg80211_ibss_params *params), 1656 TP_ARGS(wiphy, netdev, params), 1657 TP_STRUCT__entry( 1658 WIPHY_ENTRY 1659 NETDEV_ENTRY 1660 MAC_ENTRY(bssid) 1661 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) 1662 ), 1663 TP_fast_assign( 1664 WIPHY_ASSIGN; 1665 NETDEV_ASSIGN; 1666 MAC_ASSIGN(bssid, params->bssid); 1667 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 1668 memcpy(__entry->ssid, params->ssid, params->ssid_len); 1669 ), 1670 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, ssid: %s", 1671 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid) 1672 ); 1673 1674 TRACE_EVENT(rdev_join_ocb, 1675 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1676 const struct ocb_setup *setup), 1677 TP_ARGS(wiphy, netdev, setup), 1678 TP_STRUCT__entry( 1679 WIPHY_ENTRY 1680 NETDEV_ENTRY 1681 ), 1682 TP_fast_assign( 1683 WIPHY_ASSIGN; 1684 NETDEV_ASSIGN; 1685 ), 1686 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, 1687 WIPHY_PR_ARG, NETDEV_PR_ARG) 1688 ); 1689 1690 TRACE_EVENT(rdev_set_wiphy_params, 1691 TP_PROTO(struct wiphy *wiphy, int radio_idx, u32 changed), 1692 TP_ARGS(wiphy, radio_idx, changed), 1693 TP_STRUCT__entry( 1694 WIPHY_ENTRY 1695 __field(int, radio_idx) 1696 __field(u32, changed) 1697 ), 1698 TP_fast_assign( 1699 WIPHY_ASSIGN; 1700 __entry->radio_idx = radio_idx; 1701 __entry->changed = changed; 1702 ), 1703 TP_printk(WIPHY_PR_FMT ", radio_idx: %d, changed: %u", 1704 WIPHY_PR_ARG, __entry->radio_idx, __entry->changed) 1705 ); 1706 1707 DECLARE_EVENT_CLASS(wiphy_wdev_link_evt, 1708 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1709 unsigned int link_id), 1710 TP_ARGS(wiphy, wdev, link_id), 1711 TP_STRUCT__entry( 1712 WIPHY_ENTRY 1713 WDEV_ENTRY 1714 __field(unsigned int, link_id) 1715 ), 1716 TP_fast_assign( 1717 WIPHY_ASSIGN; 1718 WDEV_ASSIGN; 1719 __entry->link_id = link_id; 1720 ), 1721 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", link_id: %u", 1722 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->link_id) 1723 ); 1724 1725 TRACE_EVENT(rdev_get_tx_power, 1726 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1727 int radio_idx, unsigned int link_id), 1728 TP_ARGS(wiphy, wdev, radio_idx, link_id), 1729 TP_STRUCT__entry( 1730 WIPHY_ENTRY 1731 WDEV_ENTRY 1732 __field(int, radio_idx) 1733 __field(unsigned int, link_id) 1734 ), 1735 TP_fast_assign( 1736 WIPHY_ASSIGN; 1737 WDEV_ASSIGN; 1738 __entry->radio_idx = radio_idx; 1739 __entry->link_id = link_id; 1740 ), 1741 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 1742 ", radio_idx: %d, link_id: %u", 1743 WIPHY_PR_ARG, WDEV_PR_ARG, 1744 __entry->radio_idx, __entry->link_id) 1745 ); 1746 1747 TRACE_EVENT(rdev_set_tx_power, 1748 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1749 int radio_idx, enum nl80211_tx_power_setting type, 1750 int mbm), 1751 TP_ARGS(wiphy, wdev, radio_idx, type, mbm), 1752 TP_STRUCT__entry( 1753 WIPHY_ENTRY 1754 WDEV_ENTRY 1755 __field(int, radio_idx) 1756 __field(enum nl80211_tx_power_setting, type) 1757 __field(int, mbm) 1758 ), 1759 TP_fast_assign( 1760 WIPHY_ASSIGN; 1761 WDEV_ASSIGN; 1762 __entry->radio_idx = radio_idx; 1763 __entry->type = type; 1764 __entry->mbm = mbm; 1765 ), 1766 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 1767 ", radio_idx: %d, type: %u, mbm: %d", 1768 WIPHY_PR_ARG, WDEV_PR_ARG, 1769 __entry->radio_idx, __entry->type, __entry->mbm) 1770 ); 1771 1772 TRACE_EVENT(rdev_return_int_int, 1773 TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), 1774 TP_ARGS(wiphy, func_ret, func_fill), 1775 TP_STRUCT__entry( 1776 WIPHY_ENTRY 1777 __field(int, func_ret) 1778 __field(int, func_fill) 1779 ), 1780 TP_fast_assign( 1781 WIPHY_ASSIGN; 1782 __entry->func_ret = func_ret; 1783 __entry->func_fill = func_fill; 1784 ), 1785 TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d", 1786 WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill) 1787 ); 1788 1789 #ifdef CONFIG_NL80211_TESTMODE 1790 TRACE_EVENT(rdev_testmode_cmd, 1791 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1792 TP_ARGS(wiphy, wdev), 1793 TP_STRUCT__entry( 1794 WIPHY_ENTRY 1795 WDEV_ENTRY 1796 ), 1797 TP_fast_assign( 1798 WIPHY_ASSIGN; 1799 WDEV_ASSIGN; 1800 ), 1801 TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 1802 ); 1803 1804 TRACE_EVENT(rdev_testmode_dump, 1805 TP_PROTO(struct wiphy *wiphy), 1806 TP_ARGS(wiphy), 1807 TP_STRUCT__entry( 1808 WIPHY_ENTRY 1809 ), 1810 TP_fast_assign( 1811 WIPHY_ASSIGN; 1812 ), 1813 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) 1814 ); 1815 #endif /* CONFIG_NL80211_TESTMODE */ 1816 1817 TRACE_EVENT(rdev_set_bitrate_mask, 1818 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1819 unsigned int link_id, 1820 const u8 *peer, const struct cfg80211_bitrate_mask *mask), 1821 TP_ARGS(wiphy, netdev, link_id, peer, mask), 1822 TP_STRUCT__entry( 1823 WIPHY_ENTRY 1824 NETDEV_ENTRY 1825 __field(unsigned int, link_id) 1826 MAC_ENTRY(peer) 1827 ), 1828 TP_fast_assign( 1829 WIPHY_ASSIGN; 1830 NETDEV_ASSIGN; 1831 __entry->link_id = link_id; 1832 MAC_ASSIGN(peer, peer); 1833 ), 1834 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, peer: %pM", 1835 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, 1836 __entry->peer) 1837 ); 1838 1839 TRACE_EVENT(rdev_update_mgmt_frame_registrations, 1840 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1841 struct mgmt_frame_regs *upd), 1842 TP_ARGS(wiphy, wdev, upd), 1843 TP_STRUCT__entry( 1844 WIPHY_ENTRY 1845 WDEV_ENTRY 1846 __field(u16, global_stypes) 1847 __field(u16, interface_stypes) 1848 ), 1849 TP_fast_assign( 1850 WIPHY_ASSIGN; 1851 WDEV_ASSIGN; 1852 __entry->global_stypes = upd->global_stypes; 1853 __entry->interface_stypes = upd->interface_stypes; 1854 ), 1855 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", global: 0x%.2x, intf: 0x%.2x", 1856 WIPHY_PR_ARG, WDEV_PR_ARG, 1857 __entry->global_stypes, __entry->interface_stypes) 1858 ); 1859 1860 TRACE_EVENT(rdev_return_int_tx_rx, 1861 TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), 1862 TP_ARGS(wiphy, ret, tx, rx), 1863 TP_STRUCT__entry( 1864 WIPHY_ENTRY 1865 __field(int, ret) 1866 __field(u32, tx) 1867 __field(u32, rx) 1868 ), 1869 TP_fast_assign( 1870 WIPHY_ASSIGN; 1871 __entry->ret = ret; 1872 __entry->tx = tx; 1873 __entry->rx = rx; 1874 ), 1875 TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u", 1876 WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx) 1877 ); 1878 1879 TRACE_EVENT(rdev_return_void_tx_rx, 1880 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, 1881 u32 rx, u32 rx_max), 1882 TP_ARGS(wiphy, tx, tx_max, rx, rx_max), 1883 TP_STRUCT__entry( 1884 WIPHY_ENTRY 1885 __field(u32, tx) 1886 __field(u32, tx_max) 1887 __field(u32, rx) 1888 __field(u32, rx_max) 1889 ), 1890 TP_fast_assign( 1891 WIPHY_ASSIGN; 1892 __entry->tx = tx; 1893 __entry->tx_max = tx_max; 1894 __entry->rx = rx; 1895 __entry->rx_max = rx_max; 1896 ), 1897 TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ", 1898 WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx, 1899 __entry->rx_max) 1900 ); 1901 1902 TRACE_EVENT(rdev_set_antenna, 1903 TP_PROTO(struct wiphy *wiphy, int radio_idx, u32 tx, u32 rx), 1904 TP_ARGS(wiphy, radio_idx, tx, rx), 1905 TP_STRUCT__entry( 1906 WIPHY_ENTRY 1907 __field(int, radio_idx) 1908 __field(u32, tx) 1909 __field(u32, rx) 1910 ), 1911 TP_fast_assign( 1912 WIPHY_ASSIGN; 1913 __entry->radio_idx = radio_idx; 1914 __entry->tx = tx; 1915 __entry->rx = rx; 1916 ), 1917 TP_printk(WIPHY_PR_FMT ", radio_idx: %d, tx: %u, rx: %u ", 1918 WIPHY_PR_ARG, __entry->radio_idx, 1919 __entry->tx, __entry->rx) 1920 ); 1921 1922 DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, 1923 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), 1924 TP_ARGS(wiphy, netdev, id), 1925 TP_STRUCT__entry( 1926 WIPHY_ENTRY 1927 NETDEV_ENTRY 1928 __field(u64, id) 1929 ), 1930 TP_fast_assign( 1931 WIPHY_ASSIGN; 1932 NETDEV_ASSIGN; 1933 __entry->id = id; 1934 ), 1935 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", id: %llu", 1936 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->id) 1937 ); 1938 1939 DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, 1940 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), 1941 TP_ARGS(wiphy, netdev, id) 1942 ); 1943 1944 DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, 1945 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), 1946 TP_ARGS(wiphy, netdev, id) 1947 ); 1948 1949 TRACE_EVENT(rdev_tdls_mgmt, 1950 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1951 u8 *peer, int link_id, u8 action_code, u8 dialog_token, 1952 u16 status_code, u32 peer_capability, 1953 bool initiator, const u8 *buf, size_t len), 1954 TP_ARGS(wiphy, netdev, peer, link_id, action_code, dialog_token, 1955 status_code, peer_capability, initiator, buf, len), 1956 TP_STRUCT__entry( 1957 WIPHY_ENTRY 1958 NETDEV_ENTRY 1959 MAC_ENTRY(peer) 1960 __field(int, link_id) 1961 __field(u8, action_code) 1962 __field(u8, dialog_token) 1963 __field(u16, status_code) 1964 __field(u32, peer_capability) 1965 __field(bool, initiator) 1966 __dynamic_array(u8, buf, len) 1967 ), 1968 TP_fast_assign( 1969 WIPHY_ASSIGN; 1970 NETDEV_ASSIGN; 1971 MAC_ASSIGN(peer, peer); 1972 __entry->link_id = link_id; 1973 __entry->action_code = action_code; 1974 __entry->dialog_token = dialog_token; 1975 __entry->status_code = status_code; 1976 __entry->peer_capability = peer_capability; 1977 __entry->initiator = initiator; 1978 memcpy(__get_dynamic_array(buf), buf, len); 1979 ), 1980 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" 1981 ", link_id: %d, action_code: %u " 1982 "dialog_token: %u, status_code: %u, peer_capability: %u " 1983 "initiator: %s buf: %#.2x ", 1984 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 1985 __entry->link_id, __entry->action_code, __entry->dialog_token, 1986 __entry->status_code, __entry->peer_capability, 1987 BOOL_TO_STR(__entry->initiator), 1988 ((u8 *)__get_dynamic_array(buf))[0]) 1989 ); 1990 1991 TRACE_EVENT(rdev_dump_survey, 1992 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx), 1993 TP_ARGS(wiphy, netdev, _idx), 1994 TP_STRUCT__entry( 1995 WIPHY_ENTRY 1996 NETDEV_ENTRY 1997 __field(int, idx) 1998 ), 1999 TP_fast_assign( 2000 WIPHY_ASSIGN; 2001 NETDEV_ASSIGN; 2002 __entry->idx = _idx; 2003 ), 2004 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d", 2005 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx) 2006 ); 2007 2008 TRACE_EVENT(rdev_return_int_survey_info, 2009 TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), 2010 TP_ARGS(wiphy, ret, info), 2011 TP_STRUCT__entry( 2012 WIPHY_ENTRY 2013 CHAN_ENTRY 2014 __field(int, ret) 2015 __field(u64, time) 2016 __field(u64, time_busy) 2017 __field(u64, time_ext_busy) 2018 __field(u64, time_rx) 2019 __field(u64, time_tx) 2020 __field(u64, time_scan) 2021 __field(u32, filled) 2022 __field(s8, noise) 2023 ), 2024 TP_fast_assign( 2025 WIPHY_ASSIGN; 2026 CHAN_ASSIGN(info->channel); 2027 __entry->ret = ret; 2028 __entry->time = info->time; 2029 __entry->time_busy = info->time_busy; 2030 __entry->time_ext_busy = info->time_ext_busy; 2031 __entry->time_rx = info->time_rx; 2032 __entry->time_tx = info->time_tx; 2033 __entry->time_scan = info->time_scan; 2034 __entry->filled = info->filled; 2035 __entry->noise = info->noise; 2036 ), 2037 TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT 2038 ", channel time: %llu, channel time busy: %llu, " 2039 "channel time extension busy: %llu, channel time rx: %llu, " 2040 "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d", 2041 WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG, 2042 __entry->time, __entry->time_busy, 2043 __entry->time_ext_busy, __entry->time_rx, 2044 __entry->time_tx, __entry->time_scan, 2045 __entry->filled, __entry->noise) 2046 ); 2047 2048 TRACE_EVENT(rdev_tdls_oper, 2049 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2050 u8 *peer, enum nl80211_tdls_operation oper), 2051 TP_ARGS(wiphy, netdev, peer, oper), 2052 TP_STRUCT__entry( 2053 WIPHY_ENTRY 2054 NETDEV_ENTRY 2055 MAC_ENTRY(peer) 2056 __field(enum nl80211_tdls_operation, oper) 2057 ), 2058 TP_fast_assign( 2059 WIPHY_ASSIGN; 2060 NETDEV_ASSIGN; 2061 MAC_ASSIGN(peer, peer); 2062 __entry->oper = oper; 2063 ), 2064 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, oper: %d", 2065 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper) 2066 ); 2067 2068 DECLARE_EVENT_CLASS(rdev_pmksa, 2069 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2070 struct cfg80211_pmksa *pmksa), 2071 TP_ARGS(wiphy, netdev, pmksa), 2072 TP_STRUCT__entry( 2073 WIPHY_ENTRY 2074 NETDEV_ENTRY 2075 MAC_ENTRY(bssid) 2076 ), 2077 TP_fast_assign( 2078 WIPHY_ASSIGN; 2079 NETDEV_ASSIGN; 2080 MAC_ASSIGN(bssid, pmksa->bssid); 2081 ), 2082 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM", 2083 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid) 2084 ); 2085 2086 TRACE_EVENT(rdev_probe_client, 2087 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2088 const u8 *peer), 2089 TP_ARGS(wiphy, netdev, peer), 2090 TP_STRUCT__entry( 2091 WIPHY_ENTRY 2092 NETDEV_ENTRY 2093 MAC_ENTRY(peer) 2094 ), 2095 TP_fast_assign( 2096 WIPHY_ASSIGN; 2097 NETDEV_ASSIGN; 2098 MAC_ASSIGN(peer, peer); 2099 ), 2100 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2101 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer) 2102 ); 2103 2104 DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, 2105 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2106 struct cfg80211_pmksa *pmksa), 2107 TP_ARGS(wiphy, netdev, pmksa) 2108 ); 2109 2110 DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, 2111 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2112 struct cfg80211_pmksa *pmksa), 2113 TP_ARGS(wiphy, netdev, pmksa) 2114 ); 2115 2116 TRACE_EVENT(rdev_remain_on_channel, 2117 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2118 struct ieee80211_channel *chan, 2119 unsigned int duration), 2120 TP_ARGS(wiphy, wdev, chan, duration), 2121 TP_STRUCT__entry( 2122 WIPHY_ENTRY 2123 WDEV_ENTRY 2124 CHAN_ENTRY 2125 __field(unsigned int, duration) 2126 ), 2127 TP_fast_assign( 2128 WIPHY_ASSIGN; 2129 WDEV_ASSIGN; 2130 CHAN_ASSIGN(chan); 2131 __entry->duration = duration; 2132 ), 2133 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u", 2134 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration) 2135 ); 2136 2137 TRACE_EVENT(rdev_return_int_cookie, 2138 TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), 2139 TP_ARGS(wiphy, ret, cookie), 2140 TP_STRUCT__entry( 2141 WIPHY_ENTRY 2142 __field(int, ret) 2143 __field(u64, cookie) 2144 ), 2145 TP_fast_assign( 2146 WIPHY_ASSIGN; 2147 __entry->ret = ret; 2148 __entry->cookie = cookie; 2149 ), 2150 TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu", 2151 WIPHY_PR_ARG, __entry->ret, __entry->cookie) 2152 ); 2153 2154 TRACE_EVENT(rdev_cancel_remain_on_channel, 2155 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 2156 TP_ARGS(wiphy, wdev, cookie), 2157 TP_STRUCT__entry( 2158 WIPHY_ENTRY 2159 WDEV_ENTRY 2160 __field(u64, cookie) 2161 ), 2162 TP_fast_assign( 2163 WIPHY_ASSIGN; 2164 WDEV_ASSIGN; 2165 __entry->cookie = cookie; 2166 ), 2167 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu", 2168 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 2169 ); 2170 2171 TRACE_EVENT(rdev_mgmt_tx, 2172 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2173 struct cfg80211_mgmt_tx_params *params), 2174 TP_ARGS(wiphy, wdev, params), 2175 TP_STRUCT__entry( 2176 WIPHY_ENTRY 2177 WDEV_ENTRY 2178 CHAN_ENTRY 2179 __field(bool, offchan) 2180 __field(unsigned int, wait) 2181 __field(bool, no_cck) 2182 __field(bool, dont_wait_for_ack) 2183 ), 2184 TP_fast_assign( 2185 WIPHY_ASSIGN; 2186 WDEV_ASSIGN; 2187 CHAN_ASSIGN(params->chan); 2188 __entry->offchan = params->offchan; 2189 __entry->wait = params->wait; 2190 __entry->no_cck = params->no_cck; 2191 __entry->dont_wait_for_ack = params->dont_wait_for_ack; 2192 ), 2193 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s," 2194 " wait: %u, no cck: %s, dont wait for ack: %s", 2195 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, 2196 BOOL_TO_STR(__entry->offchan), __entry->wait, 2197 BOOL_TO_STR(__entry->no_cck), 2198 BOOL_TO_STR(__entry->dont_wait_for_ack)) 2199 ); 2200 2201 TRACE_EVENT(rdev_tx_control_port, 2202 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2203 const u8 *buf, size_t len, const u8 *dest, __be16 proto, 2204 bool unencrypted, int link_id), 2205 TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted, link_id), 2206 TP_STRUCT__entry( 2207 WIPHY_ENTRY 2208 NETDEV_ENTRY 2209 MAC_ENTRY(dest) 2210 __field(__be16, proto) 2211 __field(bool, unencrypted) 2212 __field(int, link_id) 2213 ), 2214 TP_fast_assign( 2215 WIPHY_ASSIGN; 2216 NETDEV_ASSIGN; 2217 MAC_ASSIGN(dest, dest); 2218 __entry->proto = proto; 2219 __entry->unencrypted = unencrypted; 2220 __entry->link_id = link_id; 2221 ), 2222 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM," 2223 " proto: 0x%x, unencrypted: %s, link: %d", 2224 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest, 2225 be16_to_cpu(__entry->proto), 2226 BOOL_TO_STR(__entry->unencrypted), 2227 __entry->link_id) 2228 ); 2229 2230 TRACE_EVENT(rdev_set_noack_map, 2231 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2232 u16 noack_map), 2233 TP_ARGS(wiphy, netdev, noack_map), 2234 TP_STRUCT__entry( 2235 WIPHY_ENTRY 2236 NETDEV_ENTRY 2237 __field(u16, noack_map) 2238 ), 2239 TP_fast_assign( 2240 WIPHY_ASSIGN; 2241 NETDEV_ASSIGN; 2242 __entry->noack_map = noack_map; 2243 ), 2244 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u", 2245 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map) 2246 ); 2247 DEFINE_EVENT(wiphy_wdev_link_evt, rdev_get_channel, 2248 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2249 unsigned int link_id), 2250 TP_ARGS(wiphy, wdev, link_id) 2251 ); 2252 2253 TRACE_EVENT(rdev_return_chandef, 2254 TP_PROTO(struct wiphy *wiphy, int ret, 2255 struct cfg80211_chan_def *chandef), 2256 TP_ARGS(wiphy, ret, chandef), 2257 TP_STRUCT__entry( 2258 WIPHY_ENTRY 2259 __field(int, ret) 2260 CHAN_DEF_ENTRY 2261 ), 2262 TP_fast_assign( 2263 WIPHY_ASSIGN; 2264 if (ret == 0) 2265 CHAN_DEF_ASSIGN(chandef); 2266 else 2267 CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL); 2268 __entry->ret = ret; 2269 ), 2270 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d", 2271 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret) 2272 ); 2273 2274 DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, 2275 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2276 TP_ARGS(wiphy, wdev) 2277 ); 2278 2279 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, 2280 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2281 TP_ARGS(wiphy, wdev) 2282 ); 2283 2284 TRACE_EVENT(rdev_start_nan, 2285 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2286 struct cfg80211_nan_conf *conf), 2287 TP_ARGS(wiphy, wdev, conf), 2288 TP_STRUCT__entry( 2289 WIPHY_ENTRY 2290 WDEV_ENTRY 2291 __field(u8, master_pref) 2292 __field(u8, bands) 2293 ), 2294 TP_fast_assign( 2295 WIPHY_ASSIGN; 2296 WDEV_ASSIGN; 2297 __entry->master_pref = conf->master_pref; 2298 __entry->bands = conf->bands; 2299 ), 2300 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 2301 ", master preference: %u, bands: 0x%0x", 2302 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 2303 __entry->bands) 2304 ); 2305 2306 TRACE_EVENT(rdev_nan_change_conf, 2307 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2308 struct cfg80211_nan_conf *conf, u32 changes), 2309 TP_ARGS(wiphy, wdev, conf, changes), 2310 TP_STRUCT__entry( 2311 WIPHY_ENTRY 2312 WDEV_ENTRY 2313 __field(u8, master_pref) 2314 __field(u8, bands) 2315 __field(u32, changes) 2316 ), 2317 TP_fast_assign( 2318 WIPHY_ASSIGN; 2319 WDEV_ASSIGN; 2320 __entry->master_pref = conf->master_pref; 2321 __entry->bands = conf->bands; 2322 __entry->changes = changes; 2323 ), 2324 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 2325 ", master preference: %u, bands: 0x%0x, changes: %x", 2326 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 2327 __entry->bands, __entry->changes) 2328 ); 2329 2330 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, 2331 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2332 TP_ARGS(wiphy, wdev) 2333 ); 2334 2335 TRACE_EVENT(rdev_add_nan_func, 2336 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2337 const struct cfg80211_nan_func *func), 2338 TP_ARGS(wiphy, wdev, func), 2339 TP_STRUCT__entry( 2340 WIPHY_ENTRY 2341 WDEV_ENTRY 2342 __field(u8, func_type) 2343 __field(u64, cookie) 2344 ), 2345 TP_fast_assign( 2346 WIPHY_ASSIGN; 2347 WDEV_ASSIGN; 2348 __entry->func_type = func->type; 2349 __entry->cookie = func->cookie 2350 ), 2351 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type=%u, cookie=%llu", 2352 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->func_type, 2353 __entry->cookie) 2354 ); 2355 2356 TRACE_EVENT(rdev_del_nan_func, 2357 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2358 u64 cookie), 2359 TP_ARGS(wiphy, wdev, cookie), 2360 TP_STRUCT__entry( 2361 WIPHY_ENTRY 2362 WDEV_ENTRY 2363 __field(u64, cookie) 2364 ), 2365 TP_fast_assign( 2366 WIPHY_ASSIGN; 2367 WDEV_ASSIGN; 2368 __entry->cookie = cookie; 2369 ), 2370 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie=%llu", 2371 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 2372 ); 2373 2374 TRACE_EVENT(rdev_set_mac_acl, 2375 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2376 struct cfg80211_acl_data *params), 2377 TP_ARGS(wiphy, netdev, params), 2378 TP_STRUCT__entry( 2379 WIPHY_ENTRY 2380 NETDEV_ENTRY 2381 __field(u32, acl_policy) 2382 ), 2383 TP_fast_assign( 2384 WIPHY_ASSIGN; 2385 NETDEV_ASSIGN; 2386 __entry->acl_policy = params->acl_policy; 2387 ), 2388 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d", 2389 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy) 2390 ); 2391 2392 TRACE_EVENT(rdev_update_ft_ies, 2393 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2394 struct cfg80211_update_ft_ies_params *ftie), 2395 TP_ARGS(wiphy, netdev, ftie), 2396 TP_STRUCT__entry( 2397 WIPHY_ENTRY 2398 NETDEV_ENTRY 2399 __field(u16, md) 2400 __dynamic_array(u8, ie, ftie->ie_len) 2401 ), 2402 TP_fast_assign( 2403 WIPHY_ASSIGN; 2404 NETDEV_ASSIGN; 2405 __entry->md = ftie->md; 2406 memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len); 2407 ), 2408 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x", 2409 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md) 2410 ); 2411 2412 TRACE_EVENT(rdev_crit_proto_start, 2413 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2414 enum nl80211_crit_proto_id protocol, u16 duration), 2415 TP_ARGS(wiphy, wdev, protocol, duration), 2416 TP_STRUCT__entry( 2417 WIPHY_ENTRY 2418 WDEV_ENTRY 2419 __field(u16, proto) 2420 __field(u16, duration) 2421 ), 2422 TP_fast_assign( 2423 WIPHY_ASSIGN; 2424 WDEV_ASSIGN; 2425 __entry->proto = protocol; 2426 __entry->duration = duration; 2427 ), 2428 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u", 2429 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration) 2430 ); 2431 2432 TRACE_EVENT(rdev_crit_proto_stop, 2433 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2434 TP_ARGS(wiphy, wdev), 2435 TP_STRUCT__entry( 2436 WIPHY_ENTRY 2437 WDEV_ENTRY 2438 ), 2439 TP_fast_assign( 2440 WIPHY_ASSIGN; 2441 WDEV_ASSIGN; 2442 ), 2443 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 2444 WIPHY_PR_ARG, WDEV_PR_ARG) 2445 ); 2446 2447 TRACE_EVENT(rdev_channel_switch, 2448 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2449 struct cfg80211_csa_settings *params), 2450 TP_ARGS(wiphy, netdev, params), 2451 TP_STRUCT__entry( 2452 WIPHY_ENTRY 2453 NETDEV_ENTRY 2454 CHAN_DEF_ENTRY 2455 __field(bool, radar_required) 2456 __field(bool, block_tx) 2457 __field(u8, count) 2458 __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon) 2459 __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp) 2460 __field(u8, link_id) 2461 ), 2462 TP_fast_assign( 2463 WIPHY_ASSIGN; 2464 NETDEV_ASSIGN; 2465 CHAN_DEF_ASSIGN(¶ms->chandef); 2466 __entry->radar_required = params->radar_required; 2467 __entry->block_tx = params->block_tx; 2468 __entry->count = params->count; 2469 memcpy(__get_dynamic_array(bcn_ofs), 2470 params->counter_offsets_beacon, 2471 params->n_counter_offsets_beacon * sizeof(u16)); 2472 2473 /* probe response offsets are optional */ 2474 if (params->n_counter_offsets_presp) 2475 memcpy(__get_dynamic_array(pres_ofs), 2476 params->counter_offsets_presp, 2477 params->n_counter_offsets_presp * sizeof(u16)); 2478 __entry->link_id = params->link_id; 2479 ), 2480 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 2481 ", block_tx: %d, count: %u, radar_required: %d, link_id: %d", 2482 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2483 __entry->block_tx, __entry->count, __entry->radar_required, 2484 __entry->link_id) 2485 ); 2486 2487 TRACE_EVENT(rdev_set_qos_map, 2488 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2489 struct cfg80211_qos_map *qos_map), 2490 TP_ARGS(wiphy, netdev, qos_map), 2491 TP_STRUCT__entry( 2492 WIPHY_ENTRY 2493 NETDEV_ENTRY 2494 QOS_MAP_ENTRY 2495 ), 2496 TP_fast_assign( 2497 WIPHY_ASSIGN; 2498 NETDEV_ASSIGN; 2499 QOS_MAP_ASSIGN(qos_map); 2500 ), 2501 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u", 2502 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des) 2503 ); 2504 2505 TRACE_EVENT(rdev_set_ap_chanwidth, 2506 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2507 unsigned int link_id, 2508 struct cfg80211_chan_def *chandef), 2509 TP_ARGS(wiphy, netdev, link_id, chandef), 2510 TP_STRUCT__entry( 2511 WIPHY_ENTRY 2512 NETDEV_ENTRY 2513 CHAN_DEF_ENTRY 2514 __field(unsigned int, link_id) 2515 ), 2516 TP_fast_assign( 2517 WIPHY_ASSIGN; 2518 NETDEV_ASSIGN; 2519 CHAN_DEF_ASSIGN(chandef); 2520 __entry->link_id = link_id; 2521 ), 2522 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d", 2523 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2524 __entry->link_id) 2525 ); 2526 2527 TRACE_EVENT(rdev_add_tx_ts, 2528 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2529 u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), 2530 TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time), 2531 TP_STRUCT__entry( 2532 WIPHY_ENTRY 2533 NETDEV_ENTRY 2534 MAC_ENTRY(peer) 2535 __field(u8, tsid) 2536 __field(u8, user_prio) 2537 __field(u16, admitted_time) 2538 ), 2539 TP_fast_assign( 2540 WIPHY_ASSIGN; 2541 NETDEV_ASSIGN; 2542 MAC_ASSIGN(peer, peer); 2543 __entry->tsid = tsid; 2544 __entry->user_prio = user_prio; 2545 __entry->admitted_time = admitted_time; 2546 ), 2547 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d, UP %d, time %d", 2548 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 2549 __entry->tsid, __entry->user_prio, __entry->admitted_time) 2550 ); 2551 2552 TRACE_EVENT(rdev_del_tx_ts, 2553 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2554 u8 tsid, const u8 *peer), 2555 TP_ARGS(wiphy, netdev, tsid, peer), 2556 TP_STRUCT__entry( 2557 WIPHY_ENTRY 2558 NETDEV_ENTRY 2559 MAC_ENTRY(peer) 2560 __field(u8, tsid) 2561 ), 2562 TP_fast_assign( 2563 WIPHY_ASSIGN; 2564 NETDEV_ASSIGN; 2565 MAC_ASSIGN(peer, peer); 2566 __entry->tsid = tsid; 2567 ), 2568 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d", 2569 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tsid) 2570 ); 2571 2572 TRACE_EVENT(rdev_tdls_channel_switch, 2573 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2574 const u8 *addr, u8 oper_class, 2575 struct cfg80211_chan_def *chandef), 2576 TP_ARGS(wiphy, netdev, addr, oper_class, chandef), 2577 TP_STRUCT__entry( 2578 WIPHY_ENTRY 2579 NETDEV_ENTRY 2580 MAC_ENTRY(addr) 2581 __field(u8, oper_class) 2582 CHAN_DEF_ENTRY 2583 ), 2584 TP_fast_assign( 2585 WIPHY_ASSIGN; 2586 NETDEV_ASSIGN; 2587 MAC_ASSIGN(addr, addr); 2588 CHAN_DEF_ASSIGN(chandef); 2589 ), 2590 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" 2591 " oper class %d, " CHAN_DEF_PR_FMT, 2592 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr, 2593 __entry->oper_class, CHAN_DEF_PR_ARG) 2594 ); 2595 2596 TRACE_EVENT(rdev_tdls_cancel_channel_switch, 2597 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2598 const u8 *addr), 2599 TP_ARGS(wiphy, netdev, addr), 2600 TP_STRUCT__entry( 2601 WIPHY_ENTRY 2602 NETDEV_ENTRY 2603 MAC_ENTRY(addr) 2604 ), 2605 TP_fast_assign( 2606 WIPHY_ASSIGN; 2607 NETDEV_ASSIGN; 2608 MAC_ASSIGN(addr, addr); 2609 ), 2610 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2611 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr) 2612 ); 2613 2614 TRACE_EVENT(rdev_set_pmk, 2615 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2616 struct cfg80211_pmk_conf *pmk_conf), 2617 2618 TP_ARGS(wiphy, netdev, pmk_conf), 2619 2620 TP_STRUCT__entry( 2621 WIPHY_ENTRY 2622 NETDEV_ENTRY 2623 MAC_ENTRY(aa) 2624 __field(u8, pmk_len) 2625 __field(u8, pmk_r0_name_len) 2626 __dynamic_array(u8, pmk, pmk_conf->pmk_len) 2627 __dynamic_array(u8, pmk_r0_name, WLAN_PMK_NAME_LEN) 2628 ), 2629 2630 TP_fast_assign( 2631 WIPHY_ASSIGN; 2632 NETDEV_ASSIGN; 2633 MAC_ASSIGN(aa, pmk_conf->aa); 2634 __entry->pmk_len = pmk_conf->pmk_len; 2635 __entry->pmk_r0_name_len = 2636 pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0; 2637 memcpy(__get_dynamic_array(pmk), pmk_conf->pmk, 2638 pmk_conf->pmk_len); 2639 memcpy(__get_dynamic_array(pmk_r0_name), pmk_conf->pmk_r0_name, 2640 pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0); 2641 ), 2642 2643 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" 2644 "pmk_len=%u, pmk: %s pmk_r0_name: %s", WIPHY_PR_ARG, 2645 NETDEV_PR_ARG, __entry->aa, __entry->pmk_len, 2646 __print_array(__get_dynamic_array(pmk), 2647 __get_dynamic_array_len(pmk), 1), 2648 __entry->pmk_r0_name_len ? 2649 __print_array(__get_dynamic_array(pmk_r0_name), 2650 __get_dynamic_array_len(pmk_r0_name), 1) : "") 2651 ); 2652 2653 TRACE_EVENT(rdev_del_pmk, 2654 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), 2655 2656 TP_ARGS(wiphy, netdev, aa), 2657 2658 TP_STRUCT__entry( 2659 WIPHY_ENTRY 2660 NETDEV_ENTRY 2661 MAC_ENTRY(aa) 2662 ), 2663 2664 TP_fast_assign( 2665 WIPHY_ASSIGN; 2666 NETDEV_ASSIGN; 2667 MAC_ASSIGN(aa, aa); 2668 ), 2669 2670 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2671 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->aa) 2672 ); 2673 2674 TRACE_EVENT(rdev_external_auth, 2675 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2676 struct cfg80211_external_auth_params *params), 2677 TP_ARGS(wiphy, netdev, params), 2678 TP_STRUCT__entry(WIPHY_ENTRY 2679 NETDEV_ENTRY 2680 MAC_ENTRY(bssid) 2681 __array(u8, ssid, IEEE80211_MAX_SSID_LEN + 1) 2682 __field(u16, status) 2683 MAC_ENTRY(mld_addr) 2684 ), 2685 TP_fast_assign(WIPHY_ASSIGN; 2686 NETDEV_ASSIGN; 2687 MAC_ASSIGN(bssid, params->bssid); 2688 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 2689 memcpy(__entry->ssid, params->ssid.ssid, 2690 params->ssid.ssid_len); 2691 __entry->status = params->status; 2692 MAC_ASSIGN(mld_addr, params->mld_addr); 2693 ), 2694 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 2695 ", ssid: %s, status: %u, mld_addr: %pM", 2696 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 2697 __entry->ssid, __entry->status, __entry->mld_addr) 2698 ); 2699 2700 TRACE_EVENT(rdev_start_radar_detection, 2701 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2702 struct cfg80211_chan_def *chandef, 2703 u32 cac_time_ms, int link_id), 2704 TP_ARGS(wiphy, netdev, chandef, cac_time_ms, link_id), 2705 TP_STRUCT__entry( 2706 WIPHY_ENTRY 2707 NETDEV_ENTRY 2708 CHAN_DEF_ENTRY 2709 __field(u32, cac_time_ms) 2710 __field(int, link_id) 2711 ), 2712 TP_fast_assign( 2713 WIPHY_ASSIGN; 2714 NETDEV_ASSIGN; 2715 CHAN_DEF_ASSIGN(chandef); 2716 __entry->cac_time_ms = cac_time_ms; 2717 __entry->link_id = link_id; 2718 ), 2719 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 2720 ", cac_time_ms=%u, link_id=%d", 2721 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2722 __entry->cac_time_ms, __entry->link_id) 2723 ); 2724 2725 TRACE_EVENT(rdev_set_mcast_rate, 2726 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2727 int *mcast_rate), 2728 TP_ARGS(wiphy, netdev, mcast_rate), 2729 TP_STRUCT__entry( 2730 WIPHY_ENTRY 2731 NETDEV_ENTRY 2732 __array(int, mcast_rate, NUM_NL80211_BANDS) 2733 ), 2734 TP_fast_assign( 2735 WIPHY_ASSIGN; 2736 NETDEV_ASSIGN; 2737 memcpy(__entry->mcast_rate, mcast_rate, 2738 sizeof(int) * NUM_NL80211_BANDS); 2739 ), 2740 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " 2741 "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 6GHz=0x%x, 60GHz=0x%x]", 2742 WIPHY_PR_ARG, NETDEV_PR_ARG, 2743 __entry->mcast_rate[NL80211_BAND_2GHZ], 2744 __entry->mcast_rate[NL80211_BAND_5GHZ], 2745 __entry->mcast_rate[NL80211_BAND_6GHZ], 2746 __entry->mcast_rate[NL80211_BAND_60GHZ]) 2747 ); 2748 2749 TRACE_EVENT(rdev_set_coalesce, 2750 TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), 2751 TP_ARGS(wiphy, coalesce), 2752 TP_STRUCT__entry( 2753 WIPHY_ENTRY 2754 __field(int, n_rules) 2755 ), 2756 TP_fast_assign( 2757 WIPHY_ASSIGN; 2758 __entry->n_rules = coalesce ? coalesce->n_rules : 0; 2759 ), 2760 TP_printk(WIPHY_PR_FMT ", n_rules=%d", 2761 WIPHY_PR_ARG, __entry->n_rules) 2762 ); 2763 2764 DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, 2765 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2766 TP_ARGS(wiphy, wdev) 2767 ); 2768 2769 TRACE_EVENT(rdev_set_multicast_to_unicast, 2770 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2771 const bool enabled), 2772 TP_ARGS(wiphy, netdev, enabled), 2773 TP_STRUCT__entry( 2774 WIPHY_ENTRY 2775 NETDEV_ENTRY 2776 __field(bool, enabled) 2777 ), 2778 TP_fast_assign( 2779 WIPHY_ASSIGN; 2780 NETDEV_ASSIGN; 2781 __entry->enabled = enabled; 2782 ), 2783 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", unicast: %s", 2784 WIPHY_PR_ARG, NETDEV_PR_ARG, 2785 BOOL_TO_STR(__entry->enabled)) 2786 ); 2787 2788 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_txq_stats, 2789 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2790 TP_ARGS(wiphy, wdev) 2791 ); 2792 2793 TRACE_EVENT(rdev_get_ftm_responder_stats, 2794 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2795 struct cfg80211_ftm_responder_stats *ftm_stats), 2796 2797 TP_ARGS(wiphy, netdev, ftm_stats), 2798 2799 TP_STRUCT__entry( 2800 WIPHY_ENTRY 2801 NETDEV_ENTRY 2802 __field(u64, timestamp) 2803 __field(u32, success_num) 2804 __field(u32, partial_num) 2805 __field(u32, failed_num) 2806 __field(u32, asap_num) 2807 __field(u32, non_asap_num) 2808 __field(u64, duration) 2809 __field(u32, unknown_triggers) 2810 __field(u32, reschedule) 2811 __field(u32, out_of_window) 2812 ), 2813 2814 TP_fast_assign( 2815 WIPHY_ASSIGN; 2816 NETDEV_ASSIGN; 2817 __entry->success_num = ftm_stats->success_num; 2818 __entry->partial_num = ftm_stats->partial_num; 2819 __entry->failed_num = ftm_stats->failed_num; 2820 __entry->asap_num = ftm_stats->asap_num; 2821 __entry->non_asap_num = ftm_stats->non_asap_num; 2822 __entry->duration = ftm_stats->total_duration_ms; 2823 __entry->unknown_triggers = ftm_stats->unknown_triggers_num; 2824 __entry->reschedule = ftm_stats->reschedule_requests_num; 2825 __entry->out_of_window = ftm_stats->out_of_window_triggers_num; 2826 ), 2827 2828 TP_printk(WIPHY_PR_FMT "Ftm responder stats: success %u, partial %u, " 2829 "failed %u, asap %u, non asap %u, total duration %llu, unknown " 2830 "triggers %u, rescheduled %u, out of window %u", WIPHY_PR_ARG, 2831 __entry->success_num, __entry->partial_num, __entry->failed_num, 2832 __entry->asap_num, __entry->non_asap_num, __entry->duration, 2833 __entry->unknown_triggers, __entry->reschedule, 2834 __entry->out_of_window) 2835 ); 2836 2837 DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_start_pmsr, 2838 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 2839 TP_ARGS(wiphy, wdev, cookie) 2840 ); 2841 2842 DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_abort_pmsr, 2843 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 2844 TP_ARGS(wiphy, wdev, cookie) 2845 ); 2846 2847 TRACE_EVENT(rdev_set_fils_aad, 2848 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2849 struct cfg80211_fils_aad *fils_aad), 2850 TP_ARGS(wiphy, netdev, fils_aad), 2851 TP_STRUCT__entry(WIPHY_ENTRY 2852 NETDEV_ENTRY 2853 __array(u8, macaddr, ETH_ALEN) 2854 __field(u8, kek_len) 2855 ), 2856 TP_fast_assign(WIPHY_ASSIGN; 2857 NETDEV_ASSIGN; 2858 FILS_AAD_ASSIGN(fils_aad); 2859 ), 2860 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " FILS_AAD_PR_FMT, 2861 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr, 2862 __entry->kek_len) 2863 ); 2864 2865 TRACE_EVENT(rdev_update_owe_info, 2866 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2867 struct cfg80211_update_owe_info *owe_info), 2868 TP_ARGS(wiphy, netdev, owe_info), 2869 TP_STRUCT__entry(WIPHY_ENTRY 2870 NETDEV_ENTRY 2871 MAC_ENTRY(peer) 2872 __field(u16, status) 2873 __dynamic_array(u8, ie, owe_info->ie_len)), 2874 TP_fast_assign(WIPHY_ASSIGN; 2875 NETDEV_ASSIGN; 2876 MAC_ASSIGN(peer, owe_info->peer); 2877 __entry->status = owe_info->status; 2878 memcpy(__get_dynamic_array(ie), 2879 owe_info->ie, owe_info->ie_len);), 2880 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM" 2881 " status %d", WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 2882 __entry->status) 2883 ); 2884 2885 TRACE_EVENT(rdev_probe_mesh_link, 2886 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2887 const u8 *dest, const u8 *buf, size_t len), 2888 TP_ARGS(wiphy, netdev, dest, buf, len), 2889 TP_STRUCT__entry( 2890 WIPHY_ENTRY 2891 NETDEV_ENTRY 2892 MAC_ENTRY(dest) 2893 ), 2894 TP_fast_assign( 2895 WIPHY_ASSIGN; 2896 NETDEV_ASSIGN; 2897 MAC_ASSIGN(dest, dest); 2898 ), 2899 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2900 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest) 2901 ); 2902 2903 TRACE_EVENT(rdev_set_tid_config, 2904 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2905 struct cfg80211_tid_config *tid_conf), 2906 TP_ARGS(wiphy, netdev, tid_conf), 2907 TP_STRUCT__entry( 2908 WIPHY_ENTRY 2909 NETDEV_ENTRY 2910 MAC_ENTRY(peer) 2911 ), 2912 TP_fast_assign( 2913 WIPHY_ASSIGN; 2914 NETDEV_ASSIGN; 2915 MAC_ASSIGN(peer, tid_conf->peer); 2916 ), 2917 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM", 2918 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer) 2919 ); 2920 2921 TRACE_EVENT(rdev_reset_tid_config, 2922 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2923 const u8 *peer, u8 tids), 2924 TP_ARGS(wiphy, netdev, peer, tids), 2925 TP_STRUCT__entry( 2926 WIPHY_ENTRY 2927 NETDEV_ENTRY 2928 MAC_ENTRY(peer) 2929 __field(u8, tids) 2930 ), 2931 TP_fast_assign( 2932 WIPHY_ASSIGN; 2933 NETDEV_ASSIGN; 2934 MAC_ASSIGN(peer, peer); 2935 __entry->tids = tids; 2936 ), 2937 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM, tids: 0x%x", 2938 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tids) 2939 ); 2940 2941 TRACE_EVENT(rdev_set_sar_specs, 2942 TP_PROTO(struct wiphy *wiphy, struct cfg80211_sar_specs *sar), 2943 TP_ARGS(wiphy, sar), 2944 TP_STRUCT__entry( 2945 WIPHY_ENTRY 2946 __field(u16, type) 2947 __field(u16, num) 2948 ), 2949 TP_fast_assign( 2950 WIPHY_ASSIGN; 2951 __entry->type = sar->type; 2952 __entry->num = sar->num_sub_specs; 2953 2954 ), 2955 TP_printk(WIPHY_PR_FMT ", Set type:%d, num_specs:%d", 2956 WIPHY_PR_ARG, __entry->type, __entry->num) 2957 ); 2958 2959 TRACE_EVENT(rdev_color_change, 2960 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2961 struct cfg80211_color_change_settings *params), 2962 TP_ARGS(wiphy, netdev, params), 2963 TP_STRUCT__entry( 2964 WIPHY_ENTRY 2965 NETDEV_ENTRY 2966 __field(u8, count) 2967 __field(u16, bcn_ofs) 2968 __field(u16, pres_ofs) 2969 __field(u8, link_id) 2970 ), 2971 TP_fast_assign( 2972 WIPHY_ASSIGN; 2973 NETDEV_ASSIGN; 2974 __entry->count = params->count; 2975 __entry->bcn_ofs = params->counter_offset_beacon; 2976 __entry->pres_ofs = params->counter_offset_presp; 2977 __entry->link_id = params->link_id; 2978 ), 2979 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT 2980 ", count: %u, link_id: %d", 2981 WIPHY_PR_ARG, NETDEV_PR_ARG, 2982 __entry->count, __entry->link_id) 2983 ); 2984 2985 TRACE_EVENT(rdev_set_radar_background, 2986 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2987 2988 TP_ARGS(wiphy, chandef), 2989 2990 TP_STRUCT__entry( 2991 WIPHY_ENTRY 2992 CHAN_DEF_ENTRY 2993 ), 2994 2995 TP_fast_assign( 2996 WIPHY_ASSIGN; 2997 CHAN_DEF_ASSIGN(chandef) 2998 ), 2999 3000 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 3001 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 3002 ); 3003 3004 DEFINE_EVENT(wiphy_wdev_link_evt, rdev_add_intf_link, 3005 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 3006 unsigned int link_id), 3007 TP_ARGS(wiphy, wdev, link_id) 3008 ); 3009 3010 DEFINE_EVENT(wiphy_wdev_link_evt, rdev_del_intf_link, 3011 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 3012 unsigned int link_id), 3013 TP_ARGS(wiphy, wdev, link_id) 3014 ); 3015 3016 TRACE_EVENT(rdev_del_link_station, 3017 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3018 struct link_station_del_parameters *params), 3019 TP_ARGS(wiphy, netdev, params), 3020 TP_STRUCT__entry( 3021 WIPHY_ENTRY 3022 NETDEV_ENTRY 3023 __array(u8, mld_mac, 6) 3024 __field(u32, link_id) 3025 ), 3026 TP_fast_assign( 3027 WIPHY_ASSIGN; 3028 NETDEV_ASSIGN; 3029 memset(__entry->mld_mac, 0, 6); 3030 if (params->mld_mac) 3031 memcpy(__entry->mld_mac, params->mld_mac, 6); 3032 __entry->link_id = params->link_id; 3033 ), 3034 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" 3035 ", link id: %u", 3036 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac, 3037 __entry->link_id) 3038 ); 3039 3040 TRACE_EVENT(rdev_set_hw_timestamp, 3041 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3042 struct cfg80211_set_hw_timestamp *hwts), 3043 3044 TP_ARGS(wiphy, netdev, hwts), 3045 3046 TP_STRUCT__entry( 3047 WIPHY_ENTRY 3048 NETDEV_ENTRY 3049 MAC_ENTRY(macaddr) 3050 __field(bool, enable) 3051 ), 3052 3053 TP_fast_assign( 3054 WIPHY_ASSIGN; 3055 NETDEV_ASSIGN; 3056 MAC_ASSIGN(macaddr, hwts->macaddr); 3057 __entry->enable = hwts->enable; 3058 ), 3059 3060 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac %pM, enable: %u", 3061 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr, 3062 __entry->enable) 3063 ); 3064 3065 TRACE_EVENT(rdev_set_ttlm, 3066 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3067 struct cfg80211_ttlm_params *params), 3068 TP_ARGS(wiphy, netdev, params), 3069 TP_STRUCT__entry( 3070 WIPHY_ENTRY 3071 NETDEV_ENTRY 3072 __array(u8, dlink, sizeof(u16) * 8) 3073 __array(u8, ulink, sizeof(u16) * 8) 3074 ), 3075 TP_fast_assign( 3076 WIPHY_ASSIGN; 3077 NETDEV_ASSIGN; 3078 memcpy(__entry->dlink, params->dlink, sizeof(params->dlink)); 3079 memcpy(__entry->ulink, params->ulink, sizeof(params->ulink)); 3080 ), 3081 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, 3082 WIPHY_PR_ARG, NETDEV_PR_ARG) 3083 ); 3084 3085 TRACE_EVENT(rdev_set_epcs, 3086 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3087 bool val), 3088 TP_ARGS(wiphy, netdev, val), 3089 TP_STRUCT__entry( 3090 WIPHY_ENTRY 3091 NETDEV_ENTRY 3092 __field(bool, val) 3093 ), 3094 TP_fast_assign( 3095 WIPHY_ASSIGN; 3096 NETDEV_ASSIGN; 3097 __entry->val = val; 3098 ), 3099 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", config=%u", 3100 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->val) 3101 ); 3102 3103 /************************************************************* 3104 * cfg80211 exported functions traces * 3105 *************************************************************/ 3106 3107 TRACE_EVENT(cfg80211_return_bool, 3108 TP_PROTO(bool ret), 3109 TP_ARGS(ret), 3110 TP_STRUCT__entry( 3111 __field(bool, ret) 3112 ), 3113 TP_fast_assign( 3114 __entry->ret = ret; 3115 ), 3116 TP_printk("returned %s", BOOL_TO_STR(__entry->ret)) 3117 ); 3118 3119 DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, 3120 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3121 TP_ARGS(netdev, macaddr), 3122 TP_STRUCT__entry( 3123 NETDEV_ENTRY 3124 MAC_ENTRY(macaddr) 3125 ), 3126 TP_fast_assign( 3127 NETDEV_ASSIGN; 3128 MAC_ASSIGN(macaddr, macaddr); 3129 ), 3130 TP_printk(NETDEV_PR_FMT ", mac: %pM", 3131 NETDEV_PR_ARG, __entry->macaddr) 3132 ); 3133 3134 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, 3135 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3136 TP_ARGS(netdev, macaddr) 3137 ); 3138 3139 DECLARE_EVENT_CLASS(netdev_evt_only, 3140 TP_PROTO(struct net_device *netdev), 3141 TP_ARGS(netdev), 3142 TP_STRUCT__entry( 3143 NETDEV_ENTRY 3144 ), 3145 TP_fast_assign( 3146 NETDEV_ASSIGN; 3147 ), 3148 TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG) 3149 ); 3150 3151 DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, 3152 TP_PROTO(struct net_device *netdev), 3153 TP_ARGS(netdev) 3154 ); 3155 3156 TRACE_EVENT(cfg80211_send_rx_assoc, 3157 TP_PROTO(struct net_device *netdev, 3158 const struct cfg80211_rx_assoc_resp_data *data), 3159 TP_ARGS(netdev, data), 3160 TP_STRUCT__entry( 3161 NETDEV_ENTRY 3162 MAC_ENTRY(ap_addr) 3163 ), 3164 TP_fast_assign( 3165 NETDEV_ASSIGN; 3166 MAC_ASSIGN(ap_addr, 3167 data->ap_mld_addr ?: data->links[0].bss->bssid); 3168 ), 3169 TP_printk(NETDEV_PR_FMT ", %pM", 3170 NETDEV_PR_ARG, __entry->ap_addr) 3171 ); 3172 3173 DECLARE_EVENT_CLASS(netdev_frame_event, 3174 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 3175 TP_ARGS(netdev, buf, len), 3176 TP_STRUCT__entry( 3177 NETDEV_ENTRY 3178 __dynamic_array(u8, frame, len) 3179 ), 3180 TP_fast_assign( 3181 NETDEV_ASSIGN; 3182 memcpy(__get_dynamic_array(frame), buf, len); 3183 ), 3184 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x", 3185 NETDEV_PR_ARG, 3186 le16_to_cpup((__le16 *)__get_dynamic_array(frame))) 3187 ); 3188 3189 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, 3190 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 3191 TP_ARGS(netdev, buf, len) 3192 ); 3193 3194 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, 3195 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 3196 TP_ARGS(netdev, buf, len) 3197 ); 3198 3199 TRACE_EVENT(cfg80211_tx_mlme_mgmt, 3200 TP_PROTO(struct net_device *netdev, const u8 *buf, int len, 3201 bool reconnect), 3202 TP_ARGS(netdev, buf, len, reconnect), 3203 TP_STRUCT__entry( 3204 NETDEV_ENTRY 3205 __dynamic_array(u8, frame, len) 3206 __field(int, reconnect) 3207 ), 3208 TP_fast_assign( 3209 NETDEV_ASSIGN; 3210 memcpy(__get_dynamic_array(frame), buf, len); 3211 __entry->reconnect = reconnect; 3212 ), 3213 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x reconnect:%d", 3214 NETDEV_PR_ARG, 3215 le16_to_cpup((__le16 *)__get_dynamic_array(frame)), 3216 __entry->reconnect) 3217 ); 3218 3219 DECLARE_EVENT_CLASS(netdev_mac_evt, 3220 TP_PROTO(struct net_device *netdev, const u8 *mac), 3221 TP_ARGS(netdev, mac), 3222 TP_STRUCT__entry( 3223 NETDEV_ENTRY 3224 MAC_ENTRY(mac) 3225 ), 3226 TP_fast_assign( 3227 NETDEV_ASSIGN; 3228 MAC_ASSIGN(mac, mac) 3229 ), 3230 TP_printk(NETDEV_PR_FMT ", mac: %pM", 3231 NETDEV_PR_ARG, __entry->mac) 3232 ); 3233 3234 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, 3235 TP_PROTO(struct net_device *netdev, const u8 *mac), 3236 TP_ARGS(netdev, mac) 3237 ); 3238 3239 TRACE_EVENT(cfg80211_send_assoc_failure, 3240 TP_PROTO(struct net_device *netdev, 3241 struct cfg80211_assoc_failure *data), 3242 TP_ARGS(netdev, data), 3243 TP_STRUCT__entry( 3244 NETDEV_ENTRY 3245 MAC_ENTRY(ap_addr) 3246 __field(bool, timeout) 3247 ), 3248 TP_fast_assign( 3249 NETDEV_ASSIGN; 3250 MAC_ASSIGN(ap_addr, data->ap_mld_addr ?: data->bss[0]->bssid); 3251 __entry->timeout = data->timeout; 3252 ), 3253 TP_printk(NETDEV_PR_FMT ", mac: %pM, timeout: %d", 3254 NETDEV_PR_ARG, __entry->ap_addr, __entry->timeout) 3255 ); 3256 3257 TRACE_EVENT(cfg80211_michael_mic_failure, 3258 TP_PROTO(struct net_device *netdev, const u8 *addr, 3259 enum nl80211_key_type key_type, int key_id, const u8 *tsc), 3260 TP_ARGS(netdev, addr, key_type, key_id, tsc), 3261 TP_STRUCT__entry( 3262 NETDEV_ENTRY 3263 MAC_ENTRY(addr) 3264 __field(enum nl80211_key_type, key_type) 3265 __field(int, key_id) 3266 __array(u8, tsc, 6) 3267 ), 3268 TP_fast_assign( 3269 NETDEV_ASSIGN; 3270 MAC_ASSIGN(addr, addr); 3271 __entry->key_type = key_type; 3272 __entry->key_id = key_id; 3273 if (tsc) 3274 memcpy(__entry->tsc, tsc, 6); 3275 ), 3276 TP_printk(NETDEV_PR_FMT ", %pM, key type: %d, key id: %d, tsc: %pm", 3277 NETDEV_PR_ARG, __entry->addr, __entry->key_type, 3278 __entry->key_id, __entry->tsc) 3279 ); 3280 3281 TRACE_EVENT(cfg80211_ready_on_channel, 3282 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 3283 struct ieee80211_channel *chan, 3284 unsigned int duration), 3285 TP_ARGS(wdev, cookie, chan, duration), 3286 TP_STRUCT__entry( 3287 WDEV_ENTRY 3288 __field(u64, cookie) 3289 CHAN_ENTRY 3290 __field(unsigned int, duration) 3291 ), 3292 TP_fast_assign( 3293 WDEV_ASSIGN; 3294 __entry->cookie = cookie; 3295 CHAN_ASSIGN(chan); 3296 __entry->duration = duration; 3297 ), 3298 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u", 3299 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG, 3300 __entry->duration) 3301 ); 3302 3303 TRACE_EVENT(cfg80211_ready_on_channel_expired, 3304 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 3305 struct ieee80211_channel *chan), 3306 TP_ARGS(wdev, cookie, chan), 3307 TP_STRUCT__entry( 3308 WDEV_ENTRY 3309 __field(u64, cookie) 3310 CHAN_ENTRY 3311 ), 3312 TP_fast_assign( 3313 WDEV_ASSIGN; 3314 __entry->cookie = cookie; 3315 CHAN_ASSIGN(chan); 3316 ), 3317 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT, 3318 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG) 3319 ); 3320 3321 TRACE_EVENT(cfg80211_tx_mgmt_expired, 3322 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 3323 struct ieee80211_channel *chan), 3324 TP_ARGS(wdev, cookie, chan), 3325 TP_STRUCT__entry( 3326 WDEV_ENTRY 3327 __field(u64, cookie) 3328 CHAN_ENTRY 3329 ), 3330 TP_fast_assign( 3331 WDEV_ASSIGN; 3332 __entry->cookie = cookie; 3333 CHAN_ASSIGN(chan); 3334 ), 3335 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT, 3336 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG) 3337 ); 3338 3339 TRACE_EVENT(cfg80211_new_sta, 3340 TP_PROTO(struct net_device *netdev, const u8 *mac_addr, 3341 struct station_info *sinfo), 3342 TP_ARGS(netdev, mac_addr, sinfo), 3343 TP_STRUCT__entry( 3344 NETDEV_ENTRY 3345 MAC_ENTRY(mac_addr) 3346 SINFO_ENTRY 3347 ), 3348 TP_fast_assign( 3349 NETDEV_ASSIGN; 3350 MAC_ASSIGN(mac_addr, mac_addr); 3351 SINFO_ASSIGN; 3352 ), 3353 TP_printk(NETDEV_PR_FMT ", %pM", 3354 NETDEV_PR_ARG, __entry->mac_addr) 3355 ); 3356 3357 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, 3358 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3359 TP_ARGS(netdev, macaddr) 3360 ); 3361 3362 TRACE_EVENT(cfg80211_rx_mgmt, 3363 TP_PROTO(struct wireless_dev *wdev, struct cfg80211_rx_info *info), 3364 TP_ARGS(wdev, info), 3365 TP_STRUCT__entry( 3366 WDEV_ENTRY 3367 __field(int, freq) 3368 __field(int, sig_dbm) 3369 ), 3370 TP_fast_assign( 3371 WDEV_ASSIGN; 3372 __entry->freq = info->freq; 3373 __entry->sig_dbm = info->sig_dbm; 3374 ), 3375 TP_printk(WDEV_PR_FMT ", freq: "KHZ_F", sig dbm: %d", 3376 WDEV_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm) 3377 ); 3378 3379 TRACE_EVENT(cfg80211_mgmt_tx_status, 3380 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), 3381 TP_ARGS(wdev, cookie, ack), 3382 TP_STRUCT__entry( 3383 WDEV_ENTRY 3384 __field(u64, cookie) 3385 __field(bool, ack) 3386 ), 3387 TP_fast_assign( 3388 WDEV_ASSIGN; 3389 __entry->cookie = cookie; 3390 __entry->ack = ack; 3391 ), 3392 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s", 3393 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack)) 3394 ); 3395 3396 TRACE_EVENT(cfg80211_control_port_tx_status, 3397 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), 3398 TP_ARGS(wdev, cookie, ack), 3399 TP_STRUCT__entry( 3400 WDEV_ENTRY 3401 __field(u64, cookie) 3402 __field(bool, ack) 3403 ), 3404 TP_fast_assign( 3405 WDEV_ASSIGN; 3406 __entry->cookie = cookie; 3407 __entry->ack = ack; 3408 ), 3409 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s", 3410 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack)) 3411 ); 3412 3413 TRACE_EVENT(cfg80211_rx_control_port, 3414 TP_PROTO(struct net_device *netdev, struct sk_buff *skb, 3415 bool unencrypted, int link_id), 3416 TP_ARGS(netdev, skb, unencrypted, link_id), 3417 TP_STRUCT__entry( 3418 NETDEV_ENTRY 3419 __field(int, len) 3420 MAC_ENTRY(from) 3421 __field(u16, proto) 3422 __field(bool, unencrypted) 3423 __field(int, link_id) 3424 ), 3425 TP_fast_assign( 3426 NETDEV_ASSIGN; 3427 __entry->len = skb->len; 3428 MAC_ASSIGN(from, eth_hdr(skb)->h_source); 3429 __entry->proto = be16_to_cpu(skb->protocol); 3430 __entry->unencrypted = unencrypted; 3431 __entry->link_id = link_id; 3432 ), 3433 TP_printk(NETDEV_PR_FMT ", len=%d, %pM, proto: 0x%x, unencrypted: %s, link: %d", 3434 NETDEV_PR_ARG, __entry->len, __entry->from, 3435 __entry->proto, BOOL_TO_STR(__entry->unencrypted), 3436 __entry->link_id) 3437 ); 3438 3439 TRACE_EVENT(cfg80211_cqm_rssi_notify, 3440 TP_PROTO(struct net_device *netdev, 3441 enum nl80211_cqm_rssi_threshold_event rssi_event, 3442 s32 rssi_level), 3443 TP_ARGS(netdev, rssi_event, rssi_level), 3444 TP_STRUCT__entry( 3445 NETDEV_ENTRY 3446 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event) 3447 __field(s32, rssi_level) 3448 ), 3449 TP_fast_assign( 3450 NETDEV_ASSIGN; 3451 __entry->rssi_event = rssi_event; 3452 __entry->rssi_level = rssi_level; 3453 ), 3454 TP_printk(NETDEV_PR_FMT ", rssi event: %d, level: %d", 3455 NETDEV_PR_ARG, __entry->rssi_event, __entry->rssi_level) 3456 ); 3457 3458 TRACE_EVENT(cfg80211_reg_can_beacon, 3459 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 3460 enum nl80211_iftype iftype, u32 prohibited_flags, 3461 u32 permitting_flags), 3462 TP_ARGS(wiphy, chandef, iftype, prohibited_flags, permitting_flags), 3463 TP_STRUCT__entry( 3464 WIPHY_ENTRY 3465 CHAN_DEF_ENTRY 3466 __field(enum nl80211_iftype, iftype) 3467 __field(u32, prohibited_flags) 3468 __field(u32, permitting_flags) 3469 ), 3470 TP_fast_assign( 3471 WIPHY_ASSIGN; 3472 CHAN_DEF_ASSIGN(chandef); 3473 __entry->iftype = iftype; 3474 __entry->prohibited_flags = prohibited_flags; 3475 __entry->permitting_flags = permitting_flags; 3476 ), 3477 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d prohibited_flags=0x%x permitting_flags=0x%x", 3478 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype, 3479 __entry->prohibited_flags, __entry->permitting_flags) 3480 ); 3481 3482 TRACE_EVENT(cfg80211_chandef_dfs_required, 3483 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 3484 TP_ARGS(wiphy, chandef), 3485 TP_STRUCT__entry( 3486 WIPHY_ENTRY 3487 CHAN_DEF_ENTRY 3488 ), 3489 TP_fast_assign( 3490 WIPHY_ASSIGN; 3491 CHAN_DEF_ASSIGN(chandef); 3492 ), 3493 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 3494 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 3495 ); 3496 3497 TRACE_EVENT(cfg80211_ch_switch_notify, 3498 TP_PROTO(struct net_device *netdev, 3499 struct cfg80211_chan_def *chandef, 3500 unsigned int link_id), 3501 TP_ARGS(netdev, chandef, link_id), 3502 TP_STRUCT__entry( 3503 NETDEV_ENTRY 3504 CHAN_DEF_ENTRY 3505 __field(unsigned int, link_id) 3506 ), 3507 TP_fast_assign( 3508 NETDEV_ASSIGN; 3509 CHAN_DEF_ASSIGN(chandef); 3510 __entry->link_id = link_id; 3511 ), 3512 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d", 3513 NETDEV_PR_ARG, CHAN_DEF_PR_ARG, __entry->link_id) 3514 ); 3515 3516 TRACE_EVENT(cfg80211_ch_switch_started_notify, 3517 TP_PROTO(struct net_device *netdev, 3518 struct cfg80211_chan_def *chandef, 3519 unsigned int link_id), 3520 TP_ARGS(netdev, chandef, link_id), 3521 TP_STRUCT__entry( 3522 NETDEV_ENTRY 3523 CHAN_DEF_ENTRY 3524 __field(unsigned int, link_id) 3525 ), 3526 TP_fast_assign( 3527 NETDEV_ASSIGN; 3528 CHAN_DEF_ASSIGN(chandef); 3529 __entry->link_id = link_id; 3530 ), 3531 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d", 3532 NETDEV_PR_ARG, CHAN_DEF_PR_ARG, __entry->link_id) 3533 ); 3534 3535 TRACE_EVENT(cfg80211_radar_event, 3536 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 3537 bool offchan), 3538 TP_ARGS(wiphy, chandef, offchan), 3539 TP_STRUCT__entry( 3540 WIPHY_ENTRY 3541 CHAN_DEF_ENTRY 3542 __field(bool, offchan) 3543 ), 3544 TP_fast_assign( 3545 WIPHY_ASSIGN; 3546 CHAN_DEF_ASSIGN(chandef); 3547 __entry->offchan = offchan; 3548 ), 3549 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", offchan %d", 3550 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->offchan) 3551 ); 3552 3553 TRACE_EVENT(cfg80211_cac_event, 3554 TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt, 3555 unsigned int link_id), 3556 TP_ARGS(netdev, evt, link_id), 3557 TP_STRUCT__entry( 3558 NETDEV_ENTRY 3559 __field(enum nl80211_radar_event, evt) 3560 __field(unsigned int, link_id) 3561 ), 3562 TP_fast_assign( 3563 NETDEV_ASSIGN; 3564 __entry->evt = evt; 3565 __entry->link_id = link_id; 3566 ), 3567 TP_printk(NETDEV_PR_FMT ", event: %d, link_id=%u", 3568 NETDEV_PR_ARG, __entry->evt, __entry->link_id) 3569 ); 3570 3571 DECLARE_EVENT_CLASS(cfg80211_rx_evt, 3572 TP_PROTO(struct net_device *netdev, const u8 *addr), 3573 TP_ARGS(netdev, addr), 3574 TP_STRUCT__entry( 3575 NETDEV_ENTRY 3576 MAC_ENTRY(addr) 3577 ), 3578 TP_fast_assign( 3579 NETDEV_ASSIGN; 3580 MAC_ASSIGN(addr, addr); 3581 ), 3582 TP_printk(NETDEV_PR_FMT ", %pM", NETDEV_PR_ARG, __entry->addr) 3583 ); 3584 3585 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, 3586 TP_PROTO(struct net_device *netdev, const u8 *addr), 3587 TP_ARGS(netdev, addr) 3588 ); 3589 3590 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, 3591 TP_PROTO(struct net_device *netdev, const u8 *addr), 3592 TP_ARGS(netdev, addr) 3593 ); 3594 3595 TRACE_EVENT(cfg80211_ibss_joined, 3596 TP_PROTO(struct net_device *netdev, const u8 *bssid, 3597 struct ieee80211_channel *channel), 3598 TP_ARGS(netdev, bssid, channel), 3599 TP_STRUCT__entry( 3600 NETDEV_ENTRY 3601 MAC_ENTRY(bssid) 3602 CHAN_ENTRY 3603 ), 3604 TP_fast_assign( 3605 NETDEV_ASSIGN; 3606 MAC_ASSIGN(bssid, bssid); 3607 CHAN_ASSIGN(channel); 3608 ), 3609 TP_printk(NETDEV_PR_FMT ", bssid: %pM, " CHAN_PR_FMT, 3610 NETDEV_PR_ARG, __entry->bssid, CHAN_PR_ARG) 3611 ); 3612 3613 TRACE_EVENT(cfg80211_probe_status, 3614 TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, 3615 bool acked), 3616 TP_ARGS(netdev, addr, cookie, acked), 3617 TP_STRUCT__entry( 3618 NETDEV_ENTRY 3619 MAC_ENTRY(addr) 3620 __field(u64, cookie) 3621 __field(bool, acked) 3622 ), 3623 TP_fast_assign( 3624 NETDEV_ASSIGN; 3625 MAC_ASSIGN(addr, addr); 3626 __entry->cookie = cookie; 3627 __entry->acked = acked; 3628 ), 3629 TP_printk(NETDEV_PR_FMT " addr:%pM, cookie: %llu, acked: %s", 3630 NETDEV_PR_ARG, __entry->addr, __entry->cookie, 3631 BOOL_TO_STR(__entry->acked)) 3632 ); 3633 3634 TRACE_EVENT(cfg80211_cqm_pktloss_notify, 3635 TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), 3636 TP_ARGS(netdev, peer, num_packets), 3637 TP_STRUCT__entry( 3638 NETDEV_ENTRY 3639 MAC_ENTRY(peer) 3640 __field(u32, num_packets) 3641 ), 3642 TP_fast_assign( 3643 NETDEV_ASSIGN; 3644 MAC_ASSIGN(peer, peer); 3645 __entry->num_packets = num_packets; 3646 ), 3647 TP_printk(NETDEV_PR_FMT ", peer: %pM, num of lost packets: %u", 3648 NETDEV_PR_ARG, __entry->peer, __entry->num_packets) 3649 ); 3650 3651 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, 3652 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3653 TP_ARGS(netdev, macaddr) 3654 ); 3655 3656 TRACE_EVENT(cfg80211_pmksa_candidate_notify, 3657 TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, 3658 bool preauth), 3659 TP_ARGS(netdev, index, bssid, preauth), 3660 TP_STRUCT__entry( 3661 NETDEV_ENTRY 3662 __field(int, index) 3663 MAC_ENTRY(bssid) 3664 __field(bool, preauth) 3665 ), 3666 TP_fast_assign( 3667 NETDEV_ASSIGN; 3668 __entry->index = index; 3669 MAC_ASSIGN(bssid, bssid); 3670 __entry->preauth = preauth; 3671 ), 3672 TP_printk(NETDEV_PR_FMT ", index:%d, bssid: %pM, pre auth: %s", 3673 NETDEV_PR_ARG, __entry->index, __entry->bssid, 3674 BOOL_TO_STR(__entry->preauth)) 3675 ); 3676 3677 TRACE_EVENT(cfg80211_report_obss_beacon, 3678 TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, 3679 int freq, int sig_dbm), 3680 TP_ARGS(wiphy, frame, len, freq, sig_dbm), 3681 TP_STRUCT__entry( 3682 WIPHY_ENTRY 3683 __field(int, freq) 3684 __field(int, sig_dbm) 3685 ), 3686 TP_fast_assign( 3687 WIPHY_ASSIGN; 3688 __entry->freq = freq; 3689 __entry->sig_dbm = sig_dbm; 3690 ), 3691 TP_printk(WIPHY_PR_FMT ", freq: "KHZ_F", sig_dbm: %d", 3692 WIPHY_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm) 3693 ); 3694 3695 TRACE_EVENT(cfg80211_tdls_oper_request, 3696 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, 3697 enum nl80211_tdls_operation oper, u16 reason_code), 3698 TP_ARGS(wiphy, netdev, peer, oper, reason_code), 3699 TP_STRUCT__entry( 3700 WIPHY_ENTRY 3701 NETDEV_ENTRY 3702 MAC_ENTRY(peer) 3703 __field(enum nl80211_tdls_operation, oper) 3704 __field(u16, reason_code) 3705 ), 3706 TP_fast_assign( 3707 WIPHY_ASSIGN; 3708 NETDEV_ASSIGN; 3709 MAC_ASSIGN(peer, peer); 3710 __entry->oper = oper; 3711 __entry->reason_code = reason_code; 3712 ), 3713 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM, oper: %d, reason_code %u", 3714 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper, 3715 __entry->reason_code) 3716 ); 3717 3718 TRACE_EVENT(cfg80211_scan_done, 3719 TP_PROTO(struct cfg80211_scan_request *request, 3720 struct cfg80211_scan_info *info), 3721 TP_ARGS(request, info), 3722 TP_STRUCT__entry( 3723 __field(u32, n_channels) 3724 __dynamic_array(u8, ie, request ? request->ie_len : 0) 3725 __array(u32, rates, NUM_NL80211_BANDS) 3726 __field(u32, wdev_id) 3727 MAC_ENTRY(wiphy_mac) 3728 __field(bool, no_cck) 3729 __field(bool, aborted) 3730 __field(u64, scan_start_tsf) 3731 MAC_ENTRY(tsf_bssid) 3732 ), 3733 TP_fast_assign( 3734 if (request) { 3735 memcpy(__get_dynamic_array(ie), request->ie, 3736 request->ie_len); 3737 memcpy(__entry->rates, request->rates, 3738 NUM_NL80211_BANDS); 3739 __entry->wdev_id = request->wdev ? 3740 request->wdev->identifier : 0; 3741 if (request->wiphy) 3742 MAC_ASSIGN(wiphy_mac, 3743 request->wiphy->perm_addr); 3744 __entry->no_cck = request->no_cck; 3745 } 3746 if (info) { 3747 __entry->aborted = info->aborted; 3748 __entry->scan_start_tsf = info->scan_start_tsf; 3749 MAC_ASSIGN(tsf_bssid, info->tsf_bssid); 3750 } 3751 ), 3752 TP_printk("aborted: %s, scan start (TSF): %llu, tsf_bssid: %pM", 3753 BOOL_TO_STR(__entry->aborted), 3754 (unsigned long long)__entry->scan_start_tsf, 3755 __entry->tsf_bssid) 3756 ); 3757 3758 DECLARE_EVENT_CLASS(wiphy_id_evt, 3759 TP_PROTO(struct wiphy *wiphy, u64 id), 3760 TP_ARGS(wiphy, id), 3761 TP_STRUCT__entry( 3762 WIPHY_ENTRY 3763 __field(u64, id) 3764 ), 3765 TP_fast_assign( 3766 WIPHY_ASSIGN; 3767 __entry->id = id; 3768 ), 3769 TP_printk(WIPHY_PR_FMT ", id: %llu", WIPHY_PR_ARG, __entry->id) 3770 ); 3771 3772 DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, 3773 TP_PROTO(struct wiphy *wiphy, u64 id), 3774 TP_ARGS(wiphy, id) 3775 ); 3776 3777 DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, 3778 TP_PROTO(struct wiphy *wiphy, u64 id), 3779 TP_ARGS(wiphy, id) 3780 ); 3781 3782 TRACE_EVENT(cfg80211_get_bss, 3783 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, 3784 const u8 *bssid, const u8 *ssid, size_t ssid_len, 3785 enum ieee80211_bss_type bss_type, 3786 enum ieee80211_privacy privacy), 3787 TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy), 3788 TP_STRUCT__entry( 3789 WIPHY_ENTRY 3790 CHAN_ENTRY 3791 MAC_ENTRY(bssid) 3792 __dynamic_array(u8, ssid, ssid_len) 3793 __field(enum ieee80211_bss_type, bss_type) 3794 __field(enum ieee80211_privacy, privacy) 3795 ), 3796 TP_fast_assign( 3797 WIPHY_ASSIGN; 3798 CHAN_ASSIGN(channel); 3799 MAC_ASSIGN(bssid, bssid); 3800 memcpy(__get_dynamic_array(ssid), ssid, ssid_len); 3801 __entry->bss_type = bss_type; 3802 __entry->privacy = privacy; 3803 ), 3804 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", %pM" 3805 ", buf: %#.2x, bss_type: %d, privacy: %d", 3806 WIPHY_PR_ARG, CHAN_PR_ARG, __entry->bssid, 3807 ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type, 3808 __entry->privacy) 3809 ); 3810 3811 TRACE_EVENT(cfg80211_inform_bss_frame, 3812 TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, 3813 struct ieee80211_mgmt *mgmt, size_t len), 3814 TP_ARGS(wiphy, data, mgmt, len), 3815 TP_STRUCT__entry( 3816 WIPHY_ENTRY 3817 CHAN_ENTRY 3818 __dynamic_array(u8, mgmt, len) 3819 __field(s32, signal) 3820 __field(u64, ts_boottime) 3821 __field(u64, parent_tsf) 3822 MAC_ENTRY(parent_bssid) 3823 ), 3824 TP_fast_assign( 3825 WIPHY_ASSIGN; 3826 CHAN_ASSIGN(data->chan); 3827 if (mgmt) 3828 memcpy(__get_dynamic_array(mgmt), mgmt, len); 3829 __entry->signal = data->signal; 3830 __entry->ts_boottime = data->boottime_ns; 3831 __entry->parent_tsf = data->parent_tsf; 3832 MAC_ASSIGN(parent_bssid, data->parent_bssid); 3833 ), 3834 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT 3835 "signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: %pM", 3836 WIPHY_PR_ARG, CHAN_PR_ARG, 3837 __entry->signal, (unsigned long long)__entry->ts_boottime, 3838 (unsigned long long)__entry->parent_tsf, 3839 __entry->parent_bssid) 3840 ); 3841 3842 DECLARE_EVENT_CLASS(cfg80211_bss_evt, 3843 TP_PROTO(struct cfg80211_bss *pub), 3844 TP_ARGS(pub), 3845 TP_STRUCT__entry( 3846 MAC_ENTRY(bssid) 3847 CHAN_ENTRY 3848 ), 3849 TP_fast_assign( 3850 MAC_ASSIGN(bssid, pub->bssid); 3851 CHAN_ASSIGN(pub->channel); 3852 ), 3853 TP_printk("%pM, " CHAN_PR_FMT, __entry->bssid, CHAN_PR_ARG) 3854 ); 3855 3856 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, 3857 TP_PROTO(struct cfg80211_bss *pub), 3858 TP_ARGS(pub) 3859 ); 3860 3861 TRACE_EVENT(cfg80211_return_uint, 3862 TP_PROTO(unsigned int ret), 3863 TP_ARGS(ret), 3864 TP_STRUCT__entry( 3865 __field(unsigned int, ret) 3866 ), 3867 TP_fast_assign( 3868 __entry->ret = ret; 3869 ), 3870 TP_printk("ret: %d", __entry->ret) 3871 ); 3872 3873 TRACE_EVENT(cfg80211_return_u32, 3874 TP_PROTO(u32 ret), 3875 TP_ARGS(ret), 3876 TP_STRUCT__entry( 3877 __field(u32, ret) 3878 ), 3879 TP_fast_assign( 3880 __entry->ret = ret; 3881 ), 3882 TP_printk("ret: %u", __entry->ret) 3883 ); 3884 3885 TRACE_EVENT(cfg80211_report_wowlan_wakeup, 3886 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 3887 struct cfg80211_wowlan_wakeup *wakeup), 3888 TP_ARGS(wiphy, wdev, wakeup), 3889 TP_STRUCT__entry( 3890 WIPHY_ENTRY 3891 WDEV_ENTRY 3892 __field(bool, non_wireless) 3893 __field(bool, disconnect) 3894 __field(bool, magic_pkt) 3895 __field(bool, gtk_rekey_failure) 3896 __field(bool, eap_identity_req) 3897 __field(bool, four_way_handshake) 3898 __field(bool, rfkill_release) 3899 __field(s32, pattern_idx) 3900 __field(u32, packet_len) 3901 __dynamic_array(u8, packet, 3902 wakeup ? wakeup->packet_present_len : 0) 3903 ), 3904 TP_fast_assign( 3905 WIPHY_ASSIGN; 3906 WDEV_ASSIGN; 3907 __entry->non_wireless = !wakeup; 3908 __entry->disconnect = wakeup ? wakeup->disconnect : false; 3909 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false; 3910 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false; 3911 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false; 3912 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false; 3913 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false; 3914 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false; 3915 __entry->packet_len = wakeup ? wakeup->packet_len : false; 3916 if (wakeup && wakeup->packet && wakeup->packet_present_len) 3917 memcpy(__get_dynamic_array(packet), wakeup->packet, 3918 wakeup->packet_present_len); 3919 ), 3920 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 3921 ); 3922 3923 TRACE_EVENT(cfg80211_ft_event, 3924 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3925 struct cfg80211_ft_event_params *ft_event), 3926 TP_ARGS(wiphy, netdev, ft_event), 3927 TP_STRUCT__entry( 3928 WIPHY_ENTRY 3929 NETDEV_ENTRY 3930 __dynamic_array(u8, ies, ft_event->ies_len) 3931 MAC_ENTRY(target_ap) 3932 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len) 3933 ), 3934 TP_fast_assign( 3935 WIPHY_ASSIGN; 3936 NETDEV_ASSIGN; 3937 if (ft_event->ies) 3938 memcpy(__get_dynamic_array(ies), ft_event->ies, 3939 ft_event->ies_len); 3940 MAC_ASSIGN(target_ap, ft_event->target_ap); 3941 if (ft_event->ric_ies) 3942 memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies, 3943 ft_event->ric_ies_len); 3944 ), 3945 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: %pM", 3946 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->target_ap) 3947 ); 3948 3949 TRACE_EVENT(cfg80211_stop_iface, 3950 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 3951 TP_ARGS(wiphy, wdev), 3952 TP_STRUCT__entry( 3953 WIPHY_ENTRY 3954 WDEV_ENTRY 3955 ), 3956 TP_fast_assign( 3957 WIPHY_ASSIGN; 3958 WDEV_ASSIGN; 3959 ), 3960 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 3961 WIPHY_PR_ARG, WDEV_PR_ARG) 3962 ); 3963 3964 TRACE_EVENT(cfg80211_pmsr_report, 3965 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 3966 u64 cookie, const u8 *addr), 3967 TP_ARGS(wiphy, wdev, cookie, addr), 3968 TP_STRUCT__entry( 3969 WIPHY_ENTRY 3970 WDEV_ENTRY 3971 __field(u64, cookie) 3972 MAC_ENTRY(addr) 3973 ), 3974 TP_fast_assign( 3975 WIPHY_ASSIGN; 3976 WDEV_ASSIGN; 3977 __entry->cookie = cookie; 3978 MAC_ASSIGN(addr, addr); 3979 ), 3980 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld, %pM", 3981 WIPHY_PR_ARG, WDEV_PR_ARG, 3982 (unsigned long long)__entry->cookie, 3983 __entry->addr) 3984 ); 3985 3986 TRACE_EVENT(cfg80211_pmsr_complete, 3987 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 3988 TP_ARGS(wiphy, wdev, cookie), 3989 TP_STRUCT__entry( 3990 WIPHY_ENTRY 3991 WDEV_ENTRY 3992 __field(u64, cookie) 3993 ), 3994 TP_fast_assign( 3995 WIPHY_ASSIGN; 3996 WDEV_ASSIGN; 3997 __entry->cookie = cookie; 3998 ), 3999 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld", 4000 WIPHY_PR_ARG, WDEV_PR_ARG, 4001 (unsigned long long)__entry->cookie) 4002 ); 4003 4004 TRACE_EVENT(cfg80211_update_owe_info_event, 4005 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4006 struct cfg80211_update_owe_info *owe_info), 4007 TP_ARGS(wiphy, netdev, owe_info), 4008 TP_STRUCT__entry( 4009 WIPHY_ENTRY 4010 NETDEV_ENTRY 4011 MAC_ENTRY(peer) 4012 __dynamic_array(u8, ie, owe_info->ie_len) 4013 __field(int, assoc_link_id) 4014 MAC_ENTRY(peer_mld_addr) 4015 ), 4016 TP_fast_assign( 4017 WIPHY_ASSIGN; 4018 NETDEV_ASSIGN; 4019 MAC_ASSIGN(peer, owe_info->peer); 4020 memcpy(__get_dynamic_array(ie), owe_info->ie, 4021 owe_info->ie_len); 4022 __entry->assoc_link_id = owe_info->assoc_link_id; 4023 MAC_ASSIGN(peer_mld_addr, owe_info->peer_mld_addr); 4024 ), 4025 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM," 4026 " assoc_link_id: %d, peer_mld_addr: %pM", 4027 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 4028 __entry->assoc_link_id, __entry->peer_mld_addr) 4029 ); 4030 4031 TRACE_EVENT(cfg80211_bss_color_notify, 4032 TP_PROTO(struct net_device *netdev, 4033 enum nl80211_commands cmd, 4034 u8 count, u64 color_bitmap), 4035 TP_ARGS(netdev, cmd, count, color_bitmap), 4036 TP_STRUCT__entry( 4037 NETDEV_ENTRY 4038 __field(u32, cmd) 4039 __field(u8, count) 4040 __field(u64, color_bitmap) 4041 ), 4042 TP_fast_assign( 4043 NETDEV_ASSIGN; 4044 __entry->cmd = cmd; 4045 __entry->count = count; 4046 __entry->color_bitmap = color_bitmap; 4047 ), 4048 TP_printk(NETDEV_PR_FMT ", cmd: %x, count: %u, bitmap: %llx", 4049 NETDEV_PR_ARG, __entry->cmd, __entry->count, 4050 __entry->color_bitmap) 4051 ); 4052 4053 TRACE_EVENT(cfg80211_assoc_comeback, 4054 TP_PROTO(struct wireless_dev *wdev, const u8 *ap_addr, u32 timeout), 4055 TP_ARGS(wdev, ap_addr, timeout), 4056 TP_STRUCT__entry( 4057 WDEV_ENTRY 4058 MAC_ENTRY(ap_addr) 4059 __field(u32, timeout) 4060 ), 4061 TP_fast_assign( 4062 WDEV_ASSIGN; 4063 MAC_ASSIGN(ap_addr, ap_addr); 4064 __entry->timeout = timeout; 4065 ), 4066 TP_printk(WDEV_PR_FMT ", %pM, timeout: %u TUs", 4067 WDEV_PR_ARG, __entry->ap_addr, __entry->timeout) 4068 ); 4069 4070 DECLARE_EVENT_CLASS(link_station_add_mod, 4071 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4072 struct link_station_parameters *params), 4073 TP_ARGS(wiphy, netdev, params), 4074 TP_STRUCT__entry( 4075 WIPHY_ENTRY 4076 NETDEV_ENTRY 4077 __array(u8, mld_mac, 6) 4078 __array(u8, link_mac, 6) 4079 __field(u32, link_id) 4080 __dynamic_array(u8, supported_rates, 4081 params->supported_rates_len) 4082 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap)) 4083 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap)) 4084 __field(u8, opmode_notif) 4085 __field(bool, opmode_notif_used) 4086 __dynamic_array(u8, he_capa, params->he_capa_len) 4087 __array(u8, he_6ghz_capa, (int)sizeof(struct ieee80211_he_6ghz_capa)) 4088 __dynamic_array(u8, eht_capa, params->eht_capa_len) 4089 ), 4090 TP_fast_assign( 4091 WIPHY_ASSIGN; 4092 NETDEV_ASSIGN; 4093 memset(__entry->mld_mac, 0, 6); 4094 memset(__entry->link_mac, 0, 6); 4095 if (params->mld_mac) 4096 memcpy(__entry->mld_mac, params->mld_mac, 6); 4097 if (params->link_mac) 4098 memcpy(__entry->link_mac, params->link_mac, 6); 4099 __entry->link_id = params->link_id; 4100 if (params->supported_rates && params->supported_rates_len) 4101 memcpy(__get_dynamic_array(supported_rates), 4102 params->supported_rates, 4103 params->supported_rates_len); 4104 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap)); 4105 if (params->ht_capa) 4106 memcpy(__entry->ht_capa, params->ht_capa, 4107 sizeof(struct ieee80211_ht_cap)); 4108 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap)); 4109 if (params->vht_capa) 4110 memcpy(__entry->vht_capa, params->vht_capa, 4111 sizeof(struct ieee80211_vht_cap)); 4112 __entry->opmode_notif = params->opmode_notif; 4113 __entry->opmode_notif_used = params->opmode_notif_used; 4114 if (params->he_capa && params->he_capa_len) 4115 memcpy(__get_dynamic_array(he_capa), params->he_capa, 4116 params->he_capa_len); 4117 memset(__entry->he_6ghz_capa, 0, sizeof(struct ieee80211_he_6ghz_capa)); 4118 if (params->he_6ghz_capa) 4119 memcpy(__entry->he_6ghz_capa, params->he_6ghz_capa, 4120 sizeof(struct ieee80211_he_6ghz_capa)); 4121 if (params->eht_capa && params->eht_capa_len) 4122 memcpy(__get_dynamic_array(eht_capa), params->eht_capa, 4123 params->eht_capa_len); 4124 ), 4125 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" 4126 ", link mac: %pM, link id: %u", 4127 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac, 4128 __entry->link_mac, __entry->link_id) 4129 ); 4130 4131 DEFINE_EVENT(link_station_add_mod, rdev_add_link_station, 4132 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4133 struct link_station_parameters *params), 4134 TP_ARGS(wiphy, netdev, params) 4135 ); 4136 4137 DEFINE_EVENT(link_station_add_mod, rdev_mod_link_station, 4138 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4139 struct link_station_parameters *params), 4140 TP_ARGS(wiphy, netdev, params) 4141 ); 4142 4143 TRACE_EVENT(cfg80211_links_removed, 4144 TP_PROTO(struct net_device *netdev, u16 link_mask), 4145 TP_ARGS(netdev, link_mask), 4146 TP_STRUCT__entry( 4147 NETDEV_ENTRY 4148 __field(u16, link_mask) 4149 ), 4150 TP_fast_assign( 4151 NETDEV_ASSIGN; 4152 __entry->link_mask = link_mask; 4153 ), 4154 TP_printk(NETDEV_PR_FMT ", link_mask:0x%x", NETDEV_PR_ARG, 4155 __entry->link_mask) 4156 ); 4157 4158 TRACE_EVENT(cfg80211_mlo_reconf_add_done, 4159 TP_PROTO(struct net_device *netdev, u16 link_mask, 4160 const u8 *buf, size_t len, bool driver_initiated), 4161 TP_ARGS(netdev, link_mask, buf, len, driver_initiated), 4162 TP_STRUCT__entry( 4163 NETDEV_ENTRY 4164 __field(u16, link_mask) 4165 __dynamic_array(u8, buf, len) 4166 __field(bool, driver_initiated) 4167 ), 4168 TP_fast_assign( 4169 NETDEV_ASSIGN; 4170 __entry->link_mask = link_mask; 4171 memcpy(__get_dynamic_array(buf), buf, len); 4172 __entry->driver_initiated = driver_initiated; 4173 ), 4174 TP_printk(NETDEV_PR_FMT ", link_mask:0x%x, driver_initiated:%d", 4175 NETDEV_PR_ARG, __entry->link_mask, __entry->driver_initiated) 4176 ); 4177 4178 TRACE_EVENT(rdev_assoc_ml_reconf, 4179 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4180 struct cfg80211_ml_reconf_req *req), 4181 TP_ARGS(wiphy, netdev, req), 4182 TP_STRUCT__entry( 4183 WIPHY_ENTRY 4184 NETDEV_ENTRY 4185 __field(u16, add_links) 4186 __field(u16, rem_links) 4187 __field(u16, ext_mld_capa_ops) 4188 ), 4189 TP_fast_assign( 4190 WIPHY_ASSIGN; 4191 NETDEV_ASSIGN; 4192 u32 i; 4193 4194 __entry->add_links = 0; 4195 __entry->rem_links = req->rem_links; 4196 for (i = 0; i < IEEE80211_MLD_MAX_NUM_LINKS; i++) 4197 if (req->add_links[i].bss) 4198 __entry->add_links |= BIT(i); 4199 __entry->ext_mld_capa_ops = req->ext_mld_capa_ops; 4200 ), 4201 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", add_links=0x%x, rem_links=0x%x", 4202 WIPHY_PR_ARG, NETDEV_PR_ARG, 4203 __entry->add_links, __entry->rem_links) 4204 ); 4205 4206 TRACE_EVENT(cfg80211_epcs_changed, 4207 TP_PROTO(struct wireless_dev *wdev, bool enabled), 4208 TP_ARGS(wdev, enabled), 4209 TP_STRUCT__entry( 4210 WDEV_ENTRY 4211 __field(u32, enabled) 4212 ), 4213 TP_fast_assign( 4214 WDEV_ASSIGN; 4215 __entry->enabled = enabled; 4216 ), 4217 TP_printk(WDEV_PR_FMT ", enabled=%u", 4218 WDEV_PR_ARG, __entry->enabled) 4219 ); 4220 4221 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */ 4222 4223 #undef TRACE_INCLUDE_PATH 4224 #define TRACE_INCLUDE_PATH . 4225 #undef TRACE_INCLUDE_FILE 4226 #define TRACE_INCLUDE_FILE trace 4227 #include <trace/define_trace.h> 4228