Merge citrix into master.
[openvswitch] / datapath / dp_dev.c
1 /*
2  * Copyright (c) 2009 Nicira Networks.
3  * Distributed under the terms of the GNU GPL version 2.
4  *
5  * Significant portions of this file may be copied from parts of the Linux
6  * kernel, by Linus Torvalds and others.
7  */
8
9 #include <linux/kernel.h>
10 #include <linux/netdevice.h>
11 #include <linux/etherdevice.h>
12 #include <linux/ethtool.h>
13 #include <linux/rcupdate.h>
14 #include <linux/skbuff.h>
15 #include <linux/workqueue.h>
16
17 #include "datapath.h"
18 #include "dp_dev.h"
19
20 struct pcpu_lstats {
21         unsigned long rx_packets;
22         unsigned long rx_bytes;
23         unsigned long tx_packets;
24         unsigned long tx_bytes;
25 };
26
27 struct datapath *dp_dev_get_dp(struct net_device *netdev)
28 {
29         return dp_dev_priv(netdev)->dp;
30 }
31
32 static struct net_device_stats *dp_dev_get_stats(struct net_device *netdev)
33 {
34         struct dp_dev *dp_dev = dp_dev_priv(netdev);
35         struct net_device_stats *stats;
36         int i;
37
38         stats = &dp_dev->stats;
39         memset(stats, 0, sizeof *stats);
40         for_each_possible_cpu(i) {
41                 const struct pcpu_lstats *lb_stats;
42
43                 lb_stats = per_cpu_ptr(dp_dev->lstats, i);
44                 stats->rx_bytes   += lb_stats->rx_bytes;
45                 stats->rx_packets += lb_stats->rx_packets;
46                 stats->tx_bytes   += lb_stats->tx_bytes;
47                 stats->tx_packets += lb_stats->tx_packets;
48         }
49         return stats;
50 }
51
52 int dp_dev_recv(struct net_device *netdev, struct sk_buff *skb) 
53 {
54         struct dp_dev *dp_dev = dp_dev_priv(netdev);
55         struct pcpu_lstats *lb_stats;
56         int len;
57         len = skb->len;
58         skb->pkt_type = PACKET_HOST;
59         skb->protocol = eth_type_trans(skb, netdev);
60         if (in_interrupt())
61                 netif_rx(skb);
62         else
63                 netif_rx_ni(skb);
64         netdev->last_rx = jiffies;
65         lb_stats = per_cpu_ptr(dp_dev->lstats, smp_processor_id());
66         lb_stats->rx_packets++;
67         lb_stats->rx_bytes += len;
68         return len;
69 }
70
71 static int dp_dev_mac_addr(struct net_device *dev, void *p)
72 {
73         struct sockaddr *addr = p;
74
75         if (!is_valid_ether_addr(addr->sa_data))
76                 return -EADDRNOTAVAIL;
77         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
78         return 0;
79 }
80
81 /* Not reentrant (because it is called with BHs disabled), but may be called
82  * simultaneously on different CPUs. */
83 static int dp_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
84 {
85         struct dp_dev *dp_dev = dp_dev_priv(netdev);
86         struct pcpu_lstats *lb_stats;
87
88         /* dp_process_received_packet() needs its own clone. */
89         skb = skb_share_check(skb, GFP_ATOMIC);
90         if (!skb)
91                 return 0;
92
93         lb_stats = per_cpu_ptr(dp_dev->lstats, smp_processor_id());
94         lb_stats->tx_packets++;
95         lb_stats->tx_bytes += skb->len;
96
97         skb_reset_mac_header(skb);
98         rcu_read_lock_bh();
99         dp_process_received_packet(skb, dp_dev->dp->ports[dp_dev->port_no]);
100         rcu_read_unlock_bh();
101
102         return 0;
103 }
104
105 static int dp_dev_open(struct net_device *netdev)
106 {
107         netif_start_queue(netdev);
108         return 0;
109 }
110
111 static int dp_dev_stop(struct net_device *netdev)
112 {
113         netif_stop_queue(netdev);
114         return 0;
115 }
116
117 static void dp_getinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
118 {
119         struct dp_dev *dp_dev = dp_dev_priv(netdev);
120         strcpy(info->driver, "openvswitch");
121         sprintf(info->bus_info, "%d.%d", dp_dev->dp->dp_idx, dp_dev->port_no);
122 }
123
124 static struct ethtool_ops dp_ethtool_ops = {
125         .get_drvinfo = dp_getinfo,
126         .get_link = ethtool_op_get_link,
127         .get_sg = ethtool_op_get_sg,
128         .get_tx_csum = ethtool_op_get_tx_csum,
129         .get_tso = ethtool_op_get_tso,
130 };
131
132 static int dp_dev_change_mtu(struct net_device *dev, int new_mtu)
133 {
134         if (new_mtu < 68 || new_mtu > dp_min_mtu(dp_dev_get_dp(dev)))
135                 return -EINVAL;
136
137         dev->mtu = new_mtu;
138         return 0;
139 }
140
141 static int dp_dev_init(struct net_device *netdev)
142 {
143         struct dp_dev *dp_dev = dp_dev_priv(netdev);
144
145         dp_dev->lstats = alloc_percpu(struct pcpu_lstats);
146         if (!dp_dev->lstats)
147                 return -ENOMEM;
148
149         return 0;
150 }
151
152 static void dp_dev_free(struct net_device *netdev)
153 {
154         struct dp_dev *dp_dev = dp_dev_priv(netdev);
155
156         free_percpu(dp_dev->lstats);
157         free_netdev(netdev);
158 }
159
160 static void
161 do_setup(struct net_device *netdev)
162 {
163         ether_setup(netdev);
164
165         netdev->do_ioctl = dp_ioctl_hook;
166         netdev->get_stats = dp_dev_get_stats;
167         netdev->hard_start_xmit = dp_dev_xmit;
168         netdev->open = dp_dev_open;
169         SET_ETHTOOL_OPS(netdev, &dp_ethtool_ops);
170         netdev->stop = dp_dev_stop;
171         netdev->tx_queue_len = 0;
172         netdev->set_mac_address = dp_dev_mac_addr;
173         netdev->change_mtu = dp_dev_change_mtu;
174         netdev->init = dp_dev_init;
175         netdev->destructor = dp_dev_free;
176
177         netdev->flags = IFF_BROADCAST | IFF_MULTICAST;
178         netdev->features = NETIF_F_LLTX; /* XXX other features? */
179
180         random_ether_addr(netdev->dev_addr);
181
182         /* Set the OUI to the Nicira one. */
183         netdev->dev_addr[0] = 0x00;
184         netdev->dev_addr[1] = 0x23;
185         netdev->dev_addr[2] = 0x20;
186
187         /* Set the top bits to indicate random Nicira address. */
188         netdev->dev_addr[3] |= 0xc0;
189 }
190
191 /* Create a datapath device associated with 'dp'.  If 'dp_name' is null,
192  * the device name will be of the form 'of<dp_idx>'.  Returns the new device or
193  * an error code.
194  *
195  * Called with RTNL lock and dp_mutex. */
196 struct net_device *dp_dev_create(struct datapath *dp, const char *dp_name, int port_no)
197 {
198         struct dp_dev *dp_dev;
199         struct net_device *netdev;
200         char dev_name[IFNAMSIZ];
201         int err;
202
203         if (dp_name) {
204                 if (strlen(dp_name) >= IFNAMSIZ)
205                         return ERR_PTR(-EINVAL);
206                 strncpy(dev_name, dp_name, sizeof(dev_name));
207         } else
208                 snprintf(dev_name, sizeof dev_name, "of%d", dp->dp_idx);
209
210         netdev = alloc_netdev(sizeof(struct dp_dev), dev_name, do_setup);
211         if (!netdev)
212                 return ERR_PTR(-ENOMEM);
213
214         dp_dev = dp_dev_priv(netdev);
215         dp_dev->dp = dp;
216         dp_dev->port_no = port_no;
217         dp_dev->dev = netdev;
218
219         err = register_netdevice(netdev);
220         if (err) {
221                 free_netdev(netdev);
222                 return ERR_PTR(err);
223         }
224
225         return netdev;
226 }
227
228 /* Called with RTNL lock and dp_mutex.*/
229 void dp_dev_destroy(struct net_device *netdev)
230 {
231         unregister_netdevice(netdev);
232 }
233
234 int is_dp_dev(struct net_device *netdev) 
235 {
236         return netdev->open == dp_dev_open;
237 }