?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / net / 8021q / vlanproc.c
blob1b10cc8463ec58a436d463be7d0744b1dea58951
1 /* Modified by Broadcom Corp. Portions Copyright (c) Broadcom Corp, 2012. */
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 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version
16 * 2 of the License, or (at your option) any later version.
17 * ============================================================================
18 * Jan 20, 1998 Ben Greear Initial Version
19 *****************************************************************************/
20
21 #include <linux/module.h>
22 #include <linux/errno.h>
23 #include <linux/kernel.h>
24 #include <linux/string.h>
25 #include <linux/proc_fs.h>
26 #include <linux/seq_file.h>
27 #include <linux/fs.h>
28 #include <linux/netdevice.h>
29 #include <linux/if_vlan.h>
30 #include <net/net_namespace.h>
31 #include <net/netns/generic.h>
32 #include "vlanproc.h"
33 #include "vlan.h"
34
35 /****** Function Prototypes *************************************************/
36
37 /* Methods for preparing data for reading proc entries */
38 static int vlan_seq_show(struct seq_file *seq, void *v);
39 static void *vlan_seq_start(struct seq_file *seq, loff_t *pos);
40 static void *vlan_seq_next(struct seq_file *seq, void *v, loff_t *pos);
41 static void vlan_seq_stop(struct seq_file *seq, void *);
42 static int vlandev_seq_show(struct seq_file *seq, void *v);
43 #ifdef CONFIG_INET_GRO
44 static int gro_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos);
45 #endif /* CONFIG_INET_GRO */
46
47 /*
48 * Global Data
49 */
50
51
52 /*
53 * Names of the proc directory entries
54 */
55
56 static const char name_root[] = "vlan";
57 static const char name_conf[] = "config";
58
59 /*
60 * Structures for interfacing with the /proc filesystem.
61 * VLAN creates its own directory /proc/net/vlan with the folowing
62 * entries:
63 * config device status/configuration
64 * <device> entry for each device
65 */
66
67 /*
68 * Generic /proc/net/vlan/<file> file and inode operations
69 */
70
71 static const struct seq_operations vlan_seq_ops = {
72 .start = vlan_seq_start,
73 .next = vlan_seq_next,
74 .stop = vlan_seq_stop,
75 .show = vlan_seq_show,
76 };
77
78 static int vlan_seq_open(struct inode *inode, struct file *file)
79 {
80 return seq_open_net(inode, file, &vlan_seq_ops,
81 sizeof(struct seq_net_private));
82 }
83
84 static const struct file_operations vlan_fops = {
85 .owner = THIS_MODULE,
86 .open = vlan_seq_open,
87 .read = seq_read,
88 .llseek = seq_lseek,
89 .release = seq_release_net,
90 };
91
92 /*
93 * /proc/net/vlan/<device> file and inode operations
94 */
95
96 static int vlandev_seq_open(struct inode *inode, struct file *file)
97 {
98 return single_open(file, vlandev_seq_show, PDE(inode)->data);
99 }
100
101 #ifdef CONFIG_INET_GRO
102 extern atomic_t gro_timer_init;
103 static struct timer_list gro_timer;
104 spinlock_t gro_lock;
105 static int gro_timer_interval;
106 extern struct napi_struct gro_napi;
107
108 static void gro_watchdog(ulong data)
109 {
110 struct net_device *gro_dev = (struct net_device *)data;
111
112 if (gro_dev->features & NETIF_F_GRO) {
113 gro_timer.expires = jiffies + gro_timer_interval;
114 add_timer(&gro_timer);
115 }
116
117 spin_lock_bh(&gro_lock);
118 generic_napi_gro_flush(&gro_napi);
119 spin_unlock_bh(&gro_lock);
120 }
121
122 static int gro_write(struct file *file, const char __user *buf, size_t size, loff_t *ppos)
123 {
124 struct seq_file *seq = (struct seq_file *)file->private_data;
125 struct net_device *gro_dev = seq->private;
126
127 if (!atomic_read(&gro_timer_init)) {
128 spin_lock_init(&gro_lock);
129
130 init_timer(&gro_timer);
131 gro_timer.function = gro_watchdog;
132 atomic_set(&gro_timer_init, 1);
133 }
134
135 if (size < 5 || size > 8)
136 return -EINVAL;
137
138 if (strncmp(buf, "-gro", 4))
139 return -EINVAL;
140
141 sscanf(buf, "-gro %d", &gro_timer_interval);
142
143 if (gro_timer_interval > 0) {
144 gro_dev->features |= NETIF_F_GRO;
145 gro_timer.data = (ulong)gro_dev;
146 gro_timer.expires = jiffies + gro_timer_interval;
147 mod_timer(&gro_timer, jiffies + gro_timer_interval);
148 printk("\ngro enabled with interval %d\n", gro_timer_interval);
149 }
150 else {
151 gro_dev->features &= ~NETIF_F_GRO;
152 del_timer(&gro_timer);
153
154 /* flush packet */
155 gro_watchdog((ulong)gro_dev);
156 printk("\ngro disabled\n");
157 }
158
159 return size;
160 }
161 #endif /* CONFIG_INET_GRO */
162
163 static const struct file_operations vlandev_fops = {
164 .owner = THIS_MODULE,
165 .open = vlandev_seq_open,
166 .read = seq_read,
167 #ifdef CONFIG_INET_GRO
168 .write = gro_write,
169 #endif /* CONFIG_INET_GRO */
170 .llseek = seq_lseek,
171 .release = single_release,
172 };
173
174 /*
175 * Proc filesystem derectory entries.
176 */
177
178 /* Strings */
179 static const char *const vlan_name_type_str[VLAN_NAME_TYPE_HIGHEST] = {
180 [VLAN_NAME_TYPE_RAW_PLUS_VID] = "VLAN_NAME_TYPE_RAW_PLUS_VID",
181 [VLAN_NAME_TYPE_PLUS_VID_NO_PAD] = "VLAN_NAME_TYPE_PLUS_VID_NO_PAD",
182 [VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD] = "VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD",
183 [VLAN_NAME_TYPE_PLUS_VID] = "VLAN_NAME_TYPE_PLUS_VID",
184 };
185 /*
186 * Interface functions
187 */
188
189 /*
190 * Clean up /proc/net/vlan entries
191 */
192
193 void vlan_proc_cleanup(struct net *net)
194 {
195 struct vlan_net *vn = net_generic(net, vlan_net_id);
196
197 if (vn->proc_vlan_conf)
198 remove_proc_entry(name_conf, vn->proc_vlan_dir);
199
200 if (vn->proc_vlan_dir)
201 proc_net_remove(net, name_root);
202
203 /* Dynamically added entries should be cleaned up as their vlan_device
204 * is removed, so we should not have to take care of it here...
205 */
206 }
207
208 /*
209 * Create /proc/net/vlan entries
210 */
211
212 int __net_init vlan_proc_init(struct net *net)
213 {
214 struct vlan_net *vn = net_generic(net, vlan_net_id);
215
216 vn->proc_vlan_dir = proc_net_mkdir(net, name_root, net->proc_net);
217 if (!vn->proc_vlan_dir)
218 goto err;
219
220 vn->proc_vlan_conf = proc_create(name_conf, S_IFREG|S_IRUSR|S_IWUSR,
221 vn->proc_vlan_dir, &vlan_fops);
222 if (!vn->proc_vlan_conf)
223 goto err;
224 return 0;
225
226 err:
227 pr_err("%s: can't create entry in proc filesystem!\n", __func__);
228 vlan_proc_cleanup(net);
229 return -ENOBUFS;
230 }
231
232 /*
233 * Add directory entry for VLAN device.
234 */
235
236 int vlan_proc_add_dev(struct net_device *vlandev)
237 {
238 struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);
239 struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id);
240
241 dev_info->dent =
242 proc_create_data(vlandev->name, S_IFREG|S_IRUSR|S_IWUSR,
243 vn->proc_vlan_dir, &vlandev_fops, vlandev);
244 if (!dev_info->dent)
245 return -ENOBUFS;
246 return 0;
247 }
248
249 /*
250 * Delete directory entry for VLAN device.
251 */
252 int vlan_proc_rem_dev(struct net_device *vlandev)
253 {
254 struct vlan_net *vn = net_generic(dev_net(vlandev), vlan_net_id);
255
256 /** NOTE: This will consume the memory pointed to by dent, it seems. */
257 if (vlan_dev_info(vlandev)->dent) {
258 remove_proc_entry(vlan_dev_info(vlandev)->dent->name,
259 vn->proc_vlan_dir);
260 vlan_dev_info(vlandev)->dent = NULL;
261 }
262 return 0;
263 }
264
265 /****** Proc filesystem entry points ****************************************/
266
267 /*
268 * The following few functions build the content of /proc/net/vlan/config
269 */
270
271 /* start read of /proc/net/vlan/config */
272 static void *vlan_seq_start(struct seq_file *seq, loff_t *pos)
273 __acquires(rcu)
274 {
275 struct net_device *dev;
276 struct net *net = seq_file_net(seq);
277 loff_t i = 1;
278
279 rcu_read_lock();
280 if (*pos == 0)
281 return SEQ_START_TOKEN;
282
283 for_each_netdev_rcu(net, dev) {
284 if (!is_vlan_dev(dev))
285 continue;
286
287 if (i++ == *pos)
288 return dev;
289 }
290
291 return NULL;
292 }
293
294 static void *vlan_seq_next(struct seq_file *seq, void *v, loff_t *pos)
295 {
296 struct net_device *dev;
297 struct net *net = seq_file_net(seq);
298
299 ++*pos;
300
301 dev = (struct net_device *)v;
302 if (v == SEQ_START_TOKEN)
303 dev = net_device_entry(&net->dev_base_head);
304
305 for_each_netdev_continue_rcu(net, dev) {
306 if (!is_vlan_dev(dev))
307 continue;
308
309 return dev;
310 }
311
312 return NULL;
313 }
314
315 static void vlan_seq_stop(struct seq_file *seq, void *v)
316 __releases(rcu)
317 {
318 rcu_read_unlock();
319 }
320
321 static int vlan_seq_show(struct seq_file *seq, void *v)
322 {
323 struct net *net = seq_file_net(seq);
324 struct vlan_net *vn = net_generic(net, vlan_net_id);
325
326 if (v == SEQ_START_TOKEN) {
327 const char *nmtype = NULL;
328
329 seq_puts(seq, "VLAN Dev name | VLAN ID\n");
330
331 if (vn->name_type < ARRAY_SIZE(vlan_name_type_str))
332 nmtype = vlan_name_type_str[vn->name_type];
333
334 seq_printf(seq, "Name-Type: %s\n",
335 nmtype ? nmtype : "UNKNOWN");
336 } else {
337 const struct net_device *vlandev = v;
338 const struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);
339
340 seq_printf(seq, "%-15s| %d | %s\n", vlandev->name,
341 dev_info->vlan_id, dev_info->real_dev->name);
342 }
343 return 0;
344 }
345
346 static int vlandev_seq_show(struct seq_file *seq, void *offset)
347 {
348 struct net_device *vlandev = (struct net_device *) seq->private;
349 const struct vlan_dev_info *dev_info = vlan_dev_info(vlandev);
350 struct rtnl_link_stats64 temp;
351 const struct rtnl_link_stats64 *stats;
352 static const char fmt[] = "%30s %12lu\n";
353 static const char fmt64[] = "%30s %12llu\n";
354 int i;
355
356 if (!is_vlan_dev(vlandev))
357 return 0;
358
359 stats = dev_get_stats(vlandev, &temp);
360 seq_printf(seq,
361 "%s VID: %d REORDER_HDR: %i dev->priv_flags: %hx\n",
362 vlandev->name, dev_info->vlan_id,
363 (int)(dev_info->flags & 1), vlandev->priv_flags);
364
365 seq_printf(seq, fmt64, "total frames received", stats->rx_packets);
366 seq_printf(seq, fmt64, "total bytes received", stats->rx_bytes);
367 seq_printf(seq, fmt64, "Broadcast/Multicast Rcvd", stats->multicast);
368 seq_puts(seq, "\n");
369 seq_printf(seq, fmt64, "total frames transmitted", stats->tx_packets);
370 seq_printf(seq, fmt64, "total bytes transmitted", stats->tx_bytes);
371 seq_printf(seq, fmt, "total headroom inc",
372 dev_info->cnt_inc_headroom_on_tx);
373 seq_printf(seq, fmt, "total encap on xmit",
374 dev_info->cnt_encap_on_xmit);
375 seq_printf(seq, "Device: %s", dev_info->real_dev->name);
376 /* now show all PRIORITY mappings relating to this VLAN */
377 seq_printf(seq, "\nINGRESS priority mappings: "
378 "0:%u 1:%u 2:%u 3:%u 4:%u 5:%u 6:%u 7:%u\n",
379 dev_info->ingress_priority_map[0],
380 dev_info->ingress_priority_map[1],
381 dev_info->ingress_priority_map[2],
382 dev_info->ingress_priority_map[3],
383 dev_info->ingress_priority_map[4],
384 dev_info->ingress_priority_map[5],
385 dev_info->ingress_priority_map[6],
386 dev_info->ingress_priority_map[7]);
387
388 seq_printf(seq, " EGRESS priority mappings: ");
389 for (i = 0; i < 16; i++) {
390 const struct vlan_priority_tci_mapping *mp
391 = dev_info->egress_priority_map[i];
392 while (mp) {
393 seq_printf(seq, "%u:%hu ",
394 mp->priority, ((mp->vlan_qos >> 13) & 0x7));
395 mp = mp->next;
396 }
397 }
398 seq_puts(seq, "\n");
399
400 return 0;
401 }
Tomato firmware and modifications.