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