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