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, bands); 1919 ), 1920 TP_fast_assign( 1921 WIPHY_ASSIGN; 1922 WDEV_ASSIGN; 1923 __entry->master_pref = conf->master_pref; 1924 __entry->bands = conf->bands; 1925 ), 1926 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 1927 ", master preference: %u, bands: 0x%0x", 1928 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 1929 __entry->bands) 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, bands); 1941 __field(u32, changes); 1942 ), 1943 TP_fast_assign( 1944 WIPHY_ASSIGN; 1945 WDEV_ASSIGN; 1946 __entry->master_pref = conf->master_pref; 1947 __entry->bands = conf->bands; 1948 __entry->changes = changes; 1949 ), 1950 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 1951 ", master preference: %u, bands: 0x%0x, changes: %x", 1952 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 1953 __entry->bands, __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 s32 rssi_level), 2495 TP_ARGS(netdev, rssi_event, rssi_level), 2496 TP_STRUCT__entry( 2497 NETDEV_ENTRY 2498 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event) 2499 __field(s32, rssi_level) 2500 ), 2501 TP_fast_assign( 2502 NETDEV_ASSIGN; 2503 __entry->rssi_event = rssi_event; 2504 __entry->rssi_level = rssi_level; 2505 ), 2506 TP_printk(NETDEV_PR_FMT ", rssi event: %d, level: %d", 2507 NETDEV_PR_ARG, __entry->rssi_event, __entry->rssi_level) 2508 ); 2509 2510 TRACE_EVENT(cfg80211_reg_can_beacon, 2511 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 2512 enum nl80211_iftype iftype, bool check_no_ir), 2513 TP_ARGS(wiphy, chandef, iftype, check_no_ir), 2514 TP_STRUCT__entry( 2515 WIPHY_ENTRY 2516 CHAN_DEF_ENTRY 2517 __field(enum nl80211_iftype, iftype) 2518 __field(bool, check_no_ir) 2519 ), 2520 TP_fast_assign( 2521 WIPHY_ASSIGN; 2522 CHAN_DEF_ASSIGN(chandef); 2523 __entry->iftype = iftype; 2524 __entry->check_no_ir = check_no_ir; 2525 ), 2526 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d check_no_ir=%s", 2527 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype, 2528 BOOL_TO_STR(__entry->check_no_ir)) 2529 ); 2530 2531 TRACE_EVENT(cfg80211_chandef_dfs_required, 2532 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2533 TP_ARGS(wiphy, chandef), 2534 TP_STRUCT__entry( 2535 WIPHY_ENTRY 2536 CHAN_DEF_ENTRY 2537 ), 2538 TP_fast_assign( 2539 WIPHY_ASSIGN; 2540 CHAN_DEF_ASSIGN(chandef); 2541 ), 2542 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2543 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2544 ); 2545 2546 TRACE_EVENT(cfg80211_ch_switch_notify, 2547 TP_PROTO(struct net_device *netdev, 2548 struct cfg80211_chan_def *chandef), 2549 TP_ARGS(netdev, chandef), 2550 TP_STRUCT__entry( 2551 NETDEV_ENTRY 2552 CHAN_DEF_ENTRY 2553 ), 2554 TP_fast_assign( 2555 NETDEV_ASSIGN; 2556 CHAN_DEF_ASSIGN(chandef); 2557 ), 2558 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2559 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2560 ); 2561 2562 TRACE_EVENT(cfg80211_ch_switch_started_notify, 2563 TP_PROTO(struct net_device *netdev, 2564 struct cfg80211_chan_def *chandef), 2565 TP_ARGS(netdev, chandef), 2566 TP_STRUCT__entry( 2567 NETDEV_ENTRY 2568 CHAN_DEF_ENTRY 2569 ), 2570 TP_fast_assign( 2571 NETDEV_ASSIGN; 2572 CHAN_DEF_ASSIGN(chandef); 2573 ), 2574 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2575 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2576 ); 2577 2578 TRACE_EVENT(cfg80211_radar_event, 2579 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2580 TP_ARGS(wiphy, chandef), 2581 TP_STRUCT__entry( 2582 WIPHY_ENTRY 2583 CHAN_DEF_ENTRY 2584 ), 2585 TP_fast_assign( 2586 WIPHY_ASSIGN; 2587 CHAN_DEF_ASSIGN(chandef); 2588 ), 2589 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2590 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2591 ); 2592 2593 TRACE_EVENT(cfg80211_cac_event, 2594 TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), 2595 TP_ARGS(netdev, evt), 2596 TP_STRUCT__entry( 2597 NETDEV_ENTRY 2598 __field(enum nl80211_radar_event, evt) 2599 ), 2600 TP_fast_assign( 2601 NETDEV_ASSIGN; 2602 __entry->evt = evt; 2603 ), 2604 TP_printk(NETDEV_PR_FMT ", event: %d", 2605 NETDEV_PR_ARG, __entry->evt) 2606 ); 2607 2608 DECLARE_EVENT_CLASS(cfg80211_rx_evt, 2609 TP_PROTO(struct net_device *netdev, const u8 *addr), 2610 TP_ARGS(netdev, addr), 2611 TP_STRUCT__entry( 2612 NETDEV_ENTRY 2613 MAC_ENTRY(addr) 2614 ), 2615 TP_fast_assign( 2616 NETDEV_ASSIGN; 2617 MAC_ASSIGN(addr, addr); 2618 ), 2619 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr)) 2620 ); 2621 2622 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, 2623 TP_PROTO(struct net_device *netdev, const u8 *addr), 2624 TP_ARGS(netdev, addr) 2625 ); 2626 2627 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, 2628 TP_PROTO(struct net_device *netdev, const u8 *addr), 2629 TP_ARGS(netdev, addr) 2630 ); 2631 2632 TRACE_EVENT(cfg80211_ibss_joined, 2633 TP_PROTO(struct net_device *netdev, const u8 *bssid, 2634 struct ieee80211_channel *channel), 2635 TP_ARGS(netdev, bssid, channel), 2636 TP_STRUCT__entry( 2637 NETDEV_ENTRY 2638 MAC_ENTRY(bssid) 2639 CHAN_ENTRY 2640 ), 2641 TP_fast_assign( 2642 NETDEV_ASSIGN; 2643 MAC_ASSIGN(bssid, bssid); 2644 CHAN_ASSIGN(channel); 2645 ), 2646 TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT, 2647 NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2648 ); 2649 2650 TRACE_EVENT(cfg80211_probe_status, 2651 TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, 2652 bool acked), 2653 TP_ARGS(netdev, addr, cookie, acked), 2654 TP_STRUCT__entry( 2655 NETDEV_ENTRY 2656 MAC_ENTRY(addr) 2657 __field(u64, cookie) 2658 __field(bool, acked) 2659 ), 2660 TP_fast_assign( 2661 NETDEV_ASSIGN; 2662 MAC_ASSIGN(addr, addr); 2663 __entry->cookie = cookie; 2664 __entry->acked = acked; 2665 ), 2666 TP_printk(NETDEV_PR_FMT " addr:" MAC_PR_FMT ", cookie: %llu, acked: %s", 2667 NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie, 2668 BOOL_TO_STR(__entry->acked)) 2669 ); 2670 2671 TRACE_EVENT(cfg80211_cqm_pktloss_notify, 2672 TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), 2673 TP_ARGS(netdev, peer, num_packets), 2674 TP_STRUCT__entry( 2675 NETDEV_ENTRY 2676 MAC_ENTRY(peer) 2677 __field(u32, num_packets) 2678 ), 2679 TP_fast_assign( 2680 NETDEV_ASSIGN; 2681 MAC_ASSIGN(peer, peer); 2682 __entry->num_packets = num_packets; 2683 ), 2684 TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u", 2685 NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets) 2686 ); 2687 2688 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, 2689 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2690 TP_ARGS(netdev, macaddr) 2691 ); 2692 2693 TRACE_EVENT(cfg80211_pmksa_candidate_notify, 2694 TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, 2695 bool preauth), 2696 TP_ARGS(netdev, index, bssid, preauth), 2697 TP_STRUCT__entry( 2698 NETDEV_ENTRY 2699 __field(int, index) 2700 MAC_ENTRY(bssid) 2701 __field(bool, preauth) 2702 ), 2703 TP_fast_assign( 2704 NETDEV_ASSIGN; 2705 __entry->index = index; 2706 MAC_ASSIGN(bssid, bssid); 2707 __entry->preauth = preauth; 2708 ), 2709 TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s", 2710 NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid), 2711 BOOL_TO_STR(__entry->preauth)) 2712 ); 2713 2714 TRACE_EVENT(cfg80211_report_obss_beacon, 2715 TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, 2716 int freq, int sig_dbm), 2717 TP_ARGS(wiphy, frame, len, freq, sig_dbm), 2718 TP_STRUCT__entry( 2719 WIPHY_ENTRY 2720 __field(int, freq) 2721 __field(int, sig_dbm) 2722 ), 2723 TP_fast_assign( 2724 WIPHY_ASSIGN; 2725 __entry->freq = freq; 2726 __entry->sig_dbm = sig_dbm; 2727 ), 2728 TP_printk(WIPHY_PR_FMT ", freq: %d, sig_dbm: %d", 2729 WIPHY_PR_ARG, __entry->freq, __entry->sig_dbm) 2730 ); 2731 2732 TRACE_EVENT(cfg80211_tdls_oper_request, 2733 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, 2734 enum nl80211_tdls_operation oper, u16 reason_code), 2735 TP_ARGS(wiphy, netdev, peer, oper, reason_code), 2736 TP_STRUCT__entry( 2737 WIPHY_ENTRY 2738 NETDEV_ENTRY 2739 MAC_ENTRY(peer) 2740 __field(enum nl80211_tdls_operation, oper) 2741 __field(u16, reason_code) 2742 ), 2743 TP_fast_assign( 2744 WIPHY_ASSIGN; 2745 NETDEV_ASSIGN; 2746 MAC_ASSIGN(peer, peer); 2747 __entry->oper = oper; 2748 __entry->reason_code = reason_code; 2749 ), 2750 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", oper: %d, reason_code %u", 2751 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper, 2752 __entry->reason_code) 2753 ); 2754 2755 TRACE_EVENT(cfg80211_scan_done, 2756 TP_PROTO(struct cfg80211_scan_request *request, 2757 struct cfg80211_scan_info *info), 2758 TP_ARGS(request, info), 2759 TP_STRUCT__entry( 2760 __field(u32, n_channels) 2761 __dynamic_array(u8, ie, request ? request->ie_len : 0) 2762 __array(u32, rates, NUM_NL80211_BANDS) 2763 __field(u32, wdev_id) 2764 MAC_ENTRY(wiphy_mac) 2765 __field(bool, no_cck) 2766 __field(bool, aborted) 2767 __field(u64, scan_start_tsf) 2768 MAC_ENTRY(tsf_bssid) 2769 ), 2770 TP_fast_assign( 2771 if (request) { 2772 memcpy(__get_dynamic_array(ie), request->ie, 2773 request->ie_len); 2774 memcpy(__entry->rates, request->rates, 2775 NUM_NL80211_BANDS); 2776 __entry->wdev_id = request->wdev ? 2777 request->wdev->identifier : 0; 2778 if (request->wiphy) 2779 MAC_ASSIGN(wiphy_mac, 2780 request->wiphy->perm_addr); 2781 __entry->no_cck = request->no_cck; 2782 } 2783 if (info) { 2784 __entry->aborted = info->aborted; 2785 __entry->scan_start_tsf = info->scan_start_tsf; 2786 MAC_ASSIGN(tsf_bssid, info->tsf_bssid); 2787 } 2788 ), 2789 TP_printk("aborted: %s, scan start (TSF): %llu, tsf_bssid: " MAC_PR_FMT, 2790 BOOL_TO_STR(__entry->aborted), 2791 (unsigned long long)__entry->scan_start_tsf, 2792 MAC_PR_ARG(tsf_bssid)) 2793 ); 2794 2795 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_results, 2796 TP_PROTO(struct wiphy *wiphy), 2797 TP_ARGS(wiphy) 2798 ); 2799 2800 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_stopped, 2801 TP_PROTO(struct wiphy *wiphy), 2802 TP_ARGS(wiphy) 2803 ); 2804 2805 TRACE_EVENT(cfg80211_get_bss, 2806 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, 2807 const u8 *bssid, const u8 *ssid, size_t ssid_len, 2808 enum ieee80211_bss_type bss_type, 2809 enum ieee80211_privacy privacy), 2810 TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy), 2811 TP_STRUCT__entry( 2812 WIPHY_ENTRY 2813 CHAN_ENTRY 2814 MAC_ENTRY(bssid) 2815 __dynamic_array(u8, ssid, ssid_len) 2816 __field(enum ieee80211_bss_type, bss_type) 2817 __field(enum ieee80211_privacy, privacy) 2818 ), 2819 TP_fast_assign( 2820 WIPHY_ASSIGN; 2821 CHAN_ASSIGN(channel); 2822 MAC_ASSIGN(bssid, bssid); 2823 memcpy(__get_dynamic_array(ssid), ssid, ssid_len); 2824 __entry->bss_type = bss_type; 2825 __entry->privacy = privacy; 2826 ), 2827 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", " MAC_PR_FMT 2828 ", buf: %#.2x, bss_type: %d, privacy: %d", 2829 WIPHY_PR_ARG, CHAN_PR_ARG, MAC_PR_ARG(bssid), 2830 ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type, 2831 __entry->privacy) 2832 ); 2833 2834 TRACE_EVENT(cfg80211_inform_bss_frame, 2835 TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, 2836 struct ieee80211_mgmt *mgmt, size_t len), 2837 TP_ARGS(wiphy, data, mgmt, len), 2838 TP_STRUCT__entry( 2839 WIPHY_ENTRY 2840 CHAN_ENTRY 2841 __field(enum nl80211_bss_scan_width, scan_width) 2842 __dynamic_array(u8, mgmt, len) 2843 __field(s32, signal) 2844 __field(u64, ts_boottime) 2845 __field(u64, parent_tsf) 2846 MAC_ENTRY(parent_bssid) 2847 ), 2848 TP_fast_assign( 2849 WIPHY_ASSIGN; 2850 CHAN_ASSIGN(data->chan); 2851 __entry->scan_width = data->scan_width; 2852 if (mgmt) 2853 memcpy(__get_dynamic_array(mgmt), mgmt, len); 2854 __entry->signal = data->signal; 2855 __entry->ts_boottime = data->boottime_ns; 2856 __entry->parent_tsf = data->parent_tsf; 2857 MAC_ASSIGN(parent_bssid, data->parent_bssid); 2858 ), 2859 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT 2860 "(scan_width: %d) signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: " 2861 MAC_PR_FMT, WIPHY_PR_ARG, CHAN_PR_ARG, __entry->scan_width, 2862 __entry->signal, (unsigned long long)__entry->ts_boottime, 2863 (unsigned long long)__entry->parent_tsf, 2864 MAC_PR_ARG(parent_bssid)) 2865 ); 2866 2867 DECLARE_EVENT_CLASS(cfg80211_bss_evt, 2868 TP_PROTO(struct cfg80211_bss *pub), 2869 TP_ARGS(pub), 2870 TP_STRUCT__entry( 2871 MAC_ENTRY(bssid) 2872 CHAN_ENTRY 2873 ), 2874 TP_fast_assign( 2875 MAC_ASSIGN(bssid, pub->bssid); 2876 CHAN_ASSIGN(pub->channel); 2877 ), 2878 TP_printk(MAC_PR_FMT ", " CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2879 ); 2880 2881 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, 2882 TP_PROTO(struct cfg80211_bss *pub), 2883 TP_ARGS(pub) 2884 ); 2885 2886 TRACE_EVENT(cfg80211_return_uint, 2887 TP_PROTO(unsigned int ret), 2888 TP_ARGS(ret), 2889 TP_STRUCT__entry( 2890 __field(unsigned int, ret) 2891 ), 2892 TP_fast_assign( 2893 __entry->ret = ret; 2894 ), 2895 TP_printk("ret: %d", __entry->ret) 2896 ); 2897 2898 TRACE_EVENT(cfg80211_return_u32, 2899 TP_PROTO(u32 ret), 2900 TP_ARGS(ret), 2901 TP_STRUCT__entry( 2902 __field(u32, ret) 2903 ), 2904 TP_fast_assign( 2905 __entry->ret = ret; 2906 ), 2907 TP_printk("ret: %u", __entry->ret) 2908 ); 2909 2910 TRACE_EVENT(cfg80211_report_wowlan_wakeup, 2911 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2912 struct cfg80211_wowlan_wakeup *wakeup), 2913 TP_ARGS(wiphy, wdev, wakeup), 2914 TP_STRUCT__entry( 2915 WIPHY_ENTRY 2916 WDEV_ENTRY 2917 __field(bool, non_wireless) 2918 __field(bool, disconnect) 2919 __field(bool, magic_pkt) 2920 __field(bool, gtk_rekey_failure) 2921 __field(bool, eap_identity_req) 2922 __field(bool, four_way_handshake) 2923 __field(bool, rfkill_release) 2924 __field(s32, pattern_idx) 2925 __field(u32, packet_len) 2926 __dynamic_array(u8, packet, 2927 wakeup ? wakeup->packet_present_len : 0) 2928 ), 2929 TP_fast_assign( 2930 WIPHY_ASSIGN; 2931 WDEV_ASSIGN; 2932 __entry->non_wireless = !wakeup; 2933 __entry->disconnect = wakeup ? wakeup->disconnect : false; 2934 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false; 2935 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false; 2936 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false; 2937 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false; 2938 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false; 2939 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false; 2940 __entry->packet_len = wakeup ? wakeup->packet_len : false; 2941 if (wakeup && wakeup->packet && wakeup->packet_present_len) 2942 memcpy(__get_dynamic_array(packet), wakeup->packet, 2943 wakeup->packet_present_len); 2944 ), 2945 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 2946 ); 2947 2948 TRACE_EVENT(cfg80211_ft_event, 2949 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2950 struct cfg80211_ft_event_params *ft_event), 2951 TP_ARGS(wiphy, netdev, ft_event), 2952 TP_STRUCT__entry( 2953 WIPHY_ENTRY 2954 NETDEV_ENTRY 2955 __dynamic_array(u8, ies, ft_event->ies_len) 2956 MAC_ENTRY(target_ap) 2957 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len) 2958 ), 2959 TP_fast_assign( 2960 WIPHY_ASSIGN; 2961 NETDEV_ASSIGN; 2962 if (ft_event->ies) 2963 memcpy(__get_dynamic_array(ies), ft_event->ies, 2964 ft_event->ies_len); 2965 MAC_ASSIGN(target_ap, ft_event->target_ap); 2966 if (ft_event->ric_ies) 2967 memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies, 2968 ft_event->ric_ies_len); 2969 ), 2970 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: " MAC_PR_FMT, 2971 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(target_ap)) 2972 ); 2973 2974 TRACE_EVENT(cfg80211_stop_iface, 2975 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2976 TP_ARGS(wiphy, wdev), 2977 TP_STRUCT__entry( 2978 WIPHY_ENTRY 2979 WDEV_ENTRY 2980 ), 2981 TP_fast_assign( 2982 WIPHY_ASSIGN; 2983 WDEV_ASSIGN; 2984 ), 2985 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 2986 WIPHY_PR_ARG, WDEV_PR_ARG) 2987 ); 2988 2989 TRACE_EVENT(rdev_start_radar_detection, 2990 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2991 struct cfg80211_chan_def *chandef, 2992 u32 cac_time_ms), 2993 TP_ARGS(wiphy, netdev, chandef, cac_time_ms), 2994 TP_STRUCT__entry( 2995 WIPHY_ENTRY 2996 NETDEV_ENTRY 2997 CHAN_DEF_ENTRY 2998 __field(u32, cac_time_ms) 2999 ), 3000 TP_fast_assign( 3001 WIPHY_ASSIGN; 3002 NETDEV_ASSIGN; 3003 CHAN_DEF_ASSIGN(chandef); 3004 __entry->cac_time_ms = cac_time_ms; 3005 ), 3006 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 3007 ", cac_time_ms=%u", 3008 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 3009 __entry->cac_time_ms) 3010 ); 3011 3012 TRACE_EVENT(rdev_set_mcast_rate, 3013 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3014 int mcast_rate[NUM_NL80211_BANDS]), 3015 TP_ARGS(wiphy, netdev, mcast_rate), 3016 TP_STRUCT__entry( 3017 WIPHY_ENTRY 3018 NETDEV_ENTRY 3019 __array(int, mcast_rate, NUM_NL80211_BANDS) 3020 ), 3021 TP_fast_assign( 3022 WIPHY_ASSIGN; 3023 NETDEV_ASSIGN; 3024 memcpy(__entry->mcast_rate, mcast_rate, 3025 sizeof(int) * NUM_NL80211_BANDS); 3026 ), 3027 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " 3028 "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 60GHz=0x%x]", 3029 WIPHY_PR_ARG, NETDEV_PR_ARG, 3030 __entry->mcast_rate[NL80211_BAND_2GHZ], 3031 __entry->mcast_rate[NL80211_BAND_5GHZ], 3032 __entry->mcast_rate[NL80211_BAND_60GHZ]) 3033 ); 3034 3035 TRACE_EVENT(rdev_set_coalesce, 3036 TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), 3037 TP_ARGS(wiphy, coalesce), 3038 TP_STRUCT__entry( 3039 WIPHY_ENTRY 3040 __field(int, n_rules) 3041 ), 3042 TP_fast_assign( 3043 WIPHY_ASSIGN; 3044 __entry->n_rules = coalesce ? coalesce->n_rules : 0; 3045 ), 3046 TP_printk(WIPHY_PR_FMT ", n_rules=%d", 3047 WIPHY_PR_ARG, __entry->n_rules) 3048 ); 3049 3050 DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, 3051 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 3052 TP_ARGS(wiphy, wdev) 3053 ); 3054 3055 TRACE_EVENT(rdev_set_multicast_to_unicast, 3056 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 3057 const bool enabled), 3058 TP_ARGS(wiphy, netdev, enabled), 3059 TP_STRUCT__entry( 3060 WIPHY_ENTRY 3061 NETDEV_ENTRY 3062 __field(bool, enabled) 3063 ), 3064 TP_fast_assign( 3065 WIPHY_ASSIGN; 3066 NETDEV_ASSIGN; 3067 __entry->enabled = enabled; 3068 ), 3069 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", unicast: %s", 3070 WIPHY_PR_ARG, NETDEV_PR_ARG, 3071 BOOL_TO_STR(__entry->enabled)) 3072 ); 3073 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */ 3074 3075 #undef TRACE_INCLUDE_PATH 3076 #define TRACE_INCLUDE_PATH . 3077 #undef TRACE_INCLUDE_FILE 3078 #define TRACE_INCLUDE_FILE trace 3079 #include <trace/define_trace.h> 3080