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