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