Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/drivers/net/ethernet/sun/sunvnet.c

  1 /* sunvnet.c: Sun LDOM Virtual Network Driver.
  2  *
  3  * Copyright (C) 2007, 2008 David S. Miller <davem@davemloft.net>
  4  * Copyright (C) 2016 Oracle. All rights reserved.
  5  */
  6 
  7 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  8 
  9 #include <linux/module.h>
 10 #include <linux/kernel.h>
 11 #include <linux/types.h>
 12 #include <linux/slab.h>
 13 #include <linux/delay.h>
 14 #include <linux/init.h>
 15 #include <linux/netdevice.h>
 16 #include <linux/ethtool.h>
 17 #include <linux/etherdevice.h>
 18 #include <linux/mutex.h>
 19 #include <linux/highmem.h>
 20 #include <linux/if_vlan.h>
 21 
 22 #if IS_ENABLED(CONFIG_IPV6)
 23 #include <linux/icmpv6.h>
 24 #endif
 25 
 26 #include <net/ip.h>
 27 #include <net/icmp.h>
 28 #include <net/route.h>
 29 
 30 #include <asm/vio.h>
 31 #include <asm/ldc.h>
 32 
 33 #include "sunvnet_common.h"
 34 
 35 /* length of time before we decide the hardware is borked,
 36  * and dev->tx_timeout() should be called to fix the problem
 37  */
 38 #define VNET_TX_TIMEOUT                 (5 * HZ)
 39 
 40 #define DRV_MODULE_NAME         "sunvnet"
 41 #define DRV_MODULE_VERSION      "1.0"
 42 #define DRV_MODULE_RELDATE      "June 25, 2007"
 43 
 44 static char version[] =
 45         DRV_MODULE_NAME ".c:v" DRV_MODULE_VERSION " (" DRV_MODULE_RELDATE ")\n";
 46 MODULE_AUTHOR("David S. Miller (davem@davemloft.net)");
 47 MODULE_DESCRIPTION("Sun LDOM virtual network driver");
 48 MODULE_LICENSE("GPL");
 49 MODULE_VERSION(DRV_MODULE_VERSION);
 50 
 51 /* Ordered from largest major to lowest */
 52 static struct vio_version vnet_versions[] = {
 53         { .major = 1, .minor = 8 },
 54         { .major = 1, .minor = 7 },
 55         { .major = 1, .minor = 6 },
 56         { .major = 1, .minor = 0 },
 57 };
 58 
 59 static void vnet_get_drvinfo(struct net_device *dev,
 60                              struct ethtool_drvinfo *info)
 61 {
 62         strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
 63         strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
 64 }
 65 
 66 static u32 vnet_get_msglevel(struct net_device *dev)
 67 {
 68         struct vnet *vp = netdev_priv(dev);
 69 
 70         return vp->msg_enable;
 71 }
 72 
 73 static void vnet_set_msglevel(struct net_device *dev, u32 value)
 74 {
 75         struct vnet *vp = netdev_priv(dev);
 76 
 77         vp->msg_enable = value;
 78 }
 79 
 80 static const struct ethtool_ops vnet_ethtool_ops = {
 81         .get_drvinfo            = vnet_get_drvinfo,
 82         .get_msglevel           = vnet_get_msglevel,
 83         .set_msglevel           = vnet_set_msglevel,
 84         .get_link               = ethtool_op_get_link,
 85 };
 86 
 87 static LIST_HEAD(vnet_list);
 88 static DEFINE_MUTEX(vnet_list_mutex);
 89 
 90 static struct vnet_port *__tx_port_find(struct vnet *vp, struct sk_buff *skb)
 91 {
 92         unsigned int hash = vnet_hashfn(skb->data);
 93         struct hlist_head *hp = &vp->port_hash[hash];
 94         struct vnet_port *port;
 95 
 96         hlist_for_each_entry_rcu(port, hp, hash) {
 97                 if (!sunvnet_port_is_up_common(port))
 98                         continue;
 99                 if (ether_addr_equal(port->raddr, skb->data))
100                         return port;
101         }
102         list_for_each_entry_rcu(port, &vp->port_list, list) {
103                 if (!port->switch_port)
104                         continue;
105                 if (!sunvnet_port_is_up_common(port))
106                         continue;
107                 return port;
108         }
109         return NULL;
110 }
111 
112 /* func arg to vnet_start_xmit_common() to get the proper tx port */
113 static struct vnet_port *vnet_tx_port_find(struct sk_buff *skb,
114                                            struct net_device *dev)
115 {
116         struct vnet *vp = netdev_priv(dev);
117 
118         return __tx_port_find(vp, skb);
119 }
120 
121 static u16 vnet_select_queue(struct net_device *dev, struct sk_buff *skb,
122                              void *accel_priv, select_queue_fallback_t fallback)
123 {
124         struct vnet *vp = netdev_priv(dev);
125         struct vnet_port *port = __tx_port_find(vp, skb);
126 
127         if (!port)
128                 return 0;
129 
130         return port->q_index;
131 }
132 
133 /* Wrappers to common functions */
134 static int vnet_start_xmit(struct sk_buff *skb, struct net_device *dev)
135 {
136         return sunvnet_start_xmit_common(skb, dev, vnet_tx_port_find);
137 }
138 
139 static void vnet_set_rx_mode(struct net_device *dev)
140 {
141         struct vnet *vp = netdev_priv(dev);
142 
143         return sunvnet_set_rx_mode_common(dev, vp);
144 }
145 
146 #ifdef CONFIG_NET_POLL_CONTROLLER
147 static void vnet_poll_controller(struct net_device *dev)
148 {
149         struct vnet *vp = netdev_priv(dev);
150 
151         return sunvnet_poll_controller_common(dev, vp);
152 }
153 #endif
154 
155 static const struct net_device_ops vnet_ops = {
156         .ndo_open               = sunvnet_open_common,
157         .ndo_stop               = sunvnet_close_common,
158         .ndo_set_rx_mode        = vnet_set_rx_mode,
159         .ndo_set_mac_address    = sunvnet_set_mac_addr_common,
160         .ndo_validate_addr      = eth_validate_addr,
161         .ndo_tx_timeout         = sunvnet_tx_timeout_common,
162         .ndo_start_xmit         = vnet_start_xmit,
163         .ndo_select_queue       = vnet_select_queue,
164 #ifdef CONFIG_NET_POLL_CONTROLLER
165         .ndo_poll_controller    = vnet_poll_controller,
166 #endif
167 };
168 
169 static struct vnet *vnet_new(const u64 *local_mac,
170                              struct vio_dev *vdev)
171 {
172         struct net_device *dev;
173         struct vnet *vp;
174         int err, i;
175 
176         dev = alloc_etherdev_mqs(sizeof(*vp), VNET_MAX_TXQS, 1);
177         if (!dev)
178                 return ERR_PTR(-ENOMEM);
179         dev->needed_headroom = VNET_PACKET_SKIP + 8;
180         dev->needed_tailroom = 8;
181 
182         for (i = 0; i < ETH_ALEN; i++)
183                 dev->dev_addr[i] = (*local_mac >> (5 - i) * 8) & 0xff;
184 
185         vp = netdev_priv(dev);
186 
187         spin_lock_init(&vp->lock);
188         vp->dev = dev;
189 
190         INIT_LIST_HEAD(&vp->port_list);
191         for (i = 0; i < VNET_PORT_HASH_SIZE; i++)
192                 INIT_HLIST_HEAD(&vp->port_hash[i]);
193         INIT_LIST_HEAD(&vp->list);
194         vp->local_mac = *local_mac;
195 
196         dev->netdev_ops = &vnet_ops;
197         dev->ethtool_ops = &vnet_ethtool_ops;
198         dev->watchdog_timeo = VNET_TX_TIMEOUT;
199 
200         dev->hw_features = NETIF_F_TSO | NETIF_F_GSO | NETIF_F_GSO_SOFTWARE |
201                            NETIF_F_HW_CSUM | NETIF_F_SG;
202         dev->features = dev->hw_features;
203 
204         /* MTU range: 68 - 65535 */
205         dev->min_mtu = ETH_MIN_MTU;
206         dev->max_mtu = VNET_MAX_MTU;
207 
208         SET_NETDEV_DEV(dev, &vdev->dev);
209 
210         err = register_netdev(dev);
211         if (err) {
212                 pr_err("Cannot register net device, aborting\n");
213                 goto err_out_free_dev;
214         }
215 
216         netdev_info(dev, "Sun LDOM vnet %pM\n", dev->dev_addr);
217 
218         list_add(&vp->list, &vnet_list);
219 
220         return vp;
221 
222 err_out_free_dev:
223         free_netdev(dev);
224 
225         return ERR_PTR(err);
226 }
227 
228 static struct vnet *vnet_find_or_create(const u64 *local_mac,
229                                         struct vio_dev *vdev)
230 {
231         struct vnet *iter, *vp;
232 
233         mutex_lock(&vnet_list_mutex);
234         vp = NULL;
235         list_for_each_entry(iter, &vnet_list, list) {
236                 if (iter->local_mac == *local_mac) {
237                         vp = iter;
238                         break;
239                 }
240         }
241         if (!vp)
242                 vp = vnet_new(local_mac, vdev);
243         mutex_unlock(&vnet_list_mutex);
244 
245         return vp;
246 }
247 
248 static void vnet_cleanup(void)
249 {
250         struct vnet *vp;
251         struct net_device *dev;
252 
253         mutex_lock(&vnet_list_mutex);
254         while (!list_empty(&vnet_list)) {
255                 vp = list_first_entry(&vnet_list, struct vnet, list);
256                 list_del(&vp->list);
257                 dev = vp->dev;
258                 /* vio_unregister_driver() should have cleaned up port_list */
259                 BUG_ON(!list_empty(&vp->port_list));
260                 unregister_netdev(dev);
261                 free_netdev(dev);
262         }
263         mutex_unlock(&vnet_list_mutex);
264 }
265 
266 static const char *local_mac_prop = "local-mac-address";
267 
268 static struct vnet *vnet_find_parent(struct mdesc_handle *hp,
269                                      u64 port_node,
270                                      struct vio_dev *vdev)
271 {
272         const u64 *local_mac = NULL;
273         u64 a;
274 
275         mdesc_for_each_arc(a, hp, port_node, MDESC_ARC_TYPE_BACK) {
276                 u64 target = mdesc_arc_target(hp, a);
277                 const char *name;
278 
279                 name = mdesc_get_property(hp, target, "name", NULL);
280                 if (!name || strcmp(name, "network"))
281                         continue;
282 
283                 local_mac = mdesc_get_property(hp, target,
284                                                local_mac_prop, NULL);
285                 if (local_mac)
286                         break;
287         }
288         if (!local_mac)
289                 return ERR_PTR(-ENODEV);
290 
291         return vnet_find_or_create(local_mac, vdev);
292 }
293 
294 static struct ldc_channel_config vnet_ldc_cfg = {
295         .event          = sunvnet_event_common,
296         .mtu            = 64,
297         .mode           = LDC_MODE_UNRELIABLE,
298 };
299 
300 static struct vio_driver_ops vnet_vio_ops = {
301         .send_attr              = sunvnet_send_attr_common,
302         .handle_attr            = sunvnet_handle_attr_common,
303         .handshake_complete     = sunvnet_handshake_complete_common,
304 };
305 
306 static void print_version(void)
307 {
308         printk_once(KERN_INFO "%s", version);
309 }
310 
311 const char *remote_macaddr_prop = "remote-mac-address";
312 
313 static int vnet_port_probe(struct vio_dev *vdev, const struct vio_device_id *id)
314 {
315         struct mdesc_handle *hp;
316         struct vnet_port *port;
317         unsigned long flags;
318         struct vnet *vp;
319         const u64 *rmac;
320         int len, i, err, switch_port;
321 
322         print_version();
323 
324         hp = mdesc_grab();
325 
326         vp = vnet_find_parent(hp, vdev->mp, vdev);
327         if (IS_ERR(vp)) {
328                 pr_err("Cannot find port parent vnet\n");
329                 err = PTR_ERR(vp);
330                 goto err_out_put_mdesc;
331         }
332 
333         rmac = mdesc_get_property(hp, vdev->mp, remote_macaddr_prop, &len);
334         err = -ENODEV;
335         if (!rmac) {
336                 pr_err("Port lacks %s property\n", remote_macaddr_prop);
337                 goto err_out_put_mdesc;
338         }
339 
340         port = kzalloc(sizeof(*port), GFP_KERNEL);
341         err = -ENOMEM;
342         if (!port)
343                 goto err_out_put_mdesc;
344 
345         for (i = 0; i < ETH_ALEN; i++)
346                 port->raddr[i] = (*rmac >> (5 - i) * 8) & 0xff;
347 
348         port->vp = vp;
349 
350         err = vio_driver_init(&port->vio, vdev, VDEV_NETWORK,
351                               vnet_versions, ARRAY_SIZE(vnet_versions),
352                               &vnet_vio_ops, vp->dev->name);
353         if (err)
354                 goto err_out_free_port;
355 
356         err = vio_ldc_alloc(&port->vio, &vnet_ldc_cfg, port);
357         if (err)
358                 goto err_out_free_port;
359 
360         netif_napi_add(port->vp->dev, &port->napi, sunvnet_poll_common,
361                        NAPI_POLL_WEIGHT);
362 
363         INIT_HLIST_NODE(&port->hash);
364         INIT_LIST_HEAD(&port->list);
365 
366         switch_port = 0;
367         if (mdesc_get_property(hp, vdev->mp, "switch-port", NULL))
368                 switch_port = 1;
369         port->switch_port = switch_port;
370         port->tso = true;
371         port->tsolen = 0;
372 
373         spin_lock_irqsave(&vp->lock, flags);
374         if (switch_port)
375                 list_add_rcu(&port->list, &vp->port_list);
376         else
377                 list_add_tail_rcu(&port->list, &vp->port_list);
378         hlist_add_head_rcu(&port->hash,
379                            &vp->port_hash[vnet_hashfn(port->raddr)]);
380         sunvnet_port_add_txq_common(port);
381         spin_unlock_irqrestore(&vp->lock, flags);
382 
383         dev_set_drvdata(&vdev->dev, port);
384 
385         pr_info("%s: PORT ( remote-mac %pM%s )\n",
386                 vp->dev->name, port->raddr, switch_port ? " switch-port" : "");
387 
388         setup_timer(&port->clean_timer, sunvnet_clean_timer_expire_common,
389                     (unsigned long)port);
390 
391         napi_enable(&port->napi);
392         vio_port_up(&port->vio);
393 
394         mdesc_release(hp);
395 
396         return 0;
397 
398 err_out_free_port:
399         kfree(port);
400 
401 err_out_put_mdesc:
402         mdesc_release(hp);
403         return err;
404 }
405 
406 static int vnet_port_remove(struct vio_dev *vdev)
407 {
408         struct vnet_port *port = dev_get_drvdata(&vdev->dev);
409 
410         if (port) {
411                 del_timer_sync(&port->vio.timer);
412 
413                 napi_disable(&port->napi);
414 
415                 list_del_rcu(&port->list);
416                 hlist_del_rcu(&port->hash);
417 
418                 synchronize_rcu();
419                 del_timer_sync(&port->clean_timer);
420                 sunvnet_port_rm_txq_common(port);
421                 netif_napi_del(&port->napi);
422                 sunvnet_port_free_tx_bufs_common(port);
423                 vio_ldc_free(&port->vio);
424 
425                 dev_set_drvdata(&vdev->dev, NULL);
426 
427                 kfree(port);
428         }
429         return 0;
430 }
431 
432 static const struct vio_device_id vnet_port_match[] = {
433         {
434                 .type = "vnet-port",
435         },
436         {},
437 };
438 MODULE_DEVICE_TABLE(vio, vnet_port_match);
439 
440 static struct vio_driver vnet_port_driver = {
441         .id_table       = vnet_port_match,
442         .probe          = vnet_port_probe,
443         .remove         = vnet_port_remove,
444         .name           = "vnet_port",
445 };
446 
447 static int __init vnet_init(void)
448 {
449         return vio_register_driver(&vnet_port_driver);
450 }
451 
452 static void __exit vnet_exit(void)
453 {
454         vio_unregister_driver(&vnet_port_driver);
455         vnet_cleanup();
456 }
457 
458 module_init(vnet_init);
459 module_exit(vnet_exit);
460 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us