![Sara Sharon](/assets/img/avatar_default.png)
We have a TXQ abstraction for non-data packets that need powersave buffering. Since the AP cannot sleep, in case of station we can use this TXQ for all management frames, regardless if they are bufferable. Add HW flag to allow that. Signed-off-by: Sara Sharon <sara.sharon@intel.com> Signed-off-by: Luca Coelho <luciano.coelho@intel.com> Signed-off-by: Johannes Berg <johannes.berg@intel.com>
422 lines
11 KiB
C
422 lines
11 KiB
C
/*
|
|
* mac80211 debugfs for wireless PHYs
|
|
*
|
|
* Copyright 2007 Johannes Berg <johannes@sipsolutions.net>
|
|
* Copyright 2013-2014 Intel Mobile Communications GmbH
|
|
* Copyright (C) 2018 Intel Corporation
|
|
*
|
|
* GPLv2
|
|
*
|
|
*/
|
|
|
|
#include <linux/debugfs.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <linux/vmalloc.h>
|
|
#include "ieee80211_i.h"
|
|
#include "driver-ops.h"
|
|
#include "rate.h"
|
|
#include "debugfs.h"
|
|
|
|
#define DEBUGFS_FORMAT_BUFFER_SIZE 100
|
|
|
|
int mac80211_format_buffer(char __user *userbuf, size_t count,
|
|
loff_t *ppos, char *fmt, ...)
|
|
{
|
|
va_list args;
|
|
char buf[DEBUGFS_FORMAT_BUFFER_SIZE];
|
|
int res;
|
|
|
|
va_start(args, fmt);
|
|
res = vscnprintf(buf, sizeof(buf), fmt, args);
|
|
va_end(args);
|
|
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, res);
|
|
}
|
|
|
|
#define DEBUGFS_READONLY_FILE_FN(name, fmt, value...) \
|
|
static ssize_t name## _read(struct file *file, char __user *userbuf, \
|
|
size_t count, loff_t *ppos) \
|
|
{ \
|
|
struct ieee80211_local *local = file->private_data; \
|
|
\
|
|
return mac80211_format_buffer(userbuf, count, ppos, \
|
|
fmt "\n", ##value); \
|
|
}
|
|
|
|
#define DEBUGFS_READONLY_FILE_OPS(name) \
|
|
static const struct file_operations name## _ops = { \
|
|
.read = name## _read, \
|
|
.open = simple_open, \
|
|
.llseek = generic_file_llseek, \
|
|
};
|
|
|
|
#define DEBUGFS_READONLY_FILE(name, fmt, value...) \
|
|
DEBUGFS_READONLY_FILE_FN(name, fmt, value) \
|
|
DEBUGFS_READONLY_FILE_OPS(name)
|
|
|
|
#define DEBUGFS_ADD(name) \
|
|
debugfs_create_file(#name, 0400, phyd, local, &name## _ops);
|
|
|
|
#define DEBUGFS_ADD_MODE(name, mode) \
|
|
debugfs_create_file(#name, mode, phyd, local, &name## _ops);
|
|
|
|
|
|
DEBUGFS_READONLY_FILE(user_power, "%d",
|
|
local->user_power_level);
|
|
DEBUGFS_READONLY_FILE(power, "%d",
|
|
local->hw.conf.power_level);
|
|
DEBUGFS_READONLY_FILE(total_ps_buffered, "%d",
|
|
local->total_ps_buffered);
|
|
DEBUGFS_READONLY_FILE(wep_iv, "%#08x",
|
|
local->wep_iv & 0xffffff);
|
|
DEBUGFS_READONLY_FILE(rate_ctrl_alg, "%s",
|
|
local->rate_ctrl ? local->rate_ctrl->ops->name : "hw/driver");
|
|
|
|
static ssize_t aqm_read(struct file *file,
|
|
char __user *user_buf,
|
|
size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
struct ieee80211_local *local = file->private_data;
|
|
struct fq *fq = &local->fq;
|
|
char buf[200];
|
|
int len = 0;
|
|
|
|
spin_lock_bh(&local->fq.lock);
|
|
rcu_read_lock();
|
|
|
|
len = scnprintf(buf, sizeof(buf),
|
|
"access name value\n"
|
|
"R fq_flows_cnt %u\n"
|
|
"R fq_backlog %u\n"
|
|
"R fq_overlimit %u\n"
|
|
"R fq_overmemory %u\n"
|
|
"R fq_collisions %u\n"
|
|
"R fq_memory_usage %u\n"
|
|
"RW fq_memory_limit %u\n"
|
|
"RW fq_limit %u\n"
|
|
"RW fq_quantum %u\n",
|
|
fq->flows_cnt,
|
|
fq->backlog,
|
|
fq->overmemory,
|
|
fq->overlimit,
|
|
fq->collisions,
|
|
fq->memory_usage,
|
|
fq->memory_limit,
|
|
fq->limit,
|
|
fq->quantum);
|
|
|
|
rcu_read_unlock();
|
|
spin_unlock_bh(&local->fq.lock);
|
|
|
|
return simple_read_from_buffer(user_buf, count, ppos,
|
|
buf, len);
|
|
}
|
|
|
|
static ssize_t aqm_write(struct file *file,
|
|
const char __user *user_buf,
|
|
size_t count,
|
|
loff_t *ppos)
|
|
{
|
|
struct ieee80211_local *local = file->private_data;
|
|
char buf[100];
|
|
size_t len;
|
|
|
|
if (count > sizeof(buf))
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(buf, user_buf, count))
|
|
return -EFAULT;
|
|
|
|
buf[sizeof(buf) - 1] = '\0';
|
|
len = strlen(buf);
|
|
if (len > 0 && buf[len-1] == '\n')
|
|
buf[len-1] = 0;
|
|
|
|
if (sscanf(buf, "fq_limit %u", &local->fq.limit) == 1)
|
|
return count;
|
|
else if (sscanf(buf, "fq_memory_limit %u", &local->fq.memory_limit) == 1)
|
|
return count;
|
|
else if (sscanf(buf, "fq_quantum %u", &local->fq.quantum) == 1)
|
|
return count;
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
static const struct file_operations aqm_ops = {
|
|
.write = aqm_write,
|
|
.read = aqm_read,
|
|
.open = simple_open,
|
|
.llseek = default_llseek,
|
|
};
|
|
|
|
#ifdef CONFIG_PM
|
|
static ssize_t reset_write(struct file *file, const char __user *user_buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct ieee80211_local *local = file->private_data;
|
|
|
|
rtnl_lock();
|
|
__ieee80211_suspend(&local->hw, NULL);
|
|
__ieee80211_resume(&local->hw);
|
|
rtnl_unlock();
|
|
|
|
return count;
|
|
}
|
|
|
|
static const struct file_operations reset_ops = {
|
|
.write = reset_write,
|
|
.open = simple_open,
|
|
.llseek = noop_llseek,
|
|
};
|
|
#endif
|
|
|
|
static const char *hw_flag_names[] = {
|
|
#define FLAG(F) [IEEE80211_HW_##F] = #F
|
|
FLAG(HAS_RATE_CONTROL),
|
|
FLAG(RX_INCLUDES_FCS),
|
|
FLAG(HOST_BROADCAST_PS_BUFFERING),
|
|
FLAG(SIGNAL_UNSPEC),
|
|
FLAG(SIGNAL_DBM),
|
|
FLAG(NEED_DTIM_BEFORE_ASSOC),
|
|
FLAG(SPECTRUM_MGMT),
|
|
FLAG(AMPDU_AGGREGATION),
|
|
FLAG(SUPPORTS_PS),
|
|
FLAG(PS_NULLFUNC_STACK),
|
|
FLAG(SUPPORTS_DYNAMIC_PS),
|
|
FLAG(MFP_CAPABLE),
|
|
FLAG(WANT_MONITOR_VIF),
|
|
FLAG(NO_AUTO_VIF),
|
|
FLAG(SW_CRYPTO_CONTROL),
|
|
FLAG(SUPPORT_FAST_XMIT),
|
|
FLAG(REPORTS_TX_ACK_STATUS),
|
|
FLAG(CONNECTION_MONITOR),
|
|
FLAG(QUEUE_CONTROL),
|
|
FLAG(SUPPORTS_PER_STA_GTK),
|
|
FLAG(AP_LINK_PS),
|
|
FLAG(TX_AMPDU_SETUP_IN_HW),
|
|
FLAG(SUPPORTS_RC_TABLE),
|
|
FLAG(P2P_DEV_ADDR_FOR_INTF),
|
|
FLAG(TIMING_BEACON_ONLY),
|
|
FLAG(SUPPORTS_HT_CCK_RATES),
|
|
FLAG(CHANCTX_STA_CSA),
|
|
FLAG(SUPPORTS_CLONED_SKBS),
|
|
FLAG(SINGLE_SCAN_ON_ALL_BANDS),
|
|
FLAG(TDLS_WIDER_BW),
|
|
FLAG(SUPPORTS_AMSDU_IN_AMPDU),
|
|
FLAG(BEACON_TX_STATUS),
|
|
FLAG(NEEDS_UNIQUE_STA_ADDR),
|
|
FLAG(SUPPORTS_REORDERING_BUFFER),
|
|
FLAG(USES_RSS),
|
|
FLAG(TX_AMSDU),
|
|
FLAG(TX_FRAG_LIST),
|
|
FLAG(REPORTS_LOW_ACK),
|
|
FLAG(SUPPORTS_TX_FRAG),
|
|
FLAG(SUPPORTS_TDLS_BUFFER_STA),
|
|
FLAG(DEAUTH_NEED_MGD_TX_PREP),
|
|
FLAG(DOESNT_SUPPORT_QOS_NDP),
|
|
FLAG(BUFF_MMPDU_TXQ),
|
|
FLAG(SUPPORTS_VHT_EXT_NSS_BW),
|
|
FLAG(STA_MMPDU_TXQ),
|
|
#undef FLAG
|
|
};
|
|
|
|
static ssize_t hwflags_read(struct file *file, char __user *user_buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct ieee80211_local *local = file->private_data;
|
|
size_t bufsz = 30 * NUM_IEEE80211_HW_FLAGS;
|
|
char *buf = kzalloc(bufsz, GFP_KERNEL);
|
|
char *pos = buf, *end = buf + bufsz - 1;
|
|
ssize_t rv;
|
|
int i;
|
|
|
|
if (!buf)
|
|
return -ENOMEM;
|
|
|
|
/* fail compilation if somebody adds or removes
|
|
* a flag without updating the name array above
|
|
*/
|
|
BUILD_BUG_ON(ARRAY_SIZE(hw_flag_names) != NUM_IEEE80211_HW_FLAGS);
|
|
|
|
for (i = 0; i < NUM_IEEE80211_HW_FLAGS; i++) {
|
|
if (test_bit(i, local->hw.flags))
|
|
pos += scnprintf(pos, end - pos, "%s\n",
|
|
hw_flag_names[i]);
|
|
}
|
|
|
|
rv = simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
|
|
kfree(buf);
|
|
return rv;
|
|
}
|
|
|
|
static ssize_t misc_read(struct file *file, char __user *user_buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct ieee80211_local *local = file->private_data;
|
|
/* Max len of each line is 16 characters, plus 9 for 'pending:\n' */
|
|
size_t bufsz = IEEE80211_MAX_QUEUES * 16 + 9;
|
|
char *buf;
|
|
char *pos, *end;
|
|
ssize_t rv;
|
|
int i;
|
|
int ln;
|
|
|
|
buf = kzalloc(bufsz, GFP_KERNEL);
|
|
if (!buf)
|
|
return -ENOMEM;
|
|
|
|
pos = buf;
|
|
end = buf + bufsz - 1;
|
|
|
|
pos += scnprintf(pos, end - pos, "pending:\n");
|
|
|
|
for (i = 0; i < IEEE80211_MAX_QUEUES; i++) {
|
|
ln = skb_queue_len(&local->pending[i]);
|
|
pos += scnprintf(pos, end - pos, "[%i] %d\n",
|
|
i, ln);
|
|
}
|
|
|
|
rv = simple_read_from_buffer(user_buf, count, ppos, buf, strlen(buf));
|
|
kfree(buf);
|
|
return rv;
|
|
}
|
|
|
|
static ssize_t queues_read(struct file *file, char __user *user_buf,
|
|
size_t count, loff_t *ppos)
|
|
{
|
|
struct ieee80211_local *local = file->private_data;
|
|
unsigned long flags;
|
|
char buf[IEEE80211_MAX_QUEUES * 20];
|
|
int q, res = 0;
|
|
|
|
spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
|
|
for (q = 0; q < local->hw.queues; q++)
|
|
res += sprintf(buf + res, "%02d: %#.8lx/%d\n", q,
|
|
local->queue_stop_reasons[q],
|
|
skb_queue_len(&local->pending[q]));
|
|
spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
|
|
|
|
return simple_read_from_buffer(user_buf, count, ppos, buf, res);
|
|
}
|
|
|
|
DEBUGFS_READONLY_FILE_OPS(hwflags);
|
|
DEBUGFS_READONLY_FILE_OPS(queues);
|
|
DEBUGFS_READONLY_FILE_OPS(misc);
|
|
|
|
/* statistics stuff */
|
|
|
|
static ssize_t format_devstat_counter(struct ieee80211_local *local,
|
|
char __user *userbuf,
|
|
size_t count, loff_t *ppos,
|
|
int (*printvalue)(struct ieee80211_low_level_stats *stats, char *buf,
|
|
int buflen))
|
|
{
|
|
struct ieee80211_low_level_stats stats;
|
|
char buf[20];
|
|
int res;
|
|
|
|
rtnl_lock();
|
|
res = drv_get_stats(local, &stats);
|
|
rtnl_unlock();
|
|
if (res)
|
|
return res;
|
|
res = printvalue(&stats, buf, sizeof(buf));
|
|
return simple_read_from_buffer(userbuf, count, ppos, buf, res);
|
|
}
|
|
|
|
#define DEBUGFS_DEVSTATS_FILE(name) \
|
|
static int print_devstats_##name(struct ieee80211_low_level_stats *stats,\
|
|
char *buf, int buflen) \
|
|
{ \
|
|
return scnprintf(buf, buflen, "%u\n", stats->name); \
|
|
} \
|
|
static ssize_t stats_ ##name## _read(struct file *file, \
|
|
char __user *userbuf, \
|
|
size_t count, loff_t *ppos) \
|
|
{ \
|
|
return format_devstat_counter(file->private_data, \
|
|
userbuf, \
|
|
count, \
|
|
ppos, \
|
|
print_devstats_##name); \
|
|
} \
|
|
\
|
|
static const struct file_operations stats_ ##name## _ops = { \
|
|
.read = stats_ ##name## _read, \
|
|
.open = simple_open, \
|
|
.llseek = generic_file_llseek, \
|
|
};
|
|
|
|
#define DEBUGFS_STATS_ADD(name) \
|
|
debugfs_create_u32(#name, 0400, statsd, &local->name);
|
|
#define DEBUGFS_DEVSTATS_ADD(name) \
|
|
debugfs_create_file(#name, 0400, statsd, local, &stats_ ##name## _ops);
|
|
|
|
DEBUGFS_DEVSTATS_FILE(dot11ACKFailureCount);
|
|
DEBUGFS_DEVSTATS_FILE(dot11RTSFailureCount);
|
|
DEBUGFS_DEVSTATS_FILE(dot11FCSErrorCount);
|
|
DEBUGFS_DEVSTATS_FILE(dot11RTSSuccessCount);
|
|
|
|
void debugfs_hw_add(struct ieee80211_local *local)
|
|
{
|
|
struct dentry *phyd = local->hw.wiphy->debugfsdir;
|
|
struct dentry *statsd;
|
|
|
|
if (!phyd)
|
|
return;
|
|
|
|
local->debugfs.keys = debugfs_create_dir("keys", phyd);
|
|
|
|
DEBUGFS_ADD(total_ps_buffered);
|
|
DEBUGFS_ADD(wep_iv);
|
|
DEBUGFS_ADD(rate_ctrl_alg);
|
|
DEBUGFS_ADD(queues);
|
|
DEBUGFS_ADD(misc);
|
|
#ifdef CONFIG_PM
|
|
DEBUGFS_ADD_MODE(reset, 0200);
|
|
#endif
|
|
DEBUGFS_ADD(hwflags);
|
|
DEBUGFS_ADD(user_power);
|
|
DEBUGFS_ADD(power);
|
|
|
|
if (local->ops->wake_tx_queue)
|
|
DEBUGFS_ADD_MODE(aqm, 0600);
|
|
|
|
statsd = debugfs_create_dir("statistics", phyd);
|
|
|
|
/* if the dir failed, don't put all the other things into the root! */
|
|
if (!statsd)
|
|
return;
|
|
|
|
#ifdef CONFIG_MAC80211_DEBUG_COUNTERS
|
|
DEBUGFS_STATS_ADD(dot11TransmittedFragmentCount);
|
|
DEBUGFS_STATS_ADD(dot11MulticastTransmittedFrameCount);
|
|
DEBUGFS_STATS_ADD(dot11FailedCount);
|
|
DEBUGFS_STATS_ADD(dot11RetryCount);
|
|
DEBUGFS_STATS_ADD(dot11MultipleRetryCount);
|
|
DEBUGFS_STATS_ADD(dot11FrameDuplicateCount);
|
|
DEBUGFS_STATS_ADD(dot11ReceivedFragmentCount);
|
|
DEBUGFS_STATS_ADD(dot11MulticastReceivedFrameCount);
|
|
DEBUGFS_STATS_ADD(dot11TransmittedFrameCount);
|
|
DEBUGFS_STATS_ADD(tx_handlers_drop);
|
|
DEBUGFS_STATS_ADD(tx_handlers_queued);
|
|
DEBUGFS_STATS_ADD(tx_handlers_drop_wep);
|
|
DEBUGFS_STATS_ADD(tx_handlers_drop_not_assoc);
|
|
DEBUGFS_STATS_ADD(tx_handlers_drop_unauth_port);
|
|
DEBUGFS_STATS_ADD(rx_handlers_drop);
|
|
DEBUGFS_STATS_ADD(rx_handlers_queued);
|
|
DEBUGFS_STATS_ADD(rx_handlers_drop_nullfunc);
|
|
DEBUGFS_STATS_ADD(rx_handlers_drop_defrag);
|
|
DEBUGFS_STATS_ADD(tx_expand_skb_head);
|
|
DEBUGFS_STATS_ADD(tx_expand_skb_head_cloned);
|
|
DEBUGFS_STATS_ADD(rx_expand_skb_head_defrag);
|
|
DEBUGFS_STATS_ADD(rx_handlers_fragments);
|
|
DEBUGFS_STATS_ADD(tx_status_drop);
|
|
#endif
|
|
DEBUGFS_DEVSTATS_ADD(dot11ACKFailureCount);
|
|
DEBUGFS_DEVSTATS_ADD(dot11RTSFailureCount);
|
|
DEBUGFS_DEVSTATS_ADD(dot11FCSErrorCount);
|
|
DEBUGFS_DEVSTATS_ADD(dot11RTSSuccessCount);
|
|
}
|