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, 1322 struct cfg80211_chan_def *chandef), 1323 TP_ARGS(wiphy, chandef), 1324 TP_STRUCT__entry( 1325 WIPHY_ENTRY 1326 CHAN_DEF_ENTRY 1327 ), 1328 TP_fast_assign( 1329 WIPHY_ASSIGN; 1330 CHAN_DEF_ASSIGN(chandef); 1331 ), 1332 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 1333 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 1334 ); 1335 1336 TRACE_EVENT(rdev_auth, 1337 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1338 struct cfg80211_auth_request *req), 1339 TP_ARGS(wiphy, netdev, req), 1340 TP_STRUCT__entry( 1341 WIPHY_ENTRY 1342 NETDEV_ENTRY 1343 MAC_ENTRY(bssid) 1344 __field(enum nl80211_auth_type, auth_type) 1345 ), 1346 TP_fast_assign( 1347 WIPHY_ASSIGN; 1348 NETDEV_ASSIGN; 1349 if (req->bss) 1350 MAC_ASSIGN(bssid, req->bss->bssid); 1351 else 1352 eth_zero_addr(__entry->bssid); 1353 __entry->auth_type = req->auth_type; 1354 ), 1355 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: %pM", 1356 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type, 1357 __entry->bssid) 1358 ); 1359 1360 TRACE_EVENT(rdev_assoc, 1361 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1362 struct cfg80211_assoc_request *req), 1363 TP_ARGS(wiphy, netdev, req), 1364 TP_STRUCT__entry( 1365 WIPHY_ENTRY 1366 NETDEV_ENTRY 1367 MAC_ENTRY(bssid) 1368 MAC_ENTRY(prev_bssid) 1369 __field(bool, use_mfp) 1370 __field(u32, flags) 1371 __dynamic_array(u8, elements, req->ie_len) 1372 __array(u8, ht_capa, sizeof(struct ieee80211_ht_cap)) 1373 __array(u8, ht_capa_mask, sizeof(struct ieee80211_ht_cap)) 1374 __array(u8, vht_capa, sizeof(struct ieee80211_vht_cap)) 1375 __array(u8, vht_capa_mask, sizeof(struct ieee80211_vht_cap)) 1376 __dynamic_array(u8, fils_kek, req->fils_kek_len) 1377 __dynamic_array(u8, fils_nonces, 1378 req->fils_nonces ? 2 * FILS_NONCE_LEN : 0) 1379 ), 1380 TP_fast_assign( 1381 WIPHY_ASSIGN; 1382 NETDEV_ASSIGN; 1383 if (req->bss) 1384 MAC_ASSIGN(bssid, req->bss->bssid); 1385 else 1386 eth_zero_addr(__entry->bssid); 1387 MAC_ASSIGN(prev_bssid, req->prev_bssid); 1388 __entry->use_mfp = req->use_mfp; 1389 __entry->flags = req->flags; 1390 if (req->ie) 1391 memcpy(__get_dynamic_array(elements), 1392 req->ie, req->ie_len); 1393 memcpy(__entry->ht_capa, &req->ht_capa, sizeof(req->ht_capa)); 1394 memcpy(__entry->ht_capa_mask, &req->ht_capa_mask, 1395 sizeof(req->ht_capa_mask)); 1396 memcpy(__entry->vht_capa, &req->vht_capa, sizeof(req->vht_capa)); 1397 memcpy(__entry->vht_capa_mask, &req->vht_capa_mask, 1398 sizeof(req->vht_capa_mask)); 1399 if (req->fils_kek) 1400 memcpy(__get_dynamic_array(fils_kek), 1401 req->fils_kek, req->fils_kek_len); 1402 if (req->fils_nonces) 1403 memcpy(__get_dynamic_array(fils_nonces), 1404 req->fils_nonces, 2 * FILS_NONCE_LEN); 1405 ), 1406 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 1407 ", previous bssid: %pM, use mfp: %s, flags: 0x%x", 1408 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 1409 __entry->prev_bssid, BOOL_TO_STR(__entry->use_mfp), 1410 __entry->flags) 1411 ); 1412 1413 TRACE_EVENT(rdev_deauth, 1414 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1415 struct cfg80211_deauth_request *req), 1416 TP_ARGS(wiphy, netdev, req), 1417 TP_STRUCT__entry( 1418 WIPHY_ENTRY 1419 NETDEV_ENTRY 1420 MAC_ENTRY(bssid) 1421 __field(u16, reason_code) 1422 __field(bool, local_state_change) 1423 ), 1424 TP_fast_assign( 1425 WIPHY_ASSIGN; 1426 NETDEV_ASSIGN; 1427 MAC_ASSIGN(bssid, req->bssid); 1428 __entry->reason_code = req->reason_code; 1429 __entry->local_state_change = req->local_state_change; 1430 ), 1431 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, reason: %u, local_state_change:%d", 1432 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 1433 __entry->reason_code, __entry->local_state_change) 1434 ); 1435 1436 TRACE_EVENT(rdev_disassoc, 1437 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1438 struct cfg80211_disassoc_request *req), 1439 TP_ARGS(wiphy, netdev, req), 1440 TP_STRUCT__entry( 1441 WIPHY_ENTRY 1442 NETDEV_ENTRY 1443 MAC_ENTRY(bssid) 1444 __field(u16, reason_code) 1445 __field(bool, local_state_change) 1446 ), 1447 TP_fast_assign( 1448 WIPHY_ASSIGN; 1449 NETDEV_ASSIGN; 1450 MAC_ASSIGN(bssid, req->ap_addr); 1451 __entry->reason_code = req->reason_code; 1452 __entry->local_state_change = req->local_state_change; 1453 ), 1454 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 1455 ", reason: %u, local state change: %s", 1456 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 1457 __entry->reason_code, 1458 BOOL_TO_STR(__entry->local_state_change)) 1459 ); 1460 1461 TRACE_EVENT(rdev_mgmt_tx_cancel_wait, 1462 TP_PROTO(struct wiphy *wiphy, 1463 struct wireless_dev *wdev, u64 cookie), 1464 TP_ARGS(wiphy, wdev, cookie), 1465 TP_STRUCT__entry( 1466 WIPHY_ENTRY 1467 WDEV_ENTRY 1468 __field(u64, cookie) 1469 ), 1470 TP_fast_assign( 1471 WIPHY_ASSIGN; 1472 WDEV_ASSIGN; 1473 __entry->cookie = cookie; 1474 ), 1475 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ", 1476 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 1477 ); 1478 1479 TRACE_EVENT(rdev_set_power_mgmt, 1480 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1481 bool enabled, int timeout), 1482 TP_ARGS(wiphy, netdev, enabled, timeout), 1483 TP_STRUCT__entry( 1484 WIPHY_ENTRY 1485 NETDEV_ENTRY 1486 __field(bool, enabled) 1487 __field(int, timeout) 1488 ), 1489 TP_fast_assign( 1490 WIPHY_ASSIGN; 1491 NETDEV_ASSIGN; 1492 __entry->enabled = enabled; 1493 __entry->timeout = timeout; 1494 ), 1495 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ", 1496 WIPHY_PR_ARG, NETDEV_PR_ARG, 1497 __entry->enabled ? "" : "not ", __entry->timeout) 1498 ); 1499 1500 TRACE_EVENT(rdev_connect, 1501 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1502 struct cfg80211_connect_params *sme), 1503 TP_ARGS(wiphy, netdev, sme), 1504 TP_STRUCT__entry( 1505 WIPHY_ENTRY 1506 NETDEV_ENTRY 1507 MAC_ENTRY(bssid) 1508 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) 1509 __field(enum nl80211_auth_type, auth_type) 1510 __field(bool, privacy) 1511 __field(u32, wpa_versions) 1512 __field(u32, flags) 1513 MAC_ENTRY(prev_bssid) 1514 ), 1515 TP_fast_assign( 1516 WIPHY_ASSIGN; 1517 NETDEV_ASSIGN; 1518 MAC_ASSIGN(bssid, sme->bssid); 1519 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 1520 memcpy(__entry->ssid, sme->ssid, sme->ssid_len); 1521 __entry->auth_type = sme->auth_type; 1522 __entry->privacy = sme->privacy; 1523 __entry->wpa_versions = sme->crypto.wpa_versions; 1524 __entry->flags = sme->flags; 1525 MAC_ASSIGN(prev_bssid, sme->prev_bssid); 1526 ), 1527 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 1528 ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, " 1529 "flags: 0x%x, previous bssid: %pM", 1530 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid, 1531 __entry->auth_type, BOOL_TO_STR(__entry->privacy), 1532 __entry->wpa_versions, __entry->flags, __entry->prev_bssid) 1533 ); 1534 1535 TRACE_EVENT(rdev_update_connect_params, 1536 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1537 struct cfg80211_connect_params *sme, u32 changed), 1538 TP_ARGS(wiphy, netdev, sme, changed), 1539 TP_STRUCT__entry( 1540 WIPHY_ENTRY 1541 NETDEV_ENTRY 1542 __field(u32, changed) 1543 ), 1544 TP_fast_assign( 1545 WIPHY_ASSIGN; 1546 NETDEV_ASSIGN; 1547 __entry->changed = changed; 1548 ), 1549 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", parameters changed: %u", 1550 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->changed) 1551 ); 1552 1553 TRACE_EVENT(rdev_set_cqm_rssi_config, 1554 TP_PROTO(struct wiphy *wiphy, 1555 struct net_device *netdev, s32 rssi_thold, 1556 u32 rssi_hyst), 1557 TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst), 1558 TP_STRUCT__entry( 1559 WIPHY_ENTRY 1560 NETDEV_ENTRY 1561 __field(s32, rssi_thold) 1562 __field(u32, rssi_hyst) 1563 ), 1564 TP_fast_assign( 1565 WIPHY_ASSIGN; 1566 NETDEV_ASSIGN; 1567 __entry->rssi_thold = rssi_thold; 1568 __entry->rssi_hyst = rssi_hyst; 1569 ), 1570 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT 1571 ", rssi_thold: %d, rssi_hyst: %u ", 1572 WIPHY_PR_ARG, NETDEV_PR_ARG, 1573 __entry->rssi_thold, __entry->rssi_hyst) 1574 ); 1575 1576 TRACE_EVENT(rdev_set_cqm_rssi_range_config, 1577 TP_PROTO(struct wiphy *wiphy, 1578 struct net_device *netdev, s32 low, s32 high), 1579 TP_ARGS(wiphy, netdev, low, high), 1580 TP_STRUCT__entry( 1581 WIPHY_ENTRY 1582 NETDEV_ENTRY 1583 __field(s32, rssi_low) 1584 __field(s32, rssi_high) 1585 ), 1586 TP_fast_assign( 1587 WIPHY_ASSIGN; 1588 NETDEV_ASSIGN; 1589 __entry->rssi_low = low; 1590 __entry->rssi_high = high; 1591 ), 1592 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT 1593 ", range: %d - %d ", 1594 WIPHY_PR_ARG, NETDEV_PR_ARG, 1595 __entry->rssi_low, __entry->rssi_high) 1596 ); 1597 1598 TRACE_EVENT(rdev_set_cqm_txe_config, 1599 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, 1600 u32 pkts, u32 intvl), 1601 TP_ARGS(wiphy, netdev, rate, pkts, intvl), 1602 TP_STRUCT__entry( 1603 WIPHY_ENTRY 1604 NETDEV_ENTRY 1605 __field(u32, rate) 1606 __field(u32, pkts) 1607 __field(u32, intvl) 1608 ), 1609 TP_fast_assign( 1610 WIPHY_ASSIGN; 1611 NETDEV_ASSIGN; 1612 __entry->rate = rate; 1613 __entry->pkts = pkts; 1614 __entry->intvl = intvl; 1615 ), 1616 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u", 1617 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts, 1618 __entry->intvl) 1619 ); 1620 1621 TRACE_EVENT(rdev_disconnect, 1622 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1623 u16 reason_code), 1624 TP_ARGS(wiphy, netdev, reason_code), 1625 TP_STRUCT__entry( 1626 WIPHY_ENTRY 1627 NETDEV_ENTRY 1628 __field(u16, reason_code) 1629 ), 1630 TP_fast_assign( 1631 WIPHY_ASSIGN; 1632 NETDEV_ASSIGN; 1633 __entry->reason_code = reason_code; 1634 ), 1635 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG, 1636 NETDEV_PR_ARG, __entry->reason_code) 1637 ); 1638 1639 TRACE_EVENT(rdev_join_ibss, 1640 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1641 struct cfg80211_ibss_params *params), 1642 TP_ARGS(wiphy, netdev, params), 1643 TP_STRUCT__entry( 1644 WIPHY_ENTRY 1645 NETDEV_ENTRY 1646 MAC_ENTRY(bssid) 1647 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) 1648 ), 1649 TP_fast_assign( 1650 WIPHY_ASSIGN; 1651 NETDEV_ASSIGN; 1652 MAC_ASSIGN(bssid, params->bssid); 1653 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 1654 memcpy(__entry->ssid, params->ssid, params->ssid_len); 1655 ), 1656 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, ssid: %s", 1657 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid) 1658 ); 1659 1660 TRACE_EVENT(rdev_join_ocb, 1661 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1662 const struct ocb_setup *setup), 1663 TP_ARGS(wiphy, netdev, setup), 1664 TP_STRUCT__entry( 1665 WIPHY_ENTRY 1666 NETDEV_ENTRY 1667 ), 1668 TP_fast_assign( 1669 WIPHY_ASSIGN; 1670 NETDEV_ASSIGN; 1671 ), 1672 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, 1673 WIPHY_PR_ARG, NETDEV_PR_ARG) 1674 ); 1675 1676 TRACE_EVENT(rdev_set_wiphy_params, 1677 TP_PROTO(struct wiphy *wiphy, u32 changed), 1678 TP_ARGS(wiphy, changed), 1679 TP_STRUCT__entry( 1680 WIPHY_ENTRY 1681 __field(u32, changed) 1682 ), 1683 TP_fast_assign( 1684 WIPHY_ASSIGN; 1685 __entry->changed = changed; 1686 ), 1687 TP_printk(WIPHY_PR_FMT ", changed: %u", 1688 WIPHY_PR_ARG, __entry->changed) 1689 ); 1690 1691 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, 1692 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1693 TP_ARGS(wiphy, wdev) 1694 ); 1695 1696 TRACE_EVENT(rdev_set_tx_power, 1697 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1698 enum nl80211_tx_power_setting type, int mbm), 1699 TP_ARGS(wiphy, wdev, type, mbm), 1700 TP_STRUCT__entry( 1701 WIPHY_ENTRY 1702 WDEV_ENTRY 1703 __field(enum nl80211_tx_power_setting, type) 1704 __field(int, mbm) 1705 ), 1706 TP_fast_assign( 1707 WIPHY_ASSIGN; 1708 WDEV_ASSIGN; 1709 __entry->type = type; 1710 __entry->mbm = mbm; 1711 ), 1712 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type: %u, mbm: %d", 1713 WIPHY_PR_ARG, WDEV_PR_ARG,__entry->type, __entry->mbm) 1714 ); 1715 1716 TRACE_EVENT(rdev_return_int_int, 1717 TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), 1718 TP_ARGS(wiphy, func_ret, func_fill), 1719 TP_STRUCT__entry( 1720 WIPHY_ENTRY 1721 __field(int, func_ret) 1722 __field(int, func_fill) 1723 ), 1724 TP_fast_assign( 1725 WIPHY_ASSIGN; 1726 __entry->func_ret = func_ret; 1727 __entry->func_fill = func_fill; 1728 ), 1729 TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d", 1730 WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill) 1731 ); 1732 1733 #ifdef CONFIG_NL80211_TESTMODE 1734 TRACE_EVENT(rdev_testmode_cmd, 1735 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1736 TP_ARGS(wiphy, wdev), 1737 TP_STRUCT__entry( 1738 WIPHY_ENTRY 1739 WDEV_ENTRY 1740 ), 1741 TP_fast_assign( 1742 WIPHY_ASSIGN; 1743 WDEV_ASSIGN; 1744 ), 1745 TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 1746 ); 1747 1748 TRACE_EVENT(rdev_testmode_dump, 1749 TP_PROTO(struct wiphy *wiphy), 1750 TP_ARGS(wiphy), 1751 TP_STRUCT__entry( 1752 WIPHY_ENTRY 1753 ), 1754 TP_fast_assign( 1755 WIPHY_ASSIGN; 1756 ), 1757 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) 1758 ); 1759 #endif /* CONFIG_NL80211_TESTMODE */ 1760 1761 TRACE_EVENT(rdev_set_bitrate_mask, 1762 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1763 unsigned int link_id, 1764 const u8 *peer, const struct cfg80211_bitrate_mask *mask), 1765 TP_ARGS(wiphy, netdev, link_id, peer, mask), 1766 TP_STRUCT__entry( 1767 WIPHY_ENTRY 1768 NETDEV_ENTRY 1769 __field(unsigned int, link_id) 1770 MAC_ENTRY(peer) 1771 ), 1772 TP_fast_assign( 1773 WIPHY_ASSIGN; 1774 NETDEV_ASSIGN; 1775 __entry->link_id = link_id; 1776 MAC_ASSIGN(peer, peer); 1777 ), 1778 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, peer: %pM", 1779 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, 1780 __entry->peer) 1781 ); 1782 1783 TRACE_EVENT(rdev_update_mgmt_frame_registrations, 1784 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1785 struct mgmt_frame_regs *upd), 1786 TP_ARGS(wiphy, wdev, upd), 1787 TP_STRUCT__entry( 1788 WIPHY_ENTRY 1789 WDEV_ENTRY 1790 __field(u16, global_stypes) 1791 __field(u16, interface_stypes) 1792 ), 1793 TP_fast_assign( 1794 WIPHY_ASSIGN; 1795 WDEV_ASSIGN; 1796 __entry->global_stypes = upd->global_stypes; 1797 __entry->interface_stypes = upd->interface_stypes; 1798 ), 1799 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", global: 0x%.2x, intf: 0x%.2x", 1800 WIPHY_PR_ARG, WDEV_PR_ARG, 1801 __entry->global_stypes, __entry->interface_stypes) 1802 ); 1803 1804 TRACE_EVENT(rdev_return_int_tx_rx, 1805 TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), 1806 TP_ARGS(wiphy, ret, tx, rx), 1807 TP_STRUCT__entry( 1808 WIPHY_ENTRY 1809 __field(int, ret) 1810 __field(u32, tx) 1811 __field(u32, rx) 1812 ), 1813 TP_fast_assign( 1814 WIPHY_ASSIGN; 1815 __entry->ret = ret; 1816 __entry->tx = tx; 1817 __entry->rx = rx; 1818 ), 1819 TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u", 1820 WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx) 1821 ); 1822 1823 TRACE_EVENT(rdev_return_void_tx_rx, 1824 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, 1825 u32 rx, u32 rx_max), 1826 TP_ARGS(wiphy, tx, tx_max, rx, rx_max), 1827 TP_STRUCT__entry( 1828 WIPHY_ENTRY 1829 __field(u32, tx) 1830 __field(u32, tx_max) 1831 __field(u32, rx) 1832 __field(u32, rx_max) 1833 ), 1834 TP_fast_assign( 1835 WIPHY_ASSIGN; 1836 __entry->tx = tx; 1837 __entry->tx_max = tx_max; 1838 __entry->rx = rx; 1839 __entry->rx_max = rx_max; 1840 ), 1841 TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ", 1842 WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx, 1843 __entry->rx_max) 1844 ); 1845 1846 DECLARE_EVENT_CLASS(tx_rx_evt, 1847 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), 1848 TP_ARGS(wiphy, tx, rx), 1849 TP_STRUCT__entry( 1850 WIPHY_ENTRY 1851 __field(u32, tx) 1852 __field(u32, rx) 1853 ), 1854 TP_fast_assign( 1855 WIPHY_ASSIGN; 1856 __entry->tx = tx; 1857 __entry->rx = rx; 1858 ), 1859 TP_printk(WIPHY_PR_FMT ", tx: %u, rx: %u ", 1860 WIPHY_PR_ARG, __entry->tx, __entry->rx) 1861 ); 1862 1863 DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, 1864 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), 1865 TP_ARGS(wiphy, tx, rx) 1866 ); 1867 1868 DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, 1869 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), 1870 TP_ARGS(wiphy, netdev, id), 1871 TP_STRUCT__entry( 1872 WIPHY_ENTRY 1873 NETDEV_ENTRY 1874 __field(u64, id) 1875 ), 1876 TP_fast_assign( 1877 WIPHY_ASSIGN; 1878 NETDEV_ASSIGN; 1879 __entry->id = id; 1880 ), 1881 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", id: %llu", 1882 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->id) 1883 ); 1884 1885 DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, 1886 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), 1887 TP_ARGS(wiphy, netdev, id) 1888 ); 1889 1890 DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, 1891 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), 1892 TP_ARGS(wiphy, netdev, id) 1893 ); 1894 1895 TRACE_EVENT(rdev_tdls_mgmt, 1896 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1897 u8 *peer, int link_id, u8 action_code, u8 dialog_token, 1898 u16 status_code, u32 peer_capability, 1899 bool initiator, const u8 *buf, size_t len), 1900 TP_ARGS(wiphy, netdev, peer, link_id, action_code, dialog_token, 1901 status_code, peer_capability, initiator, buf, len), 1902 TP_STRUCT__entry( 1903 WIPHY_ENTRY 1904 NETDEV_ENTRY 1905 MAC_ENTRY(peer) 1906 __field(int, link_id) 1907 __field(u8, action_code) 1908 __field(u8, dialog_token) 1909 __field(u16, status_code) 1910 __field(u32, peer_capability) 1911 __field(bool, initiator) 1912 __dynamic_array(u8, buf, len) 1913 ), 1914 TP_fast_assign( 1915 WIPHY_ASSIGN; 1916 NETDEV_ASSIGN; 1917 MAC_ASSIGN(peer, peer); 1918 __entry->link_id = link_id; 1919 __entry->action_code = action_code; 1920 __entry->dialog_token = dialog_token; 1921 __entry->status_code = status_code; 1922 __entry->peer_capability = peer_capability; 1923 __entry->initiator = initiator; 1924 memcpy(__get_dynamic_array(buf), buf, len); 1925 ), 1926 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" 1927 ", link_id: %d, action_code: %u " 1928 "dialog_token: %u, status_code: %u, peer_capability: %u " 1929 "initiator: %s buf: %#.2x ", 1930 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 1931 __entry->link_id, __entry->action_code, __entry->dialog_token, 1932 __entry->status_code, __entry->peer_capability, 1933 BOOL_TO_STR(__entry->initiator), 1934 ((u8 *)__get_dynamic_array(buf))[0]) 1935 ); 1936 1937 TRACE_EVENT(rdev_dump_survey, 1938 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx), 1939 TP_ARGS(wiphy, netdev, _idx), 1940 TP_STRUCT__entry( 1941 WIPHY_ENTRY 1942 NETDEV_ENTRY 1943 __field(int, idx) 1944 ), 1945 TP_fast_assign( 1946 WIPHY_ASSIGN; 1947 NETDEV_ASSIGN; 1948 __entry->idx = _idx; 1949 ), 1950 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d", 1951 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx) 1952 ); 1953 1954 TRACE_EVENT(rdev_return_int_survey_info, 1955 TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), 1956 TP_ARGS(wiphy, ret, info), 1957 TP_STRUCT__entry( 1958 WIPHY_ENTRY 1959 CHAN_ENTRY 1960 __field(int, ret) 1961 __field(u64, time) 1962 __field(u64, time_busy) 1963 __field(u64, time_ext_busy) 1964 __field(u64, time_rx) 1965 __field(u64, time_tx) 1966 __field(u64, time_scan) 1967 __field(u32, filled) 1968 __field(s8, noise) 1969 ), 1970 TP_fast_assign( 1971 WIPHY_ASSIGN; 1972 CHAN_ASSIGN(info->channel); 1973 __entry->ret = ret; 1974 __entry->time = info->time; 1975 __entry->time_busy = info->time_busy; 1976 __entry->time_ext_busy = info->time_ext_busy; 1977 __entry->time_rx = info->time_rx; 1978 __entry->time_tx = info->time_tx; 1979 __entry->time_scan = info->time_scan; 1980 __entry->filled = info->filled; 1981 __entry->noise = info->noise; 1982 ), 1983 TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT 1984 ", channel time: %llu, channel time busy: %llu, " 1985 "channel time extension busy: %llu, channel time rx: %llu, " 1986 "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d", 1987 WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG, 1988 __entry->time, __entry->time_busy, 1989 __entry->time_ext_busy, __entry->time_rx, 1990 __entry->time_tx, __entry->time_scan, 1991 __entry->filled, __entry->noise) 1992 ); 1993 1994 TRACE_EVENT(rdev_tdls_oper, 1995 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1996 u8 *peer, enum nl80211_tdls_operation oper), 1997 TP_ARGS(wiphy, netdev, peer, oper), 1998 TP_STRUCT__entry( 1999 WIPHY_ENTRY 2000 NETDEV_ENTRY 2001 MAC_ENTRY(peer) 2002 __field(enum nl80211_tdls_operation, oper) 2003 ), 2004 TP_fast_assign( 2005 WIPHY_ASSIGN; 2006 NETDEV_ASSIGN; 2007 MAC_ASSIGN(peer, peer); 2008 __entry->oper = oper; 2009 ), 2010 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, oper: %d", 2011 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper) 2012 ); 2013 2014 DECLARE_EVENT_CLASS(rdev_pmksa, 2015 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2016 struct cfg80211_pmksa *pmksa), 2017 TP_ARGS(wiphy, netdev, pmksa), 2018 TP_STRUCT__entry( 2019 WIPHY_ENTRY 2020 NETDEV_ENTRY 2021 MAC_ENTRY(bssid) 2022 ), 2023 TP_fast_assign( 2024 WIPHY_ASSIGN; 2025 NETDEV_ASSIGN; 2026 MAC_ASSIGN(bssid, pmksa->bssid); 2027 ), 2028 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM", 2029 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid) 2030 ); 2031 2032 TRACE_EVENT(rdev_probe_client, 2033 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2034 const u8 *peer), 2035 TP_ARGS(wiphy, netdev, peer), 2036 TP_STRUCT__entry( 2037 WIPHY_ENTRY 2038 NETDEV_ENTRY 2039 MAC_ENTRY(peer) 2040 ), 2041 TP_fast_assign( 2042 WIPHY_ASSIGN; 2043 NETDEV_ASSIGN; 2044 MAC_ASSIGN(peer, peer); 2045 ), 2046 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2047 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer) 2048 ); 2049 2050 DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, 2051 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2052 struct cfg80211_pmksa *pmksa), 2053 TP_ARGS(wiphy, netdev, pmksa) 2054 ); 2055 2056 DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, 2057 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2058 struct cfg80211_pmksa *pmksa), 2059 TP_ARGS(wiphy, netdev, pmksa) 2060 ); 2061 2062 TRACE_EVENT(rdev_remain_on_channel, 2063 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2064 struct ieee80211_channel *chan, 2065 unsigned int duration), 2066 TP_ARGS(wiphy, wdev, chan, duration), 2067 TP_STRUCT__entry( 2068 WIPHY_ENTRY 2069 WDEV_ENTRY 2070 CHAN_ENTRY 2071 __field(unsigned int, duration) 2072 ), 2073 TP_fast_assign( 2074 WIPHY_ASSIGN; 2075 WDEV_ASSIGN; 2076 CHAN_ASSIGN(chan); 2077 __entry->duration = duration; 2078 ), 2079 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u", 2080 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration) 2081 ); 2082 2083 TRACE_EVENT(rdev_return_int_cookie, 2084 TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), 2085 TP_ARGS(wiphy, ret, cookie), 2086 TP_STRUCT__entry( 2087 WIPHY_ENTRY 2088 __field(int, ret) 2089 __field(u64, cookie) 2090 ), 2091 TP_fast_assign( 2092 WIPHY_ASSIGN; 2093 __entry->ret = ret; 2094 __entry->cookie = cookie; 2095 ), 2096 TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu", 2097 WIPHY_PR_ARG, __entry->ret, __entry->cookie) 2098 ); 2099 2100 TRACE_EVENT(rdev_cancel_remain_on_channel, 2101 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 2102 TP_ARGS(wiphy, wdev, cookie), 2103 TP_STRUCT__entry( 2104 WIPHY_ENTRY 2105 WDEV_ENTRY 2106 __field(u64, cookie) 2107 ), 2108 TP_fast_assign( 2109 WIPHY_ASSIGN; 2110 WDEV_ASSIGN; 2111 __entry->cookie = cookie; 2112 ), 2113 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu", 2114 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 2115 ); 2116 2117 TRACE_EVENT(rdev_mgmt_tx, 2118 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2119 struct cfg80211_mgmt_tx_params *params), 2120 TP_ARGS(wiphy, wdev, params), 2121 TP_STRUCT__entry( 2122 WIPHY_ENTRY 2123 WDEV_ENTRY 2124 CHAN_ENTRY 2125 __field(bool, offchan) 2126 __field(unsigned int, wait) 2127 __field(bool, no_cck) 2128 __field(bool, dont_wait_for_ack) 2129 ), 2130 TP_fast_assign( 2131 WIPHY_ASSIGN; 2132 WDEV_ASSIGN; 2133 CHAN_ASSIGN(params->chan); 2134 __entry->offchan = params->offchan; 2135 __entry->wait = params->wait; 2136 __entry->no_cck = params->no_cck; 2137 __entry->dont_wait_for_ack = params->dont_wait_for_ack; 2138 ), 2139 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s," 2140 " wait: %u, no cck: %s, dont wait for ack: %s", 2141 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, 2142 BOOL_TO_STR(__entry->offchan), __entry->wait, 2143 BOOL_TO_STR(__entry->no_cck), 2144 BOOL_TO_STR(__entry->dont_wait_for_ack)) 2145 ); 2146 2147 TRACE_EVENT(rdev_tx_control_port, 2148 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2149 const u8 *buf, size_t len, const u8 *dest, __be16 proto, 2150 bool unencrypted, int link_id), 2151 TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted, link_id), 2152 TP_STRUCT__entry( 2153 WIPHY_ENTRY 2154 NETDEV_ENTRY 2155 MAC_ENTRY(dest) 2156 __field(__be16, proto) 2157 __field(bool, unencrypted) 2158 __field(int, link_id) 2159 ), 2160 TP_fast_assign( 2161 WIPHY_ASSIGN; 2162 NETDEV_ASSIGN; 2163 MAC_ASSIGN(dest, dest); 2164 __entry->proto = proto; 2165 __entry->unencrypted = unencrypted; 2166 __entry->link_id = link_id; 2167 ), 2168 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM," 2169 " proto: 0x%x, unencrypted: %s, link: %d", 2170 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest, 2171 be16_to_cpu(__entry->proto), 2172 BOOL_TO_STR(__entry->unencrypted), 2173 __entry->link_id) 2174 ); 2175 2176 TRACE_EVENT(rdev_set_noack_map, 2177 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2178 u16 noack_map), 2179 TP_ARGS(wiphy, netdev, noack_map), 2180 TP_STRUCT__entry( 2181 WIPHY_ENTRY 2182 NETDEV_ENTRY 2183 __field(u16, noack_map) 2184 ), 2185 TP_fast_assign( 2186 WIPHY_ASSIGN; 2187 NETDEV_ASSIGN; 2188 __entry->noack_map = noack_map; 2189 ), 2190 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u", 2191 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map) 2192 ); 2193 2194 DECLARE_EVENT_CLASS(wiphy_wdev_link_evt, 2195 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2196 unsigned int link_id), 2197 TP_ARGS(wiphy, wdev, link_id), 2198 TP_STRUCT__entry( 2199 WIPHY_ENTRY 2200 WDEV_ENTRY 2201 __field(unsigned int, link_id) 2202 ), 2203 TP_fast_assign( 2204 WIPHY_ASSIGN; 2205 WDEV_ASSIGN; 2206 __entry->link_id = link_id; 2207 ), 2208 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", link_id: %u", 2209 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->link_id) 2210 ); 2211 2212 DEFINE_EVENT(wiphy_wdev_link_evt, rdev_get_channel, 2213 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2214 unsigned int link_id), 2215 TP_ARGS(wiphy, wdev, link_id) 2216 ); 2217 2218 TRACE_EVENT(rdev_return_chandef, 2219 TP_PROTO(struct wiphy *wiphy, int ret, 2220 struct cfg80211_chan_def *chandef), 2221 TP_ARGS(wiphy, ret, chandef), 2222 TP_STRUCT__entry( 2223 WIPHY_ENTRY 2224 __field(int, ret) 2225 CHAN_DEF_ENTRY 2226 ), 2227 TP_fast_assign( 2228 WIPHY_ASSIGN; 2229 if (ret == 0) 2230 CHAN_DEF_ASSIGN(chandef); 2231 else 2232 CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL); 2233 __entry->ret = ret; 2234 ), 2235 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d", 2236 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret) 2237 ); 2238 2239 DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, 2240 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2241 TP_ARGS(wiphy, wdev) 2242 ); 2243 2244 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, 2245 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2246 TP_ARGS(wiphy, wdev) 2247 ); 2248 2249 TRACE_EVENT(rdev_start_nan, 2250 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2251 struct cfg80211_nan_conf *conf), 2252 TP_ARGS(wiphy, wdev, conf), 2253 TP_STRUCT__entry( 2254 WIPHY_ENTRY 2255 WDEV_ENTRY 2256 __field(u8, master_pref) 2257 __field(u8, bands) 2258 ), 2259 TP_fast_assign( 2260 WIPHY_ASSIGN; 2261 WDEV_ASSIGN; 2262 __entry->master_pref = conf->master_pref; 2263 __entry->bands = conf->bands; 2264 ), 2265 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 2266 ", master preference: %u, bands: 0x%0x", 2267 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 2268 __entry->bands) 2269 ); 2270 2271 TRACE_EVENT(rdev_nan_change_conf, 2272 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2273 struct cfg80211_nan_conf *conf, u32 changes), 2274 TP_ARGS(wiphy, wdev, conf, changes), 2275 TP_STRUCT__entry( 2276 WIPHY_ENTRY 2277 WDEV_ENTRY 2278 __field(u8, master_pref) 2279 __field(u8, bands) 2280 __field(u32, changes) 2281 ), 2282 TP_fast_assign( 2283 WIPHY_ASSIGN; 2284 WDEV_ASSIGN; 2285 __entry->master_pref = conf->master_pref; 2286 __entry->bands = conf->bands; 2287 __entry->changes = changes; 2288 ), 2289 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 2290 ", master preference: %u, bands: 0x%0x, changes: %x", 2291 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 2292 __entry->bands, __entry->changes) 2293 ); 2294 2295 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, 2296 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2297 TP_ARGS(wiphy, wdev) 2298 ); 2299 2300 TRACE_EVENT(rdev_add_nan_func, 2301 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2302 const struct cfg80211_nan_func *func), 2303 TP_ARGS(wiphy, wdev, func), 2304 TP_STRUCT__entry( 2305 WIPHY_ENTRY 2306 WDEV_ENTRY 2307 __field(u8, func_type) 2308 __field(u64, cookie) 2309 ), 2310 TP_fast_assign( 2311 WIPHY_ASSIGN; 2312 WDEV_ASSIGN; 2313 __entry->func_type = func->type; 2314 __entry->cookie = func->cookie 2315 ), 2316 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type=%u, cookie=%llu", 2317 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->func_type, 2318 __entry->cookie) 2319 ); 2320 2321 TRACE_EVENT(rdev_del_nan_func, 2322 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2323 u64 cookie), 2324 TP_ARGS(wiphy, wdev, cookie), 2325 TP_STRUCT__entry( 2326 WIPHY_ENTRY 2327 WDEV_ENTRY 2328 __field(u64, cookie) 2329 ), 2330 TP_fast_assign( 2331 WIPHY_ASSIGN; 2332 WDEV_ASSIGN; 2333 __entry->cookie = cookie; 2334 ), 2335 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie=%llu", 2336 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 2337 ); 2338 2339 TRACE_EVENT(rdev_set_mac_acl, 2340 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2341 struct cfg80211_acl_data *params), 2342 TP_ARGS(wiphy, netdev, params), 2343 TP_STRUCT__entry( 2344 WIPHY_ENTRY 2345 NETDEV_ENTRY 2346 __field(u32, acl_policy) 2347 ), 2348 TP_fast_assign( 2349 WIPHY_ASSIGN; 2350 NETDEV_ASSIGN; 2351 __entry->acl_policy = params->acl_policy; 2352 ), 2353 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d", 2354 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy) 2355 ); 2356 2357 TRACE_EVENT(rdev_update_ft_ies, 2358 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2359 struct cfg80211_update_ft_ies_params *ftie), 2360 TP_ARGS(wiphy, netdev, ftie), 2361 TP_STRUCT__entry( 2362 WIPHY_ENTRY 2363 NETDEV_ENTRY 2364 __field(u16, md) 2365 __dynamic_array(u8, ie, ftie->ie_len) 2366 ), 2367 TP_fast_assign( 2368 WIPHY_ASSIGN; 2369 NETDEV_ASSIGN; 2370 __entry->md = ftie->md; 2371 memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len); 2372 ), 2373 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x", 2374 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md) 2375 ); 2376 2377 TRACE_EVENT(rdev_crit_proto_start, 2378 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2379 enum nl80211_crit_proto_id protocol, u16 duration), 2380 TP_ARGS(wiphy, wdev, protocol, duration), 2381 TP_STRUCT__entry( 2382 WIPHY_ENTRY 2383 WDEV_ENTRY 2384 __field(u16, proto) 2385 __field(u16, duration) 2386 ), 2387 TP_fast_assign( 2388 WIPHY_ASSIGN; 2389 WDEV_ASSIGN; 2390 __entry->proto = protocol; 2391 __entry->duration = duration; 2392 ), 2393 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u", 2394 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration) 2395 ); 2396 2397 TRACE_EVENT(rdev_crit_proto_stop, 2398 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2399 TP_ARGS(wiphy, wdev), 2400 TP_STRUCT__entry( 2401 WIPHY_ENTRY 2402 WDEV_ENTRY 2403 ), 2404 TP_fast_assign( 2405 WIPHY_ASSIGN; 2406 WDEV_ASSIGN; 2407 ), 2408 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 2409 WIPHY_PR_ARG, WDEV_PR_ARG) 2410 ); 2411 2412 TRACE_EVENT(rdev_channel_switch, 2413 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2414 struct cfg80211_csa_settings *params), 2415 TP_ARGS(wiphy, netdev, params), 2416 TP_STRUCT__entry( 2417 WIPHY_ENTRY 2418 NETDEV_ENTRY 2419 CHAN_DEF_ENTRY 2420 __field(bool, radar_required) 2421 __field(bool, block_tx) 2422 __field(u8, count) 2423 __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon) 2424 __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp) 2425 __field(u8, link_id) 2426 ), 2427 TP_fast_assign( 2428 WIPHY_ASSIGN; 2429 NETDEV_ASSIGN; 2430 CHAN_DEF_ASSIGN(¶ms->chandef); 2431 __entry->radar_required = params->radar_required; 2432 __entry->block_tx = params->block_tx; 2433 __entry->count = params->count; 2434 memcpy(__get_dynamic_array(bcn_ofs), 2435 params->counter_offsets_beacon, 2436 params->n_counter_offsets_beacon * sizeof(u16)); 2437 2438 /* probe response offsets are optional */ 2439 if (params->n_counter_offsets_presp) 2440 memcpy(__get_dynamic_array(pres_ofs), 2441 params->counter_offsets_presp, 2442 params->n_counter_offsets_presp * sizeof(u16)); 2443 __entry->link_id = params->link_id; 2444 ), 2445 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 2446 ", block_tx: %d, count: %u, radar_required: %d, link_id: %d", 2447 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2448 __entry->block_tx, __entry->count, __entry->radar_required, 2449 __entry->link_id) 2450 ); 2451 2452 TRACE_EVENT(rdev_set_qos_map, 2453 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2454 struct cfg80211_qos_map *qos_map), 2455 TP_ARGS(wiphy, netdev, qos_map), 2456 TP_STRUCT__entry( 2457 WIPHY_ENTRY 2458 NETDEV_ENTRY 2459 QOS_MAP_ENTRY 2460 ), 2461 TP_fast_assign( 2462 WIPHY_ASSIGN; 2463 NETDEV_ASSIGN; 2464 QOS_MAP_ASSIGN(qos_map); 2465 ), 2466 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u", 2467 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des) 2468 ); 2469 2470 TRACE_EVENT(rdev_set_ap_chanwidth, 2471 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2472 unsigned int link_id, 2473 struct cfg80211_chan_def *chandef), 2474 TP_ARGS(wiphy, netdev, link_id, chandef), 2475 TP_STRUCT__entry( 2476 WIPHY_ENTRY 2477 NETDEV_ENTRY 2478 CHAN_DEF_ENTRY 2479 __field(unsigned int, link_id) 2480 ), 2481 TP_fast_assign( 2482 WIPHY_ASSIGN; 2483 NETDEV_ASSIGN; 2484 CHAN_DEF_ASSIGN(chandef); 2485 __entry->link_id = link_id; 2486 ), 2487 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d", 2488 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2489 __entry->link_id) 2490 ); 2491 2492 TRACE_EVENT(rdev_add_tx_ts, 2493 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2494 u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), 2495 TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time), 2496 TP_STRUCT__entry( 2497 WIPHY_ENTRY 2498 NETDEV_ENTRY 2499 MAC_ENTRY(peer) 2500 __field(u8, tsid) 2501 __field(u8, user_prio) 2502 __field(u16, admitted_time) 2503 ), 2504 TP_fast_assign( 2505 WIPHY_ASSIGN; 2506 NETDEV_ASSIGN; 2507 MAC_ASSIGN(peer, peer); 2508 __entry->tsid = tsid; 2509 __entry->user_prio = user_prio; 2510 __entry->admitted_time = admitted_time; 2511 ), 2512 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d, UP %d, time %d", 2513 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 2514 __entry->tsid, __entry->user_prio, __entry->admitted_time) 2515 ); 2516 2517 TRACE_EVENT(rdev_del_tx_ts, 2518 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2519 u8 tsid, const u8 *peer), 2520 TP_ARGS(wiphy, netdev, tsid, peer), 2521 TP_STRUCT__entry( 2522 WIPHY_ENTRY 2523 NETDEV_ENTRY 2524 MAC_ENTRY(peer) 2525 __field(u8, tsid) 2526 ), 2527 TP_fast_assign( 2528 WIPHY_ASSIGN; 2529 NETDEV_ASSIGN; 2530 MAC_ASSIGN(peer, peer); 2531 __entry->tsid = tsid; 2532 ), 2533 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d", 2534 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tsid) 2535 ); 2536 2537 TRACE_EVENT(rdev_tdls_channel_switch, 2538 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2539 const u8 *addr, u8 oper_class, 2540 struct cfg80211_chan_def *chandef), 2541 TP_ARGS(wiphy, netdev, addr, oper_class, chandef), 2542 TP_STRUCT__entry( 2543 WIPHY_ENTRY 2544 NETDEV_ENTRY 2545 MAC_ENTRY(addr) 2546 __field(u8, oper_class) 2547 CHAN_DEF_ENTRY 2548 ), 2549 TP_fast_assign( 2550 WIPHY_ASSIGN; 2551 NETDEV_ASSIGN; 2552 MAC_ASSIGN(addr, addr); 2553 CHAN_DEF_ASSIGN(chandef); 2554 ), 2555 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" 2556 " oper class %d, " CHAN_DEF_PR_FMT, 2557 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr, 2558 __entry->oper_class, CHAN_DEF_PR_ARG) 2559 ); 2560 2561 TRACE_EVENT(rdev_tdls_cancel_channel_switch, 2562 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2563 const u8 *addr), 2564 TP_ARGS(wiphy, netdev, addr), 2565 TP_STRUCT__entry( 2566 WIPHY_ENTRY 2567 NETDEV_ENTRY 2568 MAC_ENTRY(addr) 2569 ), 2570 TP_fast_assign( 2571 WIPHY_ASSIGN; 2572 NETDEV_ASSIGN; 2573 MAC_ASSIGN(addr, addr); 2574 ), 2575 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2576 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr) 2577 ); 2578 2579 TRACE_EVENT(rdev_set_pmk, 2580 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2581 struct cfg80211_pmk_conf *pmk_conf), 2582 2583 TP_ARGS(wiphy, netdev, pmk_conf), 2584 2585 TP_STRUCT__entry( 2586 WIPHY_ENTRY 2587 NETDEV_ENTRY 2588 MAC_ENTRY(aa) 2589 __field(u8, pmk_len) 2590 __field(u8, pmk_r0_name_len) 2591 __dynamic_array(u8, pmk, pmk_conf->pmk_len) 2592 __dynamic_array(u8, pmk_r0_name, WLAN_PMK_NAME_LEN) 2593 ), 2594 2595 TP_fast_assign( 2596 WIPHY_ASSIGN; 2597 NETDEV_ASSIGN; 2598 MAC_ASSIGN(aa, pmk_conf->aa); 2599 __entry->pmk_len = pmk_conf->pmk_len; 2600 __entry->pmk_r0_name_len = 2601 pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0; 2602 memcpy(__get_dynamic_array(pmk), pmk_conf->pmk, 2603 pmk_conf->pmk_len); 2604 memcpy(__get_dynamic_array(pmk_r0_name), pmk_conf->pmk_r0_name, 2605 pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0); 2606 ), 2607 2608 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" 2609 "pmk_len=%u, pmk: %s pmk_r0_name: %s", WIPHY_PR_ARG, 2610 NETDEV_PR_ARG, __entry->aa, __entry->pmk_len, 2611 __print_array(__get_dynamic_array(pmk), 2612 __get_dynamic_array_len(pmk), 1), 2613 __entry->pmk_r0_name_len ? 2614 __print_array(__get_dynamic_array(pmk_r0_name), 2615 __get_dynamic_array_len(pmk_r0_name), 1) : "") 2616 ); 2617 2618 TRACE_EVENT(rdev_del_pmk, 2619 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), 2620 2621 TP_ARGS(wiphy, netdev, aa), 2622 2623 TP_STRUCT__entry( 2624 WIPHY_ENTRY 2625 NETDEV_ENTRY 2626 MAC_ENTRY(aa) 2627 ), 2628 2629 TP_fast_assign( 2630 WIPHY_ASSIGN; 2631 NETDEV_ASSIGN; 2632 MAC_ASSIGN(aa, aa); 2633 ), 2634 2635 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2636 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->aa) 2637 ); 2638 2639 TRACE_EVENT(rdev_external_auth, 2640 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2641 struct cfg80211_external_auth_params *params), 2642 TP_ARGS(wiphy, netdev, params), 2643 TP_STRUCT__entry(WIPHY_ENTRY 2644 NETDEV_ENTRY 2645 MAC_ENTRY(bssid) 2646 __array(u8, ssid, IEEE80211_MAX_SSID_LEN + 1) 2647 __field(u16, status) 2648 MAC_ENTRY(mld_addr) 2649 ), 2650 TP_fast_assign(WIPHY_ASSIGN; 2651 NETDEV_ASSIGN; 2652 MAC_ASSIGN(bssid, params->bssid); 2653 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 2654 memcpy(__entry->ssid, params->ssid.ssid, 2655 params->ssid.ssid_len); 2656 __entry->status = params->status; 2657 MAC_ASSIGN(mld_addr, params->mld_addr); 2658 ), 2659 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" 2660 ", ssid: %s, status: %u, mld_addr: %pM", 2661 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, 2662 __entry->ssid, __entry->status, __entry->mld_addr) 2663 ); 2664 2665 TRACE_EVENT(rdev_start_radar_detection, 2666 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2667 struct cfg80211_chan_def *chandef, 2668 u32 cac_time_ms, int link_id), 2669 TP_ARGS(wiphy, netdev, chandef, cac_time_ms, link_id), 2670 TP_STRUCT__entry( 2671 WIPHY_ENTRY 2672 NETDEV_ENTRY 2673 CHAN_DEF_ENTRY 2674 __field(u32, cac_time_ms) 2675 __field(int, link_id) 2676 ), 2677 TP_fast_assign( 2678 WIPHY_ASSIGN; 2679 NETDEV_ASSIGN; 2680 CHAN_DEF_ASSIGN(chandef); 2681 __entry->cac_time_ms = cac_time_ms; 2682 __entry->link_id = link_id; 2683 ), 2684 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 2685 ", cac_time_ms=%u, link_id=%d", 2686 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2687 __entry->cac_time_ms, __entry->link_id) 2688 ); 2689 2690 TRACE_EVENT(rdev_set_mcast_rate, 2691 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2692 int *mcast_rate), 2693 TP_ARGS(wiphy, netdev, mcast_rate), 2694 TP_STRUCT__entry( 2695 WIPHY_ENTRY 2696 NETDEV_ENTRY 2697 __array(int, mcast_rate, NUM_NL80211_BANDS) 2698 ), 2699 TP_fast_assign( 2700 WIPHY_ASSIGN; 2701 NETDEV_ASSIGN; 2702 memcpy(__entry->mcast_rate, mcast_rate, 2703 sizeof(int) * NUM_NL80211_BANDS); 2704 ), 2705 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " 2706 "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 6GHz=0x%x, 60GHz=0x%x]", 2707 WIPHY_PR_ARG, NETDEV_PR_ARG, 2708 __entry->mcast_rate[NL80211_BAND_2GHZ], 2709 __entry->mcast_rate[NL80211_BAND_5GHZ], 2710 __entry->mcast_rate[NL80211_BAND_6GHZ], 2711 __entry->mcast_rate[NL80211_BAND_60GHZ]) 2712 ); 2713 2714 TRACE_EVENT(rdev_set_coalesce, 2715 TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), 2716 TP_ARGS(wiphy, coalesce), 2717 TP_STRUCT__entry( 2718 WIPHY_ENTRY 2719 __field(int, n_rules) 2720 ), 2721 TP_fast_assign( 2722 WIPHY_ASSIGN; 2723 __entry->n_rules = coalesce ? coalesce->n_rules : 0; 2724 ), 2725 TP_printk(WIPHY_PR_FMT ", n_rules=%d", 2726 WIPHY_PR_ARG, __entry->n_rules) 2727 ); 2728 2729 DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, 2730 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2731 TP_ARGS(wiphy, wdev) 2732 ); 2733 2734 TRACE_EVENT(rdev_set_multicast_to_unicast, 2735 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2736 const bool enabled), 2737 TP_ARGS(wiphy, netdev, enabled), 2738 TP_STRUCT__entry( 2739 WIPHY_ENTRY 2740 NETDEV_ENTRY 2741 __field(bool, enabled) 2742 ), 2743 TP_fast_assign( 2744 WIPHY_ASSIGN; 2745 NETDEV_ASSIGN; 2746 __entry->enabled = enabled; 2747 ), 2748 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", unicast: %s", 2749 WIPHY_PR_ARG, NETDEV_PR_ARG, 2750 BOOL_TO_STR(__entry->enabled)) 2751 ); 2752 2753 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_txq_stats, 2754 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2755 TP_ARGS(wiphy, wdev) 2756 ); 2757 2758 TRACE_EVENT(rdev_get_ftm_responder_stats, 2759 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2760 struct cfg80211_ftm_responder_stats *ftm_stats), 2761 2762 TP_ARGS(wiphy, netdev, ftm_stats), 2763 2764 TP_STRUCT__entry( 2765 WIPHY_ENTRY 2766 NETDEV_ENTRY 2767 __field(u64, timestamp) 2768 __field(u32, success_num) 2769 __field(u32, partial_num) 2770 __field(u32, failed_num) 2771 __field(u32, asap_num) 2772 __field(u32, non_asap_num) 2773 __field(u64, duration) 2774 __field(u32, unknown_triggers) 2775 __field(u32, reschedule) 2776 __field(u32, out_of_window) 2777 ), 2778 2779 TP_fast_assign( 2780 WIPHY_ASSIGN; 2781 NETDEV_ASSIGN; 2782 __entry->success_num = ftm_stats->success_num; 2783 __entry->partial_num = ftm_stats->partial_num; 2784 __entry->failed_num = ftm_stats->failed_num; 2785 __entry->asap_num = ftm_stats->asap_num; 2786 __entry->non_asap_num = ftm_stats->non_asap_num; 2787 __entry->duration = ftm_stats->total_duration_ms; 2788 __entry->unknown_triggers = ftm_stats->unknown_triggers_num; 2789 __entry->reschedule = ftm_stats->reschedule_requests_num; 2790 __entry->out_of_window = ftm_stats->out_of_window_triggers_num; 2791 ), 2792 2793 TP_printk(WIPHY_PR_FMT "Ftm responder stats: success %u, partial %u, " 2794 "failed %u, asap %u, non asap %u, total duration %llu, unknown " 2795 "triggers %u, rescheduled %u, out of window %u", WIPHY_PR_ARG, 2796 __entry->success_num, __entry->partial_num, __entry->failed_num, 2797 __entry->asap_num, __entry->non_asap_num, __entry->duration, 2798 __entry->unknown_triggers, __entry->reschedule, 2799 __entry->out_of_window) 2800 ); 2801 2802 DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_start_pmsr, 2803 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 2804 TP_ARGS(wiphy, wdev, cookie) 2805 ); 2806 2807 DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_abort_pmsr, 2808 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 2809 TP_ARGS(wiphy, wdev, cookie) 2810 ); 2811 2812 TRACE_EVENT(rdev_set_fils_aad, 2813 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2814 struct cfg80211_fils_aad *fils_aad), 2815 TP_ARGS(wiphy, netdev, fils_aad), 2816 TP_STRUCT__entry(WIPHY_ENTRY 2817 NETDEV_ENTRY 2818 __array(u8, macaddr, ETH_ALEN) 2819 __field(u8, kek_len) 2820 ), 2821 TP_fast_assign(WIPHY_ASSIGN; 2822 NETDEV_ASSIGN; 2823 FILS_AAD_ASSIGN(fils_aad); 2824 ), 2825 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " FILS_AAD_PR_FMT, 2826 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr, 2827 __entry->kek_len) 2828 ); 2829 2830 TRACE_EVENT(rdev_update_owe_info, 2831 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2832 struct cfg80211_update_owe_info *owe_info), 2833 TP_ARGS(wiphy, netdev, owe_info), 2834 TP_STRUCT__entry(WIPHY_ENTRY 2835 NETDEV_ENTRY 2836 MAC_ENTRY(peer) 2837 __field(u16, status) 2838 __dynamic_array(u8, ie, owe_info->ie_len)), 2839 TP_fast_assign(WIPHY_ASSIGN; 2840 NETDEV_ASSIGN; 2841 MAC_ASSIGN(peer, owe_info->peer); 2842 __entry->status = owe_info->status; 2843 memcpy(__get_dynamic_array(ie), 2844 owe_info->ie, owe_info->ie_len);), 2845 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM" 2846 " status %d", WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 2847 __entry->status) 2848 ); 2849 2850 TRACE_EVENT(rdev_probe_mesh_link, 2851 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2852 const u8 *dest, const u8 *buf, size_t len), 2853 TP_ARGS(wiphy, netdev, dest, buf, len), 2854 TP_STRUCT__entry( 2855 WIPHY_ENTRY 2856 NETDEV_ENTRY 2857 MAC_ENTRY(dest) 2858 ), 2859 TP_fast_assign( 2860 WIPHY_ASSIGN; 2861 NETDEV_ASSIGN; 2862 MAC_ASSIGN(dest, dest); 2863 ), 2864 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", 2865 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest) 2866 ); 2867 2868 TRACE_EVENT(rdev_set_tid_config, 2869 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2870 struct cfg80211_tid_config *tid_conf), 2871 TP_ARGS(wiphy, netdev, tid_conf), 2872 TP_STRUCT__entry( 2873 WIPHY_ENTRY 2874 NETDEV_ENTRY 2875 MAC_ENTRY(peer) 2876 ), 2877 TP_fast_assign( 2878 WIPHY_ASSIGN; 2879 NETDEV_ASSIGN; 2880 MAC_ASSIGN(peer, tid_conf->peer); 2881 ), 2882 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM", 2883 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer) 2884 ); 2885 2886 TRACE_EVENT(rdev_reset_tid_config, 2887 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2888 const u8 *peer, u8 tids), 2889 TP_ARGS(wiphy, netdev, peer, tids), 2890 TP_STRUCT__entry( 2891 WIPHY_ENTRY 2892 NETDEV_ENTRY 2893 MAC_ENTRY(peer) 2894 __field(u8, tids) 2895 ), 2896 TP_fast_assign( 2897 WIPHY_ASSIGN; 2898 NETDEV_ASSIGN; 2899 MAC_ASSIGN(peer, peer); 2900 __entry->tids = tids; 2901 ), 2902 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM, tids: 0x%x", 2903 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tids) 2904 ); 2905 2906 TRACE_EVENT(rdev_set_sar_specs, 2907 TP_PROTO(struct wiphy *wiphy, struct cfg80211_sar_specs *sar), 2908 TP_ARGS(wiphy, sar), 2909 TP_STRUCT__entry( 2910 WIPHY_ENTRY 2911 __field(u16, type) 2912 __field(u16, num) 2913 ), 2914 TP_fast_assign( 2915 WIPHY_ASSIGN; 2916 __entry->type = sar->type; 2917 __entry->num = sar->num_sub_specs; 2918 2919 ), 2920 TP_printk(WIPHY_PR_FMT ", Set type:%d, num_specs:%d", 2921 WIPHY_PR_ARG, __entry->type, __entry->num) 2922 ); 2923 2924 TRACE_EVENT(rdev_color_change, 2925 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2926 struct cfg80211_color_change_settings *params), 2927 TP_ARGS(wiphy, netdev, params), 2928 TP_STRUCT__entry( 2929 WIPHY_ENTRY 2930 NETDEV_ENTRY 2931 __field(u8, count) 2932 __field(u16, bcn_ofs) 2933 __field(u16, pres_ofs) 2934 __field(u8, link_id) 2935 ), 2936 TP_fast_assign( 2937 WIPHY_ASSIGN; 2938 NETDEV_ASSIGN; 2939 __entry->count = params->count; 2940 __entry->bcn_ofs = params->counter_offset_beacon; 2941 __entry->pres_ofs = params->counter_offset_presp; 2942 __entry->link_id = params->link_id; 2943 ), 2944 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT 2945 ", count: %u, link_id: %d", 2946 WIPHY_PR_ARG, NETDEV_PR_ARG, 2947 __entry->count, __entry->link_id) 2948 ); 2949 2950 TRACE_EVENT(rdev_set_radar_background, 2951 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2952 2953 TP_ARGS(wiphy, chandef), 2954 2955 TP_STRUCT__entry( 2956 WIPHY_ENTRY 2957 CHAN_DEF_ENTRY 2958 ), 2959 2960 TP_fast_assign( 2961 WIPHY_ASSIGN; 2962 CHAN_DEF_ASSIGN(chandef) 2963 ), 2964 2965 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2966 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2967 ); 2968 2969 DEFINE_EVENT(wiphy_wdev_link_evt, rdev_add_intf_link, 2970 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2971 unsigned int link_id), 2972 TP_ARGS(wiphy, wdev, link_id) 2973 ); 2974 2975 DEFINE_EVENT(wiphy_wdev_link_evt, rdev_del_intf_link, 2976 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2977 unsigned int link_id), 2978 TP_ARGS(wiphy, wdev, link_id) 2979 ); 2980 2981 TRACE_EVENT(rdev_del_link_station, 2982 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2983 struct link_station_del_parameters *params), 2984 TP_ARGS(wiphy, netdev, params), 2985 TP_STRUCT__entry( 2986 WIPHY_ENTRY 2987 NETDEV_ENTRY 2988 __array(u8, mld_mac, 6) 2989 __field(u32, link_id) 2990 ), 2991 TP_fast_assign( 2992 WIPHY_ASSIGN; 2993 NETDEV_ASSIGN; 2994 memset(__entry->mld_mac, 0, 6); 2995 if (params->mld_mac) 2996 memcpy(__entry->mld_mac, params->mld_mac, 6); 2997 __entry->link_id = params->link_id; 2998 ), 2999 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" 3000 ", link id: %u", 3001 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac, 3002 __entry->link_id) 3003 ); 3004 3005 TRACE_EVENT(rdev_set_hw_timestamp, 3006 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3007 struct cfg80211_set_hw_timestamp *hwts), 3008 3009 TP_ARGS(wiphy, netdev, hwts), 3010 3011 TP_STRUCT__entry( 3012 WIPHY_ENTRY 3013 NETDEV_ENTRY 3014 MAC_ENTRY(macaddr) 3015 __field(bool, enable) 3016 ), 3017 3018 TP_fast_assign( 3019 WIPHY_ASSIGN; 3020 NETDEV_ASSIGN; 3021 MAC_ASSIGN(macaddr, hwts->macaddr); 3022 __entry->enable = hwts->enable; 3023 ), 3024 3025 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac %pM, enable: %u", 3026 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr, 3027 __entry->enable) 3028 ); 3029 3030 TRACE_EVENT(rdev_set_ttlm, 3031 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3032 struct cfg80211_ttlm_params *params), 3033 TP_ARGS(wiphy, netdev, params), 3034 TP_STRUCT__entry( 3035 WIPHY_ENTRY 3036 NETDEV_ENTRY 3037 __array(u8, dlink, sizeof(u16) * 8) 3038 __array(u8, ulink, sizeof(u16) * 8) 3039 ), 3040 TP_fast_assign( 3041 WIPHY_ASSIGN; 3042 NETDEV_ASSIGN; 3043 memcpy(__entry->dlink, params->dlink, sizeof(params->dlink)); 3044 memcpy(__entry->ulink, params->ulink, sizeof(params->ulink)); 3045 ), 3046 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, 3047 WIPHY_PR_ARG, NETDEV_PR_ARG) 3048 ); 3049 3050 /************************************************************* 3051 * cfg80211 exported functions traces * 3052 *************************************************************/ 3053 3054 TRACE_EVENT(cfg80211_return_bool, 3055 TP_PROTO(bool ret), 3056 TP_ARGS(ret), 3057 TP_STRUCT__entry( 3058 __field(bool, ret) 3059 ), 3060 TP_fast_assign( 3061 __entry->ret = ret; 3062 ), 3063 TP_printk("returned %s", BOOL_TO_STR(__entry->ret)) 3064 ); 3065 3066 DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, 3067 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3068 TP_ARGS(netdev, macaddr), 3069 TP_STRUCT__entry( 3070 NETDEV_ENTRY 3071 MAC_ENTRY(macaddr) 3072 ), 3073 TP_fast_assign( 3074 NETDEV_ASSIGN; 3075 MAC_ASSIGN(macaddr, macaddr); 3076 ), 3077 TP_printk(NETDEV_PR_FMT ", mac: %pM", 3078 NETDEV_PR_ARG, __entry->macaddr) 3079 ); 3080 3081 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, 3082 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3083 TP_ARGS(netdev, macaddr) 3084 ); 3085 3086 DECLARE_EVENT_CLASS(netdev_evt_only, 3087 TP_PROTO(struct net_device *netdev), 3088 TP_ARGS(netdev), 3089 TP_STRUCT__entry( 3090 NETDEV_ENTRY 3091 ), 3092 TP_fast_assign( 3093 NETDEV_ASSIGN; 3094 ), 3095 TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG) 3096 ); 3097 3098 DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, 3099 TP_PROTO(struct net_device *netdev), 3100 TP_ARGS(netdev) 3101 ); 3102 3103 TRACE_EVENT(cfg80211_send_rx_assoc, 3104 TP_PROTO(struct net_device *netdev, 3105 const struct cfg80211_rx_assoc_resp_data *data), 3106 TP_ARGS(netdev, data), 3107 TP_STRUCT__entry( 3108 NETDEV_ENTRY 3109 MAC_ENTRY(ap_addr) 3110 ), 3111 TP_fast_assign( 3112 NETDEV_ASSIGN; 3113 MAC_ASSIGN(ap_addr, 3114 data->ap_mld_addr ?: data->links[0].bss->bssid); 3115 ), 3116 TP_printk(NETDEV_PR_FMT ", %pM", 3117 NETDEV_PR_ARG, __entry->ap_addr) 3118 ); 3119 3120 DECLARE_EVENT_CLASS(netdev_frame_event, 3121 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 3122 TP_ARGS(netdev, buf, len), 3123 TP_STRUCT__entry( 3124 NETDEV_ENTRY 3125 __dynamic_array(u8, frame, len) 3126 ), 3127 TP_fast_assign( 3128 NETDEV_ASSIGN; 3129 memcpy(__get_dynamic_array(frame), buf, len); 3130 ), 3131 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x", 3132 NETDEV_PR_ARG, 3133 le16_to_cpup((__le16 *)__get_dynamic_array(frame))) 3134 ); 3135 3136 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, 3137 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 3138 TP_ARGS(netdev, buf, len) 3139 ); 3140 3141 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, 3142 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 3143 TP_ARGS(netdev, buf, len) 3144 ); 3145 3146 TRACE_EVENT(cfg80211_tx_mlme_mgmt, 3147 TP_PROTO(struct net_device *netdev, const u8 *buf, int len, 3148 bool reconnect), 3149 TP_ARGS(netdev, buf, len, reconnect), 3150 TP_STRUCT__entry( 3151 NETDEV_ENTRY 3152 __dynamic_array(u8, frame, len) 3153 __field(int, reconnect) 3154 ), 3155 TP_fast_assign( 3156 NETDEV_ASSIGN; 3157 memcpy(__get_dynamic_array(frame), buf, len); 3158 __entry->reconnect = reconnect; 3159 ), 3160 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x reconnect:%d", 3161 NETDEV_PR_ARG, 3162 le16_to_cpup((__le16 *)__get_dynamic_array(frame)), 3163 __entry->reconnect) 3164 ); 3165 3166 DECLARE_EVENT_CLASS(netdev_mac_evt, 3167 TP_PROTO(struct net_device *netdev, const u8 *mac), 3168 TP_ARGS(netdev, mac), 3169 TP_STRUCT__entry( 3170 NETDEV_ENTRY 3171 MAC_ENTRY(mac) 3172 ), 3173 TP_fast_assign( 3174 NETDEV_ASSIGN; 3175 MAC_ASSIGN(mac, mac) 3176 ), 3177 TP_printk(NETDEV_PR_FMT ", mac: %pM", 3178 NETDEV_PR_ARG, __entry->mac) 3179 ); 3180 3181 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, 3182 TP_PROTO(struct net_device *netdev, const u8 *mac), 3183 TP_ARGS(netdev, mac) 3184 ); 3185 3186 TRACE_EVENT(cfg80211_send_assoc_failure, 3187 TP_PROTO(struct net_device *netdev, 3188 struct cfg80211_assoc_failure *data), 3189 TP_ARGS(netdev, data), 3190 TP_STRUCT__entry( 3191 NETDEV_ENTRY 3192 MAC_ENTRY(ap_addr) 3193 __field(bool, timeout) 3194 ), 3195 TP_fast_assign( 3196 NETDEV_ASSIGN; 3197 MAC_ASSIGN(ap_addr, data->ap_mld_addr ?: data->bss[0]->bssid); 3198 __entry->timeout = data->timeout; 3199 ), 3200 TP_printk(NETDEV_PR_FMT ", mac: %pM, timeout: %d", 3201 NETDEV_PR_ARG, __entry->ap_addr, __entry->timeout) 3202 ); 3203 3204 TRACE_EVENT(cfg80211_michael_mic_failure, 3205 TP_PROTO(struct net_device *netdev, const u8 *addr, 3206 enum nl80211_key_type key_type, int key_id, const u8 *tsc), 3207 TP_ARGS(netdev, addr, key_type, key_id, tsc), 3208 TP_STRUCT__entry( 3209 NETDEV_ENTRY 3210 MAC_ENTRY(addr) 3211 __field(enum nl80211_key_type, key_type) 3212 __field(int, key_id) 3213 __array(u8, tsc, 6) 3214 ), 3215 TP_fast_assign( 3216 NETDEV_ASSIGN; 3217 MAC_ASSIGN(addr, addr); 3218 __entry->key_type = key_type; 3219 __entry->key_id = key_id; 3220 if (tsc) 3221 memcpy(__entry->tsc, tsc, 6); 3222 ), 3223 TP_printk(NETDEV_PR_FMT ", %pM, key type: %d, key id: %d, tsc: %pm", 3224 NETDEV_PR_ARG, __entry->addr, __entry->key_type, 3225 __entry->key_id, __entry->tsc) 3226 ); 3227 3228 TRACE_EVENT(cfg80211_ready_on_channel, 3229 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 3230 struct ieee80211_channel *chan, 3231 unsigned int duration), 3232 TP_ARGS(wdev, cookie, chan, duration), 3233 TP_STRUCT__entry( 3234 WDEV_ENTRY 3235 __field(u64, cookie) 3236 CHAN_ENTRY 3237 __field(unsigned int, duration) 3238 ), 3239 TP_fast_assign( 3240 WDEV_ASSIGN; 3241 __entry->cookie = cookie; 3242 CHAN_ASSIGN(chan); 3243 __entry->duration = duration; 3244 ), 3245 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u", 3246 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG, 3247 __entry->duration) 3248 ); 3249 3250 TRACE_EVENT(cfg80211_ready_on_channel_expired, 3251 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 3252 struct ieee80211_channel *chan), 3253 TP_ARGS(wdev, cookie, chan), 3254 TP_STRUCT__entry( 3255 WDEV_ENTRY 3256 __field(u64, cookie) 3257 CHAN_ENTRY 3258 ), 3259 TP_fast_assign( 3260 WDEV_ASSIGN; 3261 __entry->cookie = cookie; 3262 CHAN_ASSIGN(chan); 3263 ), 3264 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT, 3265 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG) 3266 ); 3267 3268 TRACE_EVENT(cfg80211_tx_mgmt_expired, 3269 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 3270 struct ieee80211_channel *chan), 3271 TP_ARGS(wdev, cookie, chan), 3272 TP_STRUCT__entry( 3273 WDEV_ENTRY 3274 __field(u64, cookie) 3275 CHAN_ENTRY 3276 ), 3277 TP_fast_assign( 3278 WDEV_ASSIGN; 3279 __entry->cookie = cookie; 3280 CHAN_ASSIGN(chan); 3281 ), 3282 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT, 3283 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG) 3284 ); 3285 3286 TRACE_EVENT(cfg80211_new_sta, 3287 TP_PROTO(struct net_device *netdev, const u8 *mac_addr, 3288 struct station_info *sinfo), 3289 TP_ARGS(netdev, mac_addr, sinfo), 3290 TP_STRUCT__entry( 3291 NETDEV_ENTRY 3292 MAC_ENTRY(mac_addr) 3293 SINFO_ENTRY 3294 ), 3295 TP_fast_assign( 3296 NETDEV_ASSIGN; 3297 MAC_ASSIGN(mac_addr, mac_addr); 3298 SINFO_ASSIGN; 3299 ), 3300 TP_printk(NETDEV_PR_FMT ", %pM", 3301 NETDEV_PR_ARG, __entry->mac_addr) 3302 ); 3303 3304 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, 3305 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3306 TP_ARGS(netdev, macaddr) 3307 ); 3308 3309 TRACE_EVENT(cfg80211_rx_mgmt, 3310 TP_PROTO(struct wireless_dev *wdev, struct cfg80211_rx_info *info), 3311 TP_ARGS(wdev, info), 3312 TP_STRUCT__entry( 3313 WDEV_ENTRY 3314 __field(int, freq) 3315 __field(int, sig_dbm) 3316 ), 3317 TP_fast_assign( 3318 WDEV_ASSIGN; 3319 __entry->freq = info->freq; 3320 __entry->sig_dbm = info->sig_dbm; 3321 ), 3322 TP_printk(WDEV_PR_FMT ", freq: "KHZ_F", sig dbm: %d", 3323 WDEV_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm) 3324 ); 3325 3326 TRACE_EVENT(cfg80211_mgmt_tx_status, 3327 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), 3328 TP_ARGS(wdev, cookie, ack), 3329 TP_STRUCT__entry( 3330 WDEV_ENTRY 3331 __field(u64, cookie) 3332 __field(bool, ack) 3333 ), 3334 TP_fast_assign( 3335 WDEV_ASSIGN; 3336 __entry->cookie = cookie; 3337 __entry->ack = ack; 3338 ), 3339 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s", 3340 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack)) 3341 ); 3342 3343 TRACE_EVENT(cfg80211_control_port_tx_status, 3344 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), 3345 TP_ARGS(wdev, cookie, ack), 3346 TP_STRUCT__entry( 3347 WDEV_ENTRY 3348 __field(u64, cookie) 3349 __field(bool, ack) 3350 ), 3351 TP_fast_assign( 3352 WDEV_ASSIGN; 3353 __entry->cookie = cookie; 3354 __entry->ack = ack; 3355 ), 3356 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s", 3357 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack)) 3358 ); 3359 3360 TRACE_EVENT(cfg80211_rx_control_port, 3361 TP_PROTO(struct net_device *netdev, struct sk_buff *skb, 3362 bool unencrypted, int link_id), 3363 TP_ARGS(netdev, skb, unencrypted, link_id), 3364 TP_STRUCT__entry( 3365 NETDEV_ENTRY 3366 __field(int, len) 3367 MAC_ENTRY(from) 3368 __field(u16, proto) 3369 __field(bool, unencrypted) 3370 __field(int, link_id) 3371 ), 3372 TP_fast_assign( 3373 NETDEV_ASSIGN; 3374 __entry->len = skb->len; 3375 MAC_ASSIGN(from, eth_hdr(skb)->h_source); 3376 __entry->proto = be16_to_cpu(skb->protocol); 3377 __entry->unencrypted = unencrypted; 3378 __entry->link_id = link_id; 3379 ), 3380 TP_printk(NETDEV_PR_FMT ", len=%d, %pM, proto: 0x%x, unencrypted: %s, link: %d", 3381 NETDEV_PR_ARG, __entry->len, __entry->from, 3382 __entry->proto, BOOL_TO_STR(__entry->unencrypted), 3383 __entry->link_id) 3384 ); 3385 3386 TRACE_EVENT(cfg80211_cqm_rssi_notify, 3387 TP_PROTO(struct net_device *netdev, 3388 enum nl80211_cqm_rssi_threshold_event rssi_event, 3389 s32 rssi_level), 3390 TP_ARGS(netdev, rssi_event, rssi_level), 3391 TP_STRUCT__entry( 3392 NETDEV_ENTRY 3393 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event) 3394 __field(s32, rssi_level) 3395 ), 3396 TP_fast_assign( 3397 NETDEV_ASSIGN; 3398 __entry->rssi_event = rssi_event; 3399 __entry->rssi_level = rssi_level; 3400 ), 3401 TP_printk(NETDEV_PR_FMT ", rssi event: %d, level: %d", 3402 NETDEV_PR_ARG, __entry->rssi_event, __entry->rssi_level) 3403 ); 3404 3405 TRACE_EVENT(cfg80211_reg_can_beacon, 3406 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 3407 enum nl80211_iftype iftype, u32 prohibited_flags, 3408 u32 permitting_flags), 3409 TP_ARGS(wiphy, chandef, iftype, prohibited_flags, permitting_flags), 3410 TP_STRUCT__entry( 3411 WIPHY_ENTRY 3412 CHAN_DEF_ENTRY 3413 __field(enum nl80211_iftype, iftype) 3414 __field(u32, prohibited_flags) 3415 __field(u32, permitting_flags) 3416 ), 3417 TP_fast_assign( 3418 WIPHY_ASSIGN; 3419 CHAN_DEF_ASSIGN(chandef); 3420 __entry->iftype = iftype; 3421 __entry->prohibited_flags = prohibited_flags; 3422 __entry->permitting_flags = permitting_flags; 3423 ), 3424 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d prohibited_flags=0x%x permitting_flags=0x%x", 3425 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype, 3426 __entry->prohibited_flags, __entry->permitting_flags) 3427 ); 3428 3429 TRACE_EVENT(cfg80211_chandef_dfs_required, 3430 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 3431 TP_ARGS(wiphy, chandef), 3432 TP_STRUCT__entry( 3433 WIPHY_ENTRY 3434 CHAN_DEF_ENTRY 3435 ), 3436 TP_fast_assign( 3437 WIPHY_ASSIGN; 3438 CHAN_DEF_ASSIGN(chandef); 3439 ), 3440 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 3441 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 3442 ); 3443 3444 TRACE_EVENT(cfg80211_ch_switch_notify, 3445 TP_PROTO(struct net_device *netdev, 3446 struct cfg80211_chan_def *chandef, 3447 unsigned int link_id), 3448 TP_ARGS(netdev, chandef, link_id), 3449 TP_STRUCT__entry( 3450 NETDEV_ENTRY 3451 CHAN_DEF_ENTRY 3452 __field(unsigned int, link_id) 3453 ), 3454 TP_fast_assign( 3455 NETDEV_ASSIGN; 3456 CHAN_DEF_ASSIGN(chandef); 3457 __entry->link_id = link_id; 3458 ), 3459 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d", 3460 NETDEV_PR_ARG, CHAN_DEF_PR_ARG, __entry->link_id) 3461 ); 3462 3463 TRACE_EVENT(cfg80211_ch_switch_started_notify, 3464 TP_PROTO(struct net_device *netdev, 3465 struct cfg80211_chan_def *chandef, 3466 unsigned int link_id), 3467 TP_ARGS(netdev, chandef, link_id), 3468 TP_STRUCT__entry( 3469 NETDEV_ENTRY 3470 CHAN_DEF_ENTRY 3471 __field(unsigned int, link_id) 3472 ), 3473 TP_fast_assign( 3474 NETDEV_ASSIGN; 3475 CHAN_DEF_ASSIGN(chandef); 3476 __entry->link_id = link_id; 3477 ), 3478 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d", 3479 NETDEV_PR_ARG, CHAN_DEF_PR_ARG, __entry->link_id) 3480 ); 3481 3482 TRACE_EVENT(cfg80211_radar_event, 3483 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 3484 bool offchan), 3485 TP_ARGS(wiphy, chandef, offchan), 3486 TP_STRUCT__entry( 3487 WIPHY_ENTRY 3488 CHAN_DEF_ENTRY 3489 __field(bool, offchan) 3490 ), 3491 TP_fast_assign( 3492 WIPHY_ASSIGN; 3493 CHAN_DEF_ASSIGN(chandef); 3494 __entry->offchan = offchan; 3495 ), 3496 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", offchan %d", 3497 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->offchan) 3498 ); 3499 3500 TRACE_EVENT(cfg80211_cac_event, 3501 TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt, 3502 unsigned int link_id), 3503 TP_ARGS(netdev, evt, link_id), 3504 TP_STRUCT__entry( 3505 NETDEV_ENTRY 3506 __field(enum nl80211_radar_event, evt) 3507 __field(unsigned int, link_id) 3508 ), 3509 TP_fast_assign( 3510 NETDEV_ASSIGN; 3511 __entry->evt = evt; 3512 __entry->link_id = link_id; 3513 ), 3514 TP_printk(NETDEV_PR_FMT ", event: %d, link_id=%u", 3515 NETDEV_PR_ARG, __entry->evt, __entry->link_id) 3516 ); 3517 3518 DECLARE_EVENT_CLASS(cfg80211_rx_evt, 3519 TP_PROTO(struct net_device *netdev, const u8 *addr), 3520 TP_ARGS(netdev, addr), 3521 TP_STRUCT__entry( 3522 NETDEV_ENTRY 3523 MAC_ENTRY(addr) 3524 ), 3525 TP_fast_assign( 3526 NETDEV_ASSIGN; 3527 MAC_ASSIGN(addr, addr); 3528 ), 3529 TP_printk(NETDEV_PR_FMT ", %pM", NETDEV_PR_ARG, __entry->addr) 3530 ); 3531 3532 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, 3533 TP_PROTO(struct net_device *netdev, const u8 *addr), 3534 TP_ARGS(netdev, addr) 3535 ); 3536 3537 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, 3538 TP_PROTO(struct net_device *netdev, const u8 *addr), 3539 TP_ARGS(netdev, addr) 3540 ); 3541 3542 TRACE_EVENT(cfg80211_ibss_joined, 3543 TP_PROTO(struct net_device *netdev, const u8 *bssid, 3544 struct ieee80211_channel *channel), 3545 TP_ARGS(netdev, bssid, channel), 3546 TP_STRUCT__entry( 3547 NETDEV_ENTRY 3548 MAC_ENTRY(bssid) 3549 CHAN_ENTRY 3550 ), 3551 TP_fast_assign( 3552 NETDEV_ASSIGN; 3553 MAC_ASSIGN(bssid, bssid); 3554 CHAN_ASSIGN(channel); 3555 ), 3556 TP_printk(NETDEV_PR_FMT ", bssid: %pM, " CHAN_PR_FMT, 3557 NETDEV_PR_ARG, __entry->bssid, CHAN_PR_ARG) 3558 ); 3559 3560 TRACE_EVENT(cfg80211_probe_status, 3561 TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, 3562 bool acked), 3563 TP_ARGS(netdev, addr, cookie, acked), 3564 TP_STRUCT__entry( 3565 NETDEV_ENTRY 3566 MAC_ENTRY(addr) 3567 __field(u64, cookie) 3568 __field(bool, acked) 3569 ), 3570 TP_fast_assign( 3571 NETDEV_ASSIGN; 3572 MAC_ASSIGN(addr, addr); 3573 __entry->cookie = cookie; 3574 __entry->acked = acked; 3575 ), 3576 TP_printk(NETDEV_PR_FMT " addr:%pM, cookie: %llu, acked: %s", 3577 NETDEV_PR_ARG, __entry->addr, __entry->cookie, 3578 BOOL_TO_STR(__entry->acked)) 3579 ); 3580 3581 TRACE_EVENT(cfg80211_cqm_pktloss_notify, 3582 TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), 3583 TP_ARGS(netdev, peer, num_packets), 3584 TP_STRUCT__entry( 3585 NETDEV_ENTRY 3586 MAC_ENTRY(peer) 3587 __field(u32, num_packets) 3588 ), 3589 TP_fast_assign( 3590 NETDEV_ASSIGN; 3591 MAC_ASSIGN(peer, peer); 3592 __entry->num_packets = num_packets; 3593 ), 3594 TP_printk(NETDEV_PR_FMT ", peer: %pM, num of lost packets: %u", 3595 NETDEV_PR_ARG, __entry->peer, __entry->num_packets) 3596 ); 3597 3598 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, 3599 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 3600 TP_ARGS(netdev, macaddr) 3601 ); 3602 3603 TRACE_EVENT(cfg80211_pmksa_candidate_notify, 3604 TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, 3605 bool preauth), 3606 TP_ARGS(netdev, index, bssid, preauth), 3607 TP_STRUCT__entry( 3608 NETDEV_ENTRY 3609 __field(int, index) 3610 MAC_ENTRY(bssid) 3611 __field(bool, preauth) 3612 ), 3613 TP_fast_assign( 3614 NETDEV_ASSIGN; 3615 __entry->index = index; 3616 MAC_ASSIGN(bssid, bssid); 3617 __entry->preauth = preauth; 3618 ), 3619 TP_printk(NETDEV_PR_FMT ", index:%d, bssid: %pM, pre auth: %s", 3620 NETDEV_PR_ARG, __entry->index, __entry->bssid, 3621 BOOL_TO_STR(__entry->preauth)) 3622 ); 3623 3624 TRACE_EVENT(cfg80211_report_obss_beacon, 3625 TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, 3626 int freq, int sig_dbm), 3627 TP_ARGS(wiphy, frame, len, freq, sig_dbm), 3628 TP_STRUCT__entry( 3629 WIPHY_ENTRY 3630 __field(int, freq) 3631 __field(int, sig_dbm) 3632 ), 3633 TP_fast_assign( 3634 WIPHY_ASSIGN; 3635 __entry->freq = freq; 3636 __entry->sig_dbm = sig_dbm; 3637 ), 3638 TP_printk(WIPHY_PR_FMT ", freq: "KHZ_F", sig_dbm: %d", 3639 WIPHY_PR_ARG, PR_KHZ(__entry->freq), __entry->sig_dbm) 3640 ); 3641 3642 TRACE_EVENT(cfg80211_tdls_oper_request, 3643 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, 3644 enum nl80211_tdls_operation oper, u16 reason_code), 3645 TP_ARGS(wiphy, netdev, peer, oper, reason_code), 3646 TP_STRUCT__entry( 3647 WIPHY_ENTRY 3648 NETDEV_ENTRY 3649 MAC_ENTRY(peer) 3650 __field(enum nl80211_tdls_operation, oper) 3651 __field(u16, reason_code) 3652 ), 3653 TP_fast_assign( 3654 WIPHY_ASSIGN; 3655 NETDEV_ASSIGN; 3656 MAC_ASSIGN(peer, peer); 3657 __entry->oper = oper; 3658 __entry->reason_code = reason_code; 3659 ), 3660 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM, oper: %d, reason_code %u", 3661 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper, 3662 __entry->reason_code) 3663 ); 3664 3665 TRACE_EVENT(cfg80211_scan_done, 3666 TP_PROTO(struct cfg80211_scan_request *request, 3667 struct cfg80211_scan_info *info), 3668 TP_ARGS(request, info), 3669 TP_STRUCT__entry( 3670 __field(u32, n_channels) 3671 __dynamic_array(u8, ie, request ? request->ie_len : 0) 3672 __array(u32, rates, NUM_NL80211_BANDS) 3673 __field(u32, wdev_id) 3674 MAC_ENTRY(wiphy_mac) 3675 __field(bool, no_cck) 3676 __field(bool, aborted) 3677 __field(u64, scan_start_tsf) 3678 MAC_ENTRY(tsf_bssid) 3679 ), 3680 TP_fast_assign( 3681 if (request) { 3682 memcpy(__get_dynamic_array(ie), request->ie, 3683 request->ie_len); 3684 memcpy(__entry->rates, request->rates, 3685 NUM_NL80211_BANDS); 3686 __entry->wdev_id = request->wdev ? 3687 request->wdev->identifier : 0; 3688 if (request->wiphy) 3689 MAC_ASSIGN(wiphy_mac, 3690 request->wiphy->perm_addr); 3691 __entry->no_cck = request->no_cck; 3692 } 3693 if (info) { 3694 __entry->aborted = info->aborted; 3695 __entry->scan_start_tsf = info->scan_start_tsf; 3696 MAC_ASSIGN(tsf_bssid, info->tsf_bssid); 3697 } 3698 ), 3699 TP_printk("aborted: %s, scan start (TSF): %llu, tsf_bssid: %pM", 3700 BOOL_TO_STR(__entry->aborted), 3701 (unsigned long long)__entry->scan_start_tsf, 3702 __entry->tsf_bssid) 3703 ); 3704 3705 DECLARE_EVENT_CLASS(wiphy_id_evt, 3706 TP_PROTO(struct wiphy *wiphy, u64 id), 3707 TP_ARGS(wiphy, id), 3708 TP_STRUCT__entry( 3709 WIPHY_ENTRY 3710 __field(u64, id) 3711 ), 3712 TP_fast_assign( 3713 WIPHY_ASSIGN; 3714 __entry->id = id; 3715 ), 3716 TP_printk(WIPHY_PR_FMT ", id: %llu", WIPHY_PR_ARG, __entry->id) 3717 ); 3718 3719 DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_stopped, 3720 TP_PROTO(struct wiphy *wiphy, u64 id), 3721 TP_ARGS(wiphy, id) 3722 ); 3723 3724 DEFINE_EVENT(wiphy_id_evt, cfg80211_sched_scan_results, 3725 TP_PROTO(struct wiphy *wiphy, u64 id), 3726 TP_ARGS(wiphy, id) 3727 ); 3728 3729 TRACE_EVENT(cfg80211_get_bss, 3730 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, 3731 const u8 *bssid, const u8 *ssid, size_t ssid_len, 3732 enum ieee80211_bss_type bss_type, 3733 enum ieee80211_privacy privacy), 3734 TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy), 3735 TP_STRUCT__entry( 3736 WIPHY_ENTRY 3737 CHAN_ENTRY 3738 MAC_ENTRY(bssid) 3739 __dynamic_array(u8, ssid, ssid_len) 3740 __field(enum ieee80211_bss_type, bss_type) 3741 __field(enum ieee80211_privacy, privacy) 3742 ), 3743 TP_fast_assign( 3744 WIPHY_ASSIGN; 3745 CHAN_ASSIGN(channel); 3746 MAC_ASSIGN(bssid, bssid); 3747 memcpy(__get_dynamic_array(ssid), ssid, ssid_len); 3748 __entry->bss_type = bss_type; 3749 __entry->privacy = privacy; 3750 ), 3751 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", %pM" 3752 ", buf: %#.2x, bss_type: %d, privacy: %d", 3753 WIPHY_PR_ARG, CHAN_PR_ARG, __entry->bssid, 3754 ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type, 3755 __entry->privacy) 3756 ); 3757 3758 TRACE_EVENT(cfg80211_inform_bss_frame, 3759 TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, 3760 struct ieee80211_mgmt *mgmt, size_t len), 3761 TP_ARGS(wiphy, data, mgmt, len), 3762 TP_STRUCT__entry( 3763 WIPHY_ENTRY 3764 CHAN_ENTRY 3765 __dynamic_array(u8, mgmt, len) 3766 __field(s32, signal) 3767 __field(u64, ts_boottime) 3768 __field(u64, parent_tsf) 3769 MAC_ENTRY(parent_bssid) 3770 ), 3771 TP_fast_assign( 3772 WIPHY_ASSIGN; 3773 CHAN_ASSIGN(data->chan); 3774 if (mgmt) 3775 memcpy(__get_dynamic_array(mgmt), mgmt, len); 3776 __entry->signal = data->signal; 3777 __entry->ts_boottime = data->boottime_ns; 3778 __entry->parent_tsf = data->parent_tsf; 3779 MAC_ASSIGN(parent_bssid, data->parent_bssid); 3780 ), 3781 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT 3782 "signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: %pM", 3783 WIPHY_PR_ARG, CHAN_PR_ARG, 3784 __entry->signal, (unsigned long long)__entry->ts_boottime, 3785 (unsigned long long)__entry->parent_tsf, 3786 __entry->parent_bssid) 3787 ); 3788 3789 DECLARE_EVENT_CLASS(cfg80211_bss_evt, 3790 TP_PROTO(struct cfg80211_bss *pub), 3791 TP_ARGS(pub), 3792 TP_STRUCT__entry( 3793 MAC_ENTRY(bssid) 3794 CHAN_ENTRY 3795 ), 3796 TP_fast_assign( 3797 MAC_ASSIGN(bssid, pub->bssid); 3798 CHAN_ASSIGN(pub->channel); 3799 ), 3800 TP_printk("%pM, " CHAN_PR_FMT, __entry->bssid, CHAN_PR_ARG) 3801 ); 3802 3803 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, 3804 TP_PROTO(struct cfg80211_bss *pub), 3805 TP_ARGS(pub) 3806 ); 3807 3808 TRACE_EVENT(cfg80211_return_uint, 3809 TP_PROTO(unsigned int ret), 3810 TP_ARGS(ret), 3811 TP_STRUCT__entry( 3812 __field(unsigned int, ret) 3813 ), 3814 TP_fast_assign( 3815 __entry->ret = ret; 3816 ), 3817 TP_printk("ret: %d", __entry->ret) 3818 ); 3819 3820 TRACE_EVENT(cfg80211_return_u32, 3821 TP_PROTO(u32 ret), 3822 TP_ARGS(ret), 3823 TP_STRUCT__entry( 3824 __field(u32, ret) 3825 ), 3826 TP_fast_assign( 3827 __entry->ret = ret; 3828 ), 3829 TP_printk("ret: %u", __entry->ret) 3830 ); 3831 3832 TRACE_EVENT(cfg80211_report_wowlan_wakeup, 3833 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 3834 struct cfg80211_wowlan_wakeup *wakeup), 3835 TP_ARGS(wiphy, wdev, wakeup), 3836 TP_STRUCT__entry( 3837 WIPHY_ENTRY 3838 WDEV_ENTRY 3839 __field(bool, non_wireless) 3840 __field(bool, disconnect) 3841 __field(bool, magic_pkt) 3842 __field(bool, gtk_rekey_failure) 3843 __field(bool, eap_identity_req) 3844 __field(bool, four_way_handshake) 3845 __field(bool, rfkill_release) 3846 __field(s32, pattern_idx) 3847 __field(u32, packet_len) 3848 __dynamic_array(u8, packet, 3849 wakeup ? wakeup->packet_present_len : 0) 3850 ), 3851 TP_fast_assign( 3852 WIPHY_ASSIGN; 3853 WDEV_ASSIGN; 3854 __entry->non_wireless = !wakeup; 3855 __entry->disconnect = wakeup ? wakeup->disconnect : false; 3856 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false; 3857 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false; 3858 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false; 3859 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false; 3860 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false; 3861 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false; 3862 __entry->packet_len = wakeup ? wakeup->packet_len : false; 3863 if (wakeup && wakeup->packet && wakeup->packet_present_len) 3864 memcpy(__get_dynamic_array(packet), wakeup->packet, 3865 wakeup->packet_present_len); 3866 ), 3867 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 3868 ); 3869 3870 TRACE_EVENT(cfg80211_ft_event, 3871 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3872 struct cfg80211_ft_event_params *ft_event), 3873 TP_ARGS(wiphy, netdev, ft_event), 3874 TP_STRUCT__entry( 3875 WIPHY_ENTRY 3876 NETDEV_ENTRY 3877 __dynamic_array(u8, ies, ft_event->ies_len) 3878 MAC_ENTRY(target_ap) 3879 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len) 3880 ), 3881 TP_fast_assign( 3882 WIPHY_ASSIGN; 3883 NETDEV_ASSIGN; 3884 if (ft_event->ies) 3885 memcpy(__get_dynamic_array(ies), ft_event->ies, 3886 ft_event->ies_len); 3887 MAC_ASSIGN(target_ap, ft_event->target_ap); 3888 if (ft_event->ric_ies) 3889 memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies, 3890 ft_event->ric_ies_len); 3891 ), 3892 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: %pM", 3893 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->target_ap) 3894 ); 3895 3896 TRACE_EVENT(cfg80211_stop_iface, 3897 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 3898 TP_ARGS(wiphy, wdev), 3899 TP_STRUCT__entry( 3900 WIPHY_ENTRY 3901 WDEV_ENTRY 3902 ), 3903 TP_fast_assign( 3904 WIPHY_ASSIGN; 3905 WDEV_ASSIGN; 3906 ), 3907 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 3908 WIPHY_PR_ARG, WDEV_PR_ARG) 3909 ); 3910 3911 TRACE_EVENT(cfg80211_pmsr_report, 3912 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 3913 u64 cookie, const u8 *addr), 3914 TP_ARGS(wiphy, wdev, cookie, addr), 3915 TP_STRUCT__entry( 3916 WIPHY_ENTRY 3917 WDEV_ENTRY 3918 __field(u64, cookie) 3919 MAC_ENTRY(addr) 3920 ), 3921 TP_fast_assign( 3922 WIPHY_ASSIGN; 3923 WDEV_ASSIGN; 3924 __entry->cookie = cookie; 3925 MAC_ASSIGN(addr, addr); 3926 ), 3927 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld, %pM", 3928 WIPHY_PR_ARG, WDEV_PR_ARG, 3929 (unsigned long long)__entry->cookie, 3930 __entry->addr) 3931 ); 3932 3933 TRACE_EVENT(cfg80211_pmsr_complete, 3934 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 3935 TP_ARGS(wiphy, wdev, cookie), 3936 TP_STRUCT__entry( 3937 WIPHY_ENTRY 3938 WDEV_ENTRY 3939 __field(u64, cookie) 3940 ), 3941 TP_fast_assign( 3942 WIPHY_ASSIGN; 3943 WDEV_ASSIGN; 3944 __entry->cookie = cookie; 3945 ), 3946 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie:%lld", 3947 WIPHY_PR_ARG, WDEV_PR_ARG, 3948 (unsigned long long)__entry->cookie) 3949 ); 3950 3951 TRACE_EVENT(cfg80211_update_owe_info_event, 3952 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3953 struct cfg80211_update_owe_info *owe_info), 3954 TP_ARGS(wiphy, netdev, owe_info), 3955 TP_STRUCT__entry( 3956 WIPHY_ENTRY 3957 NETDEV_ENTRY 3958 MAC_ENTRY(peer) 3959 __dynamic_array(u8, ie, owe_info->ie_len) 3960 __field(int, assoc_link_id) 3961 MAC_ENTRY(peer_mld_addr) 3962 ), 3963 TP_fast_assign( 3964 WIPHY_ASSIGN; 3965 NETDEV_ASSIGN; 3966 MAC_ASSIGN(peer, owe_info->peer); 3967 memcpy(__get_dynamic_array(ie), owe_info->ie, 3968 owe_info->ie_len); 3969 __entry->assoc_link_id = owe_info->assoc_link_id; 3970 MAC_ASSIGN(peer_mld_addr, owe_info->peer_mld_addr); 3971 ), 3972 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM," 3973 " assoc_link_id: %d, peer_mld_addr: %pM", 3974 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, 3975 __entry->assoc_link_id, __entry->peer_mld_addr) 3976 ); 3977 3978 TRACE_EVENT(cfg80211_bss_color_notify, 3979 TP_PROTO(struct net_device *netdev, 3980 enum nl80211_commands cmd, 3981 u8 count, u64 color_bitmap), 3982 TP_ARGS(netdev, cmd, count, color_bitmap), 3983 TP_STRUCT__entry( 3984 NETDEV_ENTRY 3985 __field(u32, cmd) 3986 __field(u8, count) 3987 __field(u64, color_bitmap) 3988 ), 3989 TP_fast_assign( 3990 NETDEV_ASSIGN; 3991 __entry->cmd = cmd; 3992 __entry->count = count; 3993 __entry->color_bitmap = color_bitmap; 3994 ), 3995 TP_printk(NETDEV_PR_FMT ", cmd: %x, count: %u, bitmap: %llx", 3996 NETDEV_PR_ARG, __entry->cmd, __entry->count, 3997 __entry->color_bitmap) 3998 ); 3999 4000 TRACE_EVENT(cfg80211_assoc_comeback, 4001 TP_PROTO(struct wireless_dev *wdev, const u8 *ap_addr, u32 timeout), 4002 TP_ARGS(wdev, ap_addr, timeout), 4003 TP_STRUCT__entry( 4004 WDEV_ENTRY 4005 MAC_ENTRY(ap_addr) 4006 __field(u32, timeout) 4007 ), 4008 TP_fast_assign( 4009 WDEV_ASSIGN; 4010 MAC_ASSIGN(ap_addr, ap_addr); 4011 __entry->timeout = timeout; 4012 ), 4013 TP_printk(WDEV_PR_FMT ", %pM, timeout: %u TUs", 4014 WDEV_PR_ARG, __entry->ap_addr, __entry->timeout) 4015 ); 4016 4017 DECLARE_EVENT_CLASS(link_station_add_mod, 4018 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4019 struct link_station_parameters *params), 4020 TP_ARGS(wiphy, netdev, params), 4021 TP_STRUCT__entry( 4022 WIPHY_ENTRY 4023 NETDEV_ENTRY 4024 __array(u8, mld_mac, 6) 4025 __array(u8, link_mac, 6) 4026 __field(u32, link_id) 4027 __dynamic_array(u8, supported_rates, 4028 params->supported_rates_len) 4029 __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap)) 4030 __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap)) 4031 __field(u8, opmode_notif) 4032 __field(bool, opmode_notif_used) 4033 __dynamic_array(u8, he_capa, params->he_capa_len) 4034 __array(u8, he_6ghz_capa, (int)sizeof(struct ieee80211_he_6ghz_capa)) 4035 __dynamic_array(u8, eht_capa, params->eht_capa_len) 4036 ), 4037 TP_fast_assign( 4038 WIPHY_ASSIGN; 4039 NETDEV_ASSIGN; 4040 memset(__entry->mld_mac, 0, 6); 4041 memset(__entry->link_mac, 0, 6); 4042 if (params->mld_mac) 4043 memcpy(__entry->mld_mac, params->mld_mac, 6); 4044 if (params->link_mac) 4045 memcpy(__entry->link_mac, params->link_mac, 6); 4046 __entry->link_id = params->link_id; 4047 if (params->supported_rates && params->supported_rates_len) 4048 memcpy(__get_dynamic_array(supported_rates), 4049 params->supported_rates, 4050 params->supported_rates_len); 4051 memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap)); 4052 if (params->ht_capa) 4053 memcpy(__entry->ht_capa, params->ht_capa, 4054 sizeof(struct ieee80211_ht_cap)); 4055 memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap)); 4056 if (params->vht_capa) 4057 memcpy(__entry->vht_capa, params->vht_capa, 4058 sizeof(struct ieee80211_vht_cap)); 4059 __entry->opmode_notif = params->opmode_notif; 4060 __entry->opmode_notif_used = params->opmode_notif_used; 4061 if (params->he_capa && params->he_capa_len) 4062 memcpy(__get_dynamic_array(he_capa), params->he_capa, 4063 params->he_capa_len); 4064 memset(__entry->he_6ghz_capa, 0, sizeof(struct ieee80211_he_6ghz_capa)); 4065 if (params->he_6ghz_capa) 4066 memcpy(__entry->he_6ghz_capa, params->he_6ghz_capa, 4067 sizeof(struct ieee80211_he_6ghz_capa)); 4068 if (params->eht_capa && params->eht_capa_len) 4069 memcpy(__get_dynamic_array(eht_capa), params->eht_capa, 4070 params->eht_capa_len); 4071 ), 4072 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" 4073 ", link mac: %pM, link id: %u", 4074 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac, 4075 __entry->link_mac, __entry->link_id) 4076 ); 4077 4078 DEFINE_EVENT(link_station_add_mod, rdev_add_link_station, 4079 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4080 struct link_station_parameters *params), 4081 TP_ARGS(wiphy, netdev, params) 4082 ); 4083 4084 DEFINE_EVENT(link_station_add_mod, rdev_mod_link_station, 4085 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 4086 struct link_station_parameters *params), 4087 TP_ARGS(wiphy, netdev, params) 4088 ); 4089 4090 TRACE_EVENT(cfg80211_links_removed, 4091 TP_PROTO(struct net_device *netdev, u16 link_mask), 4092 TP_ARGS(netdev, link_mask), 4093 TP_STRUCT__entry( 4094 NETDEV_ENTRY 4095 __field(u16, link_mask) 4096 ), 4097 TP_fast_assign( 4098 NETDEV_ASSIGN; 4099 __entry->link_mask = link_mask; 4100 ), 4101 TP_printk(NETDEV_PR_FMT ", link_mask:%u", NETDEV_PR_ARG, 4102 __entry->link_mask) 4103 ); 4104 4105 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */ 4106 4107 #undef TRACE_INCLUDE_PATH 4108 #define TRACE_INCLUDE_PATH . 4109 #undef TRACE_INCLUDE_FILE 4110 #define TRACE_INCLUDE_FILE trace 4111 #include <trace/define_trace.h> 4112