mirror of
https://github.com/torvalds/linux.git
synced 2025-11-04 10:40:15 +02:00
virtio_net: support device stats
As the spec 42f3899898
make virtio-net support getting the stats from the device by ethtool -S
<eth0>.
NIC statistics:
rx0_packets: 582951
rx0_bytes: 155307077
rx0_drops: 0
rx0_xdp_packets: 0
rx0_xdp_tx: 0
rx0_xdp_redirects: 0
rx0_xdp_drops: 0
rx0_kicks: 17007
rx0_hw_packets: 2179409
rx0_hw_bytes: 510015040
rx0_hw_notifications: 0
rx0_hw_interrupts: 0
rx0_hw_needs_csum: 2179409
rx0_hw_ratelimit_bytes: 0
tx0_packets: 15361
tx0_bytes: 1918970
tx0_xdp_tx: 0
tx0_xdp_tx_drops: 0
tx0_kicks: 15361
tx0_timeouts: 0
tx0_hw_packets: 32272
tx0_hw_bytes: 4311698
tx0_hw_notifications: 0
tx0_hw_interrupts: 0
tx0_hw_ratelimit_bytes: 0
The follow stats are hidden, there are exported by the queue stat API
in the subsequent comment.
VIRTNET_STATS_DESC_RX(basic, drops)
VIRTNET_STATS_DESC_RX(basic, drop_overruns),
VIRTNET_STATS_DESC_TX(basic, drops),
VIRTNET_STATS_DESC_TX(basic, drop_malformed),
VIRTNET_STATS_DESC_RX(csum, csum_valid),
VIRTNET_STATS_DESC_RX(csum, csum_none),
VIRTNET_STATS_DESC_RX(csum, csum_bad),
VIRTNET_STATS_DESC_TX(csum, needs_csum),
VIRTNET_STATS_DESC_TX(csum, csum_none),
VIRTNET_STATS_DESC_RX(gso, gso_packets),
VIRTNET_STATS_DESC_RX(gso, gso_bytes),
VIRTNET_STATS_DESC_RX(gso, gso_packets_coalesced),
VIRTNET_STATS_DESC_RX(gso, gso_bytes_coalesced),
VIRTNET_STATS_DESC_TX(gso, gso_packets),
VIRTNET_STATS_DESC_TX(gso, gso_bytes),
VIRTNET_STATS_DESC_TX(gso, gso_segments),
VIRTNET_STATS_DESC_TX(gso, gso_segments_bytes),
VIRTNET_STATS_DESC_RX(speed, ratelimit_packets),
VIRTNET_STATS_DESC_TX(speed, ratelimit_packets),
Signed-off-by: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Acked-by: Jason Wang <jasowang@redhat.com>
Signed-off-by: Paolo Abeni <pabeni@redhat.com>
This commit is contained in:
Xuan Zhuo
Paolo Abeni
parent
de6df26ffc
commit
941168f8b4
1 changed files with 472 additions and 4 deletions
|
|
@ -133,6 +133,57 @@ static const struct virtnet_stat_desc virtnet_rq_stats_desc[] = {
|
|||
#define VIRTNET_SQ_STATS_LEN ARRAY_SIZE(virtnet_sq_stats_desc)
|
||||
#define VIRTNET_RQ_STATS_LEN ARRAY_SIZE(virtnet_rq_stats_desc)
|
||||
|
||||
#define VIRTNET_STATS_DESC_CQ(name) \
|
||||
{#name, offsetof(struct virtio_net_stats_cvq, name)}
|
||||
|
||||
#define VIRTNET_STATS_DESC_RX(class, name) \
|
||||
{#name, offsetof(struct virtio_net_stats_rx_ ## class, rx_ ## name)}
|
||||
|
||||
#define VIRTNET_STATS_DESC_TX(class, name) \
|
||||
{#name, offsetof(struct virtio_net_stats_tx_ ## class, tx_ ## name)}
|
||||
|
||||
static const struct virtnet_stat_desc virtnet_stats_cvq_desc[] = {
|
||||
VIRTNET_STATS_DESC_CQ(command_num),
|
||||
VIRTNET_STATS_DESC_CQ(ok_num),
|
||||
};
|
||||
|
||||
static const struct virtnet_stat_desc virtnet_stats_rx_basic_desc[] = {
|
||||
VIRTNET_STATS_DESC_RX(basic, packets),
|
||||
VIRTNET_STATS_DESC_RX(basic, bytes),
|
||||
|
||||
VIRTNET_STATS_DESC_RX(basic, notifications),
|
||||
VIRTNET_STATS_DESC_RX(basic, interrupts),
|
||||
};
|
||||
|
||||
static const struct virtnet_stat_desc virtnet_stats_tx_basic_desc[] = {
|
||||
VIRTNET_STATS_DESC_TX(basic, packets),
|
||||
VIRTNET_STATS_DESC_TX(basic, bytes),
|
||||
|
||||
VIRTNET_STATS_DESC_TX(basic, notifications),
|
||||
VIRTNET_STATS_DESC_TX(basic, interrupts),
|
||||
};
|
||||
|
||||
static const struct virtnet_stat_desc virtnet_stats_rx_csum_desc[] = {
|
||||
VIRTNET_STATS_DESC_RX(csum, needs_csum),
|
||||
};
|
||||
|
||||
static const struct virtnet_stat_desc virtnet_stats_tx_gso_desc[] = {
|
||||
VIRTNET_STATS_DESC_TX(gso, gso_packets_noseg),
|
||||
VIRTNET_STATS_DESC_TX(gso, gso_bytes_noseg),
|
||||
};
|
||||
|
||||
static const struct virtnet_stat_desc virtnet_stats_rx_speed_desc[] = {
|
||||
VIRTNET_STATS_DESC_RX(speed, ratelimit_bytes),
|
||||
};
|
||||
|
||||
static const struct virtnet_stat_desc virtnet_stats_tx_speed_desc[] = {
|
||||
VIRTNET_STATS_DESC_TX(speed, ratelimit_bytes),
|
||||
};
|
||||
|
||||
#define VIRTNET_Q_TYPE_RX 0
|
||||
#define VIRTNET_Q_TYPE_TX 1
|
||||
#define VIRTNET_Q_TYPE_CQ 2
|
||||
|
||||
struct virtnet_interrupt_coalesce {
|
||||
u32 max_packets;
|
||||
u32 max_usecs;
|
||||
|
|
@ -249,6 +300,7 @@ struct control_buf {
|
|||
struct virtio_net_ctrl_coal_tx coal_tx;
|
||||
struct virtio_net_ctrl_coal_rx coal_rx;
|
||||
struct virtio_net_ctrl_coal_vq coal_vq;
|
||||
struct virtio_net_stats_capabilities stats_cap;
|
||||
};
|
||||
|
||||
struct virtnet_info {
|
||||
|
|
@ -340,6 +392,8 @@ struct virtnet_info {
|
|||
|
||||
/* failover when STANDBY feature enabled */
|
||||
struct failover *failover;
|
||||
|
||||
u64 device_stats_cap;
|
||||
};
|
||||
|
||||
struct padded_vnet_hdr {
|
||||
|
|
@ -425,6 +479,17 @@ static int rxq2vq(int rxq)
|
|||
return rxq * 2;
|
||||
}
|
||||
|
||||
static int vq_type(struct virtnet_info *vi, int qid)
|
||||
{
|
||||
if (qid == vi->max_queue_pairs * 2)
|
||||
return VIRTNET_Q_TYPE_CQ;
|
||||
|
||||
if (qid % 2)
|
||||
return VIRTNET_Q_TYPE_TX;
|
||||
|
||||
return VIRTNET_Q_TYPE_RX;
|
||||
}
|
||||
|
||||
static inline struct virtio_net_common_hdr *
|
||||
skb_vnet_common_hdr(struct sk_buff *skb)
|
||||
{
|
||||
|
|
@ -3307,6 +3372,369 @@ static int virtnet_set_channels(struct net_device *dev,
|
|||
return err;
|
||||
}
|
||||
|
||||
static void virtnet_stats_sprintf(u8 **p, const char *fmt, const char *noq_fmt,
|
||||
int num, int qid, const struct virtnet_stat_desc *desc)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (qid < 0) {
|
||||
for (i = 0; i < num; ++i)
|
||||
ethtool_sprintf(p, noq_fmt, desc[i].desc);
|
||||
} else {
|
||||
for (i = 0; i < num; ++i)
|
||||
ethtool_sprintf(p, fmt, qid, desc[i].desc);
|
||||
}
|
||||
}
|
||||
|
||||
static void virtnet_get_hw_stats_string(struct virtnet_info *vi, int type, int qid, u8 **data)
|
||||
{
|
||||
const struct virtnet_stat_desc *desc;
|
||||
const char *fmt, *noq_fmt;
|
||||
u8 *p = *data;
|
||||
u32 num = 0;
|
||||
|
||||
if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_DEVICE_STATS))
|
||||
return;
|
||||
|
||||
if (type == VIRTNET_Q_TYPE_CQ) {
|
||||
noq_fmt = "cq_hw_%s";
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_CVQ) {
|
||||
desc = &virtnet_stats_cvq_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_cvq_desc);
|
||||
|
||||
virtnet_stats_sprintf(&p, NULL, noq_fmt, num, -1, desc);
|
||||
}
|
||||
}
|
||||
|
||||
if (type == VIRTNET_Q_TYPE_RX) {
|
||||
fmt = "rx%u_hw_%s";
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_RX_BASIC) {
|
||||
desc = &virtnet_stats_rx_basic_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_rx_basic_desc);
|
||||
|
||||
virtnet_stats_sprintf(&p, fmt, NULL, num, qid, desc);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_RX_CSUM) {
|
||||
desc = &virtnet_stats_rx_csum_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_rx_csum_desc);
|
||||
|
||||
virtnet_stats_sprintf(&p, fmt, NULL, num, qid, desc);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_RX_SPEED) {
|
||||
desc = &virtnet_stats_rx_speed_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_rx_speed_desc);
|
||||
|
||||
virtnet_stats_sprintf(&p, fmt, NULL, num, qid, desc);
|
||||
}
|
||||
}
|
||||
|
||||
if (type == VIRTNET_Q_TYPE_TX) {
|
||||
fmt = "tx%u_hw_%s";
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_TX_BASIC) {
|
||||
desc = &virtnet_stats_tx_basic_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_tx_basic_desc);
|
||||
|
||||
virtnet_stats_sprintf(&p, fmt, NULL, num, qid, desc);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_TX_GSO) {
|
||||
desc = &virtnet_stats_tx_gso_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_tx_gso_desc);
|
||||
|
||||
virtnet_stats_sprintf(&p, fmt, NULL, num, qid, desc);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_TX_SPEED) {
|
||||
desc = &virtnet_stats_tx_speed_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_tx_speed_desc);
|
||||
|
||||
virtnet_stats_sprintf(&p, fmt, NULL, num, qid, desc);
|
||||
}
|
||||
}
|
||||
|
||||
*data = p;
|
||||
}
|
||||
|
||||
struct virtnet_stats_ctx {
|
||||
/* Used to calculate the offset inside the output buffer. */
|
||||
u32 desc_num[3];
|
||||
|
||||
/* The actual supported stat types. */
|
||||
u32 bitmap[3];
|
||||
|
||||
/* Used to calculate the reply buffer size. */
|
||||
u32 size[3];
|
||||
|
||||
/* Record the output buffer. */
|
||||
u64 *data;
|
||||
};
|
||||
|
||||
static void virtnet_stats_ctx_init(struct virtnet_info *vi,
|
||||
struct virtnet_stats_ctx *ctx,
|
||||
u64 *data)
|
||||
{
|
||||
u32 queue_type;
|
||||
|
||||
ctx->data = data;
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_CVQ) {
|
||||
queue_type = VIRTNET_Q_TYPE_CQ;
|
||||
|
||||
ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_CVQ;
|
||||
ctx->desc_num[queue_type] += ARRAY_SIZE(virtnet_stats_cvq_desc);
|
||||
ctx->size[queue_type] += sizeof(struct virtio_net_stats_cvq);
|
||||
}
|
||||
|
||||
queue_type = VIRTNET_Q_TYPE_RX;
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_RX_BASIC) {
|
||||
ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_BASIC;
|
||||
ctx->desc_num[queue_type] += ARRAY_SIZE(virtnet_stats_rx_basic_desc);
|
||||
ctx->size[queue_type] += sizeof(struct virtio_net_stats_rx_basic);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_RX_CSUM) {
|
||||
ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_CSUM;
|
||||
ctx->desc_num[queue_type] += ARRAY_SIZE(virtnet_stats_rx_csum_desc);
|
||||
ctx->size[queue_type] += sizeof(struct virtio_net_stats_rx_csum);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_RX_SPEED) {
|
||||
ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_RX_SPEED;
|
||||
ctx->desc_num[queue_type] += ARRAY_SIZE(virtnet_stats_rx_speed_desc);
|
||||
ctx->size[queue_type] += sizeof(struct virtio_net_stats_rx_speed);
|
||||
}
|
||||
|
||||
queue_type = VIRTNET_Q_TYPE_TX;
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_TX_BASIC) {
|
||||
ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_BASIC;
|
||||
ctx->desc_num[queue_type] += ARRAY_SIZE(virtnet_stats_tx_basic_desc);
|
||||
ctx->size[queue_type] += sizeof(struct virtio_net_stats_tx_basic);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_TX_GSO) {
|
||||
ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_GSO;
|
||||
ctx->desc_num[queue_type] += ARRAY_SIZE(virtnet_stats_tx_gso_desc);
|
||||
ctx->size[queue_type] += sizeof(struct virtio_net_stats_tx_gso);
|
||||
}
|
||||
|
||||
if (vi->device_stats_cap & VIRTIO_NET_STATS_TYPE_TX_SPEED) {
|
||||
ctx->bitmap[queue_type] |= VIRTIO_NET_STATS_TYPE_TX_SPEED;
|
||||
ctx->desc_num[queue_type] += ARRAY_SIZE(virtnet_stats_tx_speed_desc);
|
||||
ctx->size[queue_type] += sizeof(struct virtio_net_stats_tx_speed);
|
||||
}
|
||||
}
|
||||
|
||||
/* virtnet_fill_stats - copy the stats to ethtool -S
|
||||
* The stats source is the device.
|
||||
*
|
||||
* @vi: virtio net info
|
||||
* @qid: the vq id
|
||||
* @ctx: stats ctx (initiated by virtnet_stats_ctx_init())
|
||||
* @base: pointer to the device reply.
|
||||
* @type: the type of the device reply
|
||||
*/
|
||||
static void virtnet_fill_stats(struct virtnet_info *vi, u32 qid,
|
||||
struct virtnet_stats_ctx *ctx,
|
||||
const u8 *base, u8 reply_type)
|
||||
{
|
||||
u32 queue_type, num_rx, num_tx, num_cq;
|
||||
const struct virtnet_stat_desc *desc;
|
||||
u64 offset, bitmap;
|
||||
const __le64 *v;
|
||||
int i, num;
|
||||
|
||||
num_rx = VIRTNET_RQ_STATS_LEN + ctx->desc_num[VIRTNET_Q_TYPE_RX];
|
||||
num_tx = VIRTNET_SQ_STATS_LEN + ctx->desc_num[VIRTNET_Q_TYPE_TX];
|
||||
num_cq = ctx->desc_num[VIRTNET_Q_TYPE_CQ];
|
||||
|
||||
queue_type = vq_type(vi, qid);
|
||||
bitmap = ctx->bitmap[queue_type];
|
||||
offset = 0;
|
||||
|
||||
if (queue_type == VIRTNET_Q_TYPE_TX) {
|
||||
offset = num_cq + num_rx * vi->curr_queue_pairs + num_tx * (qid / 2);
|
||||
offset += VIRTNET_SQ_STATS_LEN;
|
||||
} else if (queue_type == VIRTNET_Q_TYPE_RX) {
|
||||
offset = num_cq + num_rx * (qid / 2) + VIRTNET_RQ_STATS_LEN;
|
||||
}
|
||||
|
||||
if (bitmap & VIRTIO_NET_STATS_TYPE_CVQ) {
|
||||
desc = &virtnet_stats_cvq_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_cvq_desc);
|
||||
if (reply_type == VIRTIO_NET_STATS_TYPE_REPLY_CVQ)
|
||||
goto found;
|
||||
|
||||
offset += num;
|
||||
}
|
||||
|
||||
if (bitmap & VIRTIO_NET_STATS_TYPE_RX_BASIC) {
|
||||
desc = &virtnet_stats_rx_basic_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_rx_basic_desc);
|
||||
if (reply_type == VIRTIO_NET_STATS_TYPE_REPLY_RX_BASIC)
|
||||
goto found;
|
||||
|
||||
offset += num;
|
||||
}
|
||||
|
||||
if (bitmap & VIRTIO_NET_STATS_TYPE_RX_CSUM) {
|
||||
desc = &virtnet_stats_rx_csum_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_rx_csum_desc);
|
||||
if (reply_type == VIRTIO_NET_STATS_TYPE_REPLY_RX_CSUM)
|
||||
goto found;
|
||||
|
||||
offset += num;
|
||||
}
|
||||
|
||||
if (bitmap & VIRTIO_NET_STATS_TYPE_RX_SPEED) {
|
||||
desc = &virtnet_stats_rx_speed_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_rx_speed_desc);
|
||||
if (reply_type == VIRTIO_NET_STATS_TYPE_REPLY_RX_SPEED)
|
||||
goto found;
|
||||
|
||||
offset += num;
|
||||
}
|
||||
|
||||
if (bitmap & VIRTIO_NET_STATS_TYPE_TX_BASIC) {
|
||||
desc = &virtnet_stats_tx_basic_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_tx_basic_desc);
|
||||
if (reply_type == VIRTIO_NET_STATS_TYPE_REPLY_TX_BASIC)
|
||||
goto found;
|
||||
|
||||
offset += num;
|
||||
}
|
||||
|
||||
if (bitmap & VIRTIO_NET_STATS_TYPE_TX_GSO) {
|
||||
desc = &virtnet_stats_tx_gso_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_tx_gso_desc);
|
||||
if (reply_type == VIRTIO_NET_STATS_TYPE_REPLY_TX_GSO)
|
||||
goto found;
|
||||
|
||||
offset += num;
|
||||
}
|
||||
|
||||
if (bitmap & VIRTIO_NET_STATS_TYPE_TX_SPEED) {
|
||||
desc = &virtnet_stats_tx_speed_desc[0];
|
||||
num = ARRAY_SIZE(virtnet_stats_tx_speed_desc);
|
||||
if (reply_type == VIRTIO_NET_STATS_TYPE_REPLY_TX_SPEED)
|
||||
goto found;
|
||||
|
||||
offset += num;
|
||||
}
|
||||
|
||||
return;
|
||||
|
||||
found:
|
||||
for (i = 0; i < num; ++i) {
|
||||
v = (const __le64 *)(base + desc[i].offset);
|
||||
ctx->data[offset + i] = le64_to_cpu(*v);
|
||||
}
|
||||
}
|
||||
|
||||
static int __virtnet_get_hw_stats(struct virtnet_info *vi,
|
||||
struct virtnet_stats_ctx *ctx,
|
||||
struct virtio_net_ctrl_queue_stats *req,
|
||||
int req_size, void *reply, int res_size)
|
||||
{
|
||||
struct virtio_net_stats_reply_hdr *hdr;
|
||||
struct scatterlist sgs_in, sgs_out;
|
||||
void *p;
|
||||
u32 qid;
|
||||
int ok;
|
||||
|
||||
sg_init_one(&sgs_out, req, req_size);
|
||||
sg_init_one(&sgs_in, reply, res_size);
|
||||
|
||||
ok = virtnet_send_command_reply(vi, VIRTIO_NET_CTRL_STATS,
|
||||
VIRTIO_NET_CTRL_STATS_GET,
|
||||
&sgs_out, &sgs_in);
|
||||
|
||||
if (!ok)
|
||||
return ok;
|
||||
|
||||
for (p = reply; p - reply < res_size; p += le16_to_cpu(hdr->size)) {
|
||||
hdr = p;
|
||||
qid = le16_to_cpu(hdr->vq_index);
|
||||
virtnet_fill_stats(vi, qid, ctx, p, hdr->type);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void virtnet_make_stat_req(struct virtnet_info *vi,
|
||||
struct virtnet_stats_ctx *ctx,
|
||||
struct virtio_net_ctrl_queue_stats *req,
|
||||
int qid, int *idx)
|
||||
{
|
||||
int qtype = vq_type(vi, qid);
|
||||
u64 bitmap = ctx->bitmap[qtype];
|
||||
|
||||
if (!bitmap)
|
||||
return;
|
||||
|
||||
req->stats[*idx].vq_index = cpu_to_le16(qid);
|
||||
req->stats[*idx].types_bitmap[0] = cpu_to_le64(bitmap);
|
||||
*idx += 1;
|
||||
}
|
||||
|
||||
static int virtnet_get_hw_stats(struct virtnet_info *vi,
|
||||
struct virtnet_stats_ctx *ctx)
|
||||
{
|
||||
struct virtio_net_ctrl_queue_stats *req;
|
||||
int qnum, i, j, res_size, qtype, last_vq;
|
||||
void *reply;
|
||||
int ok;
|
||||
|
||||
if (!virtio_has_feature(vi->vdev, VIRTIO_NET_F_DEVICE_STATS))
|
||||
return 0;
|
||||
|
||||
last_vq = vi->curr_queue_pairs * 2 - 1;
|
||||
|
||||
qnum = 0;
|
||||
res_size = 0;
|
||||
for (i = 0; i <= last_vq ; ++i) {
|
||||
qtype = vq_type(vi, i);
|
||||
if (ctx->bitmap[qtype]) {
|
||||
++qnum;
|
||||
res_size += ctx->size[qtype];
|
||||
}
|
||||
}
|
||||
|
||||
if (ctx->bitmap[VIRTNET_Q_TYPE_CQ]) {
|
||||
res_size += ctx->size[VIRTNET_Q_TYPE_CQ];
|
||||
qnum += 1;
|
||||
}
|
||||
|
||||
req = kcalloc(qnum, sizeof(*req), GFP_KERNEL);
|
||||
if (!req)
|
||||
return -ENOMEM;
|
||||
|
||||
reply = kmalloc(res_size, GFP_KERNEL);
|
||||
if (!reply) {
|
||||
kfree(req);
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
j = 0;
|
||||
for (i = 0; i <= last_vq ; ++i)
|
||||
virtnet_make_stat_req(vi, ctx, req, i, &j);
|
||||
|
||||
virtnet_make_stat_req(vi, ctx, req, vi->max_queue_pairs * 2, &j);
|
||||
|
||||
ok = __virtnet_get_hw_stats(vi, ctx, req, sizeof(*req) * j, reply, res_size);
|
||||
|
||||
kfree(req);
|
||||
kfree(reply);
|
||||
|
||||
return ok;
|
||||
}
|
||||
|
||||
static void virtnet_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
||||
{
|
||||
struct virtnet_info *vi = netdev_priv(dev);
|
||||
|
|
@ -3315,16 +3743,22 @@ static void virtnet_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
|||
|
||||
switch (stringset) {
|
||||
case ETH_SS_STATS:
|
||||
virtnet_get_hw_stats_string(vi, VIRTNET_Q_TYPE_CQ, 0, &p);
|
||||
|
||||
for (i = 0; i < vi->curr_queue_pairs; i++) {
|
||||
for (j = 0; j < VIRTNET_RQ_STATS_LEN; j++)
|
||||
ethtool_sprintf(&p, "rx%u_%s", i,
|
||||
virtnet_rq_stats_desc[j].desc);
|
||||
|
||||
virtnet_get_hw_stats_string(vi, VIRTNET_Q_TYPE_RX, i, &p);
|
||||
}
|
||||
|
||||
for (i = 0; i < vi->curr_queue_pairs; i++) {
|
||||
for (j = 0; j < VIRTNET_SQ_STATS_LEN; j++)
|
||||
ethtool_sprintf(&p, "tx%u_%s", i,
|
||||
virtnet_sq_stats_desc[j].desc);
|
||||
|
||||
virtnet_get_hw_stats_string(vi, VIRTNET_Q_TYPE_TX, i, &p);
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
|
@ -3333,11 +3767,17 @@ static void virtnet_get_strings(struct net_device *dev, u32 stringset, u8 *data)
|
|||
static int virtnet_get_sset_count(struct net_device *dev, int sset)
|
||||
{
|
||||
struct virtnet_info *vi = netdev_priv(dev);
|
||||
struct virtnet_stats_ctx ctx = {0};
|
||||
u32 pair_count;
|
||||
|
||||
switch (sset) {
|
||||
case ETH_SS_STATS:
|
||||
return vi->curr_queue_pairs * (VIRTNET_RQ_STATS_LEN +
|
||||
VIRTNET_SQ_STATS_LEN);
|
||||
virtnet_stats_ctx_init(vi, &ctx, NULL);
|
||||
|
||||
pair_count = VIRTNET_RQ_STATS_LEN + VIRTNET_SQ_STATS_LEN;
|
||||
pair_count += ctx.desc_num[VIRTNET_Q_TYPE_RX] + ctx.desc_num[VIRTNET_Q_TYPE_TX];
|
||||
|
||||
return ctx.desc_num[VIRTNET_Q_TYPE_CQ] + vi->curr_queue_pairs * pair_count;
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
|
@ -3347,11 +3787,18 @@ static void virtnet_get_ethtool_stats(struct net_device *dev,
|
|||
struct ethtool_stats *stats, u64 *data)
|
||||
{
|
||||
struct virtnet_info *vi = netdev_priv(dev);
|
||||
unsigned int idx = 0, start, i, j;
|
||||
struct virtnet_stats_ctx ctx = {0};
|
||||
unsigned int idx, start, i, j;
|
||||
const u8 *stats_base;
|
||||
const u64_stats_t *p;
|
||||
size_t offset;
|
||||
|
||||
virtnet_stats_ctx_init(vi, &ctx, data);
|
||||
if (virtnet_get_hw_stats(vi, &ctx))
|
||||
dev_warn(&vi->dev->dev, "Failed to get hw stats.\n");
|
||||
|
||||
idx = ctx.desc_num[VIRTNET_Q_TYPE_CQ];
|
||||
|
||||
for (i = 0; i < vi->curr_queue_pairs; i++) {
|
||||
struct receive_queue *rq = &vi->rq[i];
|
||||
|
||||
|
|
@ -3365,6 +3812,7 @@ static void virtnet_get_ethtool_stats(struct net_device *dev,
|
|||
}
|
||||
} while (u64_stats_fetch_retry(&rq->stats.syncp, start));
|
||||
idx += VIRTNET_RQ_STATS_LEN;
|
||||
idx += ctx.desc_num[VIRTNET_Q_TYPE_RX];
|
||||
}
|
||||
|
||||
for (i = 0; i < vi->curr_queue_pairs; i++) {
|
||||
|
|
@ -3380,6 +3828,7 @@ static void virtnet_get_ethtool_stats(struct net_device *dev,
|
|||
}
|
||||
} while (u64_stats_fetch_retry(&sq->stats.syncp, start));
|
||||
idx += VIRTNET_SQ_STATS_LEN;
|
||||
idx += ctx.desc_num[VIRTNET_Q_TYPE_TX];
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -4946,6 +5395,25 @@ static int virtnet_probe(struct virtio_device *vdev)
|
|||
}
|
||||
}
|
||||
|
||||
if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_DEVICE_STATS)) {
|
||||
struct scatterlist sg;
|
||||
__le64 v;
|
||||
|
||||
sg_init_one(&sg, &vi->ctrl->stats_cap, sizeof(vi->ctrl->stats_cap));
|
||||
|
||||
if (!virtnet_send_command_reply(vi, VIRTIO_NET_CTRL_STATS,
|
||||
VIRTIO_NET_CTRL_STATS_QUERY,
|
||||
NULL, &sg)) {
|
||||
pr_debug("virtio_net: fail to get stats capability\n");
|
||||
rtnl_unlock();
|
||||
err = -EINVAL;
|
||||
goto free_unregister_netdev;
|
||||
}
|
||||
|
||||
v = vi->ctrl->stats_cap.supported_stats_types[0];
|
||||
vi->device_stats_cap = le64_to_cpu(v);
|
||||
}
|
||||
|
||||
rtnl_unlock();
|
||||
|
||||
err = virtnet_cpu_notif_add(vi);
|
||||
|
|
@ -5074,7 +5542,7 @@ static struct virtio_device_id id_table[] = {
|
|||
VIRTIO_NET_F_SPEED_DUPLEX, VIRTIO_NET_F_STANDBY, \
|
||||
VIRTIO_NET_F_RSS, VIRTIO_NET_F_HASH_REPORT, VIRTIO_NET_F_NOTF_COAL, \
|
||||
VIRTIO_NET_F_VQ_NOTF_COAL, \
|
||||
VIRTIO_NET_F_GUEST_HDRLEN
|
||||
VIRTIO_NET_F_GUEST_HDRLEN, VIRTIO_NET_F_DEVICE_STATS
|
||||
|
||||
static unsigned int features[] = {
|
||||
VIRTNET_FEATURES,
|
||||
|
|
|
|||
Loading…
Reference in a new issue