?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
added 2.6.29.6 aldebaran kernel
[nao-ulib.git] / kernel / 2.6.29.6-aldebaran-rt / drivers / net / veth.c
blob124fe75b8a8a964928092b3d42c397fa847ac943
1 /*
2 * drivers/net/veth.c
3 *
4 * Copyright (C) 2007 OpenVZ http://openvz.org, SWsoft Inc
5 *
6 * Author: Pavel Emelianov <xemul@openvz.org>
7 * Ethtool interface from: Eric W. Biederman <ebiederm@xmission.com>
8 *
9 */
10
11 #include <linux/netdevice.h>
12 #include <linux/ethtool.h>
13 #include <linux/etherdevice.h>
14
15 #include <net/dst.h>
16 #include <net/xfrm.h>
17 #include <linux/veth.h>
18
19 #define DRV_NAME "veth"
20 #define DRV_VERSION "1.0"
21
22 struct veth_net_stats {
23 unsigned long rx_packets;
24 unsigned long tx_packets;
25 unsigned long rx_bytes;
26 unsigned long tx_bytes;
27 unsigned long tx_dropped;
28 };
29
30 struct veth_priv {
31 struct net_device *peer;
32 struct veth_net_stats *stats;
33 unsigned ip_summed;
34 };
35
36 /*
37 * ethtool interface
38 */
39
40 static struct {
41 const char string[ETH_GSTRING_LEN];
42 } ethtool_stats_keys[] = {
43 { "peer_ifindex" },
44 };
45
46 static int veth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
47 {
48 cmd->supported = 0;
49 cmd->advertising = 0;
50 cmd->speed = SPEED_10000;
51 cmd->duplex = DUPLEX_FULL;
52 cmd->port = PORT_TP;
53 cmd->phy_address = 0;
54 cmd->transceiver = XCVR_INTERNAL;
55 cmd->autoneg = AUTONEG_DISABLE;
56 cmd->maxtxpkt = 0;
57 cmd->maxrxpkt = 0;
58 return 0;
59 }
60
61 static void veth_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
62 {
63 strcpy(info->driver, DRV_NAME);
64 strcpy(info->version, DRV_VERSION);
65 strcpy(info->fw_version, "N/A");
66 }
67
68 static void veth_get_strings(struct net_device *dev, u32 stringset, u8 *buf)
69 {
70 switch(stringset) {
71 case ETH_SS_STATS:
72 memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys));
73 break;
74 }
75 }
76
77 static int veth_get_sset_count(struct net_device *dev, int sset)
78 {
79 switch (sset) {
80 case ETH_SS_STATS:
81 return ARRAY_SIZE(ethtool_stats_keys);
82 default:
83 return -EOPNOTSUPP;
84 }
85 }
86
87 static void veth_get_ethtool_stats(struct net_device *dev,
88 struct ethtool_stats *stats, u64 *data)
89 {
90 struct veth_priv *priv;
91
92 priv = netdev_priv(dev);
93 data[0] = priv->peer->ifindex;
94 }
95
96 static u32 veth_get_rx_csum(struct net_device *dev)
97 {
98 struct veth_priv *priv;
99
100 priv = netdev_priv(dev);
101 return priv->ip_summed == CHECKSUM_UNNECESSARY;
102 }
103
104 static int veth_set_rx_csum(struct net_device *dev, u32 data)
105 {
106 struct veth_priv *priv;
107
108 priv = netdev_priv(dev);
109 priv->ip_summed = data ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE;
110 return 0;
111 }
112
113 static u32 veth_get_tx_csum(struct net_device *dev)
114 {
115 return (dev->features & NETIF_F_NO_CSUM) != 0;
116 }
117
118 static int veth_set_tx_csum(struct net_device *dev, u32 data)
119 {
120 if (data)
121 dev->features |= NETIF_F_NO_CSUM;
122 else
123 dev->features &= ~NETIF_F_NO_CSUM;
124 return 0;
125 }
126
127 static struct ethtool_ops veth_ethtool_ops = {
128 .get_settings = veth_get_settings,
129 .get_drvinfo = veth_get_drvinfo,
130 .get_link = ethtool_op_get_link,
131 .get_rx_csum = veth_get_rx_csum,
132 .set_rx_csum = veth_set_rx_csum,
133 .get_tx_csum = veth_get_tx_csum,
134 .set_tx_csum = veth_set_tx_csum,
135 .get_sg = ethtool_op_get_sg,
136 .set_sg = ethtool_op_set_sg,
137 .get_strings = veth_get_strings,
138 .get_sset_count = veth_get_sset_count,
139 .get_ethtool_stats = veth_get_ethtool_stats,
140 };
141
142 /*
143 * xmit
144 */
145
146 static int veth_xmit(struct sk_buff *skb, struct net_device *dev)
147 {
148 struct net_device *rcv = NULL;
149 struct veth_priv *priv, *rcv_priv;
150 struct veth_net_stats *stats;
151 int length, cpu;
152
153 skb_orphan(skb);
154
155 priv = netdev_priv(dev);
156 rcv = priv->peer;
157 rcv_priv = netdev_priv(rcv);
158
159 cpu = smp_processor_id();
160 stats = per_cpu_ptr(priv->stats, cpu);
161
162 if (!(rcv->flags & IFF_UP))
163 goto outf;
164
165 skb->pkt_type = PACKET_HOST;
166 skb->protocol = eth_type_trans(skb, rcv);
167 if (dev->features & NETIF_F_NO_CSUM)
168 skb->ip_summed = rcv_priv->ip_summed;
169
170 dst_release(skb->dst);
171 skb->dst = NULL;
172 skb->mark = 0;
173 secpath_reset(skb);
174 nf_reset(skb);
175
176 length = skb->len;
177
178 stats->tx_bytes += length;
179 stats->tx_packets++;
180
181 stats = per_cpu_ptr(rcv_priv->stats, cpu);
182 stats->rx_bytes += length;
183 stats->rx_packets++;
184
185 netif_rx(skb);
186 return 0;
187
188 outf:
189 kfree_skb(skb);
190 stats->tx_dropped++;
191 return 0;
192 }
193
194 /*
195 * general routines
196 */
197
198 static struct net_device_stats *veth_get_stats(struct net_device *dev)
199 {
200 struct veth_priv *priv;
201 struct net_device_stats *dev_stats;
202 int cpu;
203 struct veth_net_stats *stats;
204
205 priv = netdev_priv(dev);
206 dev_stats = &dev->stats;
207
208 dev_stats->rx_packets = 0;
209 dev_stats->tx_packets = 0;
210 dev_stats->rx_bytes = 0;
211 dev_stats->tx_bytes = 0;
212 dev_stats->tx_dropped = 0;
213
214 for_each_online_cpu(cpu) {
215 stats = per_cpu_ptr(priv->stats, cpu);
216
217 dev_stats->rx_packets += stats->rx_packets;
218 dev_stats->tx_packets += stats->tx_packets;
219 dev_stats->rx_bytes += stats->rx_bytes;
220 dev_stats->tx_bytes += stats->tx_bytes;
221 dev_stats->tx_dropped += stats->tx_dropped;
222 }
223
224 return dev_stats;
225 }
226
227 static int veth_open(struct net_device *dev)
228 {
229 struct veth_priv *priv;
230
231 priv = netdev_priv(dev);
232 if (priv->peer == NULL)
233 return -ENOTCONN;
234
235 if (priv->peer->flags & IFF_UP) {
236 netif_carrier_on(dev);
237 netif_carrier_on(priv->peer);
238 }
239 return 0;
240 }
241
242 static int veth_close(struct net_device *dev)
243 {
244 struct veth_priv *priv = netdev_priv(dev);
245
246 netif_carrier_off(dev);
247 netif_carrier_off(priv->peer);
248
249 return 0;
250 }
251
252 static int veth_dev_init(struct net_device *dev)
253 {
254 struct veth_net_stats *stats;
255 struct veth_priv *priv;
256
257 stats = alloc_percpu(struct veth_net_stats);
258 if (stats == NULL)
259 return -ENOMEM;
260
261 priv = netdev_priv(dev);
262 priv->stats = stats;
263 return 0;
264 }
265
266 static void veth_dev_free(struct net_device *dev)
267 {
268 struct veth_priv *priv;
269
270 priv = netdev_priv(dev);
271 free_percpu(priv->stats);
272 free_netdev(dev);
273 }
274
275 static const struct net_device_ops veth_netdev_ops = {
276 .ndo_init = veth_dev_init,
277 .ndo_open = veth_open,
278 .ndo_stop = veth_close,
279 .ndo_start_xmit = veth_xmit,
280 .ndo_get_stats = veth_get_stats,
281 .ndo_set_mac_address = eth_mac_addr,
282 };
283
284 static void veth_setup(struct net_device *dev)
285 {
286 ether_setup(dev);
287
288 dev->netdev_ops = &veth_netdev_ops;
289 dev->ethtool_ops = &veth_ethtool_ops;
290 dev->features |= NETIF_F_LLTX;
291 dev->destructor = veth_dev_free;
292 }
293
294 /*
295 * netlink interface
296 */
297
298 static int veth_validate(struct nlattr *tb[], struct nlattr *data[])
299 {
300 if (tb[IFLA_ADDRESS]) {
301 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN)
302 return -EINVAL;
303 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS])))
304 return -EADDRNOTAVAIL;
305 }
306 return 0;
307 }
308
309 static struct rtnl_link_ops veth_link_ops;
310
311 static int veth_newlink(struct net_device *dev,
312 struct nlattr *tb[], struct nlattr *data[])
313 {
314 int err;
315 struct net_device *peer;
316 struct veth_priv *priv;
317 char ifname[IFNAMSIZ];
318 struct nlattr *peer_tb[IFLA_MAX + 1], **tbp;
319
320 /*
321 * create and register peer first
322 *
323 * struct ifinfomsg is at the head of VETH_INFO_PEER, but we
324 * skip it since no info from it is useful yet
325 */
326
327 if (data != NULL && data[VETH_INFO_PEER] != NULL) {
328 struct nlattr *nla_peer;
329
330 nla_peer = data[VETH_INFO_PEER];
331 err = nla_parse(peer_tb, IFLA_MAX,
332 nla_data(nla_peer) + sizeof(struct ifinfomsg),
333 nla_len(nla_peer) - sizeof(struct ifinfomsg),
334 ifla_policy);
335 if (err < 0)
336 return err;
337
338 err = veth_validate(peer_tb, NULL);
339 if (err < 0)
340 return err;
341
342 tbp = peer_tb;
343 } else
344 tbp = tb;
345
346 if (tbp[IFLA_IFNAME])
347 nla_strlcpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ);
348 else
349 snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d");
350
351 peer = rtnl_create_link(dev_net(dev), ifname, &veth_link_ops, tbp);
352 if (IS_ERR(peer))
353 return PTR_ERR(peer);
354
355 if (tbp[IFLA_ADDRESS] == NULL)
356 random_ether_addr(peer->dev_addr);
357
358 err = register_netdevice(peer);
359 if (err < 0)
360 goto err_register_peer;
361
362 netif_carrier_off(peer);
363
364 /*
365 * register dev last
366 *
367 * note, that since we've registered new device the dev's name
368 * should be re-allocated
369 */
370
371 if (tb[IFLA_ADDRESS] == NULL)
372 random_ether_addr(dev->dev_addr);
373
374 if (tb[IFLA_IFNAME])
375 nla_strlcpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ);
376 else
377 snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d");
378
379 if (strchr(dev->name, '%')) {
380 err = dev_alloc_name(dev, dev->name);
381 if (err < 0)
382 goto err_alloc_name;
383 }
384
385 err = register_netdevice(dev);
386 if (err < 0)
387 goto err_register_dev;
388
389 netif_carrier_off(dev);
390
391 /*
392 * tie the deviced together
393 */
394
395 priv = netdev_priv(dev);
396 priv->peer = peer;
397
398 priv = netdev_priv(peer);
399 priv->peer = dev;
400 return 0;
401
402 err_register_dev:
403 /* nothing to do */
404 err_alloc_name:
405 unregister_netdevice(peer);
406 return err;
407
408 err_register_peer:
409 free_netdev(peer);
410 return err;
411 }
412
413 static void veth_dellink(struct net_device *dev)
414 {
415 struct veth_priv *priv;
416 struct net_device *peer;
417
418 priv = netdev_priv(dev);
419 peer = priv->peer;
420
421 unregister_netdevice(dev);
422 unregister_netdevice(peer);
423 }
424
425 static const struct nla_policy veth_policy[VETH_INFO_MAX + 1];
426
427 static struct rtnl_link_ops veth_link_ops = {
428 .kind = DRV_NAME,
429 .priv_size = sizeof(struct veth_priv),
430 .setup = veth_setup,
431 .validate = veth_validate,
432 .newlink = veth_newlink,
433 .dellink = veth_dellink,
434 .policy = veth_policy,
435 .maxtype = VETH_INFO_MAX,
436 };
437
438 /*
439 * init/fini
440 */
441
442 static __init int veth_init(void)
443 {
444 return rtnl_link_register(&veth_link_ops);
445 }
446
447 static __exit void veth_exit(void)
448 {
449 rtnl_link_unregister(&veth_link_ops);
450 }
451
452 module_init(veth_init);
453 module_exit(veth_exit);
454
455 MODULE_DESCRIPTION("Virtual Ethernet Tunnel");
456 MODULE_LICENSE("GPL v2");
457 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
Nao low-level kernelspace/userspace library that runs on our robots, Nao-Team HTWK