| /* SPDX-License-Identifier: GPL-2.0 */ |
| /* |
| * Portions of this file |
| * Copyright(c) 2016-2017 Intel Deutschland GmbH |
| * Copyright (C) 2018, 2020-2024 Intel Corporation |
| */ |
| #undef TRACE_SYSTEM |
| #define TRACE_SYSTEM cfg80211 |
| |
| #if !defined(__RDEV_OPS_TRACE) || defined(TRACE_HEADER_MULTI_READ) |
| #define __RDEV_OPS_TRACE |
| |
| #include <linux/tracepoint.h> |
| |
| #include <linux/rtnetlink.h> |
| #include <linux/etherdevice.h> |
| #include <net/cfg80211.h> |
| #include "core.h" |
| |
| #define MAC_ENTRY(entry_mac) __array(u8, entry_mac, ETH_ALEN) |
| #define MAC_ASSIGN(entry_mac, given_mac) do { \ |
| if (given_mac) \ |
| memcpy(__entry->entry_mac, given_mac, ETH_ALEN); \ |
| else \ |
| eth_zero_addr(__entry->entry_mac); \ |
| } while (0) |
| |
| #define MAXNAME 32 |
| #define WIPHY_ENTRY __array(char, wiphy_name, 32) |
| #define WIPHY_ASSIGN strscpy(__entry->wiphy_name, wiphy_name(wiphy), MAXNAME) |
| #define WIPHY_PR_FMT "%s" |
| #define WIPHY_PR_ARG __entry->wiphy_name |
| |
| #define WDEV_ENTRY __field(u32, id) |
| #define WDEV_ASSIGN (__entry->id) = (!IS_ERR_OR_NULL(wdev) \ |
| ? wdev->identifier : 0) |
| #define WDEV_PR_FMT "wdev(%u)" |
| #define WDEV_PR_ARG (__entry->id) |
| |
| #define NETDEV_ENTRY __array(char, name, IFNAMSIZ) \ |
| __field(int, ifindex) |
| #define NETDEV_ASSIGN \ |
| do { \ |
| memcpy(__entry->name, netdev->name, IFNAMSIZ); \ |
| (__entry->ifindex) = (netdev->ifindex); \ |
| } while (0) |
| #define NETDEV_PR_FMT "netdev:%s(%d)" |
| #define NETDEV_PR_ARG __entry->name, __entry->ifindex |
| |
| #define MESH_CFG_ENTRY __field(u16, dot11MeshRetryTimeout) \ |
| __field(u16, dot11MeshConfirmTimeout) \ |
| __field(u16, dot11MeshHoldingTimeout) \ |
| __field(u16, dot11MeshMaxPeerLinks) \ |
| __field(u8, dot11MeshMaxRetries) \ |
| __field(u8, dot11MeshTTL) \ |
| __field(u8, element_ttl) \ |
| __field(bool, auto_open_plinks) \ |
| __field(u32, dot11MeshNbrOffsetMaxNeighbor) \ |
| __field(u8, dot11MeshHWMPmaxPREQretries) \ |
| __field(u32, path_refresh_time) \ |
| __field(u32, dot11MeshHWMPactivePathTimeout) \ |
| __field(u16, min_discovery_timeout) \ |
| __field(u16, dot11MeshHWMPpreqMinInterval) \ |
| __field(u16, dot11MeshHWMPperrMinInterval) \ |
| __field(u16, dot11MeshHWMPnetDiameterTraversalTime) \ |
| __field(u8, dot11MeshHWMPRootMode) \ |
| __field(u16, dot11MeshHWMPRannInterval) \ |
| __field(bool, dot11MeshGateAnnouncementProtocol) \ |
| __field(bool, dot11MeshForwarding) \ |
| __field(s32, rssi_threshold) \ |
| __field(u16, ht_opmode) \ |
| __field(u32, dot11MeshHWMPactivePathToRootTimeout) \ |
| __field(u16, dot11MeshHWMProotInterval) \ |
| __field(u16, dot11MeshHWMPconfirmationInterval) \ |
| __field(bool, dot11MeshNolearn) |
| #define MESH_CFG_ASSIGN \ |
| do { \ |
| __entry->dot11MeshRetryTimeout = conf->dot11MeshRetryTimeout; \ |
| __entry->dot11MeshConfirmTimeout = \ |
| conf->dot11MeshConfirmTimeout; \ |
| __entry->dot11MeshHoldingTimeout = \ |
| conf->dot11MeshHoldingTimeout; \ |
| __entry->dot11MeshMaxPeerLinks = conf->dot11MeshMaxPeerLinks; \ |
| __entry->dot11MeshMaxRetries = conf->dot11MeshMaxRetries; \ |
| __entry->dot11MeshTTL = conf->dot11MeshTTL; \ |
| __entry->element_ttl = conf->element_ttl; \ |
| __entry->auto_open_plinks = conf->auto_open_plinks; \ |
| __entry->dot11MeshNbrOffsetMaxNeighbor = \ |
| conf->dot11MeshNbrOffsetMaxNeighbor; \ |
| __entry->dot11MeshHWMPmaxPREQretries = \ |
| conf->dot11MeshHWMPmaxPREQretries; \ |
| __entry->path_refresh_time = conf->path_refresh_time; \ |
| __entry->dot11MeshHWMPactivePathTimeout = \ |
| conf->dot11MeshHWMPactivePathTimeout; \ |
| __entry->min_discovery_timeout = conf->min_discovery_timeout; \ |
| __entry->dot11MeshHWMPpreqMinInterval = \ |
| conf->dot11MeshHWMPpreqMinInterval; \ |
| __entry->dot11MeshHWMPperrMinInterval = \ |
| conf->dot11MeshHWMPperrMinInterval; \ |
| __entry->dot11MeshHWMPnetDiameterTraversalTime = \ |
| conf->dot11MeshHWMPnetDiameterTraversalTime; \ |
| __entry->dot11MeshHWMPRootMode = conf->dot11MeshHWMPRootMode; \ |
| __entry->dot11MeshHWMPRannInterval = \ |
| conf->dot11MeshHWMPRannInterval; \ |
| __entry->dot11MeshGateAnnouncementProtocol = \ |
| conf->dot11MeshGateAnnouncementProtocol; \ |
| __entry->dot11MeshForwarding = conf->dot11MeshForwarding; \ |
| __entry->rssi_threshold = conf->rssi_threshold; \ |
| __entry->ht_opmode = conf->ht_opmode; \ |
| __entry->dot11MeshHWMPactivePathToRootTimeout = \ |
| conf->dot11MeshHWMPactivePathToRootTimeout; \ |
| __entry->dot11MeshHWMProotInterval = \ |
| conf->dot11MeshHWMProotInterval; \ |
| __entry->dot11MeshHWMPconfirmationInterval = \ |
| conf->dot11MeshHWMPconfirmationInterval; \ |
| __entry->dot11MeshNolearn = conf->dot11MeshNolearn; \ |
| } while (0) |
| |
| #define CHAN_ENTRY __field(enum nl80211_band, band) \ |
| __field(u32, center_freq) \ |
| __field(u16, freq_offset) |
| #define CHAN_ASSIGN(chan) \ |
| do { \ |
| if (chan) { \ |
| __entry->band = chan->band; \ |
| __entry->center_freq = chan->center_freq; \ |
| __entry->freq_offset = chan->freq_offset; \ |
| } else { \ |
| __entry->band = 0; \ |
| __entry->center_freq = 0; \ |
| __entry->freq_offset = 0; \ |
| } \ |
| } while (0) |
| #define CHAN_PR_FMT "band: %d, freq: %u.%03u" |
| #define CHAN_PR_ARG __entry->band, __entry->center_freq, __entry->freq_offset |
| |
| #define CHAN_DEF_ENTRY __field(enum nl80211_band, band) \ |
| __field(u32, control_freq) \ |
| __field(u32, freq_offset) \ |
| __field(u32, width) \ |
| __field(u32, center_freq1) \ |
| __field(u32, freq1_offset) \ |
| __field(u32, center_freq2) \ |
| __field(u16, punctured) |
| #define CHAN_DEF_ASSIGN(chandef) \ |
| do { \ |
| if ((chandef) && (chandef)->chan) { \ |
| __entry->band = (chandef)->chan->band; \ |
| __entry->control_freq = \ |
| (chandef)->chan->center_freq; \ |
| __entry->freq_offset = \ |
| (chandef)->chan->freq_offset; \ |
| __entry->width = (chandef)->width; \ |
| __entry->center_freq1 = (chandef)->center_freq1;\ |
| __entry->freq1_offset = (chandef)->freq1_offset;\ |
| __entry->center_freq2 = (chandef)->center_freq2;\ |
| __entry->punctured = (chandef)->punctured; \ |
| } else { \ |
| __entry->band = 0; \ |
| __entry->control_freq = 0; \ |
| __entry->freq_offset = 0; \ |
| __entry->width = 0; \ |
| __entry->center_freq1 = 0; \ |
| __entry->freq1_offset = 0; \ |
| __entry->center_freq2 = 0; \ |
| __entry->punctured = 0; \ |
| } \ |
| } while (0) |
| #define CHAN_DEF_PR_FMT \ |
| "band: %d, control freq: %u.%03u, width: %d, cf1: %u.%03u, cf2: %u, punct: 0x%x" |
| #define CHAN_DEF_PR_ARG __entry->band, __entry->control_freq, \ |
| __entry->freq_offset, __entry->width, \ |
| __entry->center_freq1, __entry->freq1_offset, \ |
| __entry->center_freq2, __entry->punctured |
| |
| #define FILS_AAD_ASSIGN(fa) \ |
| do { \ |
| if (fa) { \ |
| ether_addr_copy(__entry->macaddr, fa->macaddr); \ |
| __entry->kek_len = fa->kek_len; \ |
| } else { \ |
| eth_zero_addr(__entry->macaddr); \ |
| __entry->kek_len = 0; \ |
| } \ |
| } while (0) |
| #define FILS_AAD_PR_FMT \ |
| "macaddr: %pM, kek_len: %d" |
| |
| #define SINFO_ENTRY __field(int, generation) \ |
| __field(u32, connected_time) \ |
| __field(u32, inactive_time) \ |
| __field(u32, rx_bytes) \ |
| __field(u32, tx_bytes) \ |
| __field(u32, rx_packets) \ |
| __field(u32, tx_packets) \ |
| __field(u32, tx_retries) \ |
| __field(u32, tx_failed) \ |
| __field(u32, rx_dropped_misc) \ |
| __field(u32, beacon_loss_count) \ |
| __field(u16, llid) \ |
| __field(u16, plid) \ |
| __field(u8, plink_state) |
| #define SINFO_ASSIGN \ |
| do { \ |
| __entry->generation = sinfo->generation; \ |
| __entry->connected_time = sinfo->connected_time; \ |
| __entry->inactive_time = sinfo->inactive_time; \ |
| __entry->rx_bytes = sinfo->rx_bytes; \ |
| __entry->tx_bytes = sinfo->tx_bytes; \ |
| __entry->rx_packets = sinfo->rx_packets; \ |
| __entry->tx_packets = sinfo->tx_packets; \ |
| __entry->tx_retries = sinfo->tx_retries; \ |
| __entry->tx_failed = sinfo->tx_failed; \ |
| __entry->rx_dropped_misc = sinfo->rx_dropped_misc; \ |
| __entry->beacon_loss_count = sinfo->beacon_loss_count; \ |
| __entry->llid = sinfo->llid; \ |
| __entry->plid = sinfo->plid; \ |
| __entry->plink_state = sinfo->plink_state; \ |
| } while (0) |
| |
| #define BOOL_TO_STR(bo) (bo) ? "true" : "false" |
| |
| #define QOS_MAP_ENTRY __field(u8, num_des) \ |
| __array(u8, dscp_exception, \ |
| 2 * IEEE80211_QOS_MAP_MAX_EX) \ |
| __array(u8, up, IEEE80211_QOS_MAP_LEN_MIN) |
| #define QOS_MAP_ASSIGN(qos_map) \ |
| do { \ |
| if ((qos_map)) { \ |
| __entry->num_des = (qos_map)->num_des; \ |
| memcpy(__entry->dscp_exception, \ |
| &(qos_map)->dscp_exception, \ |
| 2 * IEEE80211_QOS_MAP_MAX_EX); \ |
| memcpy(__entry->up, &(qos_map)->up, \ |
| IEEE80211_QOS_MAP_LEN_MIN); \ |
| } else { \ |
| __entry->num_des = 0; \ |
| memset(__entry->dscp_exception, 0, \ |
| 2 * IEEE80211_QOS_MAP_MAX_EX); \ |
| memset(__entry->up, 0, \ |
| IEEE80211_QOS_MAP_LEN_MIN); \ |
| } \ |
| } while (0) |
| |
| /************************************************************* |
| * wiphy work traces * |
| *************************************************************/ |
| |
| DECLARE_EVENT_CLASS(wiphy_work_event, |
| TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), |
| TP_ARGS(wiphy, work), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(void *, instance) |
| __field(void *, func) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->instance = work; |
| __entry->func = work ? work->func : NULL; |
| ), |
| TP_printk(WIPHY_PR_FMT " instance=%p func=%pS", |
| WIPHY_PR_ARG, __entry->instance, __entry->func) |
| ); |
| |
| DEFINE_EVENT(wiphy_work_event, wiphy_work_queue, |
| TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), |
| TP_ARGS(wiphy, work) |
| ); |
| |
| DEFINE_EVENT(wiphy_work_event, wiphy_work_run, |
| TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), |
| TP_ARGS(wiphy, work) |
| ); |
| |
| DEFINE_EVENT(wiphy_work_event, wiphy_work_cancel, |
| TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), |
| TP_ARGS(wiphy, work) |
| ); |
| |
| DEFINE_EVENT(wiphy_work_event, wiphy_work_flush, |
| TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work), |
| TP_ARGS(wiphy, work) |
| ); |
| |
| TRACE_EVENT(wiphy_delayed_work_queue, |
| TP_PROTO(struct wiphy *wiphy, struct wiphy_work *work, |
| unsigned long delay), |
| TP_ARGS(wiphy, work, delay), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(void *, instance) |
| __field(void *, func) |
| __field(unsigned long, delay) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->instance = work; |
| __entry->func = work->func; |
| __entry->delay = delay; |
| ), |
| TP_printk(WIPHY_PR_FMT " instance=%p func=%pS delay=%ld", |
| WIPHY_PR_ARG, __entry->instance, __entry->func, |
| __entry->delay) |
| ); |
| |
| TRACE_EVENT(wiphy_work_worker_start, |
| TP_PROTO(struct wiphy *wiphy), |
| TP_ARGS(wiphy), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) |
| ); |
| |
| /************************************************************* |
| * rdev->ops traces * |
| *************************************************************/ |
| |
| TRACE_EVENT(rdev_suspend, |
| TP_PROTO(struct wiphy *wiphy, struct cfg80211_wowlan *wow), |
| TP_ARGS(wiphy, wow), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(bool, any) |
| __field(bool, disconnect) |
| __field(bool, magic_pkt) |
| __field(bool, gtk_rekey_failure) |
| __field(bool, eap_identity_req) |
| __field(bool, four_way_handshake) |
| __field(bool, rfkill_release) |
| __field(bool, valid_wow) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| if (wow) { |
| __entry->any = wow->any; |
| __entry->disconnect = wow->disconnect; |
| __entry->magic_pkt = wow->magic_pkt; |
| __entry->gtk_rekey_failure = wow->gtk_rekey_failure; |
| __entry->eap_identity_req = wow->eap_identity_req; |
| __entry->four_way_handshake = wow->four_way_handshake; |
| __entry->rfkill_release = wow->rfkill_release; |
| __entry->valid_wow = true; |
| } else { |
| __entry->valid_wow = false; |
| } |
| ), |
| TP_printk(WIPHY_PR_FMT ", wow%s - any: %d, disconnect: %d, " |
| "magic pkt: %d, gtk rekey failure: %d, eap identify req: %d, " |
| "four way handshake: %d, rfkill release: %d.", |
| WIPHY_PR_ARG, __entry->valid_wow ? "" : "(Not configured!)", |
| __entry->any, __entry->disconnect, __entry->magic_pkt, |
| __entry->gtk_rekey_failure, __entry->eap_identity_req, |
| __entry->four_way_handshake, __entry->rfkill_release) |
| ); |
| |
| TRACE_EVENT(rdev_return_int, |
| TP_PROTO(struct wiphy *wiphy, int ret), |
| TP_ARGS(wiphy, ret), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, ret) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->ret = ret; |
| ), |
| TP_printk(WIPHY_PR_FMT ", returned: %d", WIPHY_PR_ARG, __entry->ret) |
| ); |
| |
| TRACE_EVENT(rdev_scan, |
| TP_PROTO(struct wiphy *wiphy, struct cfg80211_scan_request *request), |
| TP_ARGS(wiphy, request), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_only_evt, |
| TP_PROTO(struct wiphy *wiphy), |
| TP_ARGS(wiphy), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) |
| ); |
| |
| DEFINE_EVENT(wiphy_only_evt, rdev_resume, |
| TP_PROTO(struct wiphy *wiphy), |
| TP_ARGS(wiphy) |
| ); |
| |
| DEFINE_EVENT(wiphy_only_evt, rdev_return_void, |
| TP_PROTO(struct wiphy *wiphy), |
| TP_ARGS(wiphy) |
| ); |
| |
| DEFINE_EVENT(wiphy_only_evt, rdev_get_antenna, |
| TP_PROTO(struct wiphy *wiphy), |
| TP_ARGS(wiphy) |
| ); |
| |
| DEFINE_EVENT(wiphy_only_evt, rdev_rfkill_poll, |
| TP_PROTO(struct wiphy *wiphy), |
| TP_ARGS(wiphy) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_enabled_evt, |
| TP_PROTO(struct wiphy *wiphy, bool enabled), |
| TP_ARGS(wiphy, enabled), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(bool, enabled) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->enabled = enabled; |
| ), |
| TP_printk(WIPHY_PR_FMT ", %senabled ", |
| WIPHY_PR_ARG, __entry->enabled ? "" : "not ") |
| ); |
| |
| DEFINE_EVENT(wiphy_enabled_evt, rdev_set_wakeup, |
| TP_PROTO(struct wiphy *wiphy, bool enabled), |
| TP_ARGS(wiphy, enabled) |
| ); |
| |
| TRACE_EVENT(rdev_add_virtual_intf, |
| TP_PROTO(struct wiphy *wiphy, char *name, enum nl80211_iftype type), |
| TP_ARGS(wiphy, name, type), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __string(vir_intf_name, name ? name : "<noname>") |
| __field(enum nl80211_iftype, type) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __assign_str(vir_intf_name); |
| __entry->type = type; |
| ), |
| TP_printk(WIPHY_PR_FMT ", virtual intf name: %s, type: %d", |
| WIPHY_PR_ARG, __get_str(vir_intf_name), __entry->type) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_wdev_evt, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_wdev_cookie_evt, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), |
| TP_ARGS(wiphy, wdev, cookie), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u64, cookie) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->cookie = cookie; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %lld", |
| WIPHY_PR_ARG, WDEV_PR_ARG, |
| (unsigned long long)__entry->cookie) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_return_wdev, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_del_virtual_intf, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| TRACE_EVENT(rdev_change_virtual_intf, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| enum nl80211_iftype type), |
| TP_ARGS(wiphy, netdev, type), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(enum nl80211_iftype, type) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->type = type; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", type: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->type) |
| ); |
| |
| DECLARE_EVENT_CLASS(key_handle, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, |
| u8 key_index, bool pairwise, const u8 *mac_addr), |
| TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(mac_addr) |
| __field(int, link_id) |
| __field(u8, key_index) |
| __field(bool, pairwise) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(mac_addr, mac_addr); |
| __entry->link_id = link_id; |
| __entry->key_index = key_index; |
| __entry->pairwise = pairwise; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " |
| "key_index: %u, pairwise: %s, mac addr: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, |
| __entry->key_index, BOOL_TO_STR(__entry->pairwise), |
| __entry->mac_addr) |
| ); |
| |
| DEFINE_EVENT(key_handle, rdev_get_key, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, |
| u8 key_index, bool pairwise, const u8 *mac_addr), |
| TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr) |
| ); |
| |
| DEFINE_EVENT(key_handle, rdev_del_key, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, |
| u8 key_index, bool pairwise, const u8 *mac_addr), |
| TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr) |
| ); |
| |
| TRACE_EVENT(rdev_add_key, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, |
| u8 key_index, bool pairwise, const u8 *mac_addr, u8 mode), |
| TP_ARGS(wiphy, netdev, link_id, key_index, pairwise, mac_addr, mode), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(mac_addr) |
| __field(int, link_id) |
| __field(u8, key_index) |
| __field(bool, pairwise) |
| __field(u8, mode) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(mac_addr, mac_addr); |
| __entry->link_id = link_id; |
| __entry->key_index = key_index; |
| __entry->pairwise = pairwise; |
| __entry->mode = mode; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " |
| "key_index: %u, mode: %u, pairwise: %s, " |
| "mac addr: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, |
| __entry->key_index, __entry->mode, |
| BOOL_TO_STR(__entry->pairwise), __entry->mac_addr) |
| ); |
| |
| TRACE_EVENT(rdev_set_default_key, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, |
| u8 key_index, bool unicast, bool multicast), |
| TP_ARGS(wiphy, netdev, link_id, key_index, unicast, multicast), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(int, link_id) |
| __field(u8, key_index) |
| __field(bool, unicast) |
| __field(bool, multicast) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->link_id = link_id; |
| __entry->key_index = key_index; |
| __entry->unicast = unicast; |
| __entry->multicast = multicast; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " |
| "key index: %u, unicast: %s, multicast: %s", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, |
| __entry->key_index, BOOL_TO_STR(__entry->unicast), |
| BOOL_TO_STR(__entry->multicast)) |
| ); |
| |
| TRACE_EVENT(rdev_set_default_mgmt_key, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, |
| u8 key_index), |
| TP_ARGS(wiphy, netdev, link_id, key_index), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(int, link_id) |
| __field(u8, key_index) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->link_id = link_id; |
| __entry->key_index = key_index; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " |
| "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->link_id, __entry->key_index) |
| ); |
| |
| TRACE_EVENT(rdev_set_default_beacon_key, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int link_id, |
| u8 key_index), |
| TP_ARGS(wiphy, netdev, link_id, key_index), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(int, link_id) |
| __field(u8, key_index) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->link_id = link_id; |
| __entry->key_index = key_index; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, " |
| "key index: %u", WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->link_id, __entry->key_index) |
| ); |
| |
| TRACE_EVENT(rdev_start_ap, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_ap_settings *settings), |
| TP_ARGS(wiphy, netdev, settings), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| CHAN_DEF_ENTRY |
| __field(int, beacon_interval) |
| __field(int, dtim_period) |
| __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) |
| __field(enum nl80211_hidden_ssid, hidden_ssid) |
| __field(u32, wpa_ver) |
| __field(bool, privacy) |
| __field(enum nl80211_auth_type, auth_type) |
| __field(int, inactivity_timeout) |
| __field(unsigned int, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| CHAN_DEF_ASSIGN(&settings->chandef); |
| __entry->beacon_interval = settings->beacon_interval; |
| __entry->dtim_period = settings->dtim_period; |
| __entry->hidden_ssid = settings->hidden_ssid; |
| __entry->wpa_ver = settings->crypto.wpa_versions; |
| __entry->privacy = settings->privacy; |
| __entry->auth_type = settings->auth_type; |
| __entry->inactivity_timeout = settings->inactivity_timeout; |
| memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); |
| memcpy(__entry->ssid, settings->ssid, settings->ssid_len); |
| __entry->link_id = settings->beacon.link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", AP settings - ssid: %s, " |
| CHAN_DEF_PR_FMT ", beacon interval: %d, dtim period: %d, " |
| "hidden ssid: %d, wpa versions: %u, privacy: %s, " |
| "auth type: %d, inactivity timeout: %d, link_id: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ssid, CHAN_DEF_PR_ARG, |
| __entry->beacon_interval, __entry->dtim_period, |
| __entry->hidden_ssid, __entry->wpa_ver, |
| BOOL_TO_STR(__entry->privacy), __entry->auth_type, |
| __entry->inactivity_timeout, __entry->link_id) |
| ); |
| |
| TRACE_EVENT(rdev_change_beacon, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_ap_update *info), |
| TP_ARGS(wiphy, netdev, info), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(int, link_id) |
| __dynamic_array(u8, head, info->beacon.head_len) |
| __dynamic_array(u8, tail, info->beacon.tail_len) |
| __dynamic_array(u8, beacon_ies, info->beacon.beacon_ies_len) |
| __dynamic_array(u8, proberesp_ies, info->beacon.proberesp_ies_len) |
| __dynamic_array(u8, assocresp_ies, info->beacon.assocresp_ies_len) |
| __dynamic_array(u8, probe_resp, info->beacon.probe_resp_len) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->link_id = info->beacon.link_id; |
| if (info->beacon.head) |
| memcpy(__get_dynamic_array(head), |
| info->beacon.head, |
| info->beacon.head_len); |
| if (info->beacon.tail) |
| memcpy(__get_dynamic_array(tail), |
| info->beacon.tail, |
| info->beacon.tail_len); |
| if (info->beacon.beacon_ies) |
| memcpy(__get_dynamic_array(beacon_ies), |
| info->beacon.beacon_ies, |
| info->beacon.beacon_ies_len); |
| if (info->beacon.proberesp_ies) |
| memcpy(__get_dynamic_array(proberesp_ies), |
| info->beacon.proberesp_ies, |
| info->beacon.proberesp_ies_len); |
| if (info->beacon.assocresp_ies) |
| memcpy(__get_dynamic_array(assocresp_ies), |
| info->beacon.assocresp_ies, |
| info->beacon.assocresp_ies_len); |
| if (info->beacon.probe_resp) |
| memcpy(__get_dynamic_array(probe_resp), |
| info->beacon.probe_resp, |
| info->beacon.probe_resp_len); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id:%d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id) |
| ); |
| |
| TRACE_EVENT(rdev_stop_ap, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| unsigned int link_id), |
| TP_ARGS(wiphy, netdev, link_id), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(unsigned int, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->link_id = link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_netdev_evt, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, WIPHY_PR_ARG, NETDEV_PR_ARG) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_evt, rdev_set_rekey_data, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_evt, rdev_get_mesh_config, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_mesh, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ibss, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_evt, rdev_leave_ocb, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_evt, rdev_flush_pmksa, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_evt, rdev_end_cac, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev), |
| TP_ARGS(wiphy, netdev) |
| ); |
| |
| DECLARE_EVENT_CLASS(station_add_change, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, |
| struct station_parameters *params), |
| TP_ARGS(wiphy, netdev, mac, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(sta_mac) |
| __field(u32, sta_flags_mask) |
| __field(u32, sta_flags_set) |
| __field(u32, sta_modify_mask) |
| __field(int, listen_interval) |
| __field(u16, capability) |
| __field(u16, aid) |
| __field(u8, plink_action) |
| __field(u8, plink_state) |
| __field(u8, uapsd_queues) |
| __field(u8, max_sp) |
| __field(u8, opmode_notif) |
| __field(bool, opmode_notif_used) |
| __array(u8, ht_capa, (int)sizeof(struct ieee80211_ht_cap)) |
| __array(u8, vht_capa, (int)sizeof(struct ieee80211_vht_cap)) |
| __array(char, vlan, IFNAMSIZ) |
| __dynamic_array(u8, supported_rates, |
| params->link_sta_params.supported_rates_len) |
| __dynamic_array(u8, ext_capab, params->ext_capab_len) |
| __dynamic_array(u8, supported_channels, |
| params->supported_channels_len) |
| __dynamic_array(u8, supported_oper_classes, |
| params->supported_oper_classes_len) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(sta_mac, mac); |
| __entry->sta_flags_mask = params->sta_flags_mask; |
| __entry->sta_flags_set = params->sta_flags_set; |
| __entry->sta_modify_mask = params->sta_modify_mask; |
| __entry->listen_interval = params->listen_interval; |
| __entry->aid = params->aid; |
| __entry->plink_action = params->plink_action; |
| __entry->plink_state = params->plink_state; |
| __entry->uapsd_queues = params->uapsd_queues; |
| memset(__entry->ht_capa, 0, sizeof(struct ieee80211_ht_cap)); |
| if (params->link_sta_params.ht_capa) |
| memcpy(__entry->ht_capa, |
| params->link_sta_params.ht_capa, |
| sizeof(struct ieee80211_ht_cap)); |
| memset(__entry->vht_capa, 0, sizeof(struct ieee80211_vht_cap)); |
| if (params->link_sta_params.vht_capa) |
| memcpy(__entry->vht_capa, |
| params->link_sta_params.vht_capa, |
| sizeof(struct ieee80211_vht_cap)); |
| memset(__entry->vlan, 0, sizeof(__entry->vlan)); |
| if (params->vlan) |
| memcpy(__entry->vlan, params->vlan->name, IFNAMSIZ); |
| if (params->link_sta_params.supported_rates && |
| params->link_sta_params.supported_rates_len) |
| memcpy(__get_dynamic_array(supported_rates), |
| params->link_sta_params.supported_rates, |
| params->link_sta_params.supported_rates_len); |
| if (params->ext_capab && params->ext_capab_len) |
| memcpy(__get_dynamic_array(ext_capab), |
| params->ext_capab, |
| params->ext_capab_len); |
| if (params->supported_channels && |
| params->supported_channels_len) |
| memcpy(__get_dynamic_array(supported_channels), |
| params->supported_channels, |
| params->supported_channels_len); |
| if (params->supported_oper_classes && |
| params->supported_oper_classes_len) |
| memcpy(__get_dynamic_array(supported_oper_classes), |
| params->supported_oper_classes, |
| params->supported_oper_classes_len); |
| __entry->max_sp = params->max_sp; |
| __entry->capability = params->capability; |
| __entry->opmode_notif = params->link_sta_params.opmode_notif; |
| __entry->opmode_notif_used = |
| params->link_sta_params.opmode_notif_used; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" |
| ", station flags mask: 0x%x, station flags set: 0x%x, " |
| "station modify mask: 0x%x, listen interval: %d, aid: %u, " |
| "plink action: %u, plink state: %u, uapsd queues: %u, vlan:%s", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac, |
| __entry->sta_flags_mask, __entry->sta_flags_set, |
| __entry->sta_modify_mask, __entry->listen_interval, |
| __entry->aid, __entry->plink_action, __entry->plink_state, |
| __entry->uapsd_queues, __entry->vlan) |
| ); |
| |
| DEFINE_EVENT(station_add_change, rdev_add_station, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, |
| struct station_parameters *params), |
| TP_ARGS(wiphy, netdev, mac, params) |
| ); |
| |
| DEFINE_EVENT(station_add_change, rdev_change_station, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *mac, |
| struct station_parameters *params), |
| TP_ARGS(wiphy, netdev, mac, params) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_netdev_mac_evt, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), |
| TP_ARGS(wiphy, netdev, mac), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(sta_mac) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(sta_mac, mac); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac) |
| ); |
| |
| DECLARE_EVENT_CLASS(station_del, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct station_del_parameters *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(sta_mac) |
| __field(u8, subtype) |
| __field(u16, reason_code) |
| __field(int, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(sta_mac, params->mac); |
| __entry->subtype = params->subtype; |
| __entry->reason_code = params->reason_code; |
| __entry->link_id = params->link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" |
| ", subtype: %u, reason_code: %u, link_id: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac, |
| __entry->subtype, __entry->reason_code, |
| __entry->link_id) |
| ); |
| |
| DEFINE_EVENT(station_del, rdev_del_station, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct station_del_parameters *params), |
| TP_ARGS(wiphy, netdev, params) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_get_station, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), |
| TP_ARGS(wiphy, netdev, mac) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_mac_evt, rdev_del_mpath, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *mac), |
| TP_ARGS(wiphy, netdev, mac) |
| ); |
| |
| TRACE_EVENT(rdev_dump_station, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx, |
| u8 *mac), |
| TP_ARGS(wiphy, netdev, _idx, mac), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(sta_mac) |
| __field(int, idx) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(sta_mac, mac); |
| __entry->idx = _idx; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM, idx: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->sta_mac, |
| __entry->idx) |
| ); |
| |
| TRACE_EVENT(rdev_return_int_station_info, |
| TP_PROTO(struct wiphy *wiphy, int ret, struct station_info *sinfo), |
| TP_ARGS(wiphy, ret, sinfo), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, ret) |
| SINFO_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->ret = ret; |
| SINFO_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT ", returned %d" , |
| WIPHY_PR_ARG, __entry->ret) |
| ); |
| |
| DECLARE_EVENT_CLASS(mpath_evt, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, |
| u8 *next_hop), |
| TP_ARGS(wiphy, netdev, dst, next_hop), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(dst) |
| MAC_ENTRY(next_hop) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(dst, dst); |
| MAC_ASSIGN(next_hop, next_hop); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM, next hop: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dst, |
| __entry->next_hop) |
| ); |
| |
| DEFINE_EVENT(mpath_evt, rdev_add_mpath, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, |
| u8 *next_hop), |
| TP_ARGS(wiphy, netdev, dst, next_hop) |
| ); |
| |
| DEFINE_EVENT(mpath_evt, rdev_change_mpath, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, |
| u8 *next_hop), |
| TP_ARGS(wiphy, netdev, dst, next_hop) |
| ); |
| |
| DEFINE_EVENT(mpath_evt, rdev_get_mpath, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u8 *dst, |
| u8 *next_hop), |
| TP_ARGS(wiphy, netdev, dst, next_hop) |
| ); |
| |
| TRACE_EVENT(rdev_dump_mpath, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx, |
| u8 *dst, u8 *next_hop), |
| TP_ARGS(wiphy, netdev, _idx, dst, next_hop), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(dst) |
| MAC_ENTRY(next_hop) |
| __field(int, idx) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(dst, dst); |
| MAC_ASSIGN(next_hop, next_hop); |
| __entry->idx = _idx; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, next hop: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst, |
| __entry->next_hop) |
| ); |
| |
| TRACE_EVENT(rdev_get_mpp, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| u8 *dst, u8 *mpp), |
| TP_ARGS(wiphy, netdev, dst, mpp), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(dst) |
| MAC_ENTRY(mpp) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(dst, dst); |
| MAC_ASSIGN(mpp, mpp); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", destination: %pM" |
| ", mpp: %pM", WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->dst, __entry->mpp) |
| ); |
| |
| TRACE_EVENT(rdev_dump_mpp, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx, |
| u8 *dst, u8 *mpp), |
| TP_ARGS(wiphy, netdev, _idx, dst, mpp), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(dst) |
| MAC_ENTRY(mpp) |
| __field(int, idx) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(dst, dst); |
| MAC_ASSIGN(mpp, mpp); |
| __entry->idx = _idx; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d, destination: %pM, mpp: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx, __entry->dst, |
| __entry->mpp) |
| ); |
| |
| TRACE_EVENT(rdev_return_int_mpath_info, |
| TP_PROTO(struct wiphy *wiphy, int ret, struct mpath_info *pinfo), |
| TP_ARGS(wiphy, ret, pinfo), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, ret) |
| __field(int, generation) |
| __field(u32, filled) |
| __field(u32, frame_qlen) |
| __field(u32, sn) |
| __field(u32, metric) |
| __field(u32, exptime) |
| __field(u32, discovery_timeout) |
| __field(u8, discovery_retries) |
| __field(u8, flags) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->ret = ret; |
| __entry->generation = pinfo->generation; |
| __entry->filled = pinfo->filled; |
| __entry->frame_qlen = pinfo->frame_qlen; |
| __entry->sn = pinfo->sn; |
| __entry->metric = pinfo->metric; |
| __entry->exptime = pinfo->exptime; |
| __entry->discovery_timeout = pinfo->discovery_timeout; |
| __entry->discovery_retries = pinfo->discovery_retries; |
| __entry->flags = pinfo->flags; |
| ), |
| TP_printk(WIPHY_PR_FMT ", returned %d. mpath info - generation: %d, " |
| "filled: %u, frame qlen: %u, sn: %u, metric: %u, exptime: %u," |
| " discovery timeout: %u, discovery retries: %u, flags: 0x%x", |
| WIPHY_PR_ARG, __entry->ret, __entry->generation, |
| __entry->filled, __entry->frame_qlen, __entry->sn, |
| __entry->metric, __entry->exptime, __entry->discovery_timeout, |
| __entry->discovery_retries, __entry->flags) |
| ); |
| |
| TRACE_EVENT(rdev_return_int_mesh_config, |
| TP_PROTO(struct wiphy *wiphy, int ret, struct mesh_config *conf), |
| TP_ARGS(wiphy, ret, conf), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| MESH_CFG_ENTRY |
| __field(int, ret) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| MESH_CFG_ASSIGN; |
| __entry->ret = ret; |
| ), |
| TP_printk(WIPHY_PR_FMT ", returned: %d", |
| WIPHY_PR_ARG, __entry->ret) |
| ); |
| |
| TRACE_EVENT(rdev_update_mesh_config, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 mask, |
| const struct mesh_config *conf), |
| TP_ARGS(wiphy, netdev, mask, conf), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MESH_CFG_ENTRY |
| __field(u32, mask) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MESH_CFG_ASSIGN; |
| __entry->mask = mask; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mask: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mask) |
| ); |
| |
| TRACE_EVENT(rdev_join_mesh, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const struct mesh_config *conf, |
| const struct mesh_setup *setup), |
| TP_ARGS(wiphy, netdev, conf, setup), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MESH_CFG_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MESH_CFG_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, |
| WIPHY_PR_ARG, NETDEV_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_change_bss, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct bss_parameters *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(int, use_cts_prot) |
| __field(int, use_short_preamble) |
| __field(int, use_short_slot_time) |
| __field(int, ap_isolate) |
| __field(int, ht_opmode) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->use_cts_prot = params->use_cts_prot; |
| __entry->use_short_preamble = params->use_short_preamble; |
| __entry->use_short_slot_time = params->use_short_slot_time; |
| __entry->ap_isolate = params->ap_isolate; |
| __entry->ht_opmode = params->ht_opmode; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", use cts prot: %d, " |
| "use short preamble: %d, use short slot time: %d, " |
| "ap isolate: %d, ht opmode: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->use_cts_prot, |
| __entry->use_short_preamble, __entry->use_short_slot_time, |
| __entry->ap_isolate, __entry->ht_opmode) |
| ); |
| |
| TRACE_EVENT(rdev_inform_bss, |
| TP_PROTO(struct wiphy *wiphy, struct cfg80211_bss *bss), |
| TP_ARGS(wiphy, bss), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| MAC_ENTRY(bssid) |
| CHAN_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| MAC_ASSIGN(bssid, bss->bssid); |
| CHAN_ASSIGN(bss->channel); |
| ), |
| TP_printk(WIPHY_PR_FMT ", %pM, " CHAN_PR_FMT, |
| WIPHY_PR_ARG, __entry->bssid, CHAN_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_set_txq_params, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct ieee80211_txq_params *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(enum nl80211_ac, ac) |
| __field(u16, txop) |
| __field(u16, cwmin) |
| __field(u16, cwmax) |
| __field(u8, aifs) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->ac = params->ac; |
| __entry->txop = params->txop; |
| __entry->cwmin = params->cwmin; |
| __entry->cwmax = params->cwmax; |
| __entry->aifs = params->aifs; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", ac: %d, txop: %u, cwmin: %u, cwmax: %u, aifs: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->ac, __entry->txop, |
| __entry->cwmin, __entry->cwmax, __entry->aifs) |
| ); |
| |
| TRACE_EVENT(rdev_libertas_set_mesh_channel, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct ieee80211_channel *chan), |
| TP_ARGS(wiphy, netdev, chan), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| CHAN_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| CHAN_ASSIGN(chan); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_PR_FMT, WIPHY_PR_ARG, |
| NETDEV_PR_ARG, CHAN_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_set_monitor_channel, |
| TP_PROTO(struct wiphy *wiphy, |
| struct cfg80211_chan_def *chandef), |
| TP_ARGS(wiphy, chandef), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| CHAN_DEF_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| CHAN_DEF_ASSIGN(chandef); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, |
| WIPHY_PR_ARG, CHAN_DEF_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_auth, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_auth_request *req), |
| TP_ARGS(wiphy, netdev, req), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| __field(enum nl80211_auth_type, auth_type) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| if (req->bss) |
| MAC_ASSIGN(bssid, req->bss->bssid); |
| else |
| eth_zero_addr(__entry->bssid); |
| __entry->auth_type = req->auth_type; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", auth type: %d, bssid: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->auth_type, |
| __entry->bssid) |
| ); |
| |
| TRACE_EVENT(rdev_assoc, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_assoc_request *req), |
| TP_ARGS(wiphy, netdev, req), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| MAC_ENTRY(prev_bssid) |
| __field(bool, use_mfp) |
| __field(u32, flags) |
| __dynamic_array(u8, elements, req->ie_len) |
| __array(u8, ht_capa, sizeof(struct ieee80211_ht_cap)) |
| __array(u8, ht_capa_mask, sizeof(struct ieee80211_ht_cap)) |
| __array(u8, vht_capa, sizeof(struct ieee80211_vht_cap)) |
| __array(u8, vht_capa_mask, sizeof(struct ieee80211_vht_cap)) |
| __dynamic_array(u8, fils_kek, req->fils_kek_len) |
| __dynamic_array(u8, fils_nonces, |
| req->fils_nonces ? 2 * FILS_NONCE_LEN : 0) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| if (req->bss) |
| MAC_ASSIGN(bssid, req->bss->bssid); |
| else |
| eth_zero_addr(__entry->bssid); |
| MAC_ASSIGN(prev_bssid, req->prev_bssid); |
| __entry->use_mfp = req->use_mfp; |
| __entry->flags = req->flags; |
| if (req->ie) |
| memcpy(__get_dynamic_array(elements), |
| req->ie, req->ie_len); |
| memcpy(__entry->ht_capa, &req->ht_capa, sizeof(req->ht_capa)); |
| memcpy(__entry->ht_capa_mask, &req->ht_capa_mask, |
| sizeof(req->ht_capa_mask)); |
| memcpy(__entry->vht_capa, &req->vht_capa, sizeof(req->vht_capa)); |
| memcpy(__entry->vht_capa_mask, &req->vht_capa_mask, |
| sizeof(req->vht_capa_mask)); |
| if (req->fils_kek) |
| memcpy(__get_dynamic_array(fils_kek), |
| req->fils_kek, req->fils_kek_len); |
| if (req->fils_nonces) |
| memcpy(__get_dynamic_array(fils_nonces), |
| req->fils_nonces, 2 * FILS_NONCE_LEN); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" |
| ", previous bssid: %pM, use mfp: %s, flags: 0x%x", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, |
| __entry->prev_bssid, BOOL_TO_STR(__entry->use_mfp), |
| __entry->flags) |
| ); |
| |
| TRACE_EVENT(rdev_deauth, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_deauth_request *req), |
| TP_ARGS(wiphy, netdev, req), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| __field(u16, reason_code) |
| __field(bool, local_state_change) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(bssid, req->bssid); |
| __entry->reason_code = req->reason_code; |
| __entry->local_state_change = req->local_state_change; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, reason: %u, local_state_change:%d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, |
| __entry->reason_code, __entry->local_state_change) |
| ); |
| |
| TRACE_EVENT(rdev_disassoc, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_disassoc_request *req), |
| TP_ARGS(wiphy, netdev, req), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| __field(u16, reason_code) |
| __field(bool, local_state_change) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(bssid, req->ap_addr); |
| __entry->reason_code = req->reason_code; |
| __entry->local_state_change = req->local_state_change; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" |
| ", reason: %u, local state change: %s", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, |
| __entry->reason_code, |
| BOOL_TO_STR(__entry->local_state_change)) |
| ); |
| |
| TRACE_EVENT(rdev_mgmt_tx_cancel_wait, |
| TP_PROTO(struct wiphy *wiphy, |
| struct wireless_dev *wdev, u64 cookie), |
| TP_ARGS(wiphy, wdev, cookie), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u64, cookie) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->cookie = cookie; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu ", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) |
| ); |
| |
| TRACE_EVENT(rdev_set_power_mgmt, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| bool enabled, int timeout), |
| TP_ARGS(wiphy, netdev, enabled, timeout), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(bool, enabled) |
| __field(int, timeout) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->enabled = enabled; |
| __entry->timeout = timeout; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %senabled, timeout: %d ", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->enabled ? "" : "not ", __entry->timeout) |
| ); |
| |
| TRACE_EVENT(rdev_connect, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_connect_params *sme), |
| TP_ARGS(wiphy, netdev, sme), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) |
| __field(enum nl80211_auth_type, auth_type) |
| __field(bool, privacy) |
| __field(u32, wpa_versions) |
| __field(u32, flags) |
| MAC_ENTRY(prev_bssid) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(bssid, sme->bssid); |
| memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); |
| memcpy(__entry->ssid, sme->ssid, sme->ssid_len); |
| __entry->auth_type = sme->auth_type; |
| __entry->privacy = sme->privacy; |
| __entry->wpa_versions = sme->crypto.wpa_versions; |
| __entry->flags = sme->flags; |
| MAC_ASSIGN(prev_bssid, sme->prev_bssid); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" |
| ", ssid: %s, auth type: %d, privacy: %s, wpa versions: %u, " |
| "flags: 0x%x, previous bssid: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid, |
| __entry->auth_type, BOOL_TO_STR(__entry->privacy), |
| __entry->wpa_versions, __entry->flags, __entry->prev_bssid) |
| ); |
| |
| TRACE_EVENT(rdev_update_connect_params, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_connect_params *sme, u32 changed), |
| TP_ARGS(wiphy, netdev, sme, changed), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u32, changed) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->changed = changed; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", parameters changed: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->changed) |
| ); |
| |
| TRACE_EVENT(rdev_set_cqm_rssi_config, |
| TP_PROTO(struct wiphy *wiphy, |
| struct net_device *netdev, s32 rssi_thold, |
| u32 rssi_hyst), |
| TP_ARGS(wiphy, netdev, rssi_thold, rssi_hyst), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(s32, rssi_thold) |
| __field(u32, rssi_hyst) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->rssi_thold = rssi_thold; |
| __entry->rssi_hyst = rssi_hyst; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT |
| ", rssi_thold: %d, rssi_hyst: %u ", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->rssi_thold, __entry->rssi_hyst) |
| ); |
| |
| TRACE_EVENT(rdev_set_cqm_rssi_range_config, |
| TP_PROTO(struct wiphy *wiphy, |
| struct net_device *netdev, s32 low, s32 high), |
| TP_ARGS(wiphy, netdev, low, high), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(s32, rssi_low) |
| __field(s32, rssi_high) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->rssi_low = low; |
| __entry->rssi_high = high; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT |
| ", range: %d - %d ", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->rssi_low, __entry->rssi_high) |
| ); |
| |
| TRACE_EVENT(rdev_set_cqm_txe_config, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u32 rate, |
| u32 pkts, u32 intvl), |
| TP_ARGS(wiphy, netdev, rate, pkts, intvl), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u32, rate) |
| __field(u32, pkts) |
| __field(u32, intvl) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->rate = rate; |
| __entry->pkts = pkts; |
| __entry->intvl = intvl; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", rate: %u, packets: %u, interval: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->rate, __entry->pkts, |
| __entry->intvl) |
| ); |
| |
| TRACE_EVENT(rdev_disconnect, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| u16 reason_code), |
| TP_ARGS(wiphy, netdev, reason_code), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u16, reason_code) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->reason_code = reason_code; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", reason code: %u", WIPHY_PR_ARG, |
| NETDEV_PR_ARG, __entry->reason_code) |
| ); |
| |
| TRACE_EVENT(rdev_join_ibss, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_ibss_params *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| __array(char, ssid, IEEE80211_MAX_SSID_LEN + 1) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(bssid, params->bssid); |
| memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); |
| memcpy(__entry->ssid, params->ssid, params->ssid_len); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM, ssid: %s", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, __entry->ssid) |
| ); |
| |
| TRACE_EVENT(rdev_join_ocb, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const struct ocb_setup *setup), |
| TP_ARGS(wiphy, netdev, setup), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, |
| WIPHY_PR_ARG, NETDEV_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_set_wiphy_params, |
| TP_PROTO(struct wiphy *wiphy, u32 changed), |
| TP_ARGS(wiphy, changed), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(u32, changed) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->changed = changed; |
| ), |
| TP_printk(WIPHY_PR_FMT ", changed: %u", |
| WIPHY_PR_ARG, __entry->changed) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_get_tx_power, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| TRACE_EVENT(rdev_set_tx_power, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| enum nl80211_tx_power_setting type, int mbm), |
| TP_ARGS(wiphy, wdev, type, mbm), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(enum nl80211_tx_power_setting, type) |
| __field(int, mbm) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->type = type; |
| __entry->mbm = mbm; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type: %u, mbm: %d", |
| WIPHY_PR_ARG, WDEV_PR_ARG,__entry->type, __entry->mbm) |
| ); |
| |
| TRACE_EVENT(rdev_return_int_int, |
| TP_PROTO(struct wiphy *wiphy, int func_ret, int func_fill), |
| TP_ARGS(wiphy, func_ret, func_fill), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, func_ret) |
| __field(int, func_fill) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->func_ret = func_ret; |
| __entry->func_fill = func_fill; |
| ), |
| TP_printk(WIPHY_PR_FMT ", function returns: %d, function filled: %d", |
| WIPHY_PR_ARG, __entry->func_ret, __entry->func_fill) |
| ); |
| |
| #ifdef CONFIG_NL80211_TESTMODE |
| TRACE_EVENT(rdev_testmode_cmd, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT WDEV_PR_FMT, WIPHY_PR_ARG, WDEV_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_testmode_dump, |
| TP_PROTO(struct wiphy *wiphy), |
| TP_ARGS(wiphy), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT, WIPHY_PR_ARG) |
| ); |
| #endif /* CONFIG_NL80211_TESTMODE */ |
| |
| TRACE_EVENT(rdev_set_bitrate_mask, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| unsigned int link_id, |
| const u8 *peer, const struct cfg80211_bitrate_mask *mask), |
| TP_ARGS(wiphy, netdev, link_id, peer, mask), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(unsigned int, link_id) |
| MAC_ENTRY(peer) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->link_id = link_id; |
| MAC_ASSIGN(peer, peer); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", link_id: %d, peer: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->link_id, |
| __entry->peer) |
| ); |
| |
| TRACE_EVENT(rdev_update_mgmt_frame_registrations, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| struct mgmt_frame_regs *upd), |
| TP_ARGS(wiphy, wdev, upd), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u16, global_stypes) |
| __field(u16, interface_stypes) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->global_stypes = upd->global_stypes; |
| __entry->interface_stypes = upd->interface_stypes; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", global: 0x%.2x, intf: 0x%.2x", |
| WIPHY_PR_ARG, WDEV_PR_ARG, |
| __entry->global_stypes, __entry->interface_stypes) |
| ); |
| |
| TRACE_EVENT(rdev_return_int_tx_rx, |
| TP_PROTO(struct wiphy *wiphy, int ret, u32 tx, u32 rx), |
| TP_ARGS(wiphy, ret, tx, rx), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, ret) |
| __field(u32, tx) |
| __field(u32, rx) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->ret = ret; |
| __entry->tx = tx; |
| __entry->rx = rx; |
| ), |
| TP_printk(WIPHY_PR_FMT ", returned %d, tx: %u, rx: %u", |
| WIPHY_PR_ARG, __entry->ret, __entry->tx, __entry->rx) |
| ); |
| |
| TRACE_EVENT(rdev_return_void_tx_rx, |
| TP_PROTO(struct wiphy *wiphy, u32 tx, u32 tx_max, |
| u32 rx, u32 rx_max), |
| TP_ARGS(wiphy, tx, tx_max, rx, rx_max), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(u32, tx) |
| __field(u32, tx_max) |
| __field(u32, rx) |
| __field(u32, rx_max) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->tx = tx; |
| __entry->tx_max = tx_max; |
| __entry->rx = rx; |
| __entry->rx_max = rx_max; |
| ), |
| TP_printk(WIPHY_PR_FMT ", tx: %u, tx_max: %u, rx: %u, rx_max: %u ", |
| WIPHY_PR_ARG, __entry->tx, __entry->tx_max, __entry->rx, |
| __entry->rx_max) |
| ); |
| |
| DECLARE_EVENT_CLASS(tx_rx_evt, |
| TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), |
| TP_ARGS(wiphy, tx, rx), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(u32, tx) |
| __field(u32, rx) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->tx = tx; |
| __entry->rx = rx; |
| ), |
| TP_printk(WIPHY_PR_FMT ", tx: %u, rx: %u ", |
| WIPHY_PR_ARG, __entry->tx, __entry->rx) |
| ); |
| |
| DEFINE_EVENT(tx_rx_evt, rdev_set_antenna, |
| TP_PROTO(struct wiphy *wiphy, u32 tx, u32 rx), |
| TP_ARGS(wiphy, tx, rx) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_netdev_id_evt, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), |
| TP_ARGS(wiphy, netdev, id), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u64, id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->id = id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", id: %llu", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->id) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_start, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), |
| TP_ARGS(wiphy, netdev, id) |
| ); |
| |
| DEFINE_EVENT(wiphy_netdev_id_evt, rdev_sched_scan_stop, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, u64 id), |
| TP_ARGS(wiphy, netdev, id) |
| ); |
| |
| TRACE_EVENT(rdev_tdls_mgmt, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| u8 *peer, int link_id, u8 action_code, u8 dialog_token, |
| u16 status_code, u32 peer_capability, |
| bool initiator, const u8 *buf, size_t len), |
| TP_ARGS(wiphy, netdev, peer, link_id, action_code, dialog_token, |
| status_code, peer_capability, initiator, buf, len), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| __field(int, link_id) |
| __field(u8, action_code) |
| __field(u8, dialog_token) |
| __field(u16, status_code) |
| __field(u32, peer_capability) |
| __field(bool, initiator) |
| __dynamic_array(u8, buf, len) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, peer); |
| __entry->link_id = link_id; |
| __entry->action_code = action_code; |
| __entry->dialog_token = dialog_token; |
| __entry->status_code = status_code; |
| __entry->peer_capability = peer_capability; |
| __entry->initiator = initiator; |
| memcpy(__get_dynamic_array(buf), buf, len); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" |
| ", link_id: %d, action_code: %u " |
| "dialog_token: %u, status_code: %u, peer_capability: %u " |
| "initiator: %s buf: %#.2x ", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, |
| __entry->link_id, __entry->action_code, __entry->dialog_token, |
| __entry->status_code, __entry->peer_capability, |
| BOOL_TO_STR(__entry->initiator), |
| ((u8 *)__get_dynamic_array(buf))[0]) |
| ); |
| |
| TRACE_EVENT(rdev_dump_survey, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, int _idx), |
| TP_ARGS(wiphy, netdev, _idx), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(int, idx) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->idx = _idx; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", index: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->idx) |
| ); |
| |
| TRACE_EVENT(rdev_return_int_survey_info, |
| TP_PROTO(struct wiphy *wiphy, int ret, struct survey_info *info), |
| TP_ARGS(wiphy, ret, info), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| CHAN_ENTRY |
| __field(int, ret) |
| __field(u64, time) |
| __field(u64, time_busy) |
| __field(u64, time_ext_busy) |
| __field(u64, time_rx) |
| __field(u64, time_tx) |
| __field(u64, time_scan) |
| __field(u32, filled) |
| __field(s8, noise) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| CHAN_ASSIGN(info->channel); |
| __entry->ret = ret; |
| __entry->time = info->time; |
| __entry->time_busy = info->time_busy; |
| __entry->time_ext_busy = info->time_ext_busy; |
| __entry->time_rx = info->time_rx; |
| __entry->time_tx = info->time_tx; |
| __entry->time_scan = info->time_scan; |
| __entry->filled = info->filled; |
| __entry->noise = info->noise; |
| ), |
| TP_printk(WIPHY_PR_FMT ", returned: %d, " CHAN_PR_FMT |
| ", channel time: %llu, channel time busy: %llu, " |
| "channel time extension busy: %llu, channel time rx: %llu, " |
| "channel time tx: %llu, scan time: %llu, filled: %u, noise: %d", |
| WIPHY_PR_ARG, __entry->ret, CHAN_PR_ARG, |
| __entry->time, __entry->time_busy, |
| __entry->time_ext_busy, __entry->time_rx, |
| __entry->time_tx, __entry->time_scan, |
| __entry->filled, __entry->noise) |
| ); |
| |
| TRACE_EVENT(rdev_tdls_oper, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| u8 *peer, enum nl80211_tdls_operation oper), |
| TP_ARGS(wiphy, netdev, peer, oper), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| __field(enum nl80211_tdls_operation, oper) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, peer); |
| __entry->oper = oper; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, oper: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->oper) |
| ); |
| |
| DECLARE_EVENT_CLASS(rdev_pmksa, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_pmksa *pmksa), |
| TP_ARGS(wiphy, netdev, pmksa), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(bssid, pmksa->bssid); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid) |
| ); |
| |
| TRACE_EVENT(rdev_probe_client, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const u8 *peer), |
| TP_ARGS(wiphy, netdev, peer), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, peer); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer) |
| ); |
| |
| DEFINE_EVENT(rdev_pmksa, rdev_set_pmksa, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_pmksa *pmksa), |
| TP_ARGS(wiphy, netdev, pmksa) |
| ); |
| |
| DEFINE_EVENT(rdev_pmksa, rdev_del_pmksa, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_pmksa *pmksa), |
| TP_ARGS(wiphy, netdev, pmksa) |
| ); |
| |
| TRACE_EVENT(rdev_remain_on_channel, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| struct ieee80211_channel *chan, |
| unsigned int duration), |
| TP_ARGS(wiphy, wdev, chan, duration), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| CHAN_ENTRY |
| __field(unsigned int, duration) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| CHAN_ASSIGN(chan); |
| __entry->duration = duration; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", duration: %u", |
| WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, __entry->duration) |
| ); |
| |
| TRACE_EVENT(rdev_return_int_cookie, |
| TP_PROTO(struct wiphy *wiphy, int ret, u64 cookie), |
| TP_ARGS(wiphy, ret, cookie), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, ret) |
| __field(u64, cookie) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->ret = ret; |
| __entry->cookie = cookie; |
| ), |
| TP_printk(WIPHY_PR_FMT ", returned %d, cookie: %llu", |
| WIPHY_PR_ARG, __entry->ret, __entry->cookie) |
| ); |
| |
| TRACE_EVENT(rdev_cancel_remain_on_channel, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), |
| TP_ARGS(wiphy, wdev, cookie), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u64, cookie) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->cookie = cookie; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie: %llu", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) |
| ); |
| |
| TRACE_EVENT(rdev_mgmt_tx, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| struct cfg80211_mgmt_tx_params *params), |
| TP_ARGS(wiphy, wdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| CHAN_ENTRY |
| __field(bool, offchan) |
| __field(unsigned int, wait) |
| __field(bool, no_cck) |
| __field(bool, dont_wait_for_ack) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| CHAN_ASSIGN(params->chan); |
| __entry->offchan = params->offchan; |
| __entry->wait = params->wait; |
| __entry->no_cck = params->no_cck; |
| __entry->dont_wait_for_ack = params->dont_wait_for_ack; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", " CHAN_PR_FMT ", offchan: %s," |
| " wait: %u, no cck: %s, dont wait for ack: %s", |
| WIPHY_PR_ARG, WDEV_PR_ARG, CHAN_PR_ARG, |
| BOOL_TO_STR(__entry->offchan), __entry->wait, |
| BOOL_TO_STR(__entry->no_cck), |
| BOOL_TO_STR(__entry->dont_wait_for_ack)) |
| ); |
| |
| TRACE_EVENT(rdev_tx_control_port, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const u8 *buf, size_t len, const u8 *dest, __be16 proto, |
| bool unencrypted, int link_id), |
| TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted, link_id), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(dest) |
| __field(__be16, proto) |
| __field(bool, unencrypted) |
| __field(int, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(dest, dest); |
| __entry->proto = proto; |
| __entry->unencrypted = unencrypted; |
| __entry->link_id = link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM," |
| " proto: 0x%x, unencrypted: %s, link: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest, |
| be16_to_cpu(__entry->proto), |
| BOOL_TO_STR(__entry->unencrypted), |
| __entry->link_id) |
| ); |
| |
| TRACE_EVENT(rdev_set_noack_map, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| u16 noack_map), |
| TP_ARGS(wiphy, netdev, noack_map), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u16, noack_map) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->noack_map = noack_map; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", noack_map: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->noack_map) |
| ); |
| |
| DECLARE_EVENT_CLASS(wiphy_wdev_link_evt, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| unsigned int link_id), |
| TP_ARGS(wiphy, wdev, link_id), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(unsigned int, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->link_id = link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", link_id: %u", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->link_id) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_link_evt, rdev_get_channel, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| unsigned int link_id), |
| TP_ARGS(wiphy, wdev, link_id) |
| ); |
| |
| TRACE_EVENT(rdev_return_chandef, |
| TP_PROTO(struct wiphy *wiphy, int ret, |
| struct cfg80211_chan_def *chandef), |
| TP_ARGS(wiphy, ret, chandef), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, ret) |
| CHAN_DEF_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| if (ret == 0) |
| CHAN_DEF_ASSIGN(chandef); |
| else |
| CHAN_DEF_ASSIGN((struct cfg80211_chan_def *)NULL); |
| __entry->ret = ret; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT ", ret: %d", |
| WIPHY_PR_ARG, CHAN_DEF_PR_ARG, __entry->ret) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_start_p2p_device, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_p2p_device, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| TRACE_EVENT(rdev_start_nan, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| struct cfg80211_nan_conf *conf), |
| TP_ARGS(wiphy, wdev, conf), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u8, master_pref) |
| __field(u8, bands) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->master_pref = conf->master_pref; |
| __entry->bands = conf->bands; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT |
| ", master preference: %u, bands: 0x%0x", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, |
| __entry->bands) |
| ); |
| |
| TRACE_EVENT(rdev_nan_change_conf, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| struct cfg80211_nan_conf *conf, u32 changes), |
| TP_ARGS(wiphy, wdev, conf, changes), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u8, master_pref) |
| __field(u8, bands) |
| __field(u32, changes) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->master_pref = conf->master_pref; |
| __entry->bands = conf->bands; |
| __entry->changes = changes; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT |
| ", master preference: %u, bands: 0x%0x, changes: %x", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->master_pref, |
| __entry->bands, __entry->changes) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_stop_nan, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| TRACE_EVENT(rdev_add_nan_func, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| const struct cfg80211_nan_func *func), |
| TP_ARGS(wiphy, wdev, func), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u8, func_type) |
| __field(u64, cookie) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->func_type = func->type; |
| __entry->cookie = func->cookie |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", type=%u, cookie=%llu", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->func_type, |
| __entry->cookie) |
| ); |
| |
| TRACE_EVENT(rdev_del_nan_func, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| u64 cookie), |
| TP_ARGS(wiphy, wdev, cookie), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u64, cookie) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->cookie = cookie; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", cookie=%llu", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->cookie) |
| ); |
| |
| TRACE_EVENT(rdev_set_mac_acl, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_acl_data *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u32, acl_policy) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->acl_policy = params->acl_policy; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", acl policy: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->acl_policy) |
| ); |
| |
| TRACE_EVENT(rdev_update_ft_ies, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_update_ft_ies_params *ftie), |
| TP_ARGS(wiphy, netdev, ftie), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u16, md) |
| __dynamic_array(u8, ie, ftie->ie_len) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->md = ftie->md; |
| memcpy(__get_dynamic_array(ie), ftie->ie, ftie->ie_len); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", md: 0x%x", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->md) |
| ); |
| |
| TRACE_EVENT(rdev_crit_proto_start, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| enum nl80211_crit_proto_id protocol, u16 duration), |
| TP_ARGS(wiphy, wdev, protocol, duration), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| __field(u16, proto) |
| __field(u16, duration) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| __entry->proto = protocol; |
| __entry->duration = duration; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT ", proto=%x, duration=%u", |
| WIPHY_PR_ARG, WDEV_PR_ARG, __entry->proto, __entry->duration) |
| ); |
| |
| TRACE_EVENT(rdev_crit_proto_stop, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| WDEV_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| WDEV_ASSIGN; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " WDEV_PR_FMT, |
| WIPHY_PR_ARG, WDEV_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_channel_switch, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_csa_settings *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| CHAN_DEF_ENTRY |
| __field(bool, radar_required) |
| __field(bool, block_tx) |
| __field(u8, count) |
| __dynamic_array(u16, bcn_ofs, params->n_counter_offsets_beacon) |
| __dynamic_array(u16, pres_ofs, params->n_counter_offsets_presp) |
| __field(u8, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| CHAN_DEF_ASSIGN(¶ms->chandef); |
| __entry->radar_required = params->radar_required; |
| __entry->block_tx = params->block_tx; |
| __entry->count = params->count; |
| memcpy(__get_dynamic_array(bcn_ofs), |
| params->counter_offsets_beacon, |
| params->n_counter_offsets_beacon * sizeof(u16)); |
| |
| /* probe response offsets are optional */ |
| if (params->n_counter_offsets_presp) |
| memcpy(__get_dynamic_array(pres_ofs), |
| params->counter_offsets_presp, |
| params->n_counter_offsets_presp * sizeof(u16)); |
| __entry->link_id = params->link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT |
| ", block_tx: %d, count: %u, radar_required: %d, link_id: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, |
| __entry->block_tx, __entry->count, __entry->radar_required, |
| __entry->link_id) |
| ); |
| |
| TRACE_EVENT(rdev_set_qos_map, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_qos_map *qos_map), |
| TP_ARGS(wiphy, netdev, qos_map), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| QOS_MAP_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| QOS_MAP_ASSIGN(qos_map); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", num_des: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->num_des) |
| ); |
| |
| TRACE_EVENT(rdev_set_ap_chanwidth, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| unsigned int link_id, |
| struct cfg80211_chan_def *chandef), |
| TP_ARGS(wiphy, netdev, link_id, chandef), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| CHAN_DEF_ENTRY |
| __field(unsigned int, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| CHAN_DEF_ASSIGN(chandef); |
| __entry->link_id = link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT ", link:%d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, |
| __entry->link_id) |
| ); |
| |
| TRACE_EVENT(rdev_add_tx_ts, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| u8 tsid, const u8 *peer, u8 user_prio, u16 admitted_time), |
| TP_ARGS(wiphy, netdev, tsid, peer, user_prio, admitted_time), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| __field(u8, tsid) |
| __field(u8, user_prio) |
| __field(u16, admitted_time) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, peer); |
| __entry->tsid = tsid; |
| __entry->user_prio = user_prio; |
| __entry->admitted_time = admitted_time; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d, UP %d, time %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, |
| __entry->tsid, __entry->user_prio, __entry->admitted_time) |
| ); |
| |
| TRACE_EVENT(rdev_del_tx_ts, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| u8 tsid, const u8 *peer), |
| TP_ARGS(wiphy, netdev, tsid, peer), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| __field(u8, tsid) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, peer); |
| __entry->tsid = tsid; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM, TSID %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tsid) |
| ); |
| |
| TRACE_EVENT(rdev_tdls_channel_switch, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const u8 *addr, u8 oper_class, |
| struct cfg80211_chan_def *chandef), |
| TP_ARGS(wiphy, netdev, addr, oper_class, chandef), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(addr) |
| __field(u8, oper_class) |
| CHAN_DEF_ENTRY |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(addr, addr); |
| CHAN_DEF_ASSIGN(chandef); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" |
| " oper class %d, " CHAN_DEF_PR_FMT, |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr, |
| __entry->oper_class, CHAN_DEF_PR_ARG) |
| ); |
| |
| TRACE_EVENT(rdev_tdls_cancel_channel_switch, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const u8 *addr), |
| TP_ARGS(wiphy, netdev, addr), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(addr) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(addr, addr); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->addr) |
| ); |
| |
| TRACE_EVENT(rdev_set_pmk, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_pmk_conf *pmk_conf), |
| |
| TP_ARGS(wiphy, netdev, pmk_conf), |
| |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(aa) |
| __field(u8, pmk_len) |
| __field(u8, pmk_r0_name_len) |
| __dynamic_array(u8, pmk, pmk_conf->pmk_len) |
| __dynamic_array(u8, pmk_r0_name, WLAN_PMK_NAME_LEN) |
| ), |
| |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(aa, pmk_conf->aa); |
| __entry->pmk_len = pmk_conf->pmk_len; |
| __entry->pmk_r0_name_len = |
| pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0; |
| memcpy(__get_dynamic_array(pmk), pmk_conf->pmk, |
| pmk_conf->pmk_len); |
| memcpy(__get_dynamic_array(pmk_r0_name), pmk_conf->pmk_r0_name, |
| pmk_conf->pmk_r0_name ? WLAN_PMK_NAME_LEN : 0); |
| ), |
| |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM" |
| "pmk_len=%u, pmk: %s pmk_r0_name: %s", WIPHY_PR_ARG, |
| NETDEV_PR_ARG, __entry->aa, __entry->pmk_len, |
| __print_array(__get_dynamic_array(pmk), |
| __get_dynamic_array_len(pmk), 1), |
| __entry->pmk_r0_name_len ? |
| __print_array(__get_dynamic_array(pmk_r0_name), |
| __get_dynamic_array_len(pmk_r0_name), 1) : "") |
| ); |
| |
| TRACE_EVENT(rdev_del_pmk, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, const u8 *aa), |
| |
| TP_ARGS(wiphy, netdev, aa), |
| |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(aa) |
| ), |
| |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(aa, aa); |
| ), |
| |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->aa) |
| ); |
| |
| TRACE_EVENT(rdev_external_auth, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_external_auth_params *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry(WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(bssid) |
| __array(u8, ssid, IEEE80211_MAX_SSID_LEN + 1) |
| __field(u16, status) |
| MAC_ENTRY(mld_addr) |
| ), |
| TP_fast_assign(WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(bssid, params->bssid); |
| memset(__entry->ssid, 0, IEEE80211_MAX_SSID_LEN + 1); |
| memcpy(__entry->ssid, params->ssid.ssid, |
| params->ssid.ssid_len); |
| __entry->status = params->status; |
| MAC_ASSIGN(mld_addr, params->mld_addr); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", bssid: %pM" |
| ", ssid: %s, status: %u, mld_addr: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->bssid, |
| __entry->ssid, __entry->status, __entry->mld_addr) |
| ); |
| |
| TRACE_EVENT(rdev_start_radar_detection, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_chan_def *chandef, |
| u32 cac_time_ms), |
| TP_ARGS(wiphy, netdev, chandef, cac_time_ms), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| CHAN_DEF_ENTRY |
| __field(u32, cac_time_ms) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| CHAN_DEF_ASSIGN(chandef); |
| __entry->cac_time_ms = cac_time_ms; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " CHAN_DEF_PR_FMT |
| ", cac_time_ms=%u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, CHAN_DEF_PR_ARG, |
| __entry->cac_time_ms) |
| ); |
| |
| TRACE_EVENT(rdev_set_mcast_rate, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| int *mcast_rate), |
| TP_ARGS(wiphy, netdev, mcast_rate), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __array(int, mcast_rate, NUM_NL80211_BANDS) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| memcpy(__entry->mcast_rate, mcast_rate, |
| sizeof(int) * NUM_NL80211_BANDS); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " |
| "mcast_rates [2.4GHz=0x%x, 5.2GHz=0x%x, 6GHz=0x%x, 60GHz=0x%x]", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->mcast_rate[NL80211_BAND_2GHZ], |
| __entry->mcast_rate[NL80211_BAND_5GHZ], |
| __entry->mcast_rate[NL80211_BAND_6GHZ], |
| __entry->mcast_rate[NL80211_BAND_60GHZ]) |
| ); |
| |
| TRACE_EVENT(rdev_set_coalesce, |
| TP_PROTO(struct wiphy *wiphy, struct cfg80211_coalesce *coalesce), |
| TP_ARGS(wiphy, coalesce), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(int, n_rules) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->n_rules = coalesce ? coalesce->n_rules : 0; |
| ), |
| TP_printk(WIPHY_PR_FMT ", n_rules=%d", |
| WIPHY_PR_ARG, __entry->n_rules) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_abort_scan, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| TRACE_EVENT(rdev_set_multicast_to_unicast, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const bool enabled), |
| TP_ARGS(wiphy, netdev, enabled), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(bool, enabled) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->enabled = enabled; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", unicast: %s", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, |
| BOOL_TO_STR(__entry->enabled)) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_evt, rdev_get_txq_stats, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev), |
| TP_ARGS(wiphy, wdev) |
| ); |
| |
| TRACE_EVENT(rdev_get_ftm_responder_stats, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_ftm_responder_stats *ftm_stats), |
| |
| TP_ARGS(wiphy, netdev, ftm_stats), |
| |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u64, timestamp) |
| __field(u32, success_num) |
| __field(u32, partial_num) |
| __field(u32, failed_num) |
| __field(u32, asap_num) |
| __field(u32, non_asap_num) |
| __field(u64, duration) |
| __field(u32, unknown_triggers) |
| __field(u32, reschedule) |
| __field(u32, out_of_window) |
| ), |
| |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->success_num = ftm_stats->success_num; |
| __entry->partial_num = ftm_stats->partial_num; |
| __entry->failed_num = ftm_stats->failed_num; |
| __entry->asap_num = ftm_stats->asap_num; |
| __entry->non_asap_num = ftm_stats->non_asap_num; |
| __entry->duration = ftm_stats->total_duration_ms; |
| __entry->unknown_triggers = ftm_stats->unknown_triggers_num; |
| __entry->reschedule = ftm_stats->reschedule_requests_num; |
| __entry->out_of_window = ftm_stats->out_of_window_triggers_num; |
| ), |
| |
| TP_printk(WIPHY_PR_FMT "Ftm responder stats: success %u, partial %u, " |
| "failed %u, asap %u, non asap %u, total duration %llu, unknown " |
| "triggers %u, rescheduled %u, out of window %u", WIPHY_PR_ARG, |
| __entry->success_num, __entry->partial_num, __entry->failed_num, |
| __entry->asap_num, __entry->non_asap_num, __entry->duration, |
| __entry->unknown_triggers, __entry->reschedule, |
| __entry->out_of_window) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_start_pmsr, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), |
| TP_ARGS(wiphy, wdev, cookie) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_cookie_evt, rdev_abort_pmsr, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, u64 cookie), |
| TP_ARGS(wiphy, wdev, cookie) |
| ); |
| |
| TRACE_EVENT(rdev_set_fils_aad, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_fils_aad *fils_aad), |
| TP_ARGS(wiphy, netdev, fils_aad), |
| TP_STRUCT__entry(WIPHY_ENTRY |
| NETDEV_ENTRY |
| __array(u8, macaddr, ETH_ALEN) |
| __field(u8, kek_len) |
| ), |
| TP_fast_assign(WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| FILS_AAD_ASSIGN(fils_aad); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " FILS_AAD_PR_FMT, |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr, |
| __entry->kek_len) |
| ); |
| |
| TRACE_EVENT(rdev_update_owe_info, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_update_owe_info *owe_info), |
| TP_ARGS(wiphy, netdev, owe_info), |
| TP_STRUCT__entry(WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| __field(u16, status) |
| __dynamic_array(u8, ie, owe_info->ie_len)), |
| TP_fast_assign(WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, owe_info->peer); |
| __entry->status = owe_info->status; |
| memcpy(__get_dynamic_array(ie), |
| owe_info->ie, owe_info->ie_len);), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM" |
| " status %d", WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, |
| __entry->status) |
| ); |
| |
| TRACE_EVENT(rdev_probe_mesh_link, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const u8 *dest, const u8 *buf, size_t len), |
| TP_ARGS(wiphy, netdev, dest, buf, len), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(dest) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(dest, dest); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->dest) |
| ); |
| |
| TRACE_EVENT(rdev_set_tid_config, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_tid_config *tid_conf), |
| TP_ARGS(wiphy, netdev, tid_conf), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, tid_conf->peer); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer) |
| ); |
| |
| TRACE_EVENT(rdev_reset_tid_config, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| const u8 *peer, u8 tids), |
| TP_ARGS(wiphy, netdev, peer, tids), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(peer) |
| __field(u8, tids) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(peer, peer); |
| __entry->tids = tids; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", peer: %pM, tids: 0x%x", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->peer, __entry->tids) |
| ); |
| |
| TRACE_EVENT(rdev_set_sar_specs, |
| TP_PROTO(struct wiphy *wiphy, struct cfg80211_sar_specs *sar), |
| TP_ARGS(wiphy, sar), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| __field(u16, type) |
| __field(u16, num) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| __entry->type = sar->type; |
| __entry->num = sar->num_sub_specs; |
| |
| ), |
| TP_printk(WIPHY_PR_FMT ", Set type:%d, num_specs:%d", |
| WIPHY_PR_ARG, __entry->type, __entry->num) |
| ); |
| |
| TRACE_EVENT(rdev_color_change, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_color_change_settings *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __field(u8, count) |
| __field(u16, bcn_ofs) |
| __field(u16, pres_ofs) |
| __field(u8, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| __entry->count = params->count; |
| __entry->bcn_ofs = params->counter_offset_beacon; |
| __entry->pres_ofs = params->counter_offset_presp; |
| __entry->link_id = params->link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT |
| ", count: %u, link_id: %d", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, |
| __entry->count, __entry->link_id) |
| ); |
| |
| TRACE_EVENT(rdev_set_radar_background, |
| TP_PROTO(struct wiphy *wiphy, struct cfg80211_chan_def *chandef), |
| |
| TP_ARGS(wiphy, chandef), |
| |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| CHAN_DEF_ENTRY |
| ), |
| |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| CHAN_DEF_ASSIGN(chandef) |
| ), |
| |
| TP_printk(WIPHY_PR_FMT ", " CHAN_DEF_PR_FMT, |
| WIPHY_PR_ARG, CHAN_DEF_PR_ARG) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_link_evt, rdev_add_intf_link, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| unsigned int link_id), |
| TP_ARGS(wiphy, wdev, link_id) |
| ); |
| |
| DEFINE_EVENT(wiphy_wdev_link_evt, rdev_del_intf_link, |
| TP_PROTO(struct wiphy *wiphy, struct wireless_dev *wdev, |
| unsigned int link_id), |
| TP_ARGS(wiphy, wdev, link_id) |
| ); |
| |
| TRACE_EVENT(rdev_del_link_station, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct link_station_del_parameters *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __array(u8, mld_mac, 6) |
| __field(u32, link_id) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| memset(__entry->mld_mac, 0, 6); |
| if (params->mld_mac) |
| memcpy(__entry->mld_mac, params->mld_mac, 6); |
| __entry->link_id = params->link_id; |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", station mac: %pM" |
| ", link id: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->mld_mac, |
| __entry->link_id) |
| ); |
| |
| TRACE_EVENT(rdev_set_hw_timestamp, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_set_hw_timestamp *hwts), |
| |
| TP_ARGS(wiphy, netdev, hwts), |
| |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| MAC_ENTRY(macaddr) |
| __field(bool, enable) |
| ), |
| |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(macaddr, hwts->macaddr); |
| __entry->enable = hwts->enable; |
| ), |
| |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", mac %pM, enable: %u", |
| WIPHY_PR_ARG, NETDEV_PR_ARG, __entry->macaddr, |
| __entry->enable) |
| ); |
| |
| TRACE_EVENT(rdev_set_ttlm, |
| TP_PROTO(struct wiphy *wiphy, struct net_device *netdev, |
| struct cfg80211_ttlm_params *params), |
| TP_ARGS(wiphy, netdev, params), |
| TP_STRUCT__entry( |
| WIPHY_ENTRY |
| NETDEV_ENTRY |
| __array(u8, dlink, sizeof(u16) * 8) |
| __array(u8, ulink, sizeof(u16) * 8) |
| ), |
| TP_fast_assign( |
| WIPHY_ASSIGN; |
| NETDEV_ASSIGN; |
| memcpy(__entry->dlink, params->dlink, sizeof(params->dlink)); |
| memcpy(__entry->ulink, params->ulink, sizeof(params->ulink)); |
| ), |
| TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT, |
| WIPHY_PR_ARG, NETDEV_PR_ARG) |
| ); |
| |
| /************************************************************* |
| * cfg80211 exported functions traces * |
| *************************************************************/ |
| |
| TRACE_EVENT(cfg80211_return_bool, |
| TP_PROTO(bool ret), |
| TP_ARGS(ret), |
| TP_STRUCT__entry( |
| __field(bool, ret) |
| ), |
| TP_fast_assign( |
| __entry->ret = ret; |
| ), |
| TP_printk("returned %s", BOOL_TO_STR(__entry->ret)) |
| ); |
| |
| DECLARE_EVENT_CLASS(cfg80211_netdev_mac_evt, |
| TP_PROTO(struct net_device *netdev, const u8 *macaddr), |
| TP_ARGS(netdev, macaddr), |
| TP_STRUCT__entry( |
| NETDEV_ENTRY |
| MAC_ENTRY(macaddr) |
| ), |
| TP_fast_assign( |
| NETDEV_ASSIGN; |
| MAC_ASSIGN(macaddr, macaddr); |
| ), |
| TP_printk(NETDEV_PR_FMT ", mac: %pM", |
| NETDEV_PR_ARG, __entry->macaddr) |
| ); |
| |
| DEFINE_EVENT |