#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <net/if.h>
#include <ynl.h>
#include "netdev-user.h"
#include "main.h"
struct pp_stat {
unsigned int ifc;
struct {
unsigned int cnt;
size_t refs, bytes;
} live[2];
size_t alloc_slow, alloc_fast, recycle_ring, recycle_cache;
};
struct pp_stats_array {
unsigned int i, max;
struct pp_stat *s;
};
static struct pp_stat *find_ifc(struct pp_stats_array *a, unsigned int ifindex)
{
unsigned int i;
for (i = 0; i < a->i; i++) {
if (a->s[i].ifc == ifindex)
return &a->s[i];
}
a->i++;
if (a->i == a->max) {
a->max *= 2;
a->s = reallocarray(a->s, a->max, sizeof(*a->s));
}
a->s[i].ifc = ifindex;
return &a->s[i];
}
static void count_pool(struct pp_stat *s, unsigned int l,
struct netdev_page_pool_get_rsp *pp)
{
s->live[l].cnt++;
if (pp->_present.inflight)
s->live[l].refs += pp->inflight;
if (pp->_present.inflight_mem)
s->live[l].bytes += pp->inflight_mem;
}
static void print_json_recycling_stats(struct pp_stat *s)
{
double recycle;
if (s->alloc_fast + s->alloc_slow) {
recycle = (double)(s->recycle_ring + s->recycle_cache) /
(s->alloc_fast + s->alloc_slow) * 100;
jsonw_float_field(json_wtr, "recycling_pct", recycle);
}
jsonw_name(json_wtr, "alloc");
jsonw_start_object(json_wtr);
jsonw_uint_field(json_wtr, "slow", s->alloc_slow);
jsonw_uint_field(json_wtr, "fast", s->alloc_fast);
jsonw_end_object(json_wtr);
jsonw_name(json_wtr, "recycle");
jsonw_start_object(json_wtr);
jsonw_uint_field(json_wtr, "ring", s->recycle_ring);
jsonw_uint_field(json_wtr, "cache", s->recycle_cache);
jsonw_end_object(json_wtr);
}
static void print_plain_recycling_stats(struct pp_stat *s)
{
double recycle;
if (s->alloc_fast + s->alloc_slow) {
recycle = (double)(s->recycle_ring + s->recycle_cache) /
(s->alloc_fast + s->alloc_slow) * 100;
printf("recycling: %.1lf%% (alloc: %zu:%zu recycle: %zu:%zu)",
recycle, s->alloc_slow, s->alloc_fast,
s->recycle_ring, s->recycle_cache);
}
}
static void print_json_stats(struct pp_stats_array *a)
{
jsonw_start_array(json_wtr);
for (unsigned int i = 0; i < a->i; i++) {
char ifname[IF_NAMESIZE];
struct pp_stat *s = &a->s[i];
const char *name;
jsonw_start_object(json_wtr);
if (!s->ifc) {
jsonw_string_field(json_wtr, "ifname", "<orphan>");
jsonw_uint_field(json_wtr, "ifindex", 0);
} else {
name = if_indextoname(s->ifc, ifname);
if (name)
jsonw_string_field(json_wtr, "ifname", name);
jsonw_uint_field(json_wtr, "ifindex", s->ifc);
}
jsonw_uint_field(json_wtr, "page_pools", s->live[1].cnt);
jsonw_uint_field(json_wtr, "zombies", s->live[0].cnt);
jsonw_name(json_wtr, "live");
jsonw_start_object(json_wtr);
jsonw_uint_field(json_wtr, "refs", s->live[1].refs);
jsonw_uint_field(json_wtr, "bytes", s->live[1].bytes);
jsonw_end_object(json_wtr);
jsonw_name(json_wtr, "zombie");
jsonw_start_object(json_wtr);
jsonw_uint_field(json_wtr, "refs", s->live[0].refs);
jsonw_uint_field(json_wtr, "bytes", s->live[0].bytes);
jsonw_end_object(json_wtr);
if (s->alloc_fast || s->alloc_slow)
print_json_recycling_stats(s);
jsonw_end_object(json_wtr);
}
jsonw_end_array(json_wtr);
}
static void print_plain_stats(struct pp_stats_array *a)
{
for (unsigned int i = 0; i < a->i; i++) {
char ifname[IF_NAMESIZE];
struct pp_stat *s = &a->s[i];
const char *name;
if (!s->ifc) {
printf("<orphan>\t");
} else {
name = if_indextoname(s->ifc, ifname);
if (name)
printf("%8s", name);
printf("[%u]\t", s->ifc);
}
printf("page pools: %u (zombies: %u)\n",
s->live[1].cnt, s->live[0].cnt);
printf("\t\trefs: %zu bytes: %zu (refs: %zu bytes: %zu)\n",
s->live[1].refs, s->live[1].bytes,
s->live[0].refs, s->live[0].bytes);
if (s->alloc_fast || s->alloc_slow) {
printf("\t\t");
print_plain_recycling_stats(s);
printf("\n");
}
}
}
static bool
find_pool_stat_in_list(struct netdev_page_pool_stats_get_list *pp_stats,
__u64 pool_id, struct pp_stat *pstat)
{
ynl_dump_foreach(pp_stats, pp) {
if (!pp->_present.info || !pp->info._present.id)
continue;
if (pp->info.id != pool_id)
continue;
memset(pstat, 0, sizeof(*pstat));
if (pp->_present.alloc_fast)
pstat->alloc_fast = pp->alloc_fast;
if (pp->_present.alloc_refill)
pstat->alloc_fast += pp->alloc_refill;
if (pp->_present.alloc_slow)
pstat->alloc_slow = pp->alloc_slow;
if (pp->_present.recycle_ring)
pstat->recycle_ring = pp->recycle_ring;
if (pp->_present.recycle_cached)
pstat->recycle_cache = pp->recycle_cached;
return true;
}
return false;
}
static void
print_json_pool_list(struct netdev_page_pool_get_list *pools,
struct netdev_page_pool_stats_get_list *pp_stats,
bool zombies_only)
{
jsonw_start_array(json_wtr);
ynl_dump_foreach(pools, pp) {
char ifname[IF_NAMESIZE];
struct pp_stat pstat;
const char *name;
if (zombies_only && !pp->_present.detach_time)
continue;
jsonw_start_object(json_wtr);
jsonw_uint_field(json_wtr, "id", pp->id);
if (pp->_present.ifindex) {
name = if_indextoname(pp->ifindex, ifname);
if (name)
jsonw_string_field(json_wtr, "ifname", name);
jsonw_uint_field(json_wtr, "ifindex", pp->ifindex);
}
if (pp->_present.napi_id)
jsonw_uint_field(json_wtr, "napi_id", pp->napi_id);
if (pp->_present.inflight)
jsonw_uint_field(json_wtr, "refs", pp->inflight);
if (pp->_present.inflight_mem)
jsonw_uint_field(json_wtr, "bytes", pp->inflight_mem);
if (pp->_present.detach_time)
jsonw_uint_field(json_wtr, "detach_time", pp->detach_time);
if (pp->_present.dmabuf)
jsonw_uint_field(json_wtr, "dmabuf", pp->dmabuf);
if (find_pool_stat_in_list(pp_stats, pp->id, &pstat) &&
(pstat.alloc_fast || pstat.alloc_slow))
print_json_recycling_stats(&pstat);
jsonw_end_object(json_wtr);
}
jsonw_end_array(json_wtr);
}
static void
print_plain_pool_list(struct netdev_page_pool_get_list *pools,
struct netdev_page_pool_stats_get_list *pp_stats,
bool zombies_only)
{
ynl_dump_foreach(pools, pp) {
char ifname[IF_NAMESIZE];
struct pp_stat pstat;
const char *name;
if (zombies_only && !pp->_present.detach_time)
continue;
printf("pool id: %llu", pp->id);
if (pp->_present.ifindex) {
name = if_indextoname(pp->ifindex, ifname);
if (name)
printf(" dev: %s", name);
printf("[%u]", pp->ifindex);
}
if (pp->_present.napi_id)
printf(" napi: %llu", pp->napi_id);
printf("\n");
if (pp->_present.inflight || pp->_present.inflight_mem) {
printf(" inflight:");
if (pp->_present.inflight)
printf(" %llu pages", pp->inflight);
if (pp->_present.inflight_mem)
printf(" %llu bytes", pp->inflight_mem);
printf("\n");
}
if (pp->_present.detach_time)
printf(" detached: %llu\n", pp->detach_time);
if (pp->_present.dmabuf)
printf(" dmabuf: %u\n", pp->dmabuf);
if (find_pool_stat_in_list(pp_stats, pp->id, &pstat) &&
(pstat.alloc_fast || pstat.alloc_slow)) {
printf(" ");
print_plain_recycling_stats(&pstat);
printf("\n");
}
}
}
static void aggregate_device_stats(struct pp_stats_array *a,
struct netdev_page_pool_get_list *pools,
struct netdev_page_pool_stats_get_list *pp_stats)
{
ynl_dump_foreach(pools, pp) {
struct pp_stat *s = find_ifc(a, pp->ifindex);
count_pool(s, 1, pp);
if (pp->_present.detach_time)
count_pool(s, 0, pp);
}
ynl_dump_foreach(pp_stats, pp) {
struct pp_stat *s = find_ifc(a, pp->info.ifindex);
if (pp->_present.alloc_fast)
s->alloc_fast += pp->alloc_fast;
if (pp->_present.alloc_refill)
s->alloc_fast += pp->alloc_refill;
if (pp->_present.alloc_slow)
s->alloc_slow += pp->alloc_slow;
if (pp->_present.recycle_ring)
s->recycle_ring += pp->recycle_ring;
if (pp->_present.recycle_cached)
s->recycle_cache += pp->recycle_cached;
}
}
static int do_stats(int argc, char **argv)
{
struct netdev_page_pool_stats_get_list *pp_stats;
struct netdev_page_pool_get_list *pools;
enum {
GROUP_BY_DEVICE,
GROUP_BY_POOL,
} group_by = GROUP_BY_DEVICE;
bool zombies_only = false;
struct pp_stats_array a = {};
struct ynl_error yerr;
struct ynl_sock *ys;
int ret = 0;
while (argc > 0) {
if (is_prefix(*argv, "group-by")) {
NEXT_ARG();
if (!REQ_ARGS(1))
return -1;
if (is_prefix(*argv, "device")) {
group_by = GROUP_BY_DEVICE;
} else if (is_prefix(*argv, "pp") ||
is_prefix(*argv, "page-pool") ||
is_prefix(*argv, "none")) {
group_by = GROUP_BY_POOL;
} else {
p_err("invalid group-by value '%s'", *argv);
return -1;
}
NEXT_ARG();
} else if (is_prefix(*argv, "zombies")) {
zombies_only = true;
group_by = GROUP_BY_POOL;
NEXT_ARG();
} else {
p_err("unknown option '%s'", *argv);
return -1;
}
}
ys = ynl_sock_create(&ynl_netdev_family, &yerr);
if (!ys) {
p_err("YNL: %s", yerr.msg);
return -1;
}
pools = netdev_page_pool_get_dump(ys);
if (!pools) {
p_err("failed to get page pools: %s", ys->err.msg);
ret = -1;
goto exit_close;
}
pp_stats = netdev_page_pool_stats_get_dump(ys);
if (!pp_stats) {
p_err("failed to get page pool stats: %s", ys->err.msg);
ret = -1;
goto exit_free_pp_list;
}
if (group_by == GROUP_BY_POOL) {
if (json_output)
print_json_pool_list(pools, pp_stats, zombies_only);
else
print_plain_pool_list(pools, pp_stats, zombies_only);
} else {
a.max = 64;
a.s = calloc(a.max, sizeof(*a.s));
if (!a.s) {
p_err("failed to allocate stats array");
ret = -1;
goto exit_free_stats_list;
}
aggregate_device_stats(&a, pools, pp_stats);
if (json_output)
print_json_stats(&a);
else
print_plain_stats(&a);
free(a.s);
}
exit_free_stats_list:
netdev_page_pool_stats_get_list_free(pp_stats);
exit_free_pp_list:
netdev_page_pool_get_list_free(pools);
exit_close:
ynl_sock_destroy(ys);
return ret;
}
static int do_help(int argc __attribute__((unused)),
char **argv __attribute__((unused)))
{
if (json_output) {
jsonw_null(json_wtr);
return 0;
}
fprintf(stderr,
"Usage: %s page-pool { COMMAND | help }\n"
" %s page-pool stats [ OPTIONS ]\n"
"\n"
" OPTIONS := { group-by { device | page-pool | none } | zombies }\n"
"\n"
" stats - Display page pool statistics\n"
" stats group-by device - Group statistics by network device (default)\n"
" stats group-by page-pool | pp | none\n"
" - Show individual page pool details (no grouping)\n"
" stats zombies - Show only zombie page pools (detached but with\n"
" pages in flight). Implies group-by page-pool.\n"
"",
bin_name, bin_name);
return 0;
}
static const struct cmd page_pool_cmds[] = {
{ "help", do_help },
{ "stats", do_stats },
{ 0 }
};
int do_page_pool(int argc, char **argv)
{
return cmd_select(page_pool_cmds, argc, argv, do_help);
}
