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_set_mac_acl, 1893 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1894 struct cfg80211_acl_data *params), 1895 TP_ARGS(wiphy, netdev, params), 1896 TP_STRUCT__entry( 1897 WIPHY_ENTRY 1898 NETDEV_ENTRY 1899 __field(u32, acl_policy) 1900 ), 1901 TP_fast_assign( 1902 WIPHY_ASSIGN; 1903 NETDEV_ASSIGN; 1904 __entry->acl_policy = params->acl_policy; 1905 ), 1906 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d", 1907 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy) 1908 ); 1909 1910 TRACE_EVENT(rdev_update_ft_ies, 1911 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1912 struct cfg80211_update_ft_ies_params *ftie), 1913 TP_ARGS(wiphy, netdev, ftie), 1914 TP_STRUCT__entry( 1915 WIPHY_ENTRY 1916 NETDEV_ENTRY 1917 __field(u16, md) 1918 __dynamic_array(u8, ie, ftie->ie_len) 1919 ), 1920 TP_fast_assign( 1921 WIPHY_ASSIGN; 1922 NETDEV_ASSIGN; 1923 __entry->md = ftie->md; 1924 memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len); 1925 ), 1926 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x", 1927 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md) 1928 ); 1929 1930 TRACE_EVENT(rdev_crit_proto_start, 1931 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 1932 enum nl80211_crit_proto_id protocol, u16 duration), 1933 TP_ARGS(wiphy, wdev, protocol, duration), 1934 TP_STRUCT__entry( 1935 WIPHY_ENTRY 1936 WDEV_ENTRY 1937 __field(u16, proto) 1938 __field(u16, duration) 1939 ), 1940 TP_fast_assign( 1941 WIPHY_ASSIGN; 1942 WDEV_ASSIGN; 1943 __entry->proto = protocol; 1944 __entry->duration = duration; 1945 ), 1946 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u", 1947 WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration) 1948 ); 1949 1950 TRACE_EVENT(rdev_crit_proto_stop, 1951 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 1952 TP_ARGS(wiphy, wdev), 1953 TP_STRUCT__entry( 1954 WIPHY_ENTRY 1955 WDEV_ENTRY 1956 ), 1957 TP_fast_assign( 1958 WIPHY_ASSIGN; 1959 WDEV_ASSIGN; 1960 ), 1961 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 1962 WIPHY_PR_ARG, WDEV_PR_ARG) 1963 ); 1964 1965 TRACE_EVENT(rdev_channel_switch, 1966 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 1967 struct cfg80211_csa_settings *params), 1968 TP_ARGS(wiphy, netdev, params), 1969 TP_STRUCT__entry( 1970 WIPHY_ENTRY 1971 NETDEV_ENTRY 1972 CHAN_DEF_ENTRY 1973 __field(bool, radar_required) 1974 __field(bool, block_tx) 1975 __field(u8, count) 1976 __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon) 1977 __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp) 1978 ), 1979 TP_fast_assign( 1980 WIPHY_ASSIGN; 1981 NETDEV_ASSIGN; 1982 CHAN_DEF_ASSIGN(¶ms->chandef); 1983 __entry->radar_required = params->radar_required; 1984 __entry->block_tx = params->block_tx; 1985 __entry->count = params->count; 1986 memcpy(__get_dynamic_array(bcn_ofs), 1987 params->counter_offsets_beacon, 1988 params->n_counter_offsets_beacon * sizeof(u16)); 1989 1990 /* probe response offsets are optional */ 1991 if (params->n_counter_offsets_presp) 1992 memcpy(__get_dynamic_array(pres_ofs), 1993 params->counter_offsets_presp, 1994 params->n_counter_offsets_presp * sizeof(u16)); 1995 ), 1996 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 1997 ", block_tx: %d, count: %u, radar_required: %d", 1998 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 1999 __entry->block_tx, __entry->count, __entry->radar_required) 2000 ); 2001 2002 TRACE_EVENT(rdev_set_qos_map, 2003 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2004 struct cfg80211_qos_map *qos_map), 2005 TP_ARGS(wiphy, netdev, qos_map), 2006 TP_STRUCT__entry( 2007 WIPHY_ENTRY 2008 NETDEV_ENTRY 2009 QOS_MAP_ENTRY 2010 ), 2011 TP_fast_assign( 2012 WIPHY_ASSIGN; 2013 NETDEV_ASSIGN; 2014 QOS_MAP_ASSIGN(qos_map); 2015 ), 2016 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u", 2017 WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des) 2018 ); 2019 2020 TRACE_EVENT(rdev_set_ap_chanwidth, 2021 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2022 struct cfg80211_chan_def *chandef), 2023 TP_ARGS(wiphy, netdev, chandef), 2024 TP_STRUCT__entry( 2025 WIPHY_ENTRY 2026 NETDEV_ENTRY 2027 CHAN_DEF_ENTRY 2028 ), 2029 TP_fast_assign( 2030 WIPHY_ASSIGN; 2031 NETDEV_ASSIGN; 2032 CHAN_DEF_ASSIGN(chandef); 2033 ), 2034 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2035 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2036 ); 2037 2038 TRACE_EVENT(rdev_add_tx_ts, 2039 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2040 u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), 2041 TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time), 2042 TP_STRUCT__entry( 2043 WIPHY_ENTRY 2044 NETDEV_ENTRY 2045 MAC_ENTRY(peer) 2046 __field(u8, tsid) 2047 __field(u8, user_prio) 2048 __field(u16, admitted_time) 2049 ), 2050 TP_fast_assign( 2051 WIPHY_ASSIGN; 2052 NETDEV_ASSIGN; 2053 MAC_ASSIGN(peer, peer); 2054 __entry->tsid = tsid; 2055 __entry->user_prio = user_prio; 2056 __entry->admitted_time = admitted_time; 2057 ), 2058 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d, UP %d, time %d", 2059 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), 2060 __entry->tsid, __entry->user_prio, __entry->admitted_time) 2061 ); 2062 2063 TRACE_EVENT(rdev_del_tx_ts, 2064 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2065 u8 tsid, const u8 *peer), 2066 TP_ARGS(wiphy, netdev, tsid, peer), 2067 TP_STRUCT__entry( 2068 WIPHY_ENTRY 2069 NETDEV_ENTRY 2070 MAC_ENTRY(peer) 2071 __field(u8, tsid) 2072 ), 2073 TP_fast_assign( 2074 WIPHY_ASSIGN; 2075 NETDEV_ASSIGN; 2076 MAC_ASSIGN(peer, peer); 2077 __entry->tsid = tsid; 2078 ), 2079 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ", TSID %d", 2080 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->tsid) 2081 ); 2082 2083 TRACE_EVENT(rdev_tdls_channel_switch, 2084 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2085 const u8 *addr, u8 oper_class, 2086 struct cfg80211_chan_def *chandef), 2087 TP_ARGS(wiphy, netdev, addr, oper_class, chandef), 2088 TP_STRUCT__entry( 2089 WIPHY_ENTRY 2090 NETDEV_ENTRY 2091 MAC_ENTRY(addr) 2092 __field(u8, oper_class) 2093 CHAN_DEF_ENTRY 2094 ), 2095 TP_fast_assign( 2096 WIPHY_ASSIGN; 2097 NETDEV_ASSIGN; 2098 MAC_ASSIGN(addr, addr); 2099 CHAN_DEF_ASSIGN(chandef); 2100 ), 2101 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT 2102 " oper class %d, " CHAN_DEF_PR_FMT, 2103 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr), 2104 __entry->oper_class, CHAN_DEF_PR_ARG) 2105 ); 2106 2107 TRACE_EVENT(rdev_tdls_cancel_channel_switch, 2108 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2109 const u8 *addr), 2110 TP_ARGS(wiphy, netdev, addr), 2111 TP_STRUCT__entry( 2112 WIPHY_ENTRY 2113 NETDEV_ENTRY 2114 MAC_ENTRY(addr) 2115 ), 2116 TP_fast_assign( 2117 WIPHY_ASSIGN; 2118 NETDEV_ASSIGN; 2119 MAC_ASSIGN(addr, addr); 2120 ), 2121 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT, 2122 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(addr)) 2123 ); 2124 2125 /************************************************************* 2126 * cfg80211 exported functions traces * 2127 *************************************************************/ 2128 2129 TRACE_EVENT(cfg80211_return_bool, 2130 TP_PROTO(bool ret), 2131 TP_ARGS(ret), 2132 TP_STRUCT__entry( 2133 __field(bool, ret) 2134 ), 2135 TP_fast_assign( 2136 __entry->ret = ret; 2137 ), 2138 TP_printk("returned %s", BOOL_TO_STR(__entry->ret)) 2139 ); 2140 2141 DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, 2142 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2143 TP_ARGS(netdev, macaddr), 2144 TP_STRUCT__entry( 2145 NETDEV_ENTRY 2146 MAC_ENTRY(macaddr) 2147 ), 2148 TP_fast_assign( 2149 NETDEV_ASSIGN; 2150 MAC_ASSIGN(macaddr, macaddr); 2151 ), 2152 TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT, 2153 NETDEV_PR_ARG, MAC_PR_ARG(macaddr)) 2154 ); 2155 2156 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_notify_new_peer_candidate, 2157 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2158 TP_ARGS(netdev, macaddr) 2159 ); 2160 2161 DECLARE_EVENT_CLASS(netdev_evt_only, 2162 TP_PROTO(struct net_device *netdev), 2163 TP_ARGS(netdev), 2164 TP_STRUCT__entry( 2165 NETDEV_ENTRY 2166 ), 2167 TP_fast_assign( 2168 NETDEV_ASSIGN; 2169 ), 2170 TP_printk(NETDEV_PR_FMT , NETDEV_PR_ARG) 2171 ); 2172 2173 DEFINE_EVENT(netdev_evt_only, cfg80211_send_rx_auth, 2174 TP_PROTO(struct net_device *netdev), 2175 TP_ARGS(netdev) 2176 ); 2177 2178 TRACE_EVENT(cfg80211_send_rx_assoc, 2179 TP_PROTO(struct net_device *netdev, struct cfg80211_bss *bss), 2180 TP_ARGS(netdev, bss), 2181 TP_STRUCT__entry( 2182 NETDEV_ENTRY 2183 MAC_ENTRY(bssid) 2184 CHAN_ENTRY 2185 ), 2186 TP_fast_assign( 2187 NETDEV_ASSIGN; 2188 MAC_ASSIGN(bssid, bss->bssid); 2189 CHAN_ASSIGN(bss->channel); 2190 ), 2191 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", " CHAN_PR_FMT, 2192 NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2193 ); 2194 2195 DECLARE_EVENT_CLASS(netdev_frame_event, 2196 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2197 TP_ARGS(netdev, buf, len), 2198 TP_STRUCT__entry( 2199 NETDEV_ENTRY 2200 __dynamic_array(u8, frame, len) 2201 ), 2202 TP_fast_assign( 2203 NETDEV_ASSIGN; 2204 memcpy(__get_dynamic_array(frame), buf, len); 2205 ), 2206 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x", 2207 NETDEV_PR_ARG, 2208 le16_to_cpup((__le16 *)__get_dynamic_array(frame))) 2209 ); 2210 2211 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_unprot_mlme_mgmt, 2212 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2213 TP_ARGS(netdev, buf, len) 2214 ); 2215 2216 DEFINE_EVENT(netdev_frame_event, cfg80211_rx_mlme_mgmt, 2217 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2218 TP_ARGS(netdev, buf, len) 2219 ); 2220 2221 TRACE_EVENT(cfg80211_tx_mlme_mgmt, 2222 TP_PROTO(struct net_device *netdev, const u8 *buf, int len), 2223 TP_ARGS(netdev, buf, len), 2224 TP_STRUCT__entry( 2225 NETDEV_ENTRY 2226 __dynamic_array(u8, frame, len) 2227 ), 2228 TP_fast_assign( 2229 NETDEV_ASSIGN; 2230 memcpy(__get_dynamic_array(frame), buf, len); 2231 ), 2232 TP_printk(NETDEV_PR_FMT ", ftype:0x%.2x", 2233 NETDEV_PR_ARG, 2234 le16_to_cpup((__le16 *)__get_dynamic_array(frame))) 2235 ); 2236 2237 DECLARE_EVENT_CLASS(netdev_mac_evt, 2238 TP_PROTO(struct net_device *netdev, const u8 *mac), 2239 TP_ARGS(netdev, mac), 2240 TP_STRUCT__entry( 2241 NETDEV_ENTRY 2242 MAC_ENTRY(mac) 2243 ), 2244 TP_fast_assign( 2245 NETDEV_ASSIGN; 2246 MAC_ASSIGN(mac, mac) 2247 ), 2248 TP_printk(NETDEV_PR_FMT ", mac: " MAC_PR_FMT, 2249 NETDEV_PR_ARG, MAC_PR_ARG(mac)) 2250 ); 2251 2252 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_auth_timeout, 2253 TP_PROTO(struct net_device *netdev, const u8 *mac), 2254 TP_ARGS(netdev, mac) 2255 ); 2256 2257 DEFINE_EVENT(netdev_mac_evt, cfg80211_send_assoc_timeout, 2258 TP_PROTO(struct net_device *netdev, const u8 *mac), 2259 TP_ARGS(netdev, mac) 2260 ); 2261 2262 TRACE_EVENT(cfg80211_michael_mic_failure, 2263 TP_PROTO(struct net_device *netdev, const u8 *addr, 2264 enum nl80211_key_type key_type, int key_id, const u8 *tsc), 2265 TP_ARGS(netdev, addr, key_type, key_id, tsc), 2266 TP_STRUCT__entry( 2267 NETDEV_ENTRY 2268 MAC_ENTRY(addr) 2269 __field(enum nl80211_key_type, key_type) 2270 __field(int, key_id) 2271 __array(u8, tsc, 6) 2272 ), 2273 TP_fast_assign( 2274 NETDEV_ASSIGN; 2275 MAC_ASSIGN(addr, addr); 2276 __entry->key_type = key_type; 2277 __entry->key_id = key_id; 2278 if (tsc) 2279 memcpy(__entry->tsc, tsc, 6); 2280 ), 2281 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT ", key type: %d, key id: %d, tsc: %pm", 2282 NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->key_type, 2283 __entry->key_id, __entry->tsc) 2284 ); 2285 2286 TRACE_EVENT(cfg80211_ready_on_channel, 2287 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 2288 struct ieee80211_channel *chan, 2289 unsigned int duration), 2290 TP_ARGS(wdev, cookie, chan, duration), 2291 TP_STRUCT__entry( 2292 WDEV_ENTRY 2293 __field(u64, cookie) 2294 CHAN_ENTRY 2295 __field(unsigned int, duration) 2296 ), 2297 TP_fast_assign( 2298 WDEV_ASSIGN; 2299 __entry->cookie = cookie; 2300 CHAN_ASSIGN(chan); 2301 __entry->duration = duration; 2302 ), 2303 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT ", duration: %u", 2304 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG, 2305 __entry->duration) 2306 ); 2307 2308 TRACE_EVENT(cfg80211_ready_on_channel_expired, 2309 TP_PROTO(struct wireless_dev *wdev, u64 cookie, 2310 struct ieee80211_channel *chan), 2311 TP_ARGS(wdev, cookie, chan), 2312 TP_STRUCT__entry( 2313 WDEV_ENTRY 2314 __field(u64, cookie) 2315 CHAN_ENTRY 2316 ), 2317 TP_fast_assign( 2318 WDEV_ASSIGN; 2319 __entry->cookie = cookie; 2320 CHAN_ASSIGN(chan); 2321 ), 2322 TP_printk(WDEV_PR_FMT ", cookie: %llu, " CHAN_PR_FMT, 2323 WDEV_PR_ARG, __entry->cookie, CHAN_PR_ARG) 2324 ); 2325 2326 TRACE_EVENT(cfg80211_new_sta, 2327 TP_PROTO(struct net_device *netdev, const u8 *mac_addr, 2328 struct station_info *sinfo), 2329 TP_ARGS(netdev, mac_addr, sinfo), 2330 TP_STRUCT__entry( 2331 NETDEV_ENTRY 2332 MAC_ENTRY(mac_addr) 2333 SINFO_ENTRY 2334 ), 2335 TP_fast_assign( 2336 NETDEV_ASSIGN; 2337 MAC_ASSIGN(mac_addr, mac_addr); 2338 SINFO_ASSIGN; 2339 ), 2340 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, 2341 NETDEV_PR_ARG, MAC_PR_ARG(mac_addr)) 2342 ); 2343 2344 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_del_sta, 2345 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2346 TP_ARGS(netdev, macaddr) 2347 ); 2348 2349 TRACE_EVENT(cfg80211_rx_mgmt, 2350 TP_PROTO(struct wireless_dev *wdev, int freq, int sig_mbm), 2351 TP_ARGS(wdev, freq, sig_mbm), 2352 TP_STRUCT__entry( 2353 WDEV_ENTRY 2354 __field(int, freq) 2355 __field(int, sig_mbm) 2356 ), 2357 TP_fast_assign( 2358 WDEV_ASSIGN; 2359 __entry->freq = freq; 2360 __entry->sig_mbm = sig_mbm; 2361 ), 2362 TP_printk(WDEV_PR_FMT ", freq: %d, sig mbm: %d", 2363 WDEV_PR_ARG, __entry->freq, __entry->sig_mbm) 2364 ); 2365 2366 TRACE_EVENT(cfg80211_mgmt_tx_status, 2367 TP_PROTO(struct wireless_dev *wdev, u64 cookie, bool ack), 2368 TP_ARGS(wdev, cookie, ack), 2369 TP_STRUCT__entry( 2370 WDEV_ENTRY 2371 __field(u64, cookie) 2372 __field(bool, ack) 2373 ), 2374 TP_fast_assign( 2375 WDEV_ASSIGN; 2376 __entry->cookie = cookie; 2377 __entry->ack = ack; 2378 ), 2379 TP_printk(WDEV_PR_FMT", cookie: %llu, ack: %s", 2380 WDEV_PR_ARG, __entry->cookie, BOOL_TO_STR(__entry->ack)) 2381 ); 2382 2383 TRACE_EVENT(cfg80211_cqm_rssi_notify, 2384 TP_PROTO(struct net_device *netdev, 2385 enum nl80211_cqm_rssi_threshold_event rssi_event), 2386 TP_ARGS(netdev, rssi_event), 2387 TP_STRUCT__entry( 2388 NETDEV_ENTRY 2389 __field(enum nl80211_cqm_rssi_threshold_event, rssi_event) 2390 ), 2391 TP_fast_assign( 2392 NETDEV_ASSIGN; 2393 __entry->rssi_event = rssi_event; 2394 ), 2395 TP_printk(NETDEV_PR_FMT ", rssi event: %d", 2396 NETDEV_PR_ARG, __entry->rssi_event) 2397 ); 2398 2399 TRACE_EVENT(cfg80211_reg_can_beacon, 2400 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef, 2401 enum nl80211_iftype iftype, bool check_no_ir), 2402 TP_ARGS(wiphy, chandef, iftype, check_no_ir), 2403 TP_STRUCT__entry( 2404 WIPHY_ENTRY 2405 CHAN_DEF_ENTRY 2406 __field(enum nl80211_iftype, iftype) 2407 __field(bool, check_no_ir) 2408 ), 2409 TP_fast_assign( 2410 WIPHY_ASSIGN; 2411 CHAN_DEF_ASSIGN(chandef); 2412 __entry->iftype = iftype; 2413 __entry->check_no_ir = check_no_ir; 2414 ), 2415 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", iftype=%d check_no_ir=%s", 2416 WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->iftype, 2417 BOOL_TO_STR(__entry->check_no_ir)) 2418 ); 2419 2420 TRACE_EVENT(cfg80211_chandef_dfs_required, 2421 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2422 TP_ARGS(wiphy, chandef), 2423 TP_STRUCT__entry( 2424 WIPHY_ENTRY 2425 CHAN_DEF_ENTRY 2426 ), 2427 TP_fast_assign( 2428 WIPHY_ASSIGN; 2429 CHAN_DEF_ASSIGN(chandef); 2430 ), 2431 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2432 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2433 ); 2434 2435 TRACE_EVENT(cfg80211_ch_switch_notify, 2436 TP_PROTO(struct net_device *netdev, 2437 struct cfg80211_chan_def *chandef), 2438 TP_ARGS(netdev, chandef), 2439 TP_STRUCT__entry( 2440 NETDEV_ENTRY 2441 CHAN_DEF_ENTRY 2442 ), 2443 TP_fast_assign( 2444 NETDEV_ASSIGN; 2445 CHAN_DEF_ASSIGN(chandef); 2446 ), 2447 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2448 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2449 ); 2450 2451 TRACE_EVENT(cfg80211_ch_switch_started_notify, 2452 TP_PROTO(struct net_device *netdev, 2453 struct cfg80211_chan_def *chandef), 2454 TP_ARGS(netdev, chandef), 2455 TP_STRUCT__entry( 2456 NETDEV_ENTRY 2457 CHAN_DEF_ENTRY 2458 ), 2459 TP_fast_assign( 2460 NETDEV_ASSIGN; 2461 CHAN_DEF_ASSIGN(chandef); 2462 ), 2463 TP_printk(NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT, 2464 NETDEV_PR_ARG, CHAN_DEF_PR_ARG) 2465 ); 2466 2467 TRACE_EVENT(cfg80211_radar_event, 2468 TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), 2469 TP_ARGS(wiphy, chandef), 2470 TP_STRUCT__entry( 2471 WIPHY_ENTRY 2472 CHAN_DEF_ENTRY 2473 ), 2474 TP_fast_assign( 2475 WIPHY_ASSIGN; 2476 CHAN_DEF_ASSIGN(chandef); 2477 ), 2478 TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, 2479 WIPHY_PR_ARG, CHAN_DEF_PR_ARG) 2480 ); 2481 2482 TRACE_EVENT(cfg80211_cac_event, 2483 TP_PROTO(struct net_device *netdev, enum nl80211_radar_event evt), 2484 TP_ARGS(netdev, evt), 2485 TP_STRUCT__entry( 2486 NETDEV_ENTRY 2487 __field(enum nl80211_radar_event, evt) 2488 ), 2489 TP_fast_assign( 2490 NETDEV_ASSIGN; 2491 __entry->evt = evt; 2492 ), 2493 TP_printk(NETDEV_PR_FMT ", event: %d", 2494 NETDEV_PR_ARG, __entry->evt) 2495 ); 2496 2497 DECLARE_EVENT_CLASS(cfg80211_rx_evt, 2498 TP_PROTO(struct net_device *netdev, const u8 *addr), 2499 TP_ARGS(netdev, addr), 2500 TP_STRUCT__entry( 2501 NETDEV_ENTRY 2502 MAC_ENTRY(addr) 2503 ), 2504 TP_fast_assign( 2505 NETDEV_ASSIGN; 2506 MAC_ASSIGN(addr, addr); 2507 ), 2508 TP_printk(NETDEV_PR_FMT ", " MAC_PR_FMT, NETDEV_PR_ARG, MAC_PR_ARG(addr)) 2509 ); 2510 2511 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_spurious_frame, 2512 TP_PROTO(struct net_device *netdev, const u8 *addr), 2513 TP_ARGS(netdev, addr) 2514 ); 2515 2516 DEFINE_EVENT(cfg80211_rx_evt, cfg80211_rx_unexpected_4addr_frame, 2517 TP_PROTO(struct net_device *netdev, const u8 *addr), 2518 TP_ARGS(netdev, addr) 2519 ); 2520 2521 TRACE_EVENT(cfg80211_ibss_joined, 2522 TP_PROTO(struct net_device *netdev, const u8 *bssid, 2523 struct ieee80211_channel *channel), 2524 TP_ARGS(netdev, bssid, channel), 2525 TP_STRUCT__entry( 2526 NETDEV_ENTRY 2527 MAC_ENTRY(bssid) 2528 CHAN_ENTRY 2529 ), 2530 TP_fast_assign( 2531 NETDEV_ASSIGN; 2532 MAC_ASSIGN(bssid, bssid); 2533 CHAN_ASSIGN(channel); 2534 ), 2535 TP_printk(NETDEV_PR_FMT ", bssid: " MAC_PR_FMT ", " CHAN_PR_FMT, 2536 NETDEV_PR_ARG, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2537 ); 2538 2539 TRACE_EVENT(cfg80211_probe_status, 2540 TP_PROTO(struct net_device *netdev, const u8 *addr, u64 cookie, 2541 bool acked), 2542 TP_ARGS(netdev, addr, cookie, acked), 2543 TP_STRUCT__entry( 2544 NETDEV_ENTRY 2545 MAC_ENTRY(addr) 2546 __field(u64, cookie) 2547 __field(bool, acked) 2548 ), 2549 TP_fast_assign( 2550 NETDEV_ASSIGN; 2551 MAC_ASSIGN(addr, addr); 2552 __entry->cookie = cookie; 2553 __entry->acked = acked; 2554 ), 2555 TP_printk(NETDEV_PR_FMT " addr:" MAC_PR_FMT ", cookie: %llu, acked: %s", 2556 NETDEV_PR_ARG, MAC_PR_ARG(addr), __entry->cookie, 2557 BOOL_TO_STR(__entry->acked)) 2558 ); 2559 2560 TRACE_EVENT(cfg80211_cqm_pktloss_notify, 2561 TP_PROTO(struct net_device *netdev, const u8 *peer, u32 num_packets), 2562 TP_ARGS(netdev, peer, num_packets), 2563 TP_STRUCT__entry( 2564 NETDEV_ENTRY 2565 MAC_ENTRY(peer) 2566 __field(u32, num_packets) 2567 ), 2568 TP_fast_assign( 2569 NETDEV_ASSIGN; 2570 MAC_ASSIGN(peer, peer); 2571 __entry->num_packets = num_packets; 2572 ), 2573 TP_printk(NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", num of lost packets: %u", 2574 NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->num_packets) 2575 ); 2576 2577 DEFINE_EVENT(cfg80211_netdev_mac_evt, cfg80211_gtk_rekey_notify, 2578 TP_PROTO(struct net_device *netdev, const u8 *macaddr), 2579 TP_ARGS(netdev, macaddr) 2580 ); 2581 2582 TRACE_EVENT(cfg80211_pmksa_candidate_notify, 2583 TP_PROTO(struct net_device *netdev, int index, const u8 *bssid, 2584 bool preauth), 2585 TP_ARGS(netdev, index, bssid, preauth), 2586 TP_STRUCT__entry( 2587 NETDEV_ENTRY 2588 __field(int, index) 2589 MAC_ENTRY(bssid) 2590 __field(bool, preauth) 2591 ), 2592 TP_fast_assign( 2593 NETDEV_ASSIGN; 2594 __entry->index = index; 2595 MAC_ASSIGN(bssid, bssid); 2596 __entry->preauth = preauth; 2597 ), 2598 TP_printk(NETDEV_PR_FMT ", index:%d, bssid: " MAC_PR_FMT ", pre auth: %s", 2599 NETDEV_PR_ARG, __entry->index, MAC_PR_ARG(bssid), 2600 BOOL_TO_STR(__entry->preauth)) 2601 ); 2602 2603 TRACE_EVENT(cfg80211_report_obss_beacon, 2604 TP_PROTO(struct wiphy *wiphy, const u8 *frame, size_t len, 2605 int freq, int sig_dbm), 2606 TP_ARGS(wiphy, frame, len, freq, sig_dbm), 2607 TP_STRUCT__entry( 2608 WIPHY_ENTRY 2609 __field(int, freq) 2610 __field(int, sig_dbm) 2611 ), 2612 TP_fast_assign( 2613 WIPHY_ASSIGN; 2614 __entry->freq = freq; 2615 __entry->sig_dbm = sig_dbm; 2616 ), 2617 TP_printk(WIPHY_PR_FMT ", freq: %d, sig_dbm: %d", 2618 WIPHY_PR_ARG, __entry->freq, __entry->sig_dbm) 2619 ); 2620 2621 TRACE_EVENT(cfg80211_tdls_oper_request, 2622 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *peer, 2623 enum nl80211_tdls_operation oper, u16 reason_code), 2624 TP_ARGS(wiphy, netdev, peer, oper, reason_code), 2625 TP_STRUCT__entry( 2626 WIPHY_ENTRY 2627 NETDEV_ENTRY 2628 MAC_ENTRY(peer) 2629 __field(enum nl80211_tdls_operation, oper) 2630 __field(u16, reason_code) 2631 ), 2632 TP_fast_assign( 2633 WIPHY_ASSIGN; 2634 NETDEV_ASSIGN; 2635 MAC_ASSIGN(peer, peer); 2636 __entry->oper = oper; 2637 __entry->reason_code = reason_code; 2638 ), 2639 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: " MAC_PR_FMT ", oper: %d, reason_code %u", 2640 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(peer), __entry->oper, 2641 __entry->reason_code) 2642 ); 2643 2644 TRACE_EVENT(cfg80211_scan_done, 2645 TP_PROTO(struct cfg80211_scan_request *request, bool aborted), 2646 TP_ARGS(request, aborted), 2647 TP_STRUCT__entry( 2648 __field(u32, n_channels) 2649 __dynamic_array(u8, ie, request ? request->ie_len : 0) 2650 __array(u32, rates, NUM_NL80211_BANDS) 2651 __field(u32, wdev_id) 2652 MAC_ENTRY(wiphy_mac) 2653 __field(bool, no_cck) 2654 __field(bool, aborted) 2655 ), 2656 TP_fast_assign( 2657 if (request) { 2658 memcpy(__get_dynamic_array(ie), request->ie, 2659 request->ie_len); 2660 memcpy(__entry->rates, request->rates, 2661 NUM_NL80211_BANDS); 2662 __entry->wdev_id = request->wdev ? 2663 request->wdev->identifier : 0; 2664 if (request->wiphy) 2665 MAC_ASSIGN(wiphy_mac, 2666 request->wiphy->perm_addr); 2667 __entry->no_cck = request->no_cck; 2668 } 2669 __entry->aborted = aborted; 2670 ), 2671 TP_printk("aborted: %s", BOOL_TO_STR(__entry->aborted)) 2672 ); 2673 2674 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_results, 2675 TP_PROTO(struct wiphy *wiphy), 2676 TP_ARGS(wiphy) 2677 ); 2678 2679 DEFINE_EVENT(wiphy_only_evt, cfg80211_sched_scan_stopped, 2680 TP_PROTO(struct wiphy *wiphy), 2681 TP_ARGS(wiphy) 2682 ); 2683 2684 TRACE_EVENT(cfg80211_get_bss, 2685 TP_PROTO(struct wiphy *wiphy, struct ieee80211_channel *channel, 2686 const u8 *bssid, const u8 *ssid, size_t ssid_len, 2687 enum ieee80211_bss_type bss_type, 2688 enum ieee80211_privacy privacy), 2689 TP_ARGS(wiphy, channel, bssid, ssid, ssid_len, bss_type, privacy), 2690 TP_STRUCT__entry( 2691 WIPHY_ENTRY 2692 CHAN_ENTRY 2693 MAC_ENTRY(bssid) 2694 __dynamic_array(u8, ssid, ssid_len) 2695 __field(enum ieee80211_bss_type, bss_type) 2696 __field(enum ieee80211_privacy, privacy) 2697 ), 2698 TP_fast_assign( 2699 WIPHY_ASSIGN; 2700 CHAN_ASSIGN(channel); 2701 MAC_ASSIGN(bssid, bssid); 2702 memcpy(__get_dynamic_array(ssid), ssid, ssid_len); 2703 __entry->bss_type = bss_type; 2704 __entry->privacy = privacy; 2705 ), 2706 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT ", " MAC_PR_FMT 2707 ", buf: %#.2x, bss_type: %d, privacy: %d", 2708 WIPHY_PR_ARG, CHAN_PR_ARG, MAC_PR_ARG(bssid), 2709 ((u8 *)__get_dynamic_array(ssid))[0], __entry->bss_type, 2710 __entry->privacy) 2711 ); 2712 2713 TRACE_EVENT(cfg80211_inform_bss_frame, 2714 TP_PROTO(struct wiphy *wiphy, struct cfg80211_inform_bss *data, 2715 struct ieee80211_mgmt *mgmt, size_t len), 2716 TP_ARGS(wiphy, data, mgmt, len), 2717 TP_STRUCT__entry( 2718 WIPHY_ENTRY 2719 CHAN_ENTRY 2720 __field(enum nl80211_bss_scan_width, scan_width) 2721 __dynamic_array(u8, mgmt, len) 2722 __field(s32, signal) 2723 __field(u64, ts_boottime) 2724 ), 2725 TP_fast_assign( 2726 WIPHY_ASSIGN; 2727 CHAN_ASSIGN(data->chan); 2728 __entry->scan_width = data->scan_width; 2729 if (mgmt) 2730 memcpy(__get_dynamic_array(mgmt), mgmt, len); 2731 __entry->signal = data->signal; 2732 __entry->ts_boottime = data->boottime_ns; 2733 ), 2734 TP_printk(WIPHY_PR_FMT ", " CHAN_PR_FMT "(scan_width: %d) signal: %d, tsb:%llu", 2735 WIPHY_PR_ARG, CHAN_PR_ARG, __entry->scan_width, 2736 __entry->signal, (unsigned long long)__entry->ts_boottime) 2737 ); 2738 2739 DECLARE_EVENT_CLASS(cfg80211_bss_evt, 2740 TP_PROTO(struct cfg80211_bss *pub), 2741 TP_ARGS(pub), 2742 TP_STRUCT__entry( 2743 MAC_ENTRY(bssid) 2744 CHAN_ENTRY 2745 ), 2746 TP_fast_assign( 2747 MAC_ASSIGN(bssid, pub->bssid); 2748 CHAN_ASSIGN(pub->channel); 2749 ), 2750 TP_printk(MAC_PR_FMT ", " CHAN_PR_FMT, MAC_PR_ARG(bssid), CHAN_PR_ARG) 2751 ); 2752 2753 DEFINE_EVENT(cfg80211_bss_evt, cfg80211_return_bss, 2754 TP_PROTO(struct cfg80211_bss *pub), 2755 TP_ARGS(pub) 2756 ); 2757 2758 TRACE_EVENT(cfg80211_return_uint, 2759 TP_PROTO(unsigned int ret), 2760 TP_ARGS(ret), 2761 TP_STRUCT__entry( 2762 __field(unsigned int, ret) 2763 ), 2764 TP_fast_assign( 2765 __entry->ret = ret; 2766 ), 2767 TP_printk("ret: %d", __entry->ret) 2768 ); 2769 2770 TRACE_EVENT(cfg80211_return_u32, 2771 TP_PROTO(u32 ret), 2772 TP_ARGS(ret), 2773 TP_STRUCT__entry( 2774 __field(u32, ret) 2775 ), 2776 TP_fast_assign( 2777 __entry->ret = ret; 2778 ), 2779 TP_printk("ret: %u", __entry->ret) 2780 ); 2781 2782 TRACE_EVENT(cfg80211_report_wowlan_wakeup, 2783 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, 2784 struct cfg80211_wowlan_wakeup *wakeup), 2785 TP_ARGS(wiphy, wdev, wakeup), 2786 TP_STRUCT__entry( 2787 WIPHY_ENTRY 2788 WDEV_ENTRY 2789 __field(bool, non_wireless) 2790 __field(bool, disconnect) 2791 __field(bool, magic_pkt) 2792 __field(bool, gtk_rekey_failure) 2793 __field(bool, eap_identity_req) 2794 __field(bool, four_way_handshake) 2795 __field(bool, rfkill_release) 2796 __field(s32, pattern_idx) 2797 __field(u32, packet_len) 2798 __dynamic_array(u8, packet, 2799 wakeup ? wakeup->packet_present_len : 0) 2800 ), 2801 TP_fast_assign( 2802 WIPHY_ASSIGN; 2803 WDEV_ASSIGN; 2804 __entry->non_wireless = !wakeup; 2805 __entry->disconnect = wakeup ? wakeup->disconnect : false; 2806 __entry->magic_pkt = wakeup ? wakeup->magic_pkt : false; 2807 __entry->gtk_rekey_failure = wakeup ? wakeup->gtk_rekey_failure : false; 2808 __entry->eap_identity_req = wakeup ? wakeup->eap_identity_req : false; 2809 __entry->four_way_handshake = wakeup ? wakeup->four_way_handshake : false; 2810 __entry->rfkill_release = wakeup ? wakeup->rfkill_release : false; 2811 __entry->pattern_idx = wakeup ? wakeup->pattern_idx : false; 2812 __entry->packet_len = wakeup ? wakeup->packet_len : false; 2813 if (wakeup && wakeup->packet && wakeup->packet_present_len) 2814 memcpy(__get_dynamic_array(packet), wakeup->packet, 2815 wakeup->packet_present_len); 2816 ), 2817 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) 2818 ); 2819 2820 TRACE_EVENT(cfg80211_ft_event, 2821 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2822 struct cfg80211_ft_event_params *ft_event), 2823 TP_ARGS(wiphy, netdev, ft_event), 2824 TP_STRUCT__entry( 2825 WIPHY_ENTRY 2826 NETDEV_ENTRY 2827 __dynamic_array(u8, ies, ft_event->ies_len) 2828 MAC_ENTRY(target_ap) 2829 __dynamic_array(u8, ric_ies, ft_event->ric_ies_len) 2830 ), 2831 TP_fast_assign( 2832 WIPHY_ASSIGN; 2833 NETDEV_ASSIGN; 2834 if (ft_event->ies) 2835 memcpy(__get_dynamic_array(ies), ft_event->ies, 2836 ft_event->ies_len); 2837 MAC_ASSIGN(target_ap, ft_event->target_ap); 2838 if (ft_event->ric_ies) 2839 memcpy(__get_dynamic_array(ric_ies), ft_event->ric_ies, 2840 ft_event->ric_ies_len); 2841 ), 2842 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", target_ap: " MAC_PR_FMT, 2843 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(target_ap)) 2844 ); 2845 2846 TRACE_EVENT(cfg80211_stop_iface, 2847 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2848 TP_ARGS(wiphy, wdev), 2849 TP_STRUCT__entry( 2850 WIPHY_ENTRY 2851 WDEV_ENTRY 2852 ), 2853 TP_fast_assign( 2854 WIPHY_ASSIGN; 2855 WDEV_ASSIGN; 2856 ), 2857 TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, 2858 WIPHY_PR_ARG, WDEV_PR_ARG) 2859 ); 2860 2861 TRACE_EVENT(rdev_start_radar_detection, 2862 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2863 struct cfg80211_chan_def *chandef, 2864 u32 cac_time_ms), 2865 TP_ARGS(wiphy, netdev, chandef, cac_time_ms), 2866 TP_STRUCT__entry( 2867 WIPHY_ENTRY 2868 NETDEV_ENTRY 2869 CHAN_DEF_ENTRY 2870 __field(u32, cac_time_ms) 2871 ), 2872 TP_fast_assign( 2873 WIPHY_ASSIGN; 2874 NETDEV_ASSIGN; 2875 CHAN_DEF_ASSIGN(chandef); 2876 __entry->cac_time_ms = cac_time_ms; 2877 ), 2878 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT 2879 ", cac_time_ms=%u", 2880 WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, 2881 __entry->cac_time_ms) 2882 ); 2883 2884 TRACE_EVENT(rdev_set_mcast_rate, 2885 TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, 2886 int mcast_rate[NUM_NL80211_BANDS]), 2887 TP_ARGS(wiphy, netdev, mcast_rate), 2888 TP_STRUCT__entry( 2889 WIPHY_ENTRY 2890 NETDEV_ENTRY 2891 __array(int, mcast_rate, NUM_NL80211_BANDS) 2892 ), 2893 TP_fast_assign( 2894 WIPHY_ASSIGN; 2895 NETDEV_ASSIGN; 2896 memcpy(__entry->mcast_rate, mcast_rate, 2897 sizeof(int) * NUM_NL80211_BANDS); 2898 ), 2899 TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " 2900 "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 60GHz=0x%x]", 2901 WIPHY_PR_ARG, NETDEV_PR_ARG, 2902 __entry->mcast_rate[NL80211_BAND_2GHZ], 2903 __entry->mcast_rate[NL80211_BAND_5GHZ], 2904 __entry->mcast_rate[NL80211_BAND_60GHZ]) 2905 ); 2906 2907 TRACE_EVENT(rdev_set_coalesce, 2908 TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), 2909 TP_ARGS(wiphy, coalesce), 2910 TP_STRUCT__entry( 2911 WIPHY_ENTRY 2912 __field(int, n_rules) 2913 ), 2914 TP_fast_assign( 2915 WIPHY_ASSIGN; 2916 __entry->n_rules = coalesce ? coalesce->n_rules : 0; 2917 ), 2918 TP_printk(WIPHY_PR_FMT ", n_rules=%d", 2919 WIPHY_PR_ARG, __entry->n_rules) 2920 ); 2921 2922 DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, 2923 TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), 2924 TP_ARGS(wiphy, wdev) 2925 ); 2926 #endif /* !__RDEV_OPS_TRACE || TRACE_HEADER_MULTI_READ */ 2927 2928 #undef TRACE_INCLUDE_PATH 2929 #define TRACE_INCLUDE_PATH . 2930 #undef TRACE_INCLUDE_FILE 2931 #define TRACE_INCLUDE_FILE trace 2932 #include <trace/define_trace.h> 2933