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