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