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_set_cqm_rssi_config, 1285 TP_PROTO(struct wiphy *wiphy, 1286 struct net_device *netdev, s32 rssi_thold, 1287 u32 rssi_hyst), 1288 TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst), 1289 TP_STRUCT__entry( 1290 WIPHY_ENTRY 1291 NETDEV_ENTRY 1292 __field(s32, rssi_thold) 1293 __field(u32, rssi_hyst) 1294 ), 1295 TP_fast_assign( 1296 WIPHY_ASSIGN; 1297 NETDEV_ASSIGN; 1298 __entry->rssi_thold = rssi_thold; 1299 __entry->rssi_hyst = rssi_hyst; 1300 ), 1301 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT 1302 ", rssi_thold: %d, rssi_hyst: %u ", 1303 WIPHY_PR_ARG, NETDEV_PR_ARG, 1304 __entry->rssi_thold, __entry->rssi_hyst) 1305 ); 1306 1307 TRACE_EVENT(rdev_set_cqm_txe_config, 1308 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, 1309 u32 pkts, u32 intvl), 1310 TP_ARGS(wiphy, netdev, rate, pkts, intvl), 1311 TP_STRUCT__entry( 1312 WIPHY_ENTRY 1313 NETDEV_ENTRY 1314 __field(u32, rate) 1315 __field(u32, pkts) 1316 __field(u32, intvl) 1317 ), 1318 TP_fast_assign( 1319 WIPHY_ASSIGN; 1320 NETDEV_ASSIGN; 1321 __entry->rate = rate; 1322 __entry->pkts = pkts; 1323 __entry->intvl = intvl; 1324 ), 1325 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u", 1326 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts, 1327 __entry->intvl) 1328 ); 1329 1330 TRACE_EVENT(rdev_disconnect, 1331 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1332 u16 reason_code), 1333 TP_ARGS(wiphy, netdev, reason_code), 1334 TP_STRUCT__entry( 1335 WIPHY_ENTRY 1336 NETDEV_ENTRY 1337 __field(u16, reason_code) 1338 ), 1339 TP_fast_assign( 1340 WIPHY_ASSIGN; 1341 NETDEV_ASSIGN; 1342 __entry->reason_code = reason_code; 1343 ), 1344 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG, 1345 NETDEV_PR_ARG, __entry->reason_code) 1346 ); 1347 1348 TRACE_EVENT(rdev_join_ibss, 1349 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1350 struct cfg80211_ibss_params *params), 1351 TP_ARGS(wiphy, netdev, params), 1352 TP_STRUCT__entry( 1353 WIPHY_ENTRY 1354 NETDEV_ENTRY 1355 MAC_ENTRY(bssid) 1356 __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) 1357 ), 1358 TP_fast_assign( 1359 WIPHY_ASSIGN; 1360 NETDEV_ASSIGN; 1361 MAC_ASSIGN(bssid, params->bssid); 1362 memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); 1363 memcpy(__entry->ssid, params->ssid, params->ssid_len); 1364 ), 1365 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", ssid: %s", 1366 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid), __entry->ssid) 1367 ); 1368 1369 TRACE_EVENT(rdev_join_ocb, 1370 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1371 const struct ocb_setup *setup), 1372 TP_ARGS(wiphy, netdev, setup), 1373 TP_STRUCT__entry( 1374 WIPHY_ENTRY 1375 NETDEV_ENTRY 1376 ), 1377 TP_fast_assign( 1378 WIPHY_ASSIGN; 1379 NETDEV_ASSIGN; 1380 ), 1381 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, 1382 WIPHY_PR_ARG, NETDEV_PR_ARG) 1383 ); 1384 1385 TRACE_EVENT(rdev_set_wiphy_params, 1386 TP_PROTO(struct wiphy *wiphy, u32 changed), 1387 TP_ARGS(wiphy, changed), 1388 TP_STRUCT__entry( 1389 WIPHY_ENTRY 1390 __field(u32, changed) 1391 ), 1392 TP_fast_assign( 1393 WIPHY_ASSIGN; 1394 __entry->changed = changed; 1395 ), 1396 TP_printk(WIPHY_PR_FMT ", changed: %u", 1397 WIPHY_PR_ARG, __entry->changed) 1398 ); 1399 1400 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, 1401 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1402 TP_ARGS(wiphy, wdev) 1403 ); 1404 1405 TRACE_EVENT(rdev_set_tx_power, 1406 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1407 enum nl80211_tx_power_setting type, int mbm), 1408 TP_ARGS(wiphy, wdev, type, mbm), 1409 TP_STRUCT__entry( 1410 WIPHY_ENTRY 1411 WDEV_ENTRY 1412 __field(enum nl80211_tx_power_setting, type) 1413 __field(int, mbm) 1414 ), 1415 TP_fast_assign( 1416 WIPHY_ASSIGN; 1417 WDEV_ASSIGN; 1418 __entry->type = type; 1419 __entry->mbm = mbm; 1420 ), 1421 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type: %u, mbm: %d", 1422 WIPHY_PR_ARG, WDEV_PR_ARG,__entry->type, __entry->mbm) 1423 ); 1424 1425 TRACE_EVENT(rdev_return_int_int, 1426 TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), 1427 TP_ARGS(wiphy, func_ret, func_fill), 1428 TP_STRUCT__entry( 1429 WIPHY_ENTRY 1430 __field(int, func_ret) 1431 __field(int, func_fill) 1432 ), 1433 TP_fast_assign( 1434 WIPHY_ASSIGN; 1435 __entry->func_ret = func_ret; 1436 __entry->func_fill = func_fill; 1437 ), 1438 TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d", 1439 WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill) 1440 ); 1441 1442 #ifdef CONFIG_NL80211_TESTMODE 1443 TRACE_EVENT(rdev_testmode_cmd, 1444 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1445 TP_ARGS(wiphy, wdev), 1446 TP_STRUCT__entry( 1447 WIPHY_ENTRY 1448 WDEV_ENTRY 1449 ), 1450 TP_fast_assign( 1451 WIPHY_ASSIGN; 1452 WDEV_ASSIGN; 1453 ), 1454 TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 1455 ); 1456 1457 TRACE_EVENT(rdev_testmode_dump, 1458 TP_PROTO(struct wiphy *wiphy), 1459 TP_ARGS(wiphy), 1460 TP_STRUCT__entry( 1461 WIPHY_ENTRY 1462 ), 1463 TP_fast_assign( 1464 WIPHY_ASSIGN; 1465 ), 1466 TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) 1467 ); 1468 #endif /* CONFIG_NL80211_TESTMODE */ 1469 1470 TRACE_EVENT(rdev_set_bitrate_mask, 1471 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1472 const u8 *peer, const struct cfg80211_bitrate_mask *mask), 1473 TP_ARGS(wiphy, netdev, peer, mask), 1474 TP_STRUCT__entry( 1475 WIPHY_ENTRY 1476 NETDEV_ENTRY 1477 MAC_ENTRY(peer) 1478 ), 1479 TP_fast_assign( 1480 WIPHY_ASSIGN; 1481 NETDEV_ASSIGN; 1482 MAC_ASSIGN(peer, peer); 1483 ), 1484 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT, 1485 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer)) 1486 ); 1487 1488 TRACE_EVENT(rdev_mgmt_frame_register, 1489 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1490 u16 frame_type, bool reg), 1491 TP_ARGS(wiphy, wdev, frame_type, reg), 1492 TP_STRUCT__entry( 1493 WIPHY_ENTRY 1494 WDEV_ENTRY 1495 __field(u16, frame_type) 1496 __field(bool, reg) 1497 ), 1498 TP_fast_assign( 1499 WIPHY_ASSIGN; 1500 WDEV_ASSIGN; 1501 __entry->frame_type = frame_type; 1502 __entry->reg = reg; 1503 ), 1504 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", frame_type: 0x%.2x, reg: %s ", 1505 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->frame_type, 1506 __entry->reg ? "true" : "false") 1507 ); 1508 1509 TRACE_EVENT(rdev_return_int_tx_rx, 1510 TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), 1511 TP_ARGS(wiphy, ret, tx, rx), 1512 TP_STRUCT__entry( 1513 WIPHY_ENTRY 1514 __field(int, ret) 1515 __field(u32, tx) 1516 __field(u32, rx) 1517 ), 1518 TP_fast_assign( 1519 WIPHY_ASSIGN; 1520 __entry->ret = ret; 1521 __entry->tx = tx; 1522 __entry->rx = rx; 1523 ), 1524 TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u", 1525 WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx) 1526 ); 1527 1528 TRACE_EVENT(rdev_return_void_tx_rx, 1529 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, 1530 u32 rx, u32 rx_max), 1531 TP_ARGS(wiphy, tx, tx_max, rx, rx_max), 1532 TP_STRUCT__entry( 1533 WIPHY_ENTRY 1534 __field(u32, tx) 1535 __field(u32, tx_max) 1536 __field(u32, rx) 1537 __field(u32, rx_max) 1538 ), 1539 TP_fast_assign( 1540 WIPHY_ASSIGN; 1541 __entry->tx = tx; 1542 __entry->tx_max = tx_max; 1543 __entry->rx = rx; 1544 __entry->rx_max = rx_max; 1545 ), 1546 TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ", 1547 WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx, 1548 __entry->rx_max) 1549 ); 1550 1551 DECLARE_EVENT_CLASS(tx_rx_evt, 1552 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), 1553 TP_ARGS(wiphy, rx, tx), 1554 TP_STRUCT__entry( 1555 WIPHY_ENTRY 1556 __field(u32, tx) 1557 __field(u32, rx) 1558 ), 1559 TP_fast_assign( 1560 WIPHY_ASSIGN; 1561 __entry->tx = tx; 1562 __entry->rx = rx; 1563 ), 1564 TP_printk(WIPHY_PR_FMT ", tx: %u, rx: %u ", 1565 WIPHY_PR_ARG, __entry->tx, __entry->rx) 1566 ); 1567 1568 DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, 1569 TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), 1570 TP_ARGS(wiphy, rx, tx) 1571 ); 1572 1573 TRACE_EVENT(rdev_sched_scan_start, 1574 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1575 struct cfg80211_sched_scan_request *request), 1576 TP_ARGS(wiphy, netdev, request), 1577 TP_STRUCT__entry( 1578 WIPHY_ENTRY 1579 NETDEV_ENTRY 1580 ), 1581 TP_fast_assign( 1582 WIPHY_ASSIGN; 1583 NETDEV_ASSIGN; 1584 ), 1585 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, 1586 WIPHY_PR_ARG, NETDEV_PR_ARG) 1587 ); 1588 1589 TRACE_EVENT(rdev_tdls_mgmt, 1590 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1591 u8 *peer, u8 action_code, u8 dialog_token, 1592 u16 status_code, u32 peer_capability, 1593 bool initiator, const u8 *buf, size_t len), 1594 TP_ARGS(wiphy, netdev, peer, action_code, dialog_token, status_code, 1595 peer_capability, initiator, buf, len), 1596 TP_STRUCT__entry( 1597 WIPHY_ENTRY 1598 NETDEV_ENTRY 1599 MAC_ENTRY(peer) 1600 __field(u8, action_code) 1601 __field(u8, dialog_token) 1602 __field(u16, status_code) 1603 __field(u32, peer_capability) 1604 __field(bool, initiator) 1605 __dynamic_array(u8, buf, len) 1606 ), 1607 TP_fast_assign( 1608 WIPHY_ASSIGN; 1609 NETDEV_ASSIGN; 1610 MAC_ASSIGN(peer, peer); 1611 __entry->action_code = action_code; 1612 __entry->dialog_token = dialog_token; 1613 __entry->status_code = status_code; 1614 __entry->peer_capability = peer_capability; 1615 __entry->initiator = initiator; 1616 memcpy(__get_dynamic_array(buf), buf, len); 1617 ), 1618 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", action_code: %u, " 1619 "dialog_token: %u, status_code: %u, peer_capability: %u " 1620 "initiator: %s buf: %#.2x ", 1621 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), 1622 __entry->action_code, __entry->dialog_token, 1623 __entry->status_code, __entry->peer_capability, 1624 BOOL_TO_STR(__entry->initiator), 1625 ((u8 *)__get_dynamic_array(buf))[0]) 1626 ); 1627 1628 TRACE_EVENT(rdev_dump_survey, 1629 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int idx), 1630 TP_ARGS(wiphy, netdev, idx), 1631 TP_STRUCT__entry( 1632 WIPHY_ENTRY 1633 NETDEV_ENTRY 1634 __field(int, idx) 1635 ), 1636 TP_fast_assign( 1637 WIPHY_ASSIGN; 1638 NETDEV_ASSIGN; 1639 __entry->idx = idx; 1640 ), 1641 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d", 1642 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx) 1643 ); 1644 1645 TRACE_EVENT(rdev_return_int_survey_info, 1646 TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), 1647 TP_ARGS(wiphy, ret, info), 1648 TP_STRUCT__entry( 1649 WIPHY_ENTRY 1650 CHAN_ENTRY 1651 __field(int, ret) 1652 __field(u64, time) 1653 __field(u64, time_busy) 1654 __field(u64, time_ext_busy) 1655 __field(u64, time_rx) 1656 __field(u64, time_tx) 1657 __field(u64, time_scan) 1658 __field(u32, filled) 1659 __field(s8, noise) 1660 ), 1661 TP_fast_assign( 1662 WIPHY_ASSIGN; 1663 CHAN_ASSIGN(info->channel); 1664 __entry->ret = ret; 1665 __entry->time = info->time; 1666 __entry->time_busy = info->time_busy; 1667 __entry->time_ext_busy = info->time_ext_busy; 1668 __entry->time_rx = info->time_rx; 1669 __entry->time_tx = info->time_tx; 1670 __entry->time_scan = info->time_scan; 1671 __entry->filled = info->filled; 1672 __entry->noise = info->noise; 1673 ), 1674 TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT 1675 ", channel time: %llu, channel time busy: %llu, " 1676 "channel time extension busy: %llu, channel time rx: %llu, " 1677 "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d", 1678 WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG, 1679 __entry->time, __entry->time_busy, 1680 __entry->time_ext_busy, __entry->time_rx, 1681 __entry->time_tx, __entry->time_scan, 1682 __entry->filled, __entry->noise) 1683 ); 1684 1685 TRACE_EVENT(rdev_tdls_oper, 1686 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1687 u8 *peer, enum nl80211_tdls_operation oper), 1688 TP_ARGS(wiphy, netdev, peer, oper), 1689 TP_STRUCT__entry( 1690 WIPHY_ENTRY 1691 NETDEV_ENTRY 1692 MAC_ENTRY(peer) 1693 __field(enum nl80211_tdls_operation, oper) 1694 ), 1695 TP_fast_assign( 1696 WIPHY_ASSIGN; 1697 NETDEV_ASSIGN; 1698 MAC_ASSIGN(peer, peer); 1699 __entry->oper = oper; 1700 ), 1701 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", oper: %d", 1702 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper) 1703 ); 1704 1705 DECLARE_EVENT_CLASS(rdev_pmksa, 1706 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1707 struct cfg80211_pmksa *pmksa), 1708 TP_ARGS(wiphy, netdev, pmksa), 1709 TP_STRUCT__entry( 1710 WIPHY_ENTRY 1711 NETDEV_ENTRY 1712 MAC_ENTRY(bssid) 1713 ), 1714 TP_fast_assign( 1715 WIPHY_ASSIGN; 1716 NETDEV_ASSIGN; 1717 MAC_ASSIGN(bssid, pmksa->bssid); 1718 ), 1719 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: " MAC_PR_FMT, 1720 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(bssid)) 1721 ); 1722 1723 TRACE_EVENT(rdev_probe_client, 1724 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1725 const u8 *peer), 1726 TP_ARGS(wiphy, netdev, peer), 1727 TP_STRUCT__entry( 1728 WIPHY_ENTRY 1729 NETDEV_ENTRY 1730 MAC_ENTRY(peer) 1731 ), 1732 TP_fast_assign( 1733 WIPHY_ASSIGN; 1734 NETDEV_ASSIGN; 1735 MAC_ASSIGN(peer, peer); 1736 ), 1737 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT, 1738 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer)) 1739 ); 1740 1741 DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, 1742 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1743 struct cfg80211_pmksa *pmksa), 1744 TP_ARGS(wiphy, netdev, pmksa) 1745 ); 1746 1747 DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, 1748 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1749 struct cfg80211_pmksa *pmksa), 1750 TP_ARGS(wiphy, netdev, pmksa) 1751 ); 1752 1753 TRACE_EVENT(rdev_remain_on_channel, 1754 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1755 struct ieee80211_channel *chan, 1756 unsigned int duration), 1757 TP_ARGS(wiphy, wdev, chan, duration), 1758 TP_STRUCT__entry( 1759 WIPHY_ENTRY 1760 WDEV_ENTRY 1761 CHAN_ENTRY 1762 __field(unsigned int, duration) 1763 ), 1764 TP_fast_assign( 1765 WIPHY_ASSIGN; 1766 WDEV_ASSIGN; 1767 CHAN_ASSIGN(chan); 1768 __entry->duration = duration; 1769 ), 1770 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u", 1771 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration) 1772 ); 1773 1774 TRACE_EVENT(rdev_return_int_cookie, 1775 TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), 1776 TP_ARGS(wiphy, ret, cookie), 1777 TP_STRUCT__entry( 1778 WIPHY_ENTRY 1779 __field(int, ret) 1780 __field(u64, cookie) 1781 ), 1782 TP_fast_assign( 1783 WIPHY_ASSIGN; 1784 __entry->ret = ret; 1785 __entry->cookie = cookie; 1786 ), 1787 TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu", 1788 WIPHY_PR_ARG, __entry->ret, __entry->cookie) 1789 ); 1790 1791 TRACE_EVENT(rdev_cancel_remain_on_channel, 1792 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), 1793 TP_ARGS(wiphy, wdev, cookie), 1794 TP_STRUCT__entry( 1795 WIPHY_ENTRY 1796 WDEV_ENTRY 1797 __field(u64, cookie) 1798 ), 1799 TP_fast_assign( 1800 WIPHY_ASSIGN; 1801 WDEV_ASSIGN; 1802 __entry->cookie = cookie; 1803 ), 1804 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu", 1805 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 1806 ); 1807 1808 TRACE_EVENT(rdev_mgmt_tx, 1809 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1810 struct cfg80211_mgmt_tx_params *params), 1811 TP_ARGS(wiphy, wdev, params), 1812 TP_STRUCT__entry( 1813 WIPHY_ENTRY 1814 WDEV_ENTRY 1815 CHAN_ENTRY 1816 __field(bool, offchan) 1817 __field(unsigned int, wait) 1818 __field(bool, no_cck) 1819 __field(bool, dont_wait_for_ack) 1820 ), 1821 TP_fast_assign( 1822 WIPHY_ASSIGN; 1823 WDEV_ASSIGN; 1824 CHAN_ASSIGN(params->chan); 1825 __entry->offchan = params->offchan; 1826 __entry->wait = params->wait; 1827 __entry->no_cck = params->no_cck; 1828 __entry->dont_wait_for_ack = params->dont_wait_for_ack; 1829 ), 1830 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s," 1831 " wait: %u, no cck: %s, dont wait for ack: %s", 1832 WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, 1833 BOOL_TO_STR(__entry->offchan), __entry->wait, 1834 BOOL_TO_STR(__entry->no_cck), 1835 BOOL_TO_STR(__entry->dont_wait_for_ack)) 1836 ); 1837 1838 TRACE_EVENT(rdev_set_noack_map, 1839 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1840 u16 noack_map), 1841 TP_ARGS(wiphy, netdev, noack_map), 1842 TP_STRUCT__entry( 1843 WIPHY_ENTRY 1844 NETDEV_ENTRY 1845 __field(u16, noack_map) 1846 ), 1847 TP_fast_assign( 1848 WIPHY_ASSIGN; 1849 NETDEV_ASSIGN; 1850 __entry->noack_map = noack_map; 1851 ), 1852 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u", 1853 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map) 1854 ); 1855 1856 DEFINE_EVENT(wiphy_wdev_evt, rdev_get_channel, 1857 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1858 TP_ARGS(wiphy, wdev) 1859 ); 1860 1861 TRACE_EVENT(rdev_return_chandef, 1862 TP_PROTO(struct wiphy *wiphy, int ret, 1863 struct cfg80211_chan_def *chandef), 1864 TP_ARGS(wiphy, ret, chandef), 1865 TP_STRUCT__entry( 1866 WIPHY_ENTRY 1867 __field(int, ret) 1868 CHAN_DEF_ENTRY 1869 ), 1870 TP_fast_assign( 1871 WIPHY_ASSIGN; 1872 if (ret == 0) 1873 CHAN_DEF_ASSIGN(chandef); 1874 else 1875 CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL); 1876 __entry->ret = ret; 1877 ), 1878 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d", 1879 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret) 1880 ); 1881 1882 DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, 1883 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1884 TP_ARGS(wiphy, wdev) 1885 ); 1886 1887 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, 1888 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1889 TP_ARGS(wiphy, wdev) 1890 ); 1891 1892 TRACE_EVENT(rdev_start_nan, 1893 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1894 struct cfg80211_nan_conf *conf), 1895 TP_ARGS(wiphy, wdev, conf), 1896 TP_STRUCT__entry( 1897 WIPHY_ENTRY 1898 WDEV_ENTRY 1899 __field(u8, master_pref) 1900 __field(u8, dual); 1901 ), 1902 TP_fast_assign( 1903 WIPHY_ASSIGN; 1904 WDEV_ASSIGN; 1905 __entry->master_pref = conf->master_pref; 1906 __entry->dual = conf->dual; 1907 ), 1908 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 1909 ", master preference: %u, dual: %d", 1910 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 1911 __entry->dual) 1912 ); 1913 1914 TRACE_EVENT(rdev_nan_change_conf, 1915 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1916 struct cfg80211_nan_conf *conf, u32 changes), 1917 TP_ARGS(wiphy, wdev, conf, changes), 1918 TP_STRUCT__entry( 1919 WIPHY_ENTRY 1920 WDEV_ENTRY 1921 __field(u8, master_pref) 1922 __field(u8, dual); 1923 __field(u32, changes); 1924 ), 1925 TP_fast_assign( 1926 WIPHY_ASSIGN; 1927 WDEV_ASSIGN; 1928 __entry->master_pref = conf->master_pref; 1929 __entry->dual = conf->dual; 1930 __entry->changes = changes; 1931 ), 1932 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT 1933 ", master preference: %u, dual: %d, changes: %x", 1934 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, 1935 __entry->dual, __entry->changes) 1936 ); 1937 1938 DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, 1939 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1940 TP_ARGS(wiphy, wdev) 1941 ); 1942 1943 TRACE_EVENT(rdev_add_nan_func, 1944 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1945 const struct cfg80211_nan_func *func), 1946 TP_ARGS(wiphy, wdev, func), 1947 TP_STRUCT__entry( 1948 WIPHY_ENTRY 1949 WDEV_ENTRY 1950 __field(u8, func_type) 1951 __field(u64, cookie) 1952 ), 1953 TP_fast_assign( 1954 WIPHY_ASSIGN; 1955 WDEV_ASSIGN; 1956 __entry->func_type = func->type; 1957 __entry->cookie = func->cookie 1958 ), 1959 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type=%u, cookie=%llu", 1960 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->func_type, 1961 __entry->cookie) 1962 ); 1963 1964 TRACE_EVENT(rdev_del_nan_func, 1965 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1966 u64 cookie), 1967 TP_ARGS(wiphy, wdev, cookie), 1968 TP_STRUCT__entry( 1969 WIPHY_ENTRY 1970 WDEV_ENTRY 1971 __field(u64, cookie) 1972 ), 1973 TP_fast_assign( 1974 WIPHY_ASSIGN; 1975 WDEV_ASSIGN; 1976 __entry->cookie = cookie; 1977 ), 1978 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie=%llu", 1979 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) 1980 ); 1981 1982 TRACE_EVENT(rdev_set_mac_acl, 1983 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1984 struct cfg80211_acl_data *params), 1985 TP_ARGS(wiphy, netdev, params), 1986 TP_STRUCT__entry( 1987 WIPHY_ENTRY 1988 NETDEV_ENTRY 1989 __field(u32, acl_policy) 1990 ), 1991 TP_fast_assign( 1992 WIPHY_ASSIGN; 1993 NETDEV_ASSIGN; 1994 __entry->acl_policy = params->acl_policy; 1995 ), 1996 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d", 1997 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy) 1998 ); 1999 2000 TRACE_EVENT(rdev_update_ft_ies, 2001 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2002 struct cfg80211_update_ft_ies_params *ftie), 2003 TP_ARGS(wiphy, netdev, ftie), 2004 TP_STRUCT__entry( 2005 WIPHY_ENTRY 2006 NETDEV_ENTRY 2007 __field(u16, md) 2008 __dynamic_array(u8, ie, ftie->ie_len) 2009 ), 2010 TP_fast_assign( 2011 WIPHY_ASSIGN; 2012 NETDEV_ASSIGN; 2013 __entry->md = ftie->md; 2014 memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len); 2015 ), 2016 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x", 2017 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md) 2018 ); 2019 2020 TRACE_EVENT(rdev_crit_proto_start, 2021 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2022 enum nl80211_crit_proto_id protocol, u16 duration), 2023 TP_ARGS(wiphy, wdev, protocol, duration), 2024 TP_STRUCT__entry( 2025 WIPHY_ENTRY 2026 WDEV_ENTRY 2027 __field(u16, proto) 2028 __field(u16, duration) 2029 ), 2030 TP_fast_assign( 2031 WIPHY_ASSIGN; 2032 WDEV_ASSIGN; 2033 __entry->proto = protocol; 2034 __entry->duration = duration; 2035 ), 2036 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u", 2037 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration) 2038 ); 2039 2040 TRACE_EVENT(rdev_crit_proto_stop, 2041 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2042 TP_ARGS(wiphy, wdev), 2043 TP_STRUCT__entry( 2044 WIPHY_ENTRY 2045 WDEV_ENTRY 2046 ), 2047 TP_fast_assign( 2048 WIPHY_ASSIGN; 2049 WDEV_ASSIGN; 2050 ), 2051 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 2052 WIPHY_PR_ARG, WDEV_PR_ARG) 2053 ); 2054 2055 TRACE_EVENT(rdev_channel_switch, 2056 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2057 struct cfg80211_csa_settings *params), 2058 TP_ARGS(wiphy, netdev, params), 2059 TP_STRUCT__entry( 2060 WIPHY_ENTRY 2061 NETDEV_ENTRY 2062 CHAN_DEF_ENTRY 2063 __field(bool, radar_required) 2064 __field(bool, block_tx) 2065 __field(u8, count) 2066 __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon) 2067 __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp) 2068 ), 2069 TP_fast_assign( 2070 WIPHY_ASSIGN; 2071 NETDEV_ASSIGN; 2072 CHAN_DEF_ASSIGN(¶ms->chandef); 2073 __entry->radar_required = params->radar_required; 2074 __entry->block_tx = params->block_tx; 2075 __entry->count = params->count; 2076 memcpy(__get_dynamic_array(bcn_ofs), 2077 params->counter_offsets_beacon, 2078 params->n_counter_offsets_beacon * sizeof(u16)); 2079 2080 /* probe response offsets are optional */ 2081 if (params->n_counter_offsets_presp) 2082 memcpy(__get_dynamic_array(pres_ofs), 2083 params->counter_offsets_presp, 2084 params->n_counter_offsets_presp * sizeof(u16)); 2085 ), 2086 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 2087 ", block_tx: %d, count: %u, radar_required: %d", 2088 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2089 __entry->block_tx, __entry->count, __entry->radar_required) 2090 ); 2091 2092 TRACE_EVENT(rdev_set_qos_map, 2093 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2094 struct cfg80211_qos_map *qos_map), 2095 TP_ARGS(wiphy, netdev, qos_map), 2096 TP_STRUCT__entry( 2097 WIPHY_ENTRY 2098 NETDEV_ENTRY 2099 QOS_MAP_ENTRY 2100 ), 2101 TP_fast_assign( 2102 WIPHY_ASSIGN; 2103 NETDEV_ASSIGN; 2104 QOS_MAP_ASSIGN(qos_map); 2105 ), 2106 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u", 2107 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des) 2108 ); 2109 2110 TRACE_EVENT(rdev_set_ap_chanwidth, 2111 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2112 struct cfg80211_chan_def *chandef), 2113 TP_ARGS(wiphy, netdev, chandef), 2114 TP_STRUCT__entry( 2115 WIPHY_ENTRY 2116 NETDEV_ENTRY 2117 CHAN_DEF_ENTRY 2118 ), 2119 TP_fast_assign( 2120 WIPHY_ASSIGN; 2121 NETDEV_ASSIGN; 2122 CHAN_DEF_ASSIGN(chandef); 2123 ), 2124 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2125 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2126 ); 2127 2128 TRACE_EVENT(rdev_add_tx_ts, 2129 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2130 u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), 2131 TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time), 2132 TP_STRUCT__entry( 2133 WIPHY_ENTRY 2134 NETDEV_ENTRY 2135 MAC_ENTRY(peer) 2136 __field(u8, tsid) 2137 __field(u8, user_prio) 2138 __field(u16, admitted_time) 2139 ), 2140 TP_fast_assign( 2141 WIPHY_ASSIGN; 2142 NETDEV_ASSIGN; 2143 MAC_ASSIGN(peer, peer); 2144 __entry->tsid = tsid; 2145 __entry->user_prio = user_prio; 2146 __entry->admitted_time = admitted_time; 2147 ), 2148 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d, UP %d, time %d", 2149 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), 2150 __entry->tsid, __entry->user_prio, __entry->admitted_time) 2151 ); 2152 2153 TRACE_EVENT(rdev_del_tx_ts, 2154 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2155 u8 tsid, const u8 *peer), 2156 TP_ARGS(wiphy, netdev, tsid, peer), 2157 TP_STRUCT__entry( 2158 WIPHY_ENTRY 2159 NETDEV_ENTRY 2160 MAC_ENTRY(peer) 2161 __field(u8, tsid) 2162 ), 2163 TP_fast_assign( 2164 WIPHY_ASSIGN; 2165 NETDEV_ASSIGN; 2166 MAC_ASSIGN(peer, peer); 2167 __entry->tsid = tsid; 2168 ), 2169 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d", 2170 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->tsid) 2171 ); 2172 2173 TRACE_EVENT(rdev_tdls_channel_switch, 2174 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2175 const u8 *addr, u8 oper_class, 2176 struct cfg80211_chan_def *chandef), 2177 TP_ARGS(wiphy, netdev, addr, oper_class, chandef), 2178 TP_STRUCT__entry( 2179 WIPHY_ENTRY 2180 NETDEV_ENTRY 2181 MAC_ENTRY(addr) 2182 __field(u8, oper_class) 2183 CHAN_DEF_ENTRY 2184 ), 2185 TP_fast_assign( 2186 WIPHY_ASSIGN; 2187 NETDEV_ASSIGN; 2188 MAC_ASSIGN(addr, addr); 2189 CHAN_DEF_ASSIGN(chandef); 2190 ), 2191 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT 2192 " oper class %d, " CHAN_DEF_PR_FMT, 2193 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr), 2194 __entry->oper_class, CHAN_DEF_PR_ARG) 2195 ); 2196 2197 TRACE_EVENT(rdev_tdls_cancel_channel_switch, 2198 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2199 const u8 *addr), 2200 TP_ARGS(wiphy, netdev, addr), 2201 TP_STRUCT__entry( 2202 WIPHY_ENTRY 2203 NETDEV_ENTRY 2204 MAC_ENTRY(addr) 2205 ), 2206 TP_fast_assign( 2207 WIPHY_ASSIGN; 2208 NETDEV_ASSIGN; 2209 MAC_ASSIGN(addr, addr); 2210 ), 2211 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT, 2212 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr)) 2213 ); 2214 2215 /************************************************************* 2216 * cfg80211 exported functions traces * 2217 *************************************************************/ 2218 2219 TRACE_EVENT(cfg80211_return_bool, 2220 TP_PROTO(bool ret), 2221 TP_ARGS(ret), 2222 TP_STRUCT__entry( 2223 __field(bool, ret) 2224 ), 2225 TP_fast_assign( 2226 __entry->ret = ret; 2227 ), 2228 TP_printk("returned %s", BOOL_TO_STR(__entry->ret)) 2229 ); 2230 2231 DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, 2232 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2233 TP_ARGS(netdev, macaddr), 2234 TP_STRUCT__entry( 2235 NETDEV_ENTRY 2236 MAC_ENTRY(macaddr) 2237 ), 2238 TP_fast_assign( 2239 NETDEV_ASSIGN; 2240 MAC_ASSIGN(macaddr, macaddr); 2241 ), 2242 TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT, 2243 NETDEV_PR_ARG, MAC_PR_ARG(macaddr)) 2244 ); 2245 2246 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, 2247 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2248 TP_ARGS(netdev, macaddr) 2249 ); 2250 2251 DECLARE_EVENT_CLASS(netdev_evt_only, 2252 TP_PROTO(struct net_device *netdev), 2253 TP_ARGS(netdev), 2254 TP_STRUCT__entry( 2255 NETDEV_ENTRY 2256 ), 2257 TP_fast_assign( 2258 NETDEV_ASSIGN; 2259 ), 2260 TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG) 2261 ); 2262 2263 DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, 2264 TP_PROTO(struct net_device *netdev), 2265 TP_ARGS(netdev) 2266 ); 2267 2268 TRACE_EVENT(cfg80211_send_rx_assoc, 2269 TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), 2270 TP_ARGS(netdev, bss), 2271 TP_STRUCT__entry( 2272 NETDEV_ENTRY 2273 MAC_ENTRY(bssid) 2274 CHAN_ENTRY 2275 ), 2276 TP_fast_assign( 2277 NETDEV_ASSIGN; 2278 MAC_ASSIGN(bssid, bss->bssid); 2279 CHAN_ASSIGN(bss->channel); 2280 ), 2281 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", " CHAN_PR_FMT, 2282 NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2283 ); 2284 2285 DECLARE_EVENT_CLASS(netdev_frame_event, 2286 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2287 TP_ARGS(netdev, buf, len), 2288 TP_STRUCT__entry( 2289 NETDEV_ENTRY 2290 __dynamic_array(u8, frame, len) 2291 ), 2292 TP_fast_assign( 2293 NETDEV_ASSIGN; 2294 memcpy(__get_dynamic_array(frame), buf, len); 2295 ), 2296 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x", 2297 NETDEV_PR_ARG, 2298 le16_to_cpup((__le16 *)__get_dynamic_array(frame))) 2299 ); 2300 2301 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, 2302 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2303 TP_ARGS(netdev, buf, len) 2304 ); 2305 2306 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, 2307 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2308 TP_ARGS(netdev, buf, len) 2309 ); 2310 2311 TRACE_EVENT(cfg80211_tx_mlme_mgmt, 2312 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2313 TP_ARGS(netdev, buf, len), 2314 TP_STRUCT__entry( 2315 NETDEV_ENTRY 2316 __dynamic_array(u8, frame, len) 2317 ), 2318 TP_fast_assign( 2319 NETDEV_ASSIGN; 2320 memcpy(__get_dynamic_array(frame), buf, len); 2321 ), 2322 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x", 2323 NETDEV_PR_ARG, 2324 le16_to_cpup((__le16 *)__get_dynamic_array(frame))) 2325 ); 2326 2327 DECLARE_EVENT_CLASS(netdev_mac_evt, 2328 TP_PROTO(struct net_device *netdev, const u8 *mac), 2329 TP_ARGS(netdev, mac), 2330 TP_STRUCT__entry( 2331 NETDEV_ENTRY 2332 MAC_ENTRY(mac) 2333 ), 2334 TP_fast_assign( 2335 NETDEV_ASSIGN; 2336 MAC_ASSIGN(mac, mac) 2337 ), 2338 TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT, 2339 NETDEV_PR_ARG, MAC_PR_ARG(mac)) 2340 ); 2341 2342 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, 2343 TP_PROTO(struct net_device *netdev, const u8 *mac), 2344 TP_ARGS(netdev, mac) 2345 ); 2346 2347 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, 2348 TP_PROTO(struct net_device *netdev, const u8 *mac), 2349 TP_ARGS(netdev, mac) 2350 ); 2351 2352 TRACE_EVENT(cfg80211_michael_mic_failure, 2353 TP_PROTO(struct net_device *netdev, const u8 *addr, 2354 enum nl80211_key_type key_type, int key_id, const u8 *tsc), 2355 TP_ARGS(netdev, addr, key_type, key_id, tsc), 2356 TP_STRUCT__entry( 2357 NETDEV_ENTRY 2358 MAC_ENTRY(addr) 2359 __field(enum nl80211_key_type, key_type) 2360 __field(int, key_id) 2361 __array(u8, tsc, 6) 2362 ), 2363 TP_fast_assign( 2364 NETDEV_ASSIGN; 2365 MAC_ASSIGN(addr, addr); 2366 __entry->key_type = key_type; 2367 __entry->key_id = key_id; 2368 if (tsc) 2369 memcpy(__entry->tsc, tsc, 6); 2370 ), 2371 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", key type: %d, key id: %d, tsc: %pm", 2372 NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->key_type, 2373 __entry->key_id, __entry->tsc) 2374 ); 2375 2376 TRACE_EVENT(cfg80211_ready_on_channel, 2377 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 2378 struct ieee80211_channel *chan, 2379 unsigned int duration), 2380 TP_ARGS(wdev, cookie, chan, duration), 2381 TP_STRUCT__entry( 2382 WDEV_ENTRY 2383 __field(u64, cookie) 2384 CHAN_ENTRY 2385 __field(unsigned int, duration) 2386 ), 2387 TP_fast_assign( 2388 WDEV_ASSIGN; 2389 __entry->cookie = cookie; 2390 CHAN_ASSIGN(chan); 2391 __entry->duration = duration; 2392 ), 2393 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u", 2394 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG, 2395 __entry->duration) 2396 ); 2397 2398 TRACE_EVENT(cfg80211_ready_on_channel_expired, 2399 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 2400 struct ieee80211_channel *chan), 2401 TP_ARGS(wdev, cookie, chan), 2402 TP_STRUCT__entry( 2403 WDEV_ENTRY 2404 __field(u64, cookie) 2405 CHAN_ENTRY 2406 ), 2407 TP_fast_assign( 2408 WDEV_ASSIGN; 2409 __entry->cookie = cookie; 2410 CHAN_ASSIGN(chan); 2411 ), 2412 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT, 2413 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG) 2414 ); 2415 2416 TRACE_EVENT(cfg80211_new_sta, 2417 TP_PROTO(struct net_device *netdev, const u8 *mac_addr, 2418 struct station_info *sinfo), 2419 TP_ARGS(netdev, mac_addr, sinfo), 2420 TP_STRUCT__entry( 2421 NETDEV_ENTRY 2422 MAC_ENTRY(mac_addr) 2423 SINFO_ENTRY 2424 ), 2425 TP_fast_assign( 2426 NETDEV_ASSIGN; 2427 MAC_ASSIGN(mac_addr, mac_addr); 2428 SINFO_ASSIGN; 2429 ), 2430 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, 2431 NETDEV_PR_ARG, MAC_PR_ARG(mac_addr)) 2432 ); 2433 2434 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, 2435 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2436 TP_ARGS(netdev, macaddr) 2437 ); 2438 2439 TRACE_EVENT(cfg80211_rx_mgmt, 2440 TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm), 2441 TP_ARGS(wdev, freq, sig_mbm), 2442 TP_STRUCT__entry( 2443 WDEV_ENTRY 2444 __field(int, freq) 2445 __field(int, sig_mbm) 2446 ), 2447 TP_fast_assign( 2448 WDEV_ASSIGN; 2449 __entry->freq = freq; 2450 __entry->sig_mbm = sig_mbm; 2451 ), 2452 TP_printk(WDEV_PR_FMT ", freq: %d, sig mbm: %d", 2453 WDEV_PR_ARG, __entry->freq, __entry->sig_mbm) 2454 ); 2455 2456 TRACE_EVENT(cfg80211_mgmt_tx_status, 2457 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), 2458 TP_ARGS(wdev, cookie, ack), 2459 TP_STRUCT__entry( 2460 WDEV_ENTRY 2461 __field(u64, cookie) 2462 __field(bool, ack) 2463 ), 2464 TP_fast_assign( 2465 WDEV_ASSIGN; 2466 __entry->cookie = cookie; 2467 __entry->ack = ack; 2468 ), 2469 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s", 2470 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack)) 2471 ); 2472 2473 TRACE_EVENT(cfg80211_cqm_rssi_notify, 2474 TP_PROTO(struct net_device *netdev, 2475 enum nl80211_cqm_rssi_threshold_event rssi_event), 2476 TP_ARGS(netdev, rssi_event), 2477 TP_STRUCT__entry( 2478 NETDEV_ENTRY 2479 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event) 2480 ), 2481 TP_fast_assign( 2482 NETDEV_ASSIGN; 2483 __entry->rssi_event = rssi_event; 2484 ), 2485 TP_printk(NETDEV_PR_FMT ", rssi event: %d", 2486 NETDEV_PR_ARG, __entry->rssi_event) 2487 ); 2488 2489 TRACE_EVENT(cfg80211_reg_can_beacon, 2490 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 2491 enum nl80211_iftype iftype, bool check_no_ir), 2492 TP_ARGS(wiphy, chandef, iftype, check_no_ir), 2493 TP_STRUCT__entry( 2494 WIPHY_ENTRY 2495 CHAN_DEF_ENTRY 2496 __field(enum nl80211_iftype, iftype) 2497 __field(bool, check_no_ir) 2498 ), 2499 TP_fast_assign( 2500 WIPHY_ASSIGN; 2501 CHAN_DEF_ASSIGN(chandef); 2502 __entry->iftype = iftype; 2503 __entry->check_no_ir = check_no_ir; 2504 ), 2505 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d check_no_ir=%s", 2506 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype, 2507 BOOL_TO_STR(__entry->check_no_ir)) 2508 ); 2509 2510 TRACE_EVENT(cfg80211_chandef_dfs_required, 2511 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2512 TP_ARGS(wiphy, chandef), 2513 TP_STRUCT__entry( 2514 WIPHY_ENTRY 2515 CHAN_DEF_ENTRY 2516 ), 2517 TP_fast_assign( 2518 WIPHY_ASSIGN; 2519 CHAN_DEF_ASSIGN(chandef); 2520 ), 2521 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2522 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2523 ); 2524 2525 TRACE_EVENT(cfg80211_ch_switch_notify, 2526 TP_PROTO(struct net_device *netdev, 2527 struct cfg80211_chan_def *chandef), 2528 TP_ARGS(netdev, chandef), 2529 TP_STRUCT__entry( 2530 NETDEV_ENTRY 2531 CHAN_DEF_ENTRY 2532 ), 2533 TP_fast_assign( 2534 NETDEV_ASSIGN; 2535 CHAN_DEF_ASSIGN(chandef); 2536 ), 2537 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2538 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2539 ); 2540 2541 TRACE_EVENT(cfg80211_ch_switch_started_notify, 2542 TP_PROTO(struct net_device *netdev, 2543 struct cfg80211_chan_def *chandef), 2544 TP_ARGS(netdev, chandef), 2545 TP_STRUCT__entry( 2546 NETDEV_ENTRY 2547 CHAN_DEF_ENTRY 2548 ), 2549 TP_fast_assign( 2550 NETDEV_ASSIGN; 2551 CHAN_DEF_ASSIGN(chandef); 2552 ), 2553 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2554 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2555 ); 2556 2557 TRACE_EVENT(cfg80211_radar_event, 2558 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2559 TP_ARGS(wiphy, chandef), 2560 TP_STRUCT__entry( 2561 WIPHY_ENTRY 2562 CHAN_DEF_ENTRY 2563 ), 2564 TP_fast_assign( 2565 WIPHY_ASSIGN; 2566 CHAN_DEF_ASSIGN(chandef); 2567 ), 2568 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2569 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2570 ); 2571 2572 TRACE_EVENT(cfg80211_cac_event, 2573 TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), 2574 TP_ARGS(netdev, evt), 2575 TP_STRUCT__entry( 2576 NETDEV_ENTRY 2577 __field(enum nl80211_radar_event, evt) 2578 ), 2579 TP_fast_assign( 2580 NETDEV_ASSIGN; 2581 __entry->evt = evt; 2582 ), 2583 TP_printk(NETDEV_PR_FMT ", event: %d", 2584 NETDEV_PR_ARG, __entry->evt) 2585 ); 2586 2587 DECLARE_EVENT_CLASS(cfg80211_rx_evt, 2588 TP_PROTO(struct net_device *netdev, const u8 *addr), 2589 TP_ARGS(netdev, addr), 2590 TP_STRUCT__entry( 2591 NETDEV_ENTRY 2592 MAC_ENTRY(addr) 2593 ), 2594 TP_fast_assign( 2595 NETDEV_ASSIGN; 2596 MAC_ASSIGN(addr, addr); 2597 ), 2598 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr)) 2599 ); 2600 2601 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, 2602 TP_PROTO(struct net_device *netdev, const u8 *addr), 2603 TP_ARGS(netdev, addr) 2604 ); 2605 2606 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, 2607 TP_PROTO(struct net_device *netdev, const u8 *addr), 2608 TP_ARGS(netdev, addr) 2609 ); 2610 2611 TRACE_EVENT(cfg80211_ibss_joined, 2612 TP_PROTO(struct net_device *netdev, const u8 *bssid, 2613 struct ieee80211_channel *channel), 2614 TP_ARGS(netdev, bssid, channel), 2615 TP_STRUCT__entry( 2616 NETDEV_ENTRY 2617 MAC_ENTRY(bssid) 2618 CHAN_ENTRY 2619 ), 2620 TP_fast_assign( 2621 NETDEV_ASSIGN; 2622 MAC_ASSIGN(bssid, bssid); 2623 CHAN_ASSIGN(channel); 2624 ), 2625 TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT, 2626 NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2627 ); 2628 2629 TRACE_EVENT(cfg80211_probe_status, 2630 TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, 2631 bool acked), 2632 TP_ARGS(netdev, addr, cookie, acked), 2633 TP_STRUCT__entry( 2634 NETDEV_ENTRY 2635 MAC_ENTRY(addr) 2636 __field(u64, cookie) 2637 __field(bool, acked) 2638 ), 2639 TP_fast_assign( 2640 NETDEV_ASSIGN; 2641 MAC_ASSIGN(addr, addr); 2642 __entry->cookie = cookie; 2643 __entry->acked = acked; 2644 ), 2645 TP_printk(NETDEV_PR_FMT " addr:" MAC_PR_FMT ", cookie: %llu, acked: %s", 2646 NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie, 2647 BOOL_TO_STR(__entry->acked)) 2648 ); 2649 2650 TRACE_EVENT(cfg80211_cqm_pktloss_notify, 2651 TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), 2652 TP_ARGS(netdev, peer, num_packets), 2653 TP_STRUCT__entry( 2654 NETDEV_ENTRY 2655 MAC_ENTRY(peer) 2656 __field(u32, num_packets) 2657 ), 2658 TP_fast_assign( 2659 NETDEV_ASSIGN; 2660 MAC_ASSIGN(peer, peer); 2661 __entry->num_packets = num_packets; 2662 ), 2663 TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u", 2664 NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets) 2665 ); 2666 2667 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, 2668 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2669 TP_ARGS(netdev, macaddr) 2670 ); 2671 2672 TRACE_EVENT(cfg80211_pmksa_candidate_notify, 2673 TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, 2674 bool preauth), 2675 TP_ARGS(netdev, index, bssid, preauth), 2676 TP_STRUCT__entry( 2677 NETDEV_ENTRY 2678 __field(int, index) 2679 MAC_ENTRY(bssid) 2680 __field(bool, preauth) 2681 ), 2682 TP_fast_assign( 2683 NETDEV_ASSIGN; 2684 __entry->index = index; 2685 MAC_ASSIGN(bssid, bssid); 2686 __entry->preauth = preauth; 2687 ), 2688 TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s", 2689 NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid), 2690 BOOL_TO_STR(__entry->preauth)) 2691 ); 2692 2693 TRACE_EVENT(cfg80211_report_obss_beacon, 2694 TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, 2695 int freq, int sig_dbm), 2696 TP_ARGS(wiphy, frame, len, freq, sig_dbm), 2697 TP_STRUCT__entry( 2698 WIPHY_ENTRY 2699 __field(int, freq) 2700 __field(int, sig_dbm) 2701 ), 2702 TP_fast_assign( 2703 WIPHY_ASSIGN; 2704 __entry->freq = freq; 2705 __entry->sig_dbm = sig_dbm; 2706 ), 2707 TP_printk(WIPHY_PR_FMT ", freq: %d, sig_dbm: %d", 2708 WIPHY_PR_ARG, __entry->freq, __entry->sig_dbm) 2709 ); 2710 2711 TRACE_EVENT(cfg80211_tdls_oper_request, 2712 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, 2713 enum nl80211_tdls_operation oper, u16 reason_code), 2714 TP_ARGS(wiphy, netdev, peer, oper, reason_code), 2715 TP_STRUCT__entry( 2716 WIPHY_ENTRY 2717 NETDEV_ENTRY 2718 MAC_ENTRY(peer) 2719 __field(enum nl80211_tdls_operation, oper) 2720 __field(u16, reason_code) 2721 ), 2722 TP_fast_assign( 2723 WIPHY_ASSIGN; 2724 NETDEV_ASSIGN; 2725 MAC_ASSIGN(peer, peer); 2726 __entry->oper = oper; 2727 __entry->reason_code = reason_code; 2728 ), 2729 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", oper: %d, reason_code %u", 2730 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper, 2731 __entry->reason_code) 2732 ); 2733 2734 TRACE_EVENT(cfg80211_scan_done, 2735 TP_PROTO(struct cfg80211_scan_request *request, 2736 struct cfg80211_scan_info *info), 2737 TP_ARGS(request, info), 2738 TP_STRUCT__entry( 2739 __field(u32, n_channels) 2740 __dynamic_array(u8, ie, request ? request->ie_len : 0) 2741 __array(u32, rates, NUM_NL80211_BANDS) 2742 __field(u32, wdev_id) 2743 MAC_ENTRY(wiphy_mac) 2744 __field(bool, no_cck) 2745 __field(bool, aborted) 2746 __field(u64, scan_start_tsf) 2747 MAC_ENTRY(tsf_bssid) 2748 ), 2749 TP_fast_assign( 2750 if (request) { 2751 memcpy(__get_dynamic_array(ie), request->ie, 2752 request->ie_len); 2753 memcpy(__entry->rates, request->rates, 2754 NUM_NL80211_BANDS); 2755 __entry->wdev_id = request->wdev ? 2756 request->wdev->identifier : 0; 2757 if (request->wiphy) 2758 MAC_ASSIGN(wiphy_mac, 2759 request->wiphy->perm_addr); 2760 __entry->no_cck = request->no_cck; 2761 } 2762 if (info) { 2763 __entry->aborted = info->aborted; 2764 __entry->scan_start_tsf = info->scan_start_tsf; 2765 MAC_ASSIGN(tsf_bssid, info->tsf_bssid); 2766 } 2767 ), 2768 TP_printk("aborted: %s, scan start (TSF): %llu, tsf_bssid: " MAC_PR_FMT, 2769 BOOL_TO_STR(__entry->aborted), 2770 (unsigned long long)__entry->scan_start_tsf, 2771 MAC_PR_ARG(tsf_bssid)) 2772 ); 2773 2774 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_results, 2775 TP_PROTO(struct wiphy *wiphy), 2776 TP_ARGS(wiphy) 2777 ); 2778 2779 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_stopped, 2780 TP_PROTO(struct wiphy *wiphy), 2781 TP_ARGS(wiphy) 2782 ); 2783 2784 TRACE_EVENT(cfg80211_get_bss, 2785 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, 2786 const u8 *bssid, const u8 *ssid, size_t ssid_len, 2787 enum ieee80211_bss_type bss_type, 2788 enum ieee80211_privacy privacy), 2789 TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy), 2790 TP_STRUCT__entry( 2791 WIPHY_ENTRY 2792 CHAN_ENTRY 2793 MAC_ENTRY(bssid) 2794 __dynamic_array(u8, ssid, ssid_len) 2795 __field(enum ieee80211_bss_type, bss_type) 2796 __field(enum ieee80211_privacy, privacy) 2797 ), 2798 TP_fast_assign( 2799 WIPHY_ASSIGN; 2800 CHAN_ASSIGN(channel); 2801 MAC_ASSIGN(bssid, bssid); 2802 memcpy(__get_dynamic_array(ssid), ssid, ssid_len); 2803 __entry->bss_type = bss_type; 2804 __entry->privacy = privacy; 2805 ), 2806 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", " MAC_PR_FMT 2807 ", buf: %#.2x, bss_type: %d, privacy: %d", 2808 WIPHY_PR_ARG, CHAN_PR_ARG, MAC_PR_ARG(bssid), 2809 ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type, 2810 __entry->privacy) 2811 ); 2812 2813 TRACE_EVENT(cfg80211_inform_bss_frame, 2814 TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, 2815 struct ieee80211_mgmt *mgmt, size_t len), 2816 TP_ARGS(wiphy, data, mgmt, len), 2817 TP_STRUCT__entry( 2818 WIPHY_ENTRY 2819 CHAN_ENTRY 2820 __field(enum nl80211_bss_scan_width, scan_width) 2821 __dynamic_array(u8, mgmt, len) 2822 __field(s32, signal) 2823 __field(u64, ts_boottime) 2824 __field(u64, parent_tsf) 2825 MAC_ENTRY(parent_bssid) 2826 ), 2827 TP_fast_assign( 2828 WIPHY_ASSIGN; 2829 CHAN_ASSIGN(data->chan); 2830 __entry->scan_width = data->scan_width; 2831 if (mgmt) 2832 memcpy(__get_dynamic_array(mgmt), mgmt, len); 2833 __entry->signal = data->signal; 2834 __entry->ts_boottime = data->boottime_ns; 2835 __entry->parent_tsf = data->parent_tsf; 2836 MAC_ASSIGN(parent_bssid, data->parent_bssid); 2837 ), 2838 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT 2839 "(scan_width: %d) signal: %d, tsb:%llu, detect_tsf:%llu, tsf_bssid: " 2840 MAC_PR_FMT, WIPHY_PR_ARG, CHAN_PR_ARG, __entry->scan_width, 2841 __entry->signal, (unsigned long long)__entry->ts_boottime, 2842 (unsigned long long)__entry->parent_tsf, 2843 MAC_PR_ARG(parent_bssid)) 2844 ); 2845 2846 DECLARE_EVENT_CLASS(cfg80211_bss_evt, 2847 TP_PROTO(struct cfg80211_bss *pub), 2848 TP_ARGS(pub), 2849 TP_STRUCT__entry( 2850 MAC_ENTRY(bssid) 2851 CHAN_ENTRY 2852 ), 2853 TP_fast_assign( 2854 MAC_ASSIGN(bssid, pub->bssid); 2855 CHAN_ASSIGN(pub->channel); 2856 ), 2857 TP_printk(MAC_PR_FMT ", " CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2858 ); 2859 2860 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, 2861 TP_PROTO(struct cfg80211_bss *pub), 2862 TP_ARGS(pub) 2863 ); 2864 2865 TRACE_EVENT(cfg80211_return_uint, 2866 TP_PROTO(unsigned int ret), 2867 TP_ARGS(ret), 2868 TP_STRUCT__entry( 2869 __field(unsigned int, ret) 2870 ), 2871 TP_fast_assign( 2872 __entry->ret = ret; 2873 ), 2874 TP_printk("ret: %d", __entry->ret) 2875 ); 2876 2877 TRACE_EVENT(cfg80211_return_u32, 2878 TP_PROTO(u32 ret), 2879 TP_ARGS(ret), 2880 TP_STRUCT__entry( 2881 __field(u32, ret) 2882 ), 2883 TP_fast_assign( 2884 __entry->ret = ret; 2885 ), 2886 TP_printk("ret: %u", __entry->ret) 2887 ); 2888 2889 TRACE_EVENT(cfg80211_report_wowlan_wakeup, 2890 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2891 struct cfg80211_wowlan_wakeup *wakeup), 2892 TP_ARGS(wiphy, wdev, wakeup), 2893 TP_STRUCT__entry( 2894 WIPHY_ENTRY 2895 WDEV_ENTRY 2896 __field(bool, non_wireless) 2897 __field(bool, disconnect) 2898 __field(bool, magic_pkt) 2899 __field(bool, gtk_rekey_failure) 2900 __field(bool, eap_identity_req) 2901 __field(bool, four_way_handshake) 2902 __field(bool, rfkill_release) 2903 __field(s32, pattern_idx) 2904 __field(u32, packet_len) 2905 __dynamic_array(u8, packet, 2906 wakeup ? wakeup->packet_present_len : 0) 2907 ), 2908 TP_fast_assign( 2909 WIPHY_ASSIGN; 2910 WDEV_ASSIGN; 2911 __entry->non_wireless = !wakeup; 2912 __entry->disconnect = wakeup ? wakeup->disconnect : false; 2913 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false; 2914 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false; 2915 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false; 2916 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false; 2917 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false; 2918 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false; 2919 __entry->packet_len = wakeup ? wakeup->packet_len : false; 2920 if (wakeup && wakeup->packet && wakeup->packet_present_len) 2921 memcpy(__get_dynamic_array(packet), wakeup->packet, 2922 wakeup->packet_present_len); 2923 ), 2924 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 2925 ); 2926 2927 TRACE_EVENT(cfg80211_ft_event, 2928 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2929 struct cfg80211_ft_event_params *ft_event), 2930 TP_ARGS(wiphy, netdev, ft_event), 2931 TP_STRUCT__entry( 2932 WIPHY_ENTRY 2933 NETDEV_ENTRY 2934 __dynamic_array(u8, ies, ft_event->ies_len) 2935 MAC_ENTRY(target_ap) 2936 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len) 2937 ), 2938 TP_fast_assign( 2939 WIPHY_ASSIGN; 2940 NETDEV_ASSIGN; 2941 if (ft_event->ies) 2942 memcpy(__get_dynamic_array(ies), ft_event->ies, 2943 ft_event->ies_len); 2944 MAC_ASSIGN(target_ap, ft_event->target_ap); 2945 if (ft_event->ric_ies) 2946 memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies, 2947 ft_event->ric_ies_len); 2948 ), 2949 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: " MAC_PR_FMT, 2950 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(target_ap)) 2951 ); 2952 2953 TRACE_EVENT(cfg80211_stop_iface, 2954 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2955 TP_ARGS(wiphy, wdev), 2956 TP_STRUCT__entry( 2957 WIPHY_ENTRY 2958 WDEV_ENTRY 2959 ), 2960 TP_fast_assign( 2961 WIPHY_ASSIGN; 2962 WDEV_ASSIGN; 2963 ), 2964 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 2965 WIPHY_PR_ARG, WDEV_PR_ARG) 2966 ); 2967 2968 TRACE_EVENT(rdev_start_radar_detection, 2969 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2970 struct cfg80211_chan_def *chandef, 2971 u32 cac_time_ms), 2972 TP_ARGS(wiphy, netdev, chandef, cac_time_ms), 2973 TP_STRUCT__entry( 2974 WIPHY_ENTRY 2975 NETDEV_ENTRY 2976 CHAN_DEF_ENTRY 2977 __field(u32, cac_time_ms) 2978 ), 2979 TP_fast_assign( 2980 WIPHY_ASSIGN; 2981 NETDEV_ASSIGN; 2982 CHAN_DEF_ASSIGN(chandef); 2983 __entry->cac_time_ms = cac_time_ms; 2984 ), 2985 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 2986 ", cac_time_ms=%u", 2987 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2988 __entry->cac_time_ms) 2989 ); 2990 2991 TRACE_EVENT(rdev_set_mcast_rate, 2992 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2993 int mcast_rate[NUM_NL80211_BANDS]), 2994 TP_ARGS(wiphy, netdev, mcast_rate), 2995 TP_STRUCT__entry( 2996 WIPHY_ENTRY 2997 NETDEV_ENTRY 2998 __array(int, mcast_rate, NUM_NL80211_BANDS) 2999 ), 3000 TP_fast_assign( 3001 WIPHY_ASSIGN; 3002 NETDEV_ASSIGN; 3003 memcpy(__entry->mcast_rate, mcast_rate, 3004 sizeof(int) * NUM_NL80211_BANDS); 3005 ), 3006 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " 3007 "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 60GHz=0x%x]", 3008 WIPHY_PR_ARG, NETDEV_PR_ARG, 3009 __entry->mcast_rate[NL80211_BAND_2GHZ], 3010 __entry->mcast_rate[NL80211_BAND_5GHZ], 3011 __entry->mcast_rate[NL80211_BAND_60GHZ]) 3012 ); 3013 3014 TRACE_EVENT(rdev_set_coalesce, 3015 TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), 3016 TP_ARGS(wiphy, coalesce), 3017 TP_STRUCT__entry( 3018 WIPHY_ENTRY 3019 __field(int, n_rules) 3020 ), 3021 TP_fast_assign( 3022 WIPHY_ASSIGN; 3023 __entry->n_rules = coalesce ? coalesce->n_rules : 0; 3024 ), 3025 TP_printk(WIPHY_PR_FMT ", n_rules=%d", 3026 WIPHY_PR_ARG, __entry->n_rules) 3027 ); 3028 3029 DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, 3030 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 3031 TP_ARGS(wiphy, wdev) 3032 ); 3033 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */ 3034 3035 #undef TRACE_INCLUDE_PATH 3036 #define TRACE_INCLUDE_PATH . 3037 #undef TRACE_INCLUDE_FILE 3038 #define TRACE_INCLUDE_FILE trace 3039 #include <trace/define_trace.h> 3040