net/l2tp/l2tp_debugfs.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * L2TP subsystem debugfs
   4  *
   5  * Copyright (c) 2010 Katalix Systems Ltd
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9
  10 #include <linux/module.h>
  11 #include <linux/skbuff.h>
  12 #include <linux/socket.h>
  13 #include <linux/hash.h>
  14 #include <linux/l2tp.h>
  15 #include <linux/in.h>
  16 #include <linux/etherdevice.h>
  17 #include <linux/spinlock.h>
  18 #include <linux/debugfs.h>
  19 #include <net/sock.h>
  20 #include <net/ip.h>
  21 #include <net/icmp.h>
  22 #include <net/udp.h>
  23 #include <net/inet_common.h>
  24 #include <net/inet_hashtables.h>
  25 #include <net/tcp_states.h>
  26 #include <net/protocol.h>
  27 #include <net/xfrm.h>
  28 #include <net/net_namespace.h>
  29 #include <net/netns/generic.h>
  30
  31 #include "l2tp_core.h"
  32
  33 static struct dentry *rootdir;
  34
  35 struct l2tp_dfs_seq_data {
  36         struct net *net;
  37         int tunnel_idx;                 /* current tunnel */
  38         int session_idx;                /* index of session within current tunnel */
  39         struct l2tp_tunnel *tunnel;
  40         struct l2tp_session *session;   /* NULL means get next tunnel */
  41 };
  42
  43 static void l2tp_dfs_next_tunnel(struct l2tp_dfs_seq_data *pd)
  44 {
  45         /* Drop reference taken during previous invocation */
  46         if (pd->tunnel)
  47                 l2tp_tunnel_dec_refcount(pd->tunnel);
  48
  49         pd->tunnel = l2tp_tunnel_get_nth(pd->net, pd->tunnel_idx);
  50         pd->tunnel_idx++;
  51 }
  52
  53 static void l2tp_dfs_next_session(struct l2tp_dfs_seq_data *pd)
  54 {
  55         /* Drop reference taken during previous invocation */
  56         if (pd->session)
  57                 l2tp_session_dec_refcount(pd->session);
  58
  59         pd->session = l2tp_session_get_nth(pd->tunnel, pd->session_idx);
  60         pd->session_idx++;
  61
  62         if (pd->session == NULL) {
  63                 pd->session_idx = 0;
  64                 l2tp_dfs_next_tunnel(pd);
  65         }
  66 }
  67
  68 static void *l2tp_dfs_seq_start(struct seq_file *m, loff_t *offs)
  69 {
  70         struct l2tp_dfs_seq_data *pd = SEQ_START_TOKEN;
  71         loff_t pos = *offs;
  72
  73         if (!pos)
  74                 goto out;
  75
  76         BUG_ON(m->private == NULL);
  77         pd = m->private;
  78
  79         if (pd->tunnel == NULL)
  80                 l2tp_dfs_next_tunnel(pd);
  81         else
  82                 l2tp_dfs_next_session(pd);
  83
  84         /* NULL tunnel and session indicates end of list */
  85         if ((pd->tunnel == NULL) && (pd->session == NULL))
  86                 pd = NULL;
  87
  88 out:
  89         return pd;
  90 }
  91
  92 static void *l2tp_dfs_seq_next(struct seq_file *m, void *v, loff_t *pos)
  93 {
  94         (*pos)++;
  95         return NULL;
  96 }
  97
  98 static void l2tp_dfs_seq_stop(struct seq_file *p, void *v)
  99 {
 100         struct l2tp_dfs_seq_data *pd = v;
 101
 102         if (!pd || pd == SEQ_START_TOKEN)
 103                 return;
 104
 105         /* Drop reference taken by last invocation of l2tp_dfs_next_session()
 106          * or l2tp_dfs_next_tunnel().
 107          */
 108         if (pd->session) {
 109                 l2tp_session_dec_refcount(pd->session);
 110                 pd->session = NULL;
 111         }
 112         if (pd->tunnel) {
 113                 l2tp_tunnel_dec_refcount(pd->tunnel);
 114                 pd->tunnel = NULL;
 115         }
 116 }
 117
 118 static void l2tp_dfs_seq_tunnel_show(struct seq_file *m, void *v)
 119 {
 120         struct l2tp_tunnel *tunnel = v;
 121         int session_count = 0;
 122         int hash;
 123         struct hlist_node *walk;
 124         struct hlist_node *tmp;
 125
 126         read_lock_bh(&tunnel->hlist_lock);
 127         for (hash = 0; hash < L2TP_HASH_SIZE; hash++) {
 128                 hlist_for_each_safe(walk, tmp, &tunnel->session_hlist[hash]) {
 129                         struct l2tp_session *session;
 130
 131                         session = hlist_entry(walk, struct l2tp_session, hlist);
 132                         if (session->session_id == 0)
 133                                 continue;
 134
 135                         session_count++;
 136                 }
 137         }
 138         read_unlock_bh(&tunnel->hlist_lock);
 139
 140         seq_printf(m, "\nTUNNEL %u peer %u", tunnel->tunnel_id, tunnel->peer_tunnel_id);
 141         if (tunnel->sock) {
 142                 struct inet_sock *inet = inet_sk(tunnel->sock);
 143
 144 #if IS_ENABLED(CONFIG_IPV6)
 145                 if (tunnel->sock->sk_family == AF_INET6) {
 146                         const struct ipv6_pinfo *np = inet6_sk(tunnel->sock);
 147
 148                         seq_printf(m, " from %pI6c to %pI6c\n",
 149                                 &np->saddr, &tunnel->sock->sk_v6_daddr);
 150                 } else
 151 #endif
 152                 seq_printf(m, " from %pI4 to %pI4\n",
 153                            &inet->inet_saddr, &inet->inet_daddr);
 154                 if (tunnel->encap == L2TP_ENCAPTYPE_UDP)
 155                         seq_printf(m, " source port %hu, dest port %hu\n",
 156                                    ntohs(inet->inet_sport), ntohs(inet->inet_dport));
 157         }
 158         seq_printf(m, " L2TPv%d, %s\n", tunnel->version,
 159                    tunnel->encap == L2TP_ENCAPTYPE_UDP ? "UDP" :
 160                    tunnel->encap == L2TP_ENCAPTYPE_IP ? "IP" :
 161                    "");
 162         seq_printf(m, " %d sessions, refcnt %d/%d\n", session_count,
 163                    tunnel->sock ? refcount_read(&tunnel->sock->sk_refcnt) : 0,
 164                    refcount_read(&tunnel->ref_count));
 165         seq_printf(m, " %08x rx %ld/%ld/%ld rx %ld/%ld/%ld\n",
 166                    tunnel->debug,
 167                    atomic_long_read(&tunnel->stats.tx_packets),
 168                    atomic_long_read(&tunnel->stats.tx_bytes),
 169                    atomic_long_read(&tunnel->stats.tx_errors),
 170                    atomic_long_read(&tunnel->stats.rx_packets),
 171                    atomic_long_read(&tunnel->stats.rx_bytes),
 172                    atomic_long_read(&tunnel->stats.rx_errors));
 173 }
 174
 175 static void l2tp_dfs_seq_session_show(struct seq_file *m, void *v)
 176 {
 177         struct l2tp_session *session = v;
 178
 179         seq_printf(m, "  SESSION %u, peer %u, %s\n", session->session_id,
 180                    session->peer_session_id,
 181                    session->pwtype == L2TP_PWTYPE_ETH ? "ETH" :
 182                    session->pwtype == L2TP_PWTYPE_PPP ? "PPP" :
 183                    "");
 184         if (session->send_seq || session->recv_seq)
 185                 seq_printf(m, "   nr %hu, ns %hu\n", session->nr, session->ns);
 186         seq_printf(m, "   refcnt %d\n", refcount_read(&session->ref_count));
 187         seq_printf(m, "   config 0/0/%c/%c/-/%s %08x %u\n",
 188                    session->recv_seq ? 'R' : '-',
 189                    session->send_seq ? 'S' : '-',
 190                    session->lns_mode ? "LNS" : "LAC",
 191                    session->debug,
 192                    jiffies_to_msecs(session->reorder_timeout));
 193         seq_printf(m, "   offset 0 l2specific %hu/%hu\n",
 194                    session->l2specific_type, l2tp_get_l2specific_len(session));
 195         if (session->cookie_len) {
 196                 seq_printf(m, "   cookie %02x%02x%02x%02x",
 197                            session->cookie[0], session->cookie[1],
 198                            session->cookie[2], session->cookie[3]);
 199                 if (session->cookie_len == 8)
 200                         seq_printf(m, "%02x%02x%02x%02x",
 201                                    session->cookie[4], session->cookie[5],
 202                                    session->cookie[6], session->cookie[7]);
 203                 seq_printf(m, "\n");
 204         }
 205         if (session->peer_cookie_len) {
 206                 seq_printf(m, "   peer cookie %02x%02x%02x%02x",
 207                            session->peer_cookie[0], session->peer_cookie[1],
 208                            session->peer_cookie[2], session->peer_cookie[3]);
 209                 if (session->peer_cookie_len == 8)
 210                         seq_printf(m, "%02x%02x%02x%02x",
 211                                    session->peer_cookie[4], session->peer_cookie[5],
 212                                    session->peer_cookie[6], session->peer_cookie[7]);
 213                 seq_printf(m, "\n");
 214         }
 215
 216         seq_printf(m, "   %hu/%hu tx %ld/%ld/%ld rx %ld/%ld/%ld\n",
 217                    session->nr, session->ns,
 218                    atomic_long_read(&session->stats.tx_packets),
 219                    atomic_long_read(&session->stats.tx_bytes),
 220                    atomic_long_read(&session->stats.tx_errors),
 221                    atomic_long_read(&session->stats.rx_packets),
 222                    atomic_long_read(&session->stats.rx_bytes),
 223                    atomic_long_read(&session->stats.rx_errors));
 224
 225         if (session->show != NULL)
 226                 session->show(m, session);
 227 }
 228
 229 static int l2tp_dfs_seq_show(struct seq_file *m, void *v)
 230 {
 231         struct l2tp_dfs_seq_data *pd = v;
 232
 233         /* display header on line 1 */
 234         if (v == SEQ_START_TOKEN) {
 235                 seq_puts(m, "TUNNEL ID, peer ID from IP to IP\n");
 236                 seq_puts(m, " L2TPv2/L2TPv3, UDP/IP\n");
 237                 seq_puts(m, " sessions session-count, refcnt refcnt/sk->refcnt\n");
 238                 seq_puts(m, " debug tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
 239                 seq_puts(m, "  SESSION ID, peer ID, PWTYPE\n");
 240                 seq_puts(m, "   refcnt cnt\n");
 241                 seq_puts(m, "   offset OFFSET l2specific TYPE/LEN\n");
 242                 seq_puts(m, "   [ cookie ]\n");
 243                 seq_puts(m, "   [ peer cookie ]\n");
 244                 seq_puts(m, "   config mtu/mru/rcvseq/sendseq/dataseq/lns debug reorderto\n");
 245                 seq_puts(m, "   nr/ns tx-pkts/bytes/errs rx-pkts/bytes/errs\n");
 246                 goto out;
 247         }
 248
 249         if (!pd->session)
 250                 l2tp_dfs_seq_tunnel_show(m, pd->tunnel);
 251         else
 252                 l2tp_dfs_seq_session_show(m, pd->session);
 253
 254 out:
 255         return 0;
 256 }
 257
 258 static const struct seq_operations l2tp_dfs_seq_ops = {
 259         .start          = l2tp_dfs_seq_start,
 260         .next           = l2tp_dfs_seq_next,
 261         .stop           = l2tp_dfs_seq_stop,
 262         .show           = l2tp_dfs_seq_show,
 263 };
 264
 265 static int l2tp_dfs_seq_open(struct inode *inode, struct file *file)
 266 {
 267         struct l2tp_dfs_seq_data *pd;
 268         struct seq_file *seq;
 269         int rc = -ENOMEM;
 270
 271         pd = kzalloc(sizeof(*pd), GFP_KERNEL);
 272         if (pd == NULL)
 273                 goto out;
 274
 275         /* Derive the network namespace from the pid opening the
 276          * file.
 277          */
 278         pd->net = get_net_ns_by_pid(current->pid);
 279         if (IS_ERR(pd->net)) {
 280                 rc = PTR_ERR(pd->net);
 281                 goto err_free_pd;
 282         }
 283
 284         rc = seq_open(file, &l2tp_dfs_seq_ops);
 285         if (rc)
 286                 goto err_free_net;
 287
 288         seq = file->private_data;
 289         seq->private = pd;
 290
 291 out:
 292         return rc;
 293
 294 err_free_net:
 295         put_net(pd->net);
 296 err_free_pd:
 297         kfree(pd);
 298         goto out;
 299 }
 300
 301 static int l2tp_dfs_seq_release(struct inode *inode, struct file *file)
 302 {
 303         struct l2tp_dfs_seq_data *pd;
 304         struct seq_file *seq;
 305
 306         seq = file->private_data;
 307         pd = seq->private;
 308         if (pd->net)
 309                 put_net(pd->net);
 310         kfree(pd);
 311         seq_release(inode, file);
 312
 313         return 0;
 314 }
 315
 316 static const struct file_operations l2tp_dfs_fops = {
 317         .owner          = THIS_MODULE,
 318         .open           = l2tp_dfs_seq_open,
 319         .read           = seq_read,
 320         .llseek         = seq_lseek,
 321         .release        = l2tp_dfs_seq_release,
 322 };
 323
 324 static int __init l2tp_debugfs_init(void)
 325 {
 326         rootdir = debugfs_create_dir("l2tp", NULL);
 327
 328         debugfs_create_file("tunnels", 0600, rootdir, NULL, &l2tp_dfs_fops);
 329
 330         pr_info("L2TP debugfs support\n");
 331
 332         return 0;
 333 }
 334
 335 static void __exit l2tp_debugfs_exit(void)
 336 {
 337         debugfs_remove_recursive(rootdir);
 338 }
 339
 340 module_init(l2tp_debugfs_init);
 341 module_exit(l2tp_debugfs_exit);
 342
 343 MODULE_LICENSE("GPL");
 344 MODULE_AUTHOR("James Chapman <jchapman@katalix.com>");
 345 MODULE_DESCRIPTION("L2TP debugfs driver");
 346 MODULE_VERSION("1.0");