net/8021q/vlanproc.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /******************************************************************************
   3  * vlanproc.c   VLAN Module. /proc filesystem interface.
   4  *
   5  *              This module is completely hardware-independent and provides
   6  *              access to the router using Linux /proc filesystem.
   7  *
   8  * Author:      Ben Greear, <[email protected]> coppied from wanproc.c
   9  *               by: Gene Kozin <[email protected]>
  10  *
  11  * Copyright:   (c) 1998 Ben Greear
  12  *
  13  * ============================================================================
  14  * Jan 20, 1998        Ben Greear     Initial Version
  15  *****************************************************************************/
  16
  17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19 #include <linux/module.h>
  20 #include <linux/errno.h>
  21 #include <linux/kernel.h>
  22 #include <linux/string.h>
  23 #include <linux/proc_fs.h>
  24 #include <linux/seq_file.h>
  25 #include <linux/fs.h>
  26 #include <linux/netdevice.h>
  27 #include <linux/if_vlan.h>
  28 #include <net/net_namespace.h>
  29 #include <net/netns/generic.h>
  30 #include "vlanproc.h"
  31 #include "vlan.h"
  32
  33 /****** Function Prototypes *************************************************/
  34
  35 /* Methods for preparing data for reading proc entries */
  36 static int vlan_seq_show(struct seq_file *seq, void *v);
  37 static void *vlan_seq_start(struct seq_file *seq, loff_t *pos);
  38 static void *vlan_seq_next(struct seq_file *seq, void *v, loff_t *pos);
  39 static void vlan_seq_stop(struct seq_file *seq, void *);
  40 static int vlandev_seq_show(struct seq_file *seq, void *v);
  41
  42 /*
  43  *      Global Data
  44  */
  45
  46
  47 /*
  48  *      Names of the proc directory entries
  49  */
  50
  51 static const char name_root[]    = "vlan";
  52 static const char name_conf[]    = "config";
  53
  54 /*
  55  *      Structures for interfacing with the /proc filesystem.
  56  *      VLAN creates its own directory /proc/net/vlan with the following
  57  *      entries:
  58  *      config          device status/configuration
  59  *      <device>        entry for each  device
  60  */
  61
  62 /*
  63  *      Generic /proc/net/vlan/<file> file and inode operations
  64  */
  65
  66 static const struct seq_operations vlan_seq_ops = {
  67         .start = vlan_seq_start,
  68         .next = vlan_seq_next,
  69         .stop = vlan_seq_stop,
  70         .show = vlan_seq_show,
  71 };
  72
  73 /*
  74  * Proc filesystem directory entries.
  75  */
  76
  77 /* Strings */
  78 static const char *const vlan_name_type_str[VLAN_NAME_TYPE_HIGHEST] = {
  79     [VLAN_NAME_TYPE_RAW_PLUS_VID]        = "VLAN_NAME_TYPE_RAW_PLUS_VID",
  80     [VLAN_NAME_TYPE_PLUS_VID_NO_PAD]     = "VLAN_NAME_TYPE_PLUS_VID_NO_PAD",
  81     [VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD] = "VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD",
  82     [VLAN_NAME_TYPE_PLUS_VID]            = "VLAN_NAME_TYPE_PLUS_VID",
  83 };
  84 /*
  85  *      Interface functions
  86  */
  87
  88 /*
  89  *      Clean up /proc/net/vlan entries
  90  */
  91
  92 void vlan_proc_cleanup(struct net *net)
  93 {
  94         struct vlan_net *vn = net_generic(net, vlan_net_id);
  95
  96         if (vn->proc_vlan_conf)
  97                 remove_proc_entry(name_conf, vn->proc_vlan_dir);
  98
  99         if (vn->proc_vlan_dir)
 100                 remove_proc_entry(name_root, net->proc_net);
 101
 102         /* Dynamically added entries should be cleaned up as their vlan_device
 103          * is removed, so we should not have to take care of it here...
 104          */
 105 }
 106
 107 /*
 108  *      Create /proc/net/vlan entries
 109  */
 110
 111 int __net_init vlan_proc_init(struct net *net)
 112 {
 113         struct vlan_net *vn = net_generic(net, vlan_net_id);
 114
 115         vn->proc_vlan_dir = proc_net_mkdir(net, name_root, net->proc_net);
 116         if (!vn->proc_vlan_dir)
 117                 goto err;
 118
 119         vn->proc_vlan_conf = proc_create_net(name_conf, S_IFREG | 0600,
 120                         vn->proc_vlan_dir, &vlan_seq_ops,
 121                         sizeof(struct seq_net_private));
 122         if (!vn->proc_vlan_conf)
 123                 goto err;
 124         return 0;
 125
 126 err:
 127         pr_err("can't create entry in proc filesystem!\n");
 128         vlan_proc_cleanup(net);
 129         return -ENOBUFS;
 130 }
 131
 132 /*
 133  *      Add directory entry for VLAN device.
 134  */
 135
 136 int vlan_proc_add_dev(struct net_device *vlandev)
 137 {
 138         struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);
 139         struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id);
 140
 141         if (!strcmp(vlandev->name, name_conf))
 142                 return -EINVAL;
 143         vlan->dent = proc_create_single_data(vlandev->name, S_IFREG | 0600,
 144                         vn->proc_vlan_dir, vlandev_seq_show, vlandev);
 145         if (!vlan->dent)
 146                 return -ENOBUFS;
 147         return 0;
 148 }
 149
 150 /*
 151  *      Delete directory entry for VLAN device.
 152  */
 153 void vlan_proc_rem_dev(struct net_device *vlandev)
 154 {
 155         /** NOTE:  This will consume the memory pointed to by dent, it seems. */
 156         proc_remove(vlan_dev_priv(vlandev)->dent);
 157         vlan_dev_priv(vlandev)->dent = NULL;
 158 }
 159
 160 /****** Proc filesystem entry points ****************************************/
 161
 162 /*
 163  * The following few functions build the content of /proc/net/vlan/config
 164  */
 165
 166 static void *vlan_seq_from_index(struct seq_file *seq, loff_t *pos)
 167 {
 168         unsigned long ifindex = *pos;
 169         struct net_device *dev;
 170
 171         for_each_netdev_dump(seq_file_net(seq), dev, ifindex) {
 172                 if (!is_vlan_dev(dev))
 173                         continue;
 174                 *pos = dev->ifindex;
 175                 return dev;
 176         }
 177         return NULL;
 178 }
 179
 180 static void *vlan_seq_start(struct seq_file *seq, loff_t *pos)
 181         __acquires(rcu)
 182 {
 183         rcu_read_lock();
 184         if (*pos == 0)
 185                 return SEQ_START_TOKEN;
 186
 187         return vlan_seq_from_index(seq, pos);
 188 }
 189
 190 static void *vlan_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 191 {
 192         ++*pos;
 193         return vlan_seq_from_index(seq, pos);
 194 }
 195
 196 static void vlan_seq_stop(struct seq_file *seq, void *v)
 197         __releases(rcu)
 198 {
 199         rcu_read_unlock();
 200 }
 201
 202 static int vlan_seq_show(struct seq_file *seq, void *v)
 203 {
 204         struct net *net = seq_file_net(seq);
 205         struct vlan_net *vn = net_generic(net, vlan_net_id);
 206
 207         if (v == SEQ_START_TOKEN) {
 208                 const char *nmtype = NULL;
 209
 210                 seq_puts(seq, "VLAN Dev name     | VLAN ID\n");
 211
 212                 if (vn->name_type < ARRAY_SIZE(vlan_name_type_str))
 213                     nmtype =  vlan_name_type_str[vn->name_type];
 214
 215                 seq_printf(seq, "Name-Type: %s\n",
 216                            nmtype ? nmtype :  "UNKNOWN");
 217         } else {
 218                 const struct net_device *vlandev = v;
 219                 const struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);
 220
 221                 seq_printf(seq, "%-15s| %d  | %s\n",  vlandev->name,
 222                            vlan->vlan_id,    vlan->real_dev->name);
 223         }
 224         return 0;
 225 }
 226
 227 static int vlandev_seq_show(struct seq_file *seq, void *offset)
 228 {
 229         struct net_device *vlandev = (struct net_device *) seq->private;
 230         const struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);
 231         struct rtnl_link_stats64 temp;
 232         const struct rtnl_link_stats64 *stats;
 233         static const char fmt64[] = "%30s %12llu\n";
 234         int i;
 235
 236         if (!is_vlan_dev(vlandev))
 237                 return 0;
 238
 239         stats = dev_get_stats(vlandev, &temp);
 240         seq_printf(seq,
 241                    "%s  VID: %d  REORDER_HDR: %i  dev->priv_flags: %x\n",
 242                    vlandev->name, vlan->vlan_id,
 243                    (int)(vlan->flags & 1), (u32)vlandev->priv_flags);
 244
 245         seq_printf(seq, fmt64, "total frames received", stats->rx_packets);
 246         seq_printf(seq, fmt64, "total bytes received", stats->rx_bytes);
 247         seq_printf(seq, fmt64, "Broadcast/Multicast Rcvd", stats->multicast);
 248         seq_puts(seq, "\n");
 249         seq_printf(seq, fmt64, "total frames transmitted", stats->tx_packets);
 250         seq_printf(seq, fmt64, "total bytes transmitted", stats->tx_bytes);
 251         seq_printf(seq, "Device: %s", vlan->real_dev->name);
 252         /* now show all PRIORITY mappings relating to this VLAN */
 253         seq_printf(seq, "\nINGRESS priority mappings: "
 254                         "0:%u  1:%u  2:%u  3:%u  4:%u  5:%u  6:%u 7:%u\n",
 255                    vlan->ingress_priority_map[0],
 256                    vlan->ingress_priority_map[1],
 257                    vlan->ingress_priority_map[2],
 258                    vlan->ingress_priority_map[3],
 259                    vlan->ingress_priority_map[4],
 260                    vlan->ingress_priority_map[5],
 261                    vlan->ingress_priority_map[6],
 262                    vlan->ingress_priority_map[7]);
 263
 264         seq_printf(seq, " EGRESS priority mappings: ");
 265         for (i = 0; i < 16; i++) {
 266                 const struct vlan_priority_tci_mapping *mp
 267                         = vlan->egress_priority_map[i];
 268                 while (mp) {
 269                         seq_printf(seq, "%u:%d ",
 270                                    mp->priority, ((mp->vlan_qos >> 13) & 0x7));
 271                         mp = mp->next;
 272                 }
 273         }
 274         seq_puts(seq, "\n");
 275
 276         return 0;
 277 }