Import from old repository commit 61ef2b42a9c4ba8e1600f15bb0236765edc2ad45.
[openvswitch] / datapath / dp_dev.c
1 #include <linux/kernel.h>
2 #include <linux/netdevice.h>
3 #include <linux/etherdevice.h>
4 #include <linux/ethtool.h>
5 #include <linux/rcupdate.h>
6 #include <linux/skbuff.h>
7 #include <linux/workqueue.h>
8
9 #include "datapath.h"
10 #include "dp_dev.h"
11
12 struct datapath *dp_dev_get_dp(struct net_device *netdev)
13 {
14         return dp_dev_priv(netdev)->dp;
15 }
16 EXPORT_SYMBOL(dp_dev_get_dp);
17
18 static struct net_device_stats *dp_dev_get_stats(struct net_device *netdev)
19 {
20         struct dp_dev *dp_dev = dp_dev_priv(netdev);
21         return &dp_dev->stats;
22 }
23
24 int dp_dev_recv(struct net_device *netdev, struct sk_buff *skb) 
25 {
26         struct dp_dev *dp_dev = dp_dev_priv(netdev);
27         int len;
28         len = skb->len;
29         skb->pkt_type = PACKET_HOST;
30         skb->protocol = eth_type_trans(skb, netdev);
31         if (in_interrupt())
32                 netif_rx(skb);
33         else
34                 netif_rx_ni(skb);
35         netdev->last_rx = jiffies;
36         dp_dev->stats.rx_packets++;
37         dp_dev->stats.rx_bytes += len;
38         return len;
39 }
40
41 static int dp_dev_mac_addr(struct net_device *dev, void *p)
42 {
43         struct sockaddr *addr = p;
44
45         if (!is_valid_ether_addr(addr->sa_data))
46                 return -EADDRNOTAVAIL;
47         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
48         return 0;
49 }
50
51 static int dp_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
52 {
53         struct dp_dev *dp_dev = dp_dev_priv(netdev);
54
55         /* By orphaning 'skb' we will screw up socket accounting slightly, but
56          * the effect is limited to the device queue length.  If we don't
57          * do this, then the sk_buff will be destructed eventually, but it is
58          * harder to predict when. */
59         skb_orphan(skb);
60
61         /* We are going to modify 'skb', by sticking it on &dp_dev->xmit_queue,
62          * so we need to have our own clone.  (At any rate, fwd_port_input()
63          * will need its own clone, so there's no benefit to queuing any other
64          * way.) */
65         skb = skb_share_check(skb, GFP_ATOMIC);
66         if (!skb)
67                 return 0;
68
69         dp_dev->stats.tx_packets++;
70         dp_dev->stats.tx_bytes += skb->len;
71
72         if (skb_queue_len(&dp_dev->xmit_queue) >= netdev->tx_queue_len) {
73                 /* Queue overflow.  Stop transmitter. */
74                 netif_stop_queue(netdev);
75
76                 /* We won't see all dropped packets individually, so overrun
77                  * error is appropriate. */
78                 dp_dev->stats.tx_fifo_errors++;
79         }
80         skb_queue_tail(&dp_dev->xmit_queue, skb);
81         netdev->trans_start = jiffies;
82
83         schedule_work(&dp_dev->xmit_work);
84
85         return 0;
86 }
87
88 static void dp_dev_do_xmit(struct work_struct *work)
89 {
90         struct dp_dev *dp_dev = container_of(work, struct dp_dev, xmit_work);
91         struct datapath *dp = dp_dev->dp;
92         struct sk_buff *skb;
93
94         while ((skb = skb_dequeue(&dp_dev->xmit_queue)) != NULL) {
95                 skb_reset_mac_header(skb);
96                 rcu_read_lock_bh();
97                 dp_process_received_packet(skb, dp->ports[dp_dev->port_no]);
98                 rcu_read_unlock_bh();
99         }
100         netif_wake_queue(dp_dev->dev);
101 }
102
103 static int dp_dev_open(struct net_device *netdev)
104 {
105         netif_start_queue(netdev);
106         return 0;
107 }
108
109 static int dp_dev_stop(struct net_device *netdev)
110 {
111         netif_stop_queue(netdev);
112         return 0;
113 }
114
115 static void dp_getinfo(struct net_device *netdev, struct ethtool_drvinfo *info)
116 {
117         struct dp_dev *dp_dev = dp_dev_priv(netdev);
118         strcpy(info->driver, "openvswitch");
119         sprintf(info->bus_info, "%d", dp_dev->dp->dp_idx);
120 }
121
122 static struct ethtool_ops dp_ethtool_ops = {
123         .get_drvinfo = dp_getinfo,
124         .get_link = ethtool_op_get_link,
125         .get_sg = ethtool_op_get_sg,
126         .get_tx_csum = ethtool_op_get_tx_csum,
127         .get_tso = ethtool_op_get_tso,
128 };
129
130 static void
131 do_setup(struct net_device *netdev)
132 {
133         ether_setup(netdev);
134
135         netdev->do_ioctl = dp_ioctl_hook;
136         netdev->get_stats = dp_dev_get_stats;
137         netdev->hard_start_xmit = dp_dev_xmit;
138         netdev->open = dp_dev_open;
139         SET_ETHTOOL_OPS(netdev, &dp_ethtool_ops);
140         netdev->stop = dp_dev_stop;
141         netdev->tx_queue_len = 100;
142         netdev->set_mac_address = dp_dev_mac_addr;
143
144         netdev->flags = IFF_BROADCAST | IFF_MULTICAST;
145
146         random_ether_addr(netdev->dev_addr);
147
148         /* Set the OUI to the Nicira one. */
149         netdev->dev_addr[0] = 0x00;
150         netdev->dev_addr[1] = 0x23;
151         netdev->dev_addr[2] = 0x20;
152
153         /* Set the top bits to indicate random Nicira address. */
154         netdev->dev_addr[3] |= 0xc0;
155 }
156
157 /* Create a datapath device associated with 'dp'.  If 'dp_name' is null,
158  * the device name will be of the form 'of<dp_idx>'.  Returns the new device or
159  * an error code.
160  *
161  * Called with RTNL lock and dp_mutex. */
162 struct net_device *dp_dev_create(struct datapath *dp, const char *dp_name, int port_no)
163 {
164         struct dp_dev *dp_dev;
165         struct net_device *netdev;
166         char dev_name[IFNAMSIZ];
167         int err;
168
169         if (dp_name) {
170                 if (strlen(dp_name) >= IFNAMSIZ)
171                         return ERR_PTR(-EINVAL);
172                 strncpy(dev_name, dp_name, sizeof(dev_name));
173         } else
174                 snprintf(dev_name, sizeof dev_name, "of%d", dp->dp_idx);
175
176         netdev = alloc_netdev(sizeof(struct dp_dev), dev_name, do_setup);
177         if (!netdev)
178                 return ERR_PTR(-ENOMEM);
179
180         err = register_netdevice(netdev);
181         if (err) {
182                 free_netdev(netdev);
183                 return ERR_PTR(err);
184         }
185
186         dp_dev = dp_dev_priv(netdev);
187         dp_dev->dp = dp;
188         dp_dev->port_no = port_no;
189         dp_dev->dev = netdev;
190         skb_queue_head_init(&dp_dev->xmit_queue);
191         INIT_WORK(&dp_dev->xmit_work, dp_dev_do_xmit);
192         return netdev;
193 }
194
195 /* Called with RTNL lock and dp_mutex.*/
196 void dp_dev_destroy(struct net_device *netdev)
197 {
198         struct dp_dev *dp_dev = dp_dev_priv(netdev);
199
200         netif_tx_disable(netdev);
201         synchronize_net();
202         skb_queue_purge(&dp_dev->xmit_queue);
203         unregister_netdevice(netdev);
204 }
205
206 int is_dp_dev(struct net_device *netdev) 
207 {
208         return netdev->open == dp_dev_open;
209 }
210 EXPORT_SYMBOL(is_dp_dev);