2 * Network-device interface management.
4 * Copyright (c) 2004-2005, Keir Fraser
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version 2
8 * as published by the Free Software Foundation; or, when distributed
9 * separately from the Linux kernel or incorporated into other
10 * software packages, subject to the following license:
12 * Permission is hereby granted, free of charge, to any person obtaining a copy
13 * of this source file (the "Software"), to deal in the Software without
14 * restriction, including without limitation the rights to use, copy, modify,
15 * merge, publish, distribute, sublicense, and/or sell copies of the Software,
16 * and to permit persons to whom the Software is furnished to do so, subject to
17 * the following conditions:
19 * The above copyright notice and this permission notice shall be included in
20 * all copies or substantial portions of the Software.
22 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
23 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
24 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
25 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
26 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
27 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
33 #include <linux/kthread.h>
34 #include <linux/ethtool.h>
35 #include <linux/rtnetlink.h>
36 #include <linux/if_vlan.h>
38 #include <xen/events.h>
39 #include <asm/xen/hypercall.h>
41 #define XENVIF_QUEUE_LENGTH 32
42 #define XENVIF_NAPI_WEIGHT 64
44 int xenvif_schedulable(struct xenvif
*vif
)
46 return netif_running(vif
->dev
) && netif_carrier_ok(vif
->dev
);
49 static int xenvif_rx_schedulable(struct xenvif
*vif
)
51 return xenvif_schedulable(vif
) && !xenvif_rx_ring_full(vif
);
54 static irqreturn_t
xenvif_tx_interrupt(int irq
, void *dev_id
)
56 struct xenvif
*vif
= dev_id
;
58 if (RING_HAS_UNCONSUMED_REQUESTS(&vif
->tx
))
59 napi_schedule(&vif
->napi
);
64 static int xenvif_poll(struct napi_struct
*napi
, int budget
)
66 struct xenvif
*vif
= container_of(napi
, struct xenvif
, napi
);
69 work_done
= xenvif_tx_action(vif
, budget
);
71 if (work_done
< budget
) {
75 /* It is necessary to disable IRQ before calling
76 * RING_HAS_UNCONSUMED_REQUESTS. Otherwise we might
77 * lose event from the frontend.
80 * RING_HAS_UNCONSUMED_REQUESTS
81 * <frontend generates event to trigger napi_schedule>
84 * This handler is still in scheduled state so the
85 * event has no effect at all. After __napi_complete
86 * this handler is descheduled and cannot get
87 * scheduled again. We lose event in this case and the ring
88 * will be completely stalled.
91 local_irq_save(flags
);
93 RING_FINAL_CHECK_FOR_REQUESTS(&vif
->tx
, more_to_do
);
95 __napi_complete(napi
);
97 local_irq_restore(flags
);
103 static irqreturn_t
xenvif_rx_interrupt(int irq
, void *dev_id
)
105 struct xenvif
*vif
= dev_id
;
107 if (xenvif_rx_schedulable(vif
))
108 netif_wake_queue(vif
->dev
);
113 static irqreturn_t
xenvif_interrupt(int irq
, void *dev_id
)
115 xenvif_tx_interrupt(irq
, dev_id
);
116 xenvif_rx_interrupt(irq
, dev_id
);
121 static int xenvif_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
123 struct xenvif
*vif
= netdev_priv(dev
);
125 BUG_ON(skb
->dev
!= dev
);
127 /* Drop the packet if vif is not ready */
128 if (vif
->task
== NULL
)
131 /* Drop the packet if the target domain has no receive buffers. */
132 if (!xenvif_rx_schedulable(vif
))
135 /* Reserve ring slots for the worst-case number of fragments. */
136 vif
->rx_req_cons_peek
+= xenvif_count_skb_slots(vif
, skb
);
138 if (vif
->can_queue
&& xenvif_must_stop_queue(vif
))
139 netif_stop_queue(dev
);
141 xenvif_queue_tx_skb(vif
, skb
);
146 vif
->dev
->stats
.tx_dropped
++;
151 void xenvif_notify_tx_completion(struct xenvif
*vif
)
153 if (netif_queue_stopped(vif
->dev
) && xenvif_rx_schedulable(vif
))
154 netif_wake_queue(vif
->dev
);
157 static struct net_device_stats
*xenvif_get_stats(struct net_device
*dev
)
159 struct xenvif
*vif
= netdev_priv(dev
);
160 return &vif
->dev
->stats
;
163 static void xenvif_up(struct xenvif
*vif
)
165 napi_enable(&vif
->napi
);
166 enable_irq(vif
->tx_irq
);
167 if (vif
->tx_irq
!= vif
->rx_irq
)
168 enable_irq(vif
->rx_irq
);
169 xenvif_check_rx_xenvif(vif
);
172 static void xenvif_down(struct xenvif
*vif
)
174 napi_disable(&vif
->napi
);
175 disable_irq(vif
->tx_irq
);
176 if (vif
->tx_irq
!= vif
->rx_irq
)
177 disable_irq(vif
->rx_irq
);
178 del_timer_sync(&vif
->credit_timeout
);
181 static int xenvif_open(struct net_device
*dev
)
183 struct xenvif
*vif
= netdev_priv(dev
);
184 if (netif_carrier_ok(dev
))
186 netif_start_queue(dev
);
190 static int xenvif_close(struct net_device
*dev
)
192 struct xenvif
*vif
= netdev_priv(dev
);
193 if (netif_carrier_ok(dev
))
195 netif_stop_queue(dev
);
199 static int xenvif_change_mtu(struct net_device
*dev
, int mtu
)
201 struct xenvif
*vif
= netdev_priv(dev
);
202 int max
= vif
->can_sg
? 65535 - VLAN_ETH_HLEN
: ETH_DATA_LEN
;
210 static netdev_features_t
xenvif_fix_features(struct net_device
*dev
,
211 netdev_features_t features
)
213 struct xenvif
*vif
= netdev_priv(dev
);
216 features
&= ~NETIF_F_SG
;
217 if (~(vif
->gso_mask
| vif
->gso_prefix_mask
) & GSO_BIT(TCPV4
))
218 features
&= ~NETIF_F_TSO
;
219 if (~(vif
->gso_mask
| vif
->gso_prefix_mask
) & GSO_BIT(TCPV6
))
220 features
&= ~NETIF_F_TSO6
;
222 features
&= ~NETIF_F_IP_CSUM
;
224 features
&= ~NETIF_F_IPV6_CSUM
;
229 static const struct xenvif_stat
{
230 char name
[ETH_GSTRING_LEN
];
234 "rx_gso_checksum_fixup",
235 offsetof(struct xenvif
, rx_gso_checksum_fixup
)
239 static int xenvif_get_sset_count(struct net_device
*dev
, int string_set
)
241 switch (string_set
) {
243 return ARRAY_SIZE(xenvif_stats
);
249 static void xenvif_get_ethtool_stats(struct net_device
*dev
,
250 struct ethtool_stats
*stats
, u64
* data
)
252 void *vif
= netdev_priv(dev
);
255 for (i
= 0; i
< ARRAY_SIZE(xenvif_stats
); i
++)
256 data
[i
] = *(unsigned long *)(vif
+ xenvif_stats
[i
].offset
);
259 static void xenvif_get_strings(struct net_device
*dev
, u32 stringset
, u8
* data
)
265 for (i
= 0; i
< ARRAY_SIZE(xenvif_stats
); i
++)
266 memcpy(data
+ i
* ETH_GSTRING_LEN
,
267 xenvif_stats
[i
].name
, ETH_GSTRING_LEN
);
272 static const struct ethtool_ops xenvif_ethtool_ops
= {
273 .get_link
= ethtool_op_get_link
,
275 .get_sset_count
= xenvif_get_sset_count
,
276 .get_ethtool_stats
= xenvif_get_ethtool_stats
,
277 .get_strings
= xenvif_get_strings
,
280 static const struct net_device_ops xenvif_netdev_ops
= {
281 .ndo_start_xmit
= xenvif_start_xmit
,
282 .ndo_get_stats
= xenvif_get_stats
,
283 .ndo_open
= xenvif_open
,
284 .ndo_stop
= xenvif_close
,
285 .ndo_change_mtu
= xenvif_change_mtu
,
286 .ndo_fix_features
= xenvif_fix_features
,
287 .ndo_set_mac_address
= eth_mac_addr
,
288 .ndo_validate_addr
= eth_validate_addr
,
291 struct xenvif
*xenvif_alloc(struct device
*parent
, domid_t domid
,
295 struct net_device
*dev
;
297 char name
[IFNAMSIZ
] = {};
300 snprintf(name
, IFNAMSIZ
- 1, "vif%u.%u", domid
, handle
);
301 dev
= alloc_netdev(sizeof(struct xenvif
), name
, ether_setup
);
303 pr_warn("Could not allocate netdev for %s\n", name
);
304 return ERR_PTR(-ENOMEM
);
307 SET_NETDEV_DEV(dev
, parent
);
309 vif
= netdev_priv(dev
);
311 vif
->handle
= handle
;
316 vif
->credit_bytes
= vif
->remaining_credit
= ~0UL;
317 vif
->credit_usec
= 0UL;
318 init_timer(&vif
->credit_timeout
);
319 vif
->credit_window_start
= get_jiffies_64();
321 dev
->netdev_ops
= &xenvif_netdev_ops
;
322 dev
->hw_features
= NETIF_F_SG
|
323 NETIF_F_IP_CSUM
| NETIF_F_IPV6_CSUM
|
324 NETIF_F_TSO
| NETIF_F_TSO6
;
325 dev
->features
= dev
->hw_features
| NETIF_F_RXCSUM
;
326 SET_ETHTOOL_OPS(dev
, &xenvif_ethtool_ops
);
328 dev
->tx_queue_len
= XENVIF_QUEUE_LENGTH
;
330 skb_queue_head_init(&vif
->rx_queue
);
331 skb_queue_head_init(&vif
->tx_queue
);
333 vif
->pending_cons
= 0;
334 vif
->pending_prod
= MAX_PENDING_REQS
;
335 for (i
= 0; i
< MAX_PENDING_REQS
; i
++)
336 vif
->pending_ring
[i
] = i
;
337 for (i
= 0; i
< MAX_PENDING_REQS
; i
++)
338 vif
->mmap_pages
[i
] = NULL
;
341 * Initialise a dummy MAC address. We choose the numerically
342 * largest non-broadcast address to prevent the address getting
343 * stolen by an Ethernet bridge for STP purposes.
344 * (FE:FF:FF:FF:FF:FF)
346 memset(dev
->dev_addr
, 0xFF, ETH_ALEN
);
347 dev
->dev_addr
[0] &= ~0x01;
349 netif_napi_add(dev
, &vif
->napi
, xenvif_poll
, XENVIF_NAPI_WEIGHT
);
351 netif_carrier_off(dev
);
353 err
= register_netdev(dev
);
355 netdev_warn(dev
, "Could not register device: err=%d\n", err
);
360 netdev_dbg(dev
, "Successfully created xenvif\n");
362 __module_get(THIS_MODULE
);
367 int xenvif_connect(struct xenvif
*vif
, unsigned long tx_ring_ref
,
368 unsigned long rx_ring_ref
, unsigned int tx_evtchn
,
369 unsigned int rx_evtchn
)
373 /* Already connected through? */
377 err
= xenvif_map_frontend_rings(vif
, tx_ring_ref
, rx_ring_ref
);
381 if (tx_evtchn
== rx_evtchn
) {
382 /* feature-split-event-channels == 0 */
383 err
= bind_interdomain_evtchn_to_irqhandler(
384 vif
->domid
, tx_evtchn
, xenvif_interrupt
, 0,
385 vif
->dev
->name
, vif
);
388 vif
->tx_irq
= vif
->rx_irq
= err
;
389 disable_irq(vif
->tx_irq
);
391 /* feature-split-event-channels == 1 */
392 snprintf(vif
->tx_irq_name
, sizeof(vif
->tx_irq_name
),
393 "%s-tx", vif
->dev
->name
);
394 err
= bind_interdomain_evtchn_to_irqhandler(
395 vif
->domid
, tx_evtchn
, xenvif_tx_interrupt
, 0,
396 vif
->tx_irq_name
, vif
);
400 disable_irq(vif
->tx_irq
);
402 snprintf(vif
->rx_irq_name
, sizeof(vif
->rx_irq_name
),
403 "%s-rx", vif
->dev
->name
);
404 err
= bind_interdomain_evtchn_to_irqhandler(
405 vif
->domid
, rx_evtchn
, xenvif_rx_interrupt
, 0,
406 vif
->rx_irq_name
, vif
);
410 disable_irq(vif
->rx_irq
);
413 init_waitqueue_head(&vif
->wq
);
414 vif
->task
= kthread_create(xenvif_kthread
,
415 (void *)vif
, "%s", vif
->dev
->name
);
416 if (IS_ERR(vif
->task
)) {
417 pr_warn("Could not allocate kthread for %s\n", vif
->dev
->name
);
418 err
= PTR_ERR(vif
->task
);
423 if (!vif
->can_sg
&& vif
->dev
->mtu
> ETH_DATA_LEN
)
424 dev_set_mtu(vif
->dev
, ETH_DATA_LEN
);
425 netdev_update_features(vif
->dev
);
426 netif_carrier_on(vif
->dev
);
427 if (netif_running(vif
->dev
))
431 wake_up_process(vif
->task
);
436 unbind_from_irqhandler(vif
->rx_irq
, vif
);
439 unbind_from_irqhandler(vif
->tx_irq
, vif
);
442 xenvif_unmap_frontend_rings(vif
);
444 module_put(THIS_MODULE
);
448 void xenvif_carrier_off(struct xenvif
*vif
)
450 struct net_device
*dev
= vif
->dev
;
453 netif_carrier_off(dev
); /* discard queued packets */
454 if (netif_running(dev
))
459 void xenvif_disconnect(struct xenvif
*vif
)
461 if (netif_carrier_ok(vif
->dev
))
462 xenvif_carrier_off(vif
);
465 kthread_stop(vif
->task
);
468 if (vif
->tx_irq
== vif
->rx_irq
)
469 unbind_from_irqhandler(vif
->tx_irq
, vif
);
471 unbind_from_irqhandler(vif
->tx_irq
, vif
);
472 unbind_from_irqhandler(vif
->rx_irq
, vif
);
477 xenvif_unmap_frontend_rings(vif
);
480 void xenvif_free(struct xenvif
*vif
)
482 netif_napi_del(&vif
->napi
);
484 unregister_netdev(vif
->dev
);
486 free_netdev(vif
->dev
);
488 module_put(THIS_MODULE
);