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