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