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