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