1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include "common.h"
32
33#include <linux/ethtool.h>
34#include <linux/rtnetlink.h>
35#include <linux/if_vlan.h>
36
37#include <xen/events.h>
38#include <asm/xen/hypercall.h>
39
40#define XENVIF_QUEUE_LENGTH 32
41
42void xenvif_get(struct xenvif *vif)
43{
44 atomic_inc(&vif->refcnt);
45}
46
47void xenvif_put(struct xenvif *vif)
48{
49 if (atomic_dec_and_test(&vif->refcnt))
50 wake_up(&vif->waiting_to_free);
51}
52
53int xenvif_schedulable(struct xenvif *vif)
54{
55 return netif_running(vif->dev) && netif_carrier_ok(vif->dev);
56}
57
58static int xenvif_rx_schedulable(struct xenvif *vif)
59{
60 return xenvif_schedulable(vif) && !xen_netbk_rx_ring_full(vif);
61}
62
63static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
64{
65 struct xenvif *vif = dev_id;
66
67 if (vif->netbk == NULL)
68 return IRQ_HANDLED;
69
70 xen_netbk_schedule_xenvif(vif);
71
72 return IRQ_HANDLED;
73}
74
75static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
76{
77 struct xenvif *vif = dev_id;
78
79 if (vif->netbk == NULL)
80 return IRQ_HANDLED;
81
82 if (xenvif_rx_schedulable(vif))
83 netif_wake_queue(vif->dev);
84
85 return IRQ_HANDLED;
86}
87
88static irqreturn_t xenvif_interrupt(int irq, void *dev_id)
89{
90 xenvif_tx_interrupt(irq, dev_id);
91 xenvif_rx_interrupt(irq, dev_id);
92
93 return IRQ_HANDLED;
94}
95
96static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
97{
98 struct xenvif *vif = netdev_priv(dev);
99
100 BUG_ON(skb->dev != dev);
101
102 if (vif->netbk == NULL)
103 goto drop;
104
105
106 if (!xenvif_rx_schedulable(vif))
107 goto drop;
108
109
110 vif->rx_req_cons_peek += xen_netbk_count_skb_slots(vif, skb);
111 xenvif_get(vif);
112
113 if (vif->can_queue && xen_netbk_must_stop_queue(vif))
114 netif_stop_queue(dev);
115
116 xen_netbk_queue_tx_skb(vif, skb);
117
118 return NETDEV_TX_OK;
119
120 drop:
121 vif->dev->stats.tx_dropped++;
122 dev_kfree_skb(skb);
123 return NETDEV_TX_OK;
124}
125
126void xenvif_receive_skb(struct xenvif *vif, struct sk_buff *skb)
127{
128 netif_rx_ni(skb);
129}
130
131void xenvif_notify_tx_completion(struct xenvif *vif)
132{
133 if (netif_queue_stopped(vif->dev) && xenvif_rx_schedulable(vif))
134 netif_wake_queue(vif->dev);
135}
136
137static struct net_device_stats *xenvif_get_stats(struct net_device *dev)
138{
139 struct xenvif *vif = netdev_priv(dev);
140 return &vif->dev->stats;
141}
142
143static void xenvif_up(struct xenvif *vif)
144{
145 xen_netbk_add_xenvif(vif);
146 enable_irq(vif->tx_irq);
147 if (vif->tx_irq != vif->rx_irq)
148 enable_irq(vif->rx_irq);
149 xen_netbk_check_rx_xenvif(vif);
150}
151
152static void xenvif_down(struct xenvif *vif)
153{
154 disable_irq(vif->tx_irq);
155 if (vif->tx_irq != vif->rx_irq)
156 disable_irq(vif->rx_irq);
157 del_timer_sync(&vif->credit_timeout);
158 xen_netbk_deschedule_xenvif(vif);
159 xen_netbk_remove_xenvif(vif);
160}
161
162static int xenvif_open(struct net_device *dev)
163{
164 struct xenvif *vif = netdev_priv(dev);
165 if (netif_carrier_ok(dev))
166 xenvif_up(vif);
167 netif_start_queue(dev);
168 return 0;
169}
170
171static int xenvif_close(struct net_device *dev)
172{
173 struct xenvif *vif = netdev_priv(dev);
174 if (netif_carrier_ok(dev))
175 xenvif_down(vif);
176 netif_stop_queue(dev);
177 return 0;
178}
179
180static int xenvif_change_mtu(struct net_device *dev, int mtu)
181{
182 struct xenvif *vif = netdev_priv(dev);
183 int max = vif->can_sg ? 65535 - VLAN_ETH_HLEN : ETH_DATA_LEN;
184
185 if (mtu > max)
186 return -EINVAL;
187 dev->mtu = mtu;
188 return 0;
189}
190
191static netdev_features_t xenvif_fix_features(struct net_device *dev,
192 netdev_features_t features)
193{
194 struct xenvif *vif = netdev_priv(dev);
195
196 if (!vif->can_sg)
197 features &= ~NETIF_F_SG;
198 if (!vif->gso && !vif->gso_prefix)
199 features &= ~NETIF_F_TSO;
200 if (!vif->csum)
201 features &= ~NETIF_F_IP_CSUM;
202
203 return features;
204}
205
206static const struct xenvif_stat {
207 char name[ETH_GSTRING_LEN];
208 u16 offset;
209} xenvif_stats[] = {
210 {
211 "rx_gso_checksum_fixup",
212 offsetof(struct xenvif, rx_gso_checksum_fixup)
213 },
214};
215
216static int xenvif_get_sset_count(struct net_device *dev, int string_set)
217{
218 switch (string_set) {
219 case ETH_SS_STATS:
220 return ARRAY_SIZE(xenvif_stats);
221 default:
222 return -EINVAL;
223 }
224}
225
226static void xenvif_get_ethtool_stats(struct net_device *dev,
227 struct ethtool_stats *stats, u64 * data)
228{
229 void *vif = netdev_priv(dev);
230 int i;
231
232 for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++)
233 data[i] = *(unsigned long *)(vif + xenvif_stats[i].offset);
234}
235
236static void xenvif_get_strings(struct net_device *dev, u32 stringset, u8 * data)
237{
238 int i;
239
240 switch (stringset) {
241 case ETH_SS_STATS:
242 for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++)
243 memcpy(data + i * ETH_GSTRING_LEN,
244 xenvif_stats[i].name, ETH_GSTRING_LEN);
245 break;
246 }
247}
248
249static const struct ethtool_ops xenvif_ethtool_ops = {
250 .get_link = ethtool_op_get_link,
251
252 .get_sset_count = xenvif_get_sset_count,
253 .get_ethtool_stats = xenvif_get_ethtool_stats,
254 .get_strings = xenvif_get_strings,
255};
256
257static const struct net_device_ops xenvif_netdev_ops = {
258 .ndo_start_xmit = xenvif_start_xmit,
259 .ndo_get_stats = xenvif_get_stats,
260 .ndo_open = xenvif_open,
261 .ndo_stop = xenvif_close,
262 .ndo_change_mtu = xenvif_change_mtu,
263 .ndo_fix_features = xenvif_fix_features,
264 .ndo_set_mac_address = eth_mac_addr,
265 .ndo_validate_addr = eth_validate_addr,
266};
267
268struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
269 unsigned int handle)
270{
271 int err;
272 struct net_device *dev;
273 struct xenvif *vif;
274 char name[IFNAMSIZ] = {};
275
276 snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle);
277 dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup);
278 if (dev == NULL) {
279 pr_warn("Could not allocate netdev\n");
280 return ERR_PTR(-ENOMEM);
281 }
282
283 SET_NETDEV_DEV(dev, parent);
284
285 vif = netdev_priv(dev);
286 vif->domid = domid;
287 vif->handle = handle;
288 vif->netbk = NULL;
289 vif->can_sg = 1;
290 vif->csum = 1;
291 atomic_set(&vif->refcnt, 1);
292 init_waitqueue_head(&vif->waiting_to_free);
293 vif->dev = dev;
294 INIT_LIST_HEAD(&vif->schedule_list);
295 INIT_LIST_HEAD(&vif->notify_list);
296
297 vif->credit_bytes = vif->remaining_credit = ~0UL;
298 vif->credit_usec = 0UL;
299 init_timer(&vif->credit_timeout);
300
301 vif->credit_timeout.expires = jiffies;
302
303 dev->netdev_ops = &xenvif_netdev_ops;
304 dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO;
305 dev->features = dev->hw_features;
306 SET_ETHTOOL_OPS(dev, &xenvif_ethtool_ops);
307
308 dev->tx_queue_len = XENVIF_QUEUE_LENGTH;
309
310
311
312
313
314
315
316 memset(dev->dev_addr, 0xFF, ETH_ALEN);
317 dev->dev_addr[0] &= ~0x01;
318
319 netif_carrier_off(dev);
320
321 err = register_netdev(dev);
322 if (err) {
323 netdev_warn(dev, "Could not register device: err=%d\n", err);
324 free_netdev(dev);
325 return ERR_PTR(err);
326 }
327
328 netdev_dbg(dev, "Successfully created xenvif\n");
329 return vif;
330}
331
332int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
333 unsigned long rx_ring_ref, unsigned int tx_evtchn,
334 unsigned int rx_evtchn)
335{
336 int err = -ENOMEM;
337
338
339 if (vif->tx_irq)
340 return 0;
341
342 __module_get(THIS_MODULE);
343
344 err = xen_netbk_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref);
345 if (err < 0)
346 goto err;
347
348 if (tx_evtchn == rx_evtchn) {
349
350 err = bind_interdomain_evtchn_to_irqhandler(
351 vif->domid, tx_evtchn, xenvif_interrupt, 0,
352 vif->dev->name, vif);
353 if (err < 0)
354 goto err_unmap;
355 vif->tx_irq = vif->rx_irq = err;
356 disable_irq(vif->tx_irq);
357 } else {
358
359 snprintf(vif->tx_irq_name, sizeof(vif->tx_irq_name),
360 "%s-tx", vif->dev->name);
361 err = bind_interdomain_evtchn_to_irqhandler(
362 vif->domid, tx_evtchn, xenvif_tx_interrupt, 0,
363 vif->tx_irq_name, vif);
364 if (err < 0)
365 goto err_unmap;
366 vif->tx_irq = err;
367 disable_irq(vif->tx_irq);
368
369 snprintf(vif->rx_irq_name, sizeof(vif->rx_irq_name),
370 "%s-rx", vif->dev->name);
371 err = bind_interdomain_evtchn_to_irqhandler(
372 vif->domid, rx_evtchn, xenvif_rx_interrupt, 0,
373 vif->rx_irq_name, vif);
374 if (err < 0)
375 goto err_tx_unbind;
376 vif->rx_irq = err;
377 disable_irq(vif->rx_irq);
378 }
379
380 xenvif_get(vif);
381
382 rtnl_lock();
383 if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN)
384 dev_set_mtu(vif->dev, ETH_DATA_LEN);
385 netdev_update_features(vif->dev);
386 netif_carrier_on(vif->dev);
387 if (netif_running(vif->dev))
388 xenvif_up(vif);
389 rtnl_unlock();
390
391 return 0;
392err_tx_unbind:
393 unbind_from_irqhandler(vif->tx_irq, vif);
394 vif->tx_irq = 0;
395err_unmap:
396 xen_netbk_unmap_frontend_rings(vif);
397err:
398 module_put(THIS_MODULE);
399 return err;
400}
401
402void xenvif_carrier_off(struct xenvif *vif)
403{
404 struct net_device *dev = vif->dev;
405
406 rtnl_lock();
407 netif_carrier_off(dev);
408 if (netif_running(dev))
409 xenvif_down(vif);
410 rtnl_unlock();
411 xenvif_put(vif);
412}
413
414void xenvif_disconnect(struct xenvif *vif)
415{
416
417
418
419
420 int need_module_put = 0;
421
422 if (netif_carrier_ok(vif->dev))
423 xenvif_carrier_off(vif);
424
425 atomic_dec(&vif->refcnt);
426 wait_event(vif->waiting_to_free, atomic_read(&vif->refcnt) == 0);
427
428 if (vif->tx_irq) {
429 if (vif->tx_irq == vif->rx_irq)
430 unbind_from_irqhandler(vif->tx_irq, vif);
431 else {
432 unbind_from_irqhandler(vif->tx_irq, vif);
433 unbind_from_irqhandler(vif->rx_irq, vif);
434 }
435
436
437
438 need_module_put = 1;
439 }
440
441 unregister_netdev(vif->dev);
442
443 xen_netbk_unmap_frontend_rings(vif);
444
445 free_netdev(vif->dev);
446
447 if (need_module_put)
448 module_put(THIS_MODULE);
449}
450