1 /* 2 * Network-device interface management. 3 * 4 * Copyright (c) 2004-2005, Keir Fraser 5 * 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: 11 * 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: 18 * 19 * The above copyright notice and this permission notice shall be included in 20 * all copies or substantial portions of the Software. 21 * 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 28 * IN THE SOFTWARE. 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 42 void xenvif_get(struct xenvif *vif) 43 { 44 atomic_inc(&vif->refcnt); 45 } 46 47 void xenvif_put(struct xenvif *vif) 48 { 49 if (atomic_dec_and_test(&vif->refcnt)) 50 wake_up(&vif->waiting_to_free); 51 } 52 53 int xenvif_schedulable(struct xenvif *vif) 54 { 55 return netif_running(vif->dev) && netif_carrier_ok(vif->dev); 56 } 57 58 static int xenvif_rx_schedulable(struct xenvif *vif) 59 { 60 return xenvif_schedulable(vif) && !xen_netbk_rx_ring_full(vif); 61 } 62 63 static irqreturn_t xenvif_interrupt(int irq, void *dev_id) 64 { 65 struct xenvif *vif = dev_id; 66 67 if (vif->netbk == NULL) 68 return IRQ_NONE; 69 70 xen_netbk_schedule_xenvif(vif); 71 72 if (xenvif_rx_schedulable(vif)) 73 netif_wake_queue(vif->dev); 74 75 return IRQ_HANDLED; 76 } 77 78 static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) 79 { 80 struct xenvif *vif = netdev_priv(dev); 81 82 BUG_ON(skb->dev != dev); 83 84 if (vif->netbk == NULL) 85 goto drop; 86 87 /* Drop the packet if the target domain has no receive buffers. */ 88 if (!xenvif_rx_schedulable(vif)) 89 goto drop; 90 91 /* Reserve ring slots for the worst-case number of fragments. */ 92 vif->rx_req_cons_peek += xen_netbk_count_skb_slots(vif, skb); 93 xenvif_get(vif); 94 95 if (vif->can_queue && xen_netbk_must_stop_queue(vif)) 96 netif_stop_queue(dev); 97 98 xen_netbk_queue_tx_skb(vif, skb); 99 100 return NETDEV_TX_OK; 101 102 drop: 103 vif->dev->stats.tx_dropped++; 104 dev_kfree_skb(skb); 105 return NETDEV_TX_OK; 106 } 107 108 void xenvif_receive_skb(struct xenvif *vif, struct sk_buff *skb) 109 { 110 netif_rx_ni(skb); 111 } 112 113 void xenvif_notify_tx_completion(struct xenvif *vif) 114 { 115 if (netif_queue_stopped(vif->dev) && xenvif_rx_schedulable(vif)) 116 netif_wake_queue(vif->dev); 117 } 118 119 static struct net_device_stats *xenvif_get_stats(struct net_device *dev) 120 { 121 struct xenvif *vif = netdev_priv(dev); 122 return &vif->dev->stats; 123 } 124 125 static void xenvif_up(struct xenvif *vif) 126 { 127 xen_netbk_add_xenvif(vif); 128 enable_irq(vif->irq); 129 xen_netbk_check_rx_xenvif(vif); 130 } 131 132 static void xenvif_down(struct xenvif *vif) 133 { 134 disable_irq(vif->irq); 135 xen_netbk_deschedule_xenvif(vif); 136 xen_netbk_remove_xenvif(vif); 137 } 138 139 static int xenvif_open(struct net_device *dev) 140 { 141 struct xenvif *vif = netdev_priv(dev); 142 if (netif_carrier_ok(dev)) 143 xenvif_up(vif); 144 netif_start_queue(dev); 145 return 0; 146 } 147 148 static int xenvif_close(struct net_device *dev) 149 { 150 struct xenvif *vif = netdev_priv(dev); 151 if (netif_carrier_ok(dev)) 152 xenvif_down(vif); 153 netif_stop_queue(dev); 154 return 0; 155 } 156 157 static int xenvif_change_mtu(struct net_device *dev, int mtu) 158 { 159 struct xenvif *vif = netdev_priv(dev); 160 int max = vif->can_sg ? 65535 - VLAN_ETH_HLEN : ETH_DATA_LEN; 161 162 if (mtu > max) 163 return -EINVAL; 164 dev->mtu = mtu; 165 return 0; 166 } 167 168 static u32 xenvif_fix_features(struct net_device *dev, u32 features) 169 { 170 struct xenvif *vif = netdev_priv(dev); 171 172 if (!vif->can_sg) 173 features &= ~NETIF_F_SG; 174 if (!vif->gso && !vif->gso_prefix) 175 features &= ~NETIF_F_TSO; 176 if (!vif->csum) 177 features &= ~NETIF_F_IP_CSUM; 178 179 return features; 180 } 181 182 static const struct xenvif_stat { 183 char name[ETH_GSTRING_LEN]; 184 u16 offset; 185 } xenvif_stats[] = { 186 { 187 "rx_gso_checksum_fixup", 188 offsetof(struct xenvif, rx_gso_checksum_fixup) 189 }, 190 }; 191 192 static int xenvif_get_sset_count(struct net_device *dev, int string_set) 193 { 194 switch (string_set) { 195 case ETH_SS_STATS: 196 return ARRAY_SIZE(xenvif_stats); 197 default: 198 return -EINVAL; 199 } 200 } 201 202 static void xenvif_get_ethtool_stats(struct net_device *dev, 203 struct ethtool_stats *stats, u64 * data) 204 { 205 void *vif = netdev_priv(dev); 206 int i; 207 208 for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++) 209 data[i] = *(unsigned long *)(vif + xenvif_stats[i].offset); 210 } 211 212 static void xenvif_get_strings(struct net_device *dev, u32 stringset, u8 * data) 213 { 214 int i; 215 216 switch (stringset) { 217 case ETH_SS_STATS: 218 for (i = 0; i < ARRAY_SIZE(xenvif_stats); i++) 219 memcpy(data + i * ETH_GSTRING_LEN, 220 xenvif_stats[i].name, ETH_GSTRING_LEN); 221 break; 222 } 223 } 224 225 static struct ethtool_ops xenvif_ethtool_ops = { 226 .get_link = ethtool_op_get_link, 227 228 .get_sset_count = xenvif_get_sset_count, 229 .get_ethtool_stats = xenvif_get_ethtool_stats, 230 .get_strings = xenvif_get_strings, 231 }; 232 233 static struct net_device_ops xenvif_netdev_ops = { 234 .ndo_start_xmit = xenvif_start_xmit, 235 .ndo_get_stats = xenvif_get_stats, 236 .ndo_open = xenvif_open, 237 .ndo_stop = xenvif_close, 238 .ndo_change_mtu = xenvif_change_mtu, 239 .ndo_fix_features = xenvif_fix_features, 240 }; 241 242 struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, 243 unsigned int handle) 244 { 245 int err; 246 struct net_device *dev; 247 struct xenvif *vif; 248 char name[IFNAMSIZ] = {}; 249 250 snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle); 251 dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup); 252 if (dev == NULL) { 253 pr_warn("Could not allocate netdev\n"); 254 return ERR_PTR(-ENOMEM); 255 } 256 257 SET_NETDEV_DEV(dev, parent); 258 259 vif = netdev_priv(dev); 260 vif->domid = domid; 261 vif->handle = handle; 262 vif->netbk = NULL; 263 vif->can_sg = 1; 264 vif->csum = 1; 265 atomic_set(&vif->refcnt, 1); 266 init_waitqueue_head(&vif->waiting_to_free); 267 vif->dev = dev; 268 INIT_LIST_HEAD(&vif->schedule_list); 269 INIT_LIST_HEAD(&vif->notify_list); 270 271 vif->credit_bytes = vif->remaining_credit = ~0UL; 272 vif->credit_usec = 0UL; 273 init_timer(&vif->credit_timeout); 274 /* Initialize 'expires' now: it's used to track the credit window. */ 275 vif->credit_timeout.expires = jiffies; 276 277 dev->netdev_ops = &xenvif_netdev_ops; 278 dev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO; 279 dev->features = dev->hw_features; 280 SET_ETHTOOL_OPS(dev, &xenvif_ethtool_ops); 281 282 dev->tx_queue_len = XENVIF_QUEUE_LENGTH; 283 284 /* 285 * Initialise a dummy MAC address. We choose the numerically 286 * largest non-broadcast address to prevent the address getting 287 * stolen by an Ethernet bridge for STP purposes. 288 * (FE:FF:FF:FF:FF:FF) 289 */ 290 memset(dev->dev_addr, 0xFF, ETH_ALEN); 291 dev->dev_addr[0] &= ~0x01; 292 293 netif_carrier_off(dev); 294 295 err = register_netdev(dev); 296 if (err) { 297 netdev_warn(dev, "Could not register device: err=%d\n", err); 298 free_netdev(dev); 299 return ERR_PTR(err); 300 } 301 302 netdev_dbg(dev, "Successfully created xenvif\n"); 303 return vif; 304 } 305 306 int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, 307 unsigned long rx_ring_ref, unsigned int evtchn) 308 { 309 int err = -ENOMEM; 310 311 /* Already connected through? */ 312 if (vif->irq) 313 return 0; 314 315 err = xen_netbk_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref); 316 if (err < 0) 317 goto err; 318 319 err = bind_interdomain_evtchn_to_irqhandler( 320 vif->domid, evtchn, xenvif_interrupt, 0, 321 vif->dev->name, vif); 322 if (err < 0) 323 goto err_unmap; 324 vif->irq = err; 325 disable_irq(vif->irq); 326 327 xenvif_get(vif); 328 329 rtnl_lock(); 330 if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN) 331 dev_set_mtu(vif->dev, ETH_DATA_LEN); 332 netdev_update_features(vif->dev); 333 netif_carrier_on(vif->dev); 334 if (netif_running(vif->dev)) 335 xenvif_up(vif); 336 rtnl_unlock(); 337 338 return 0; 339 err_unmap: 340 xen_netbk_unmap_frontend_rings(vif); 341 err: 342 return err; 343 } 344 345 void xenvif_disconnect(struct xenvif *vif) 346 { 347 struct net_device *dev = vif->dev; 348 if (netif_carrier_ok(dev)) { 349 rtnl_lock(); 350 netif_carrier_off(dev); /* discard queued packets */ 351 if (netif_running(dev)) 352 xenvif_down(vif); 353 rtnl_unlock(); 354 xenvif_put(vif); 355 } 356 357 atomic_dec(&vif->refcnt); 358 wait_event(vif->waiting_to_free, atomic_read(&vif->refcnt) == 0); 359 360 del_timer_sync(&vif->credit_timeout); 361 362 if (vif->irq) 363 unbind_from_irqhandler(vif->irq, vif); 364 365 unregister_netdev(vif->dev); 366 367 xen_netbk_unmap_frontend_rings(vif); 368 369 free_netdev(vif->dev); 370 } 371