net/xdp/xsk_diag.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* XDP sockets monitoring support
   3  *
   4  * Copyright(c) 2019 Intel Corporation.
   5  *
   6  * Author: Björn Töpel <bjorn.topel@intel.com>
   7  */
   8
   9 #include <linux/module.h>
  10 #include <net/xdp_sock.h>
  11 #include <linux/xdp_diag.h>
  12 #include <linux/sock_diag.h>
  13
  14 #include "xsk_queue.h"
  15 #include "xsk.h"
  16
  17 static int xsk_diag_put_info(const struct xdp_sock *xs, struct sk_buff *nlskb)
  18 {
  19         struct xdp_diag_info di = {};
  20
  21         di.ifindex = xs->dev ? xs->dev->ifindex : 0;
  22         di.queue_id = xs->queue_id;
  23         return nla_put(nlskb, XDP_DIAG_INFO, sizeof(di), &di);
  24 }
  25
  26 static int xsk_diag_put_ring(const struct xsk_queue *queue, int nl_type,
  27                              struct sk_buff *nlskb)
  28 {
  29         struct xdp_diag_ring dr = {};
  30
  31         dr.entries = queue->nentries;
  32         return nla_put(nlskb, nl_type, sizeof(dr), &dr);
  33 }
  34
  35 static int xsk_diag_put_rings_cfg(const struct xdp_sock *xs,
  36                                   struct sk_buff *nlskb)
  37 {
  38         int err = 0;
  39
  40         if (xs->rx)
  41                 err = xsk_diag_put_ring(xs->rx, XDP_DIAG_RX_RING, nlskb);
  42         if (!err && xs->tx)
  43                 err = xsk_diag_put_ring(xs->tx, XDP_DIAG_TX_RING, nlskb);
  44         return err;
  45 }
  46
  47 static int xsk_diag_put_umem(const struct xdp_sock *xs, struct sk_buff *nlskb)
  48 {
  49         struct xsk_buff_pool *pool = xs->pool;
  50         struct xdp_umem *umem = xs->umem;
  51         struct xdp_diag_umem du = {};
  52         int err;
  53
  54         if (!umem)
  55                 return 0;
  56
  57         du.id = umem->id;
  58         du.size = umem->size;
  59         du.num_pages = umem->npgs;
  60         du.chunk_size = umem->chunk_size;
  61         du.headroom = umem->headroom;
  62         du.ifindex = (pool && pool->netdev) ? pool->netdev->ifindex : 0;
  63         du.queue_id = pool ? pool->queue_id : 0;
  64         du.flags = 0;
  65         if (umem->zc)
  66                 du.flags |= XDP_DU_F_ZEROCOPY;
  67         du.refs = refcount_read(&umem->users);
  68
  69         err = nla_put(nlskb, XDP_DIAG_UMEM, sizeof(du), &du);
  70         if (!err && pool && pool->fq)
  71                 err = xsk_diag_put_ring(pool->fq,
  72                                         XDP_DIAG_UMEM_FILL_RING, nlskb);
  73         if (!err && pool && pool->cq)
  74                 err = xsk_diag_put_ring(pool->cq,
  75                                         XDP_DIAG_UMEM_COMPLETION_RING, nlskb);
  76         return err;
  77 }
  78
  79 static int xsk_diag_put_stats(const struct xdp_sock *xs, struct sk_buff *nlskb)
  80 {
  81         struct xdp_diag_stats du = {};
  82
  83         du.n_rx_dropped = xs->rx_dropped;
  84         du.n_rx_invalid = xskq_nb_invalid_descs(xs->rx);
  85         du.n_rx_full = xs->rx_queue_full;
  86         du.n_fill_ring_empty = xs->pool ? xskq_nb_queue_empty_descs(xs->pool->fq) : 0;
  87         du.n_tx_invalid = xskq_nb_invalid_descs(xs->tx);
  88         du.n_tx_ring_empty = xskq_nb_queue_empty_descs(xs->tx);
  89         return nla_put(nlskb, XDP_DIAG_STATS, sizeof(du), &du);
  90 }
  91
  92 static int xsk_diag_fill(struct sock *sk, struct sk_buff *nlskb,
  93                          struct xdp_diag_req *req,
  94                          struct user_namespace *user_ns,
  95                          u32 portid, u32 seq, u32 flags, int sk_ino)
  96 {
  97         struct xdp_sock *xs = xdp_sk(sk);
  98         struct xdp_diag_msg *msg;
  99         struct nlmsghdr *nlh;
 100
 101         nlh = nlmsg_put(nlskb, portid, seq, SOCK_DIAG_BY_FAMILY, sizeof(*msg),
 102                         flags);
 103         if (!nlh)
 104                 return -EMSGSIZE;
 105
 106         msg = nlmsg_data(nlh);
 107         memset(msg, 0, sizeof(*msg));
 108         msg->xdiag_family = AF_XDP;
 109         msg->xdiag_type = sk->sk_type;
 110         msg->xdiag_ino = sk_ino;
 111         sock_diag_save_cookie(sk, msg->xdiag_cookie);
 112
 113         mutex_lock(&xs->mutex);
 114         if (READ_ONCE(xs->state) == XSK_UNBOUND)
 115                 goto out_nlmsg_trim;
 116
 117         if ((req->xdiag_show & XDP_SHOW_INFO) && xsk_diag_put_info(xs, nlskb))
 118                 goto out_nlmsg_trim;
 119
 120         if ((req->xdiag_show & XDP_SHOW_INFO) &&
 121             nla_put_u32(nlskb, XDP_DIAG_UID,
 122                         from_kuid_munged(user_ns, sock_i_uid(sk))))
 123                 goto out_nlmsg_trim;
 124
 125         if ((req->xdiag_show & XDP_SHOW_RING_CFG) &&
 126             xsk_diag_put_rings_cfg(xs, nlskb))
 127                 goto out_nlmsg_trim;
 128
 129         if ((req->xdiag_show & XDP_SHOW_UMEM) &&
 130             xsk_diag_put_umem(xs, nlskb))
 131                 goto out_nlmsg_trim;
 132
 133         if ((req->xdiag_show & XDP_SHOW_MEMINFO) &&
 134             sock_diag_put_meminfo(sk, nlskb, XDP_DIAG_MEMINFO))
 135                 goto out_nlmsg_trim;
 136
 137         if ((req->xdiag_show & XDP_SHOW_STATS) &&
 138             xsk_diag_put_stats(xs, nlskb))
 139                 goto out_nlmsg_trim;
 140
 141         mutex_unlock(&xs->mutex);
 142         nlmsg_end(nlskb, nlh);
 143         return 0;
 144
 145 out_nlmsg_trim:
 146         mutex_unlock(&xs->mutex);
 147         nlmsg_cancel(nlskb, nlh);
 148         return -EMSGSIZE;
 149 }
 150
 151 static int xsk_diag_dump(struct sk_buff *nlskb, struct netlink_callback *cb)
 152 {
 153         struct xdp_diag_req *req = nlmsg_data(cb->nlh);
 154         struct net *net = sock_net(nlskb->sk);
 155         int num = 0, s_num = cb->args[0];
 156         struct sock *sk;
 157
 158         mutex_lock(&net->xdp.lock);
 159
 160         sk_for_each(sk, &net->xdp.list) {
 161                 if (!net_eq(sock_net(sk), net))
 162                         continue;
 163                 if (num++ < s_num)
 164                         continue;
 165
 166                 if (xsk_diag_fill(sk, nlskb, req,
 167                                   sk_user_ns(NETLINK_CB(cb->skb).sk),
 168                                   NETLINK_CB(cb->skb).portid,
 169                                   cb->nlh->nlmsg_seq, NLM_F_MULTI,
 170                                   sock_i_ino(sk)) < 0) {
 171                         num--;
 172                         break;
 173                 }
 174         }
 175
 176         mutex_unlock(&net->xdp.lock);
 177         cb->args[0] = num;
 178         return nlskb->len;
 179 }
 180
 181 static int xsk_diag_handler_dump(struct sk_buff *nlskb, struct nlmsghdr *hdr)
 182 {
 183         struct netlink_dump_control c = { .dump = xsk_diag_dump };
 184         int hdrlen = sizeof(struct xdp_diag_req);
 185         struct net *net = sock_net(nlskb->sk);
 186
 187         if (nlmsg_len(hdr) < hdrlen)
 188                 return -EINVAL;
 189
 190         if (!(hdr->nlmsg_flags & NLM_F_DUMP))
 191                 return -EOPNOTSUPP;
 192
 193         return netlink_dump_start(net->diag_nlsk, nlskb, hdr, &c);
 194 }
 195
 196 static const struct sock_diag_handler xsk_diag_handler = {
 197         .owner = THIS_MODULE,
 198         .family = AF_XDP,
 199         .dump = xsk_diag_handler_dump,
 200 };
 201
 202 static int __init xsk_diag_init(void)
 203 {
 204         return sock_diag_register(&xsk_diag_handler);
 205 }
 206
 207 static void __exit xsk_diag_exit(void)
 208 {
 209         sock_diag_unregister(&xsk_diag_handler);
 210 }
 211
 212 module_init(xsk_diag_init);
 213 module_exit(xsk_diag_exit);
 214 MODULE_LICENSE("GPL");
 215 MODULE_DESCRIPTION("XDP socket monitoring via SOCK_DIAG");
 216 MODULE_ALIAS_NET_PF_PROTO_TYPE(PF_NETLINK, NETLINK_SOCK_DIAG, AF_XDP);