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, <greearb@candelatech.com> coppied from wanproc.c |
9 | * by: Gene Kozin <genek@compuserve.com> |
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, id: 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, id: vlan_net_id); |
114 | |
115 | vn->proc_vlan_dir = proc_net_mkdir(net, name: name_root, parent: 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(dev: vlandev); |
139 | struct vlan_net *vn = net_generic(net: dev_net(dev: vlandev), id: vlan_net_id); |
140 | |
141 | if (!strcmp(vlandev->name, name_conf)) |
142 | return -EINVAL; |
143 | vlan->dent = proc_create_single_data(name: vlandev->name, S_IFREG | 0600, |
144 | parent: vn->proc_vlan_dir, show: vlandev_seq_show, data: 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(dev: vlandev)->dent); |
157 | vlan_dev_priv(dev: 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, id: vlan_net_id); |
206 | |
207 | if (v == SEQ_START_TOKEN) { |
208 | const char *nmtype = NULL; |
209 | |
210 | seq_puts(m: seq, s: "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(m: seq, fmt: "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(dev: vlandev); |
220 | |
221 | seq_printf(m: seq, fmt: "%-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(dev: 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(dev: vlandev)) |
237 | return 0; |
238 | |
239 | stats = dev_get_stats(dev: vlandev, storage: &temp); |
240 | seq_printf(m: seq, |
241 | fmt: "%s VID: %d REORDER_HDR: %i dev->priv_flags: %llx\n" , |
242 | vlandev->name, vlan->vlan_id, |
243 | (int)(vlan->flags & 1), vlandev->priv_flags); |
244 | |
245 | seq_printf(m: seq, fmt: fmt64, "total frames received" , stats->rx_packets); |
246 | seq_printf(m: seq, fmt: fmt64, "total bytes received" , stats->rx_bytes); |
247 | seq_printf(m: seq, fmt: fmt64, "Broadcast/Multicast Rcvd" , stats->multicast); |
248 | seq_puts(m: seq, s: "\n" ); |
249 | seq_printf(m: seq, fmt: fmt64, "total frames transmitted" , stats->tx_packets); |
250 | seq_printf(m: seq, fmt: fmt64, "total bytes transmitted" , stats->tx_bytes); |
251 | seq_printf(m: seq, fmt: "Device: %s" , vlan->real_dev->name); |
252 | /* now show all PRIORITY mappings relating to this VLAN */ |
253 | seq_printf(m: seq, fmt: "\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(m: seq, fmt: " 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(m: seq, fmt: "%u:%d " , |
270 | mp->priority, ((mp->vlan_qos >> 13) & 0x7)); |
271 | mp = mp->next; |
272 | } |
273 | } |
274 | seq_puts(m: seq, s: "\n" ); |
275 | |
276 | return 0; |
277 | } |
278 | |