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