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