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