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