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