netdev: Remove may_create/may_open flags.
[sliver-openvswitch.git] / lib / netdev.c
1 /*
2  * Copyright (c) 2008, 2009, 2010 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "netdev.h"
19
20 #include <assert.h>
21 #include <errno.h>
22 #include <inttypes.h>
23 #include <netinet/in.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27
28 #include "coverage.h"
29 #include "dynamic-string.h"
30 #include "fatal-signal.h"
31 #include "hash.h"
32 #include "list.h"
33 #include "netdev-provider.h"
34 #include "ofpbuf.h"
35 #include "openflow/openflow.h"
36 #include "packets.h"
37 #include "poll-loop.h"
38 #include "shash.h"
39 #include "svec.h"
40
41 #define THIS_MODULE VLM_netdev
42 #include "vlog.h"
43
44 static const struct netdev_class *base_netdev_classes[] = {
45 #ifdef HAVE_NETLINK
46     &netdev_linux_class,
47     &netdev_tap_class,
48     &netdev_patch_class,
49     &netdev_gre_class,
50 #endif
51 };
52
53 static struct shash netdev_classes = SHASH_INITIALIZER(&netdev_classes);
54
55 /* All created network devices. */
56 static struct shash netdev_dev_shash = SHASH_INITIALIZER(&netdev_dev_shash);
57
58 /* All open network devices. */
59 static struct list netdev_list = LIST_INITIALIZER(&netdev_list);
60
61 /* This is set pretty low because we probably won't learn anything from the
62  * additional log messages. */
63 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20);
64
65 static void close_all_netdevs(void *aux OVS_UNUSED);
66 static int restore_flags(struct netdev *netdev);
67 void update_device_args(struct netdev_dev *, const struct shash *args);
68
69 static void
70 netdev_initialize(void)
71 {
72     static int status = -1;
73
74     if (status < 0) {
75         int i;
76
77         fatal_signal_add_hook(close_all_netdevs, NULL, NULL, true);
78
79         status = 0;
80         for (i = 0; i < ARRAY_SIZE(base_netdev_classes); i++) {
81             netdev_register_provider(base_netdev_classes[i]);
82         }
83     }
84 }
85
86 /* Performs periodic work needed by all the various kinds of netdevs.
87  *
88  * If your program opens any netdevs, it must call this function within its
89  * main poll loop. */
90 void
91 netdev_run(void)
92 {
93     struct shash_node *node;
94     SHASH_FOR_EACH(node, &netdev_classes) {
95         const struct netdev_class *netdev_class = node->data;
96         if (netdev_class->run) {
97             netdev_class->run();
98         }
99     }
100 }
101
102 /* Arranges for poll_block() to wake up when netdev_run() needs to be called.
103  *
104  * If your program opens any netdevs, it must call this function within its
105  * main poll loop. */
106 void
107 netdev_wait(void)
108 {
109     struct shash_node *node;
110     SHASH_FOR_EACH(node, &netdev_classes) {
111         const struct netdev_class *netdev_class = node->data;
112         if (netdev_class->wait) {
113             netdev_class->wait();
114         }
115     }
116 }
117
118 /* Initializes and registers a new netdev provider.  After successful
119  * registration, new netdevs of that type can be opened using netdev_open(). */
120 int
121 netdev_register_provider(const struct netdev_class *new_class)
122 {
123     struct netdev_class *new_provider;
124
125     if (shash_find(&netdev_classes, new_class->type)) {
126         VLOG_WARN("attempted to register duplicate netdev provider: %s",
127                    new_class->type);
128         return EEXIST;
129     }
130
131     if (new_class->init) {
132         int error = new_class->init();
133         if (error) {
134             VLOG_ERR("failed to initialize %s network device class: %s",
135                      new_class->type, strerror(error));
136             return error;
137         }
138     }
139
140     new_provider = xmalloc(sizeof *new_provider);
141     memcpy(new_provider, new_class, sizeof *new_provider);
142
143     shash_add(&netdev_classes, new_class->type, new_provider);
144
145     return 0;
146 }
147
148 /* Unregisters a netdev provider.  'type' must have been previously
149  * registered and not currently be in use by any netdevs.  After unregistration
150  * new netdevs of that type cannot be opened using netdev_open(). */
151 int
152 netdev_unregister_provider(const char *type)
153 {
154     struct shash_node *del_node, *netdev_dev_node;
155
156     del_node = shash_find(&netdev_classes, type);
157     if (!del_node) {
158         VLOG_WARN("attempted to unregister a netdev provider that is not "
159                   "registered: %s", type);
160         return EAFNOSUPPORT;
161     }
162
163     SHASH_FOR_EACH(netdev_dev_node, &netdev_dev_shash) {
164         struct netdev_dev *netdev_dev = netdev_dev_node->data;
165         if (!strcmp(netdev_dev->netdev_class->type, type)) {
166             VLOG_WARN("attempted to unregister in use netdev provider: %s",
167                       type);
168             return EBUSY;
169         }
170     }
171
172     shash_delete(&netdev_classes, del_node);
173     free(del_node->data);
174
175     return 0;
176 }
177
178 /* Clears 'types' and enumerates the types of all currently registered netdev
179  * providers into it.  The caller must first initialize the svec. */
180 void
181 netdev_enumerate_types(struct svec *types)
182 {
183     struct shash_node *node;
184
185     netdev_initialize();
186     svec_clear(types);
187
188     SHASH_FOR_EACH(node, &netdev_classes) {
189         const struct netdev_class *netdev_class = node->data;
190         svec_add(types, netdev_class->type);
191     }
192 }
193
194 /* Compares 'args' to those used to those used by 'dev'.  Returns true
195  * if the arguments are the same, false otherwise.  Does not update the
196  * values stored in 'dev'. */
197 static bool
198 compare_device_args(const struct netdev_dev *dev, const struct shash *args)
199 {
200     const struct shash_node **new_args;
201     bool result = true;
202     int i;
203
204     if (shash_count(args) != dev->n_args) {
205         return false;
206     }
207
208     new_args = shash_sort(args);
209     for (i = 0; i < dev->n_args; i++) {
210         if (strcmp(dev->args[i].key, new_args[i]->name) || 
211             strcmp(dev->args[i].value, new_args[i]->data)) {
212             result = false;
213             goto finish;
214         }
215     }
216
217 finish:
218     free(new_args);
219     return result;
220 }
221
222 static int
223 compare_args(const void *a_, const void *b_)
224 {
225     const struct arg *a = a_;
226     const struct arg *b = b_;
227     return strcmp(a->key, b->key);
228 }
229
230 void
231 update_device_args(struct netdev_dev *dev, const struct shash *args)
232 {
233     struct shash_node *node;
234     int i;
235
236     if (dev->n_args) {
237         for (i = 0; i < dev->n_args; i++) {
238             free(dev->args[i].key);
239             free(dev->args[i].value);
240         }
241
242         free(dev->args);
243         dev->n_args = 0;
244     }
245
246     if (!args || shash_is_empty(args)) {
247         return;
248     }
249
250     dev->n_args = shash_count(args);
251     dev->args = xmalloc(dev->n_args * sizeof *dev->args);
252
253     i = 0;
254     SHASH_FOR_EACH(node, args) {
255         dev->args[i].key = xstrdup(node->name);
256         dev->args[i].value = xstrdup(node->data);
257         i++;
258     }
259
260     qsort(dev->args, dev->n_args, sizeof *dev->args, compare_args);
261 }
262
263 static int
264 create_device(struct netdev_options *options, struct netdev_dev **netdev_devp)
265 {
266     struct netdev_class *netdev_class;
267
268     if (!options->type || strlen(options->type) == 0) {
269         /* Default to system. */
270         options->type = "system";
271     }
272
273     netdev_class = shash_find_data(&netdev_classes, options->type);
274     if (!netdev_class) {
275         VLOG_WARN("could not create netdev %s of unknown type %s",
276                   options->name, options->type);
277         return EAFNOSUPPORT;
278     }
279
280     return netdev_class->create(options->name, options->type, options->args,
281                                 netdev_devp);
282 }
283
284 /* Opens the network device named 'name' (e.g. "eth0") and returns zero if
285  * successful, otherwise a positive errno value.  On success, sets '*netdevp'
286  * to the new network device, otherwise to null.
287  *
288  * If this is the first time the device has been opened, then create is called
289  * before opening.  The device is  created using the given type and arguments.
290  *
291  * 'ethertype' may be a 16-bit Ethernet protocol value in host byte order to
292  * capture frames of that type received on the device.  It may also be one of
293  * the 'enum netdev_pseudo_ethertype' values to receive frames in one of those
294  * categories. */
295
296 int
297 netdev_open(struct netdev_options *options, struct netdev **netdevp)
298 {
299     struct shash empty_args = SHASH_INITIALIZER(&empty_args);
300     struct netdev_dev *netdev_dev;
301     int error;
302
303     *netdevp = NULL;
304     netdev_initialize();
305
306     if (!options->args) {
307         options->args = &empty_args;
308     }
309
310     netdev_dev = shash_find_data(&netdev_dev_shash, options->name);
311
312     if (!netdev_dev) {
313         error = create_device(options, &netdev_dev);
314         if (error) {
315             return error;
316         }
317         update_device_args(netdev_dev, options->args);
318
319     } else if (!shash_is_empty(options->args) &&
320                !compare_device_args(netdev_dev, options->args)) {
321
322         VLOG_WARN("%s: attempted to open already open netdev with "
323                   "different arguments", options->name);
324         return EINVAL;
325     }
326
327     error = netdev_dev->netdev_class->open(netdev_dev, options->ethertype, 
328                 netdevp);
329
330     if (!error) {
331         netdev_dev->ref_cnt++;
332     } else {
333         if (!netdev_dev->ref_cnt) {
334             netdev_dev_uninit(netdev_dev, true);
335         }
336     }
337
338     return error;
339 }
340
341 int
342 netdev_open_default(const char *name, struct netdev **netdevp)
343 {
344     struct netdev_options options;
345
346     memset(&options, 0, sizeof options);
347     options.name = name;
348     options.ethertype = NETDEV_ETH_TYPE_NONE;
349
350     return netdev_open(&options, netdevp);
351 }
352
353 /* Reconfigures the device 'netdev' with 'args'.  'args' may be empty
354  * or NULL if none are needed. */
355 int
356 netdev_reconfigure(struct netdev *netdev, const struct shash *args)
357 {
358     struct shash empty_args = SHASH_INITIALIZER(&empty_args);
359     struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
360
361     if (!args) {
362         args = &empty_args;
363     }
364
365     if (netdev_dev->netdev_class->reconfigure) {
366         if (!compare_device_args(netdev_dev, args)) {
367             update_device_args(netdev_dev, args);
368             return netdev_dev->netdev_class->reconfigure(netdev_dev, args);
369         }
370     } else if (!shash_is_empty(args)) {
371         VLOG_WARN("%s: arguments provided to device that does not have a "
372                   "reconfigure function", netdev_get_name(netdev));
373     }
374
375     return 0;
376 }
377
378 /* Closes and destroys 'netdev'. */
379 void
380 netdev_close(struct netdev *netdev)
381 {
382     if (netdev) {
383         struct netdev_dev *netdev_dev = netdev_get_dev(netdev);
384
385         assert(netdev_dev->ref_cnt);
386         netdev_dev->ref_cnt--;
387         netdev_uninit(netdev, true);
388
389         /* If the reference count for the netdev device is zero, destroy it. */
390         if (!netdev_dev->ref_cnt) {
391             netdev_dev_uninit(netdev_dev, true);
392         }
393     }
394 }
395
396 /* Returns true if a network device named 'name' exists and may be opened,
397  * otherwise false. */
398 bool
399 netdev_exists(const char *name)
400 {
401     struct netdev *netdev;
402     int error;
403
404     error = netdev_open_default(name, &netdev);
405     if (!error) {
406         netdev_close(netdev);
407         return true;
408     } else {
409         if (error != ENODEV) {
410             VLOG_WARN("failed to open network device %s: %s",
411                       name, strerror(error));
412         }
413         return false;
414     }
415 }
416
417 /* Returns true if a network device named 'name' is currently opened,
418  * otherwise false. */
419 bool
420 netdev_is_open(const char *name)
421 {
422     return !!shash_find_data(&netdev_dev_shash, name);
423 }
424
425 /*  Clears 'svec' and enumerates the names of all known network devices. */
426 int
427 netdev_enumerate(struct svec *svec)
428 {
429     struct shash_node *node;
430     int error = 0;
431
432     netdev_initialize();
433     svec_clear(svec);
434
435     SHASH_FOR_EACH(node, &netdev_classes) {
436         const struct netdev_class *netdev_class = node->data;
437         if (netdev_class->enumerate) {
438             int retval = netdev_class->enumerate(svec);
439             if (retval) {
440                 VLOG_WARN("failed to enumerate %s network devices: %s",
441                           netdev_class->type, strerror(retval));
442                 if (!error) {
443                     error = retval;
444                 }
445             }
446         }
447     }
448
449     return error;
450 }
451
452 /* Attempts to receive a packet from 'netdev' into 'buffer', which the caller
453  * must have initialized with sufficient room for the packet.  The space
454  * required to receive any packet is ETH_HEADER_LEN bytes, plus VLAN_HEADER_LEN
455  * bytes, plus the device's MTU (which may be retrieved via netdev_get_mtu()).
456  * (Some devices do not allow for a VLAN header, in which case VLAN_HEADER_LEN
457  * need not be included.)
458  *
459  * If a packet is successfully retrieved, returns 0.  In this case 'buffer' is
460  * guaranteed to contain at least ETH_TOTAL_MIN bytes.  Otherwise, returns a
461  * positive errno value.  Returns EAGAIN immediately if no packet is ready to
462  * be returned.
463  *
464  * Some network devices may not implement support for this function.  In such
465  * cases this function will always return EOPNOTSUPP.
466  */
467 int
468 netdev_recv(struct netdev *netdev, struct ofpbuf *buffer)
469 {
470     int (*recv)(struct netdev *, void *, size_t);
471     int retval;
472
473     assert(buffer->size == 0);
474     assert(ofpbuf_tailroom(buffer) >= ETH_TOTAL_MIN);
475
476     recv = netdev_get_dev(netdev)->netdev_class->recv;
477     retval = (recv
478               ? (recv)(netdev, buffer->data, ofpbuf_tailroom(buffer))
479               : -EOPNOTSUPP);
480     if (retval >= 0) {
481         COVERAGE_INC(netdev_received);
482         buffer->size += retval;
483         if (buffer->size < ETH_TOTAL_MIN) {
484             ofpbuf_put_zeros(buffer, ETH_TOTAL_MIN - buffer->size);
485         }
486         return 0;
487     } else {
488         return -retval;
489     }
490 }
491
492 /* Registers with the poll loop to wake up from the next call to poll_block()
493  * when a packet is ready to be received with netdev_recv() on 'netdev'. */
494 void
495 netdev_recv_wait(struct netdev *netdev)
496 {
497     void (*recv_wait)(struct netdev *);
498
499     recv_wait = netdev_get_dev(netdev)->netdev_class->recv_wait;
500     if (recv_wait) {
501         recv_wait(netdev);
502     }
503 }
504
505 /* Discards all packets waiting to be received from 'netdev'. */
506 int
507 netdev_drain(struct netdev *netdev)
508 {
509     int (*drain)(struct netdev *);
510
511     drain = netdev_get_dev(netdev)->netdev_class->drain;
512     return drain ? drain(netdev) : 0;
513 }
514
515 /* Sends 'buffer' on 'netdev'.  Returns 0 if successful, otherwise a positive
516  * errno value.  Returns EAGAIN without blocking if the packet cannot be queued
517  * immediately.  Returns EMSGSIZE if a partial packet was transmitted or if
518  * the packet is too big or too small to transmit on the device.
519  *
520  * The caller retains ownership of 'buffer' in all cases.
521  *
522  * The kernel maintains a packet transmission queue, so the caller is not
523  * expected to do additional queuing of packets.
524  *
525  * Some network devices may not implement support for this function.  In such
526  * cases this function will always return EOPNOTSUPP. */
527 int
528 netdev_send(struct netdev *netdev, const struct ofpbuf *buffer)
529 {
530     int (*send)(struct netdev *, const void *, size_t);
531     int error;
532
533     send = netdev_get_dev(netdev)->netdev_class->send;
534     error = send ? (send)(netdev, buffer->data, buffer->size) : EOPNOTSUPP;
535     if (!error) {
536         COVERAGE_INC(netdev_sent);
537     }
538     return error;
539 }
540
541 /* Registers with the poll loop to wake up from the next call to poll_block()
542  * when the packet transmission queue has sufficient room to transmit a packet
543  * with netdev_send().
544  *
545  * The kernel maintains a packet transmission queue, so the client is not
546  * expected to do additional queuing of packets.  Thus, this function is
547  * unlikely to ever be used.  It is included for completeness. */
548 void
549 netdev_send_wait(struct netdev *netdev)
550 {
551     void (*send_wait)(struct netdev *);
552
553     send_wait = netdev_get_dev(netdev)->netdev_class->send_wait;
554     if (send_wait) {
555         send_wait(netdev);
556     }
557 }
558
559 /* Attempts to set 'netdev''s MAC address to 'mac'.  Returns 0 if successful,
560  * otherwise a positive errno value. */
561 int
562 netdev_set_etheraddr(struct netdev *netdev, const uint8_t mac[ETH_ADDR_LEN])
563 {
564     return netdev_get_dev(netdev)->netdev_class->set_etheraddr(netdev, mac);
565 }
566
567 /* Retrieves 'netdev''s MAC address.  If successful, returns 0 and copies the
568  * the MAC address into 'mac'.  On failure, returns a positive errno value and
569  * clears 'mac' to all-zeros. */
570 int
571 netdev_get_etheraddr(const struct netdev *netdev, uint8_t mac[ETH_ADDR_LEN])
572 {
573     return netdev_get_dev(netdev)->netdev_class->get_etheraddr(netdev, mac);
574 }
575
576 /* Returns the name of the network device that 'netdev' represents,
577  * e.g. "eth0".  The caller must not modify or free the returned string. */
578 const char *
579 netdev_get_name(const struct netdev *netdev)
580 {
581     return netdev_get_dev(netdev)->name;
582 }
583
584 /* Retrieves the MTU of 'netdev'.  The MTU is the maximum size of transmitted
585  * (and received) packets, in bytes, not including the hardware header; thus,
586  * this is typically 1500 bytes for Ethernet devices.
587  *
588  * If successful, returns 0 and stores the MTU size in '*mtup'.  On failure,
589  * returns a positive errno value and stores ETH_PAYLOAD_MAX (1500) in
590  * '*mtup'. */
591 int
592 netdev_get_mtu(const struct netdev *netdev, int *mtup)
593 {
594     int error = netdev_get_dev(netdev)->netdev_class->get_mtu(netdev, mtup);
595     if (error) {
596         VLOG_WARN_RL(&rl, "failed to retrieve MTU for network device %s: %s",
597                      netdev_get_name(netdev), strerror(error));
598         *mtup = ETH_PAYLOAD_MAX;
599     }
600     return error;
601 }
602
603 /* Returns the ifindex of 'netdev', if successful, as a positive number.  On
604  * failure, returns a negative errno value.
605  *
606  * The desired semantics of the ifindex value are a combination of those
607  * specified by POSIX for if_nametoindex() and by SNMP for ifIndex.  An ifindex
608  * value should be unique within a host and remain stable at least until
609  * reboot.  SNMP says an ifindex "ranges between 1 and the value of ifNumber"
610  * but many systems do not follow this rule anyhow.
611  *
612  * Some network devices may not implement support for this function.  In such
613  * cases this function will always return -EOPNOTSUPP.
614  */
615 int
616 netdev_get_ifindex(const struct netdev *netdev)
617 {
618     int (*get_ifindex)(const struct netdev *);
619
620     get_ifindex = netdev_get_dev(netdev)->netdev_class->get_ifindex;
621
622     return get_ifindex ? get_ifindex(netdev) : -EOPNOTSUPP;
623 }
624
625 /* Stores the features supported by 'netdev' into each of '*current',
626  * '*advertised', '*supported', and '*peer' that are non-null.  Each value is a
627  * bitmap of "enum ofp_port_features" bits, in host byte order.  Returns 0 if
628  * successful, otherwise a positive errno value.  On failure, all of the
629  * passed-in values are set to 0.
630  *
631  * Some network devices may not implement support for this function.  In such
632  * cases this function will always return EOPNOTSUPP.
633  */
634 int
635 netdev_get_features(struct netdev *netdev,
636                     uint32_t *current, uint32_t *advertised,
637                     uint32_t *supported, uint32_t *peer)
638 {
639     int (*get_features)(struct netdev *netdev,
640                         uint32_t *current, uint32_t *advertised,
641                         uint32_t *supported, uint32_t *peer);
642     uint32_t dummy[4];
643     int error;
644
645     if (!current) {
646         current = &dummy[0];
647     }
648     if (!advertised) {
649         advertised = &dummy[1];
650     }
651     if (!supported) {
652         supported = &dummy[2];
653     }
654     if (!peer) {
655         peer = &dummy[3];
656     }
657
658     get_features = netdev_get_dev(netdev)->netdev_class->get_features;
659     error = get_features
660                     ? get_features(netdev, current, advertised, supported, peer)
661                     : EOPNOTSUPP;
662     if (error) {
663         *current = *advertised = *supported = *peer = 0;
664     }
665     return error;
666 }
667
668 /* Returns the maximum speed of a network connection that has the "enum
669  * ofp_port_features" bits in 'features', in bits per second.  If no bits that
670  * indicate a speed are set in 'features', assumes 100Mbps. */
671 uint64_t
672 netdev_features_to_bps(uint32_t features)
673 {
674     enum {
675         F_10000MB = OFPPF_10GB_FD,
676         F_1000MB = OFPPF_1GB_HD | OFPPF_1GB_FD,
677         F_100MB = OFPPF_100MB_HD | OFPPF_100MB_FD,
678         F_10MB = OFPPF_10MB_HD | OFPPF_10MB_FD
679     };
680
681     return (  features & F_10000MB  ? UINT64_C(10000000000)
682             : features & F_1000MB   ? UINT64_C(1000000000)
683             : features & F_100MB    ? UINT64_C(100000000)
684             : features & F_10MB     ? UINT64_C(10000000)
685                                     : UINT64_C(100000000));
686 }
687
688 /* Returns true if any of the "enum ofp_port_features" bits that indicate a
689  * full-duplex link are set in 'features', otherwise false. */
690 bool
691 netdev_features_is_full_duplex(uint32_t features)
692 {
693     return (features & (OFPPF_10MB_FD | OFPPF_100MB_FD | OFPPF_1GB_FD
694                         | OFPPF_10GB_FD)) != 0;
695 }
696
697 /* Set the features advertised by 'netdev' to 'advertise'.  Returns 0 if
698  * successful, otherwise a positive errno value. */
699 int
700 netdev_set_advertisements(struct netdev *netdev, uint32_t advertise)
701 {
702     return (netdev_get_dev(netdev)->netdev_class->set_advertisements
703             ? netdev_get_dev(netdev)->netdev_class->set_advertisements(
704                     netdev, advertise)
705             : EOPNOTSUPP);
706 }
707
708 /* If 'netdev' has an assigned IPv4 address, sets '*address' to that address
709  * and '*netmask' to its netmask and returns 0.  Otherwise, returns a positive
710  * errno value and sets '*address' to 0 (INADDR_ANY).
711  *
712  * The following error values have well-defined meanings:
713  *
714  *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv4 address.
715  *
716  *   - EOPNOTSUPP: No IPv4 network stack attached to 'netdev'.
717  *
718  * 'address' or 'netmask' or both may be null, in which case the address or netmask
719  * is not reported. */
720 int
721 netdev_get_in4(const struct netdev *netdev,
722                struct in_addr *address_, struct in_addr *netmask_)
723 {
724     struct in_addr address;
725     struct in_addr netmask;
726     int error;
727
728     error = (netdev_get_dev(netdev)->netdev_class->get_in4
729              ? netdev_get_dev(netdev)->netdev_class->get_in4(netdev, 
730                     &address, &netmask)
731              : EOPNOTSUPP);
732     if (address_) {
733         address_->s_addr = error ? 0 : address.s_addr;
734     }
735     if (netmask_) {
736         netmask_->s_addr = error ? 0 : netmask.s_addr;
737     }
738     return error;
739 }
740
741 /* Assigns 'addr' as 'netdev''s IPv4 address and 'mask' as its netmask.  If
742  * 'addr' is INADDR_ANY, 'netdev''s IPv4 address is cleared.  Returns a
743  * positive errno value. */
744 int
745 netdev_set_in4(struct netdev *netdev, struct in_addr addr, struct in_addr mask)
746 {
747     return (netdev_get_dev(netdev)->netdev_class->set_in4
748             ? netdev_get_dev(netdev)->netdev_class->set_in4(netdev, addr, mask)
749             : EOPNOTSUPP);
750 }
751
752 /* Adds 'router' as a default IP gateway for the TCP/IP stack that corresponds
753  * to 'netdev'. */
754 int
755 netdev_add_router(struct netdev *netdev, struct in_addr router)
756 {
757     COVERAGE_INC(netdev_add_router);
758     return (netdev_get_dev(netdev)->netdev_class->add_router
759             ? netdev_get_dev(netdev)->netdev_class->add_router(netdev, router)
760             : EOPNOTSUPP);
761 }
762
763 /* Looks up the next hop for 'host' for the TCP/IP stack that corresponds to
764  * 'netdev'.  If a route cannot not be determined, sets '*next_hop' to 0,
765  * '*netdev_name' to null, and returns a positive errno value.  Otherwise, if a
766  * next hop is found, stores the next hop gateway's address (0 if 'host' is on
767  * a directly connected network) in '*next_hop' and a copy of the name of the
768  * device to reach 'host' in '*netdev_name', and returns 0.  The caller is
769  * responsible for freeing '*netdev_name' (by calling free()). */
770 int
771 netdev_get_next_hop(const struct netdev *netdev,
772                     const struct in_addr *host, struct in_addr *next_hop,
773                     char **netdev_name)
774 {
775     int error = (netdev_get_dev(netdev)->netdev_class->get_next_hop
776                  ? netdev_get_dev(netdev)->netdev_class->get_next_hop(
777                         host, next_hop, netdev_name)
778                  : EOPNOTSUPP);
779     if (error) {
780         next_hop->s_addr = 0;
781         *netdev_name = NULL;
782     }
783     return error;
784 }
785
786 /* If 'netdev' has an assigned IPv6 address, sets '*in6' to that address and
787  * returns 0.  Otherwise, returns a positive errno value and sets '*in6' to
788  * all-zero-bits (in6addr_any).
789  *
790  * The following error values have well-defined meanings:
791  *
792  *   - EADDRNOTAVAIL: 'netdev' has no assigned IPv6 address.
793  *
794  *   - EOPNOTSUPP: No IPv6 network stack attached to 'netdev'.
795  *
796  * 'in6' may be null, in which case the address itself is not reported. */
797 int
798 netdev_get_in6(const struct netdev *netdev, struct in6_addr *in6)
799 {
800     struct in6_addr dummy;
801     int error;
802
803     error = (netdev_get_dev(netdev)->netdev_class->get_in6
804              ? netdev_get_dev(netdev)->netdev_class->get_in6(netdev, 
805                     in6 ? in6 : &dummy)
806              : EOPNOTSUPP);
807     if (error && in6) {
808         memset(in6, 0, sizeof *in6);
809     }
810     return error;
811 }
812
813 /* On 'netdev', turns off the flags in 'off' and then turns on the flags in
814  * 'on'.  If 'permanent' is true, the changes will persist; otherwise, they
815  * will be reverted when 'netdev' is closed or the program exits.  Returns 0 if
816  * successful, otherwise a positive errno value. */
817 static int
818 do_update_flags(struct netdev *netdev, enum netdev_flags off,
819                 enum netdev_flags on, enum netdev_flags *old_flagsp,
820                 bool permanent)
821 {
822     enum netdev_flags old_flags;
823     int error;
824
825     error = netdev_get_dev(netdev)->netdev_class->update_flags(netdev, 
826                 off & ~on, on, &old_flags);
827     if (error) {
828         VLOG_WARN_RL(&rl, "failed to %s flags for network device %s: %s",
829                      off || on ? "set" : "get", netdev_get_name(netdev),
830                      strerror(error));
831         old_flags = 0;
832     } else if ((off || on) && !permanent) {
833         enum netdev_flags new_flags = (old_flags & ~off) | on;
834         enum netdev_flags changed_flags = old_flags ^ new_flags;
835         if (changed_flags) {
836             if (!netdev->changed_flags) {
837                 netdev->save_flags = old_flags;
838             }
839             netdev->changed_flags |= changed_flags;
840         }
841     }
842     if (old_flagsp) {
843         *old_flagsp = old_flags;
844     }
845     return error;
846 }
847
848 /* Obtains the current flags for 'netdev' and stores them into '*flagsp'.
849  * Returns 0 if successful, otherwise a positive errno value.  On failure,
850  * stores 0 into '*flagsp'. */
851 int
852 netdev_get_flags(const struct netdev *netdev_, enum netdev_flags *flagsp)
853 {
854     struct netdev *netdev = (struct netdev *) netdev_;
855     return do_update_flags(netdev, 0, 0, flagsp, false);
856 }
857
858 /* Sets the flags for 'netdev' to 'flags'.
859  * If 'permanent' is true, the changes will persist; otherwise, they
860  * will be reverted when 'netdev' is closed or the program exits.
861  * Returns 0 if successful, otherwise a positive errno value. */
862 int
863 netdev_set_flags(struct netdev *netdev, enum netdev_flags flags,
864                  bool permanent)
865 {
866     return do_update_flags(netdev, -1, flags, NULL, permanent);
867 }
868
869 /* Turns on the specified 'flags' on 'netdev'.
870  * If 'permanent' is true, the changes will persist; otherwise, they
871  * will be reverted when 'netdev' is closed or the program exits.
872  * Returns 0 if successful, otherwise a positive errno value. */
873 int
874 netdev_turn_flags_on(struct netdev *netdev, enum netdev_flags flags,
875                      bool permanent)
876 {
877     return do_update_flags(netdev, 0, flags, NULL, permanent);
878 }
879
880 /* Turns off the specified 'flags' on 'netdev'.
881  * If 'permanent' is true, the changes will persist; otherwise, they
882  * will be reverted when 'netdev' is closed or the program exits.
883  * Returns 0 if successful, otherwise a positive errno value. */
884 int
885 netdev_turn_flags_off(struct netdev *netdev, enum netdev_flags flags,
886                       bool permanent)
887 {
888     return do_update_flags(netdev, flags, 0, NULL, permanent);
889 }
890
891 /* Looks up the ARP table entry for 'ip' on 'netdev'.  If one exists and can be
892  * successfully retrieved, it stores the corresponding MAC address in 'mac' and
893  * returns 0.  Otherwise, it returns a positive errno value; in particular,
894  * ENXIO indicates that there is no ARP table entry for 'ip' on 'netdev'. */
895 int
896 netdev_arp_lookup(const struct netdev *netdev,
897                   uint32_t ip, uint8_t mac[ETH_ADDR_LEN])
898 {
899     int error = (netdev_get_dev(netdev)->netdev_class->arp_lookup
900                  ? netdev_get_dev(netdev)->netdev_class->arp_lookup(netdev, 
901                         ip, mac)
902                  : EOPNOTSUPP);
903     if (error) {
904         memset(mac, 0, ETH_ADDR_LEN);
905     }
906     return error;
907 }
908
909 /* Sets 'carrier' to true if carrier is active (link light is on) on
910  * 'netdev'. */
911 int
912 netdev_get_carrier(const struct netdev *netdev, bool *carrier)
913 {
914     int error = (netdev_get_dev(netdev)->netdev_class->get_carrier
915                  ? netdev_get_dev(netdev)->netdev_class->get_carrier(netdev, 
916                         carrier)
917                  : EOPNOTSUPP);
918     if (error) {
919         *carrier = false;
920     }
921     return error;
922 }
923
924 /* Retrieves current device stats for 'netdev'. */
925 int
926 netdev_get_stats(const struct netdev *netdev, struct netdev_stats *stats)
927 {
928     int error;
929
930     COVERAGE_INC(netdev_get_stats);
931     error = (netdev_get_dev(netdev)->netdev_class->get_stats
932              ? netdev_get_dev(netdev)->netdev_class->get_stats(netdev, stats)
933              : EOPNOTSUPP);
934     if (error) {
935         memset(stats, 0xff, sizeof *stats);
936     }
937     return error;
938 }
939
940 /* Attempts to change the stats for 'netdev' to those provided in 'stats'.
941  * Returns 0 if successful, otherwise a positive errno value.
942  *
943  * This will probably fail for most network devices.  Some devices might only
944  * allow setting their stats to 0. */
945 int
946 netdev_set_stats(struct netdev *netdev, const struct netdev_stats *stats)
947 {
948     return (netdev_get_dev(netdev)->netdev_class->set_stats
949              ? netdev_get_dev(netdev)->netdev_class->set_stats(netdev, stats)
950              : EOPNOTSUPP);
951 }
952
953 /* Attempts to set input rate limiting (policing) policy, such that up to
954  * 'kbits_rate' kbps of traffic is accepted, with a maximum accumulative burst
955  * size of 'kbits' kb. */
956 int
957 netdev_set_policing(struct netdev *netdev, uint32_t kbits_rate,
958                     uint32_t kbits_burst)
959 {
960     return (netdev_get_dev(netdev)->netdev_class->set_policing
961             ? netdev_get_dev(netdev)->netdev_class->set_policing(netdev, 
962                     kbits_rate, kbits_burst)
963             : EOPNOTSUPP);
964 }
965
966 /* If 'netdev' is a VLAN network device (e.g. one created with vconfig(8)),
967  * sets '*vlan_vid' to the VLAN VID associated with that device and returns 0.
968  * Otherwise returns a errno value (specifically ENOENT if 'netdev_name' is the
969  * name of a network device that is not a VLAN device) and sets '*vlan_vid' to
970  * -1. */
971 int
972 netdev_get_vlan_vid(const struct netdev *netdev, int *vlan_vid)
973 {
974     int error = (netdev_get_dev(netdev)->netdev_class->get_vlan_vid
975                  ? netdev_get_dev(netdev)->netdev_class->get_vlan_vid(netdev, 
976                         vlan_vid)
977                  : ENOENT);
978     if (error) {
979         *vlan_vid = 0;
980     }
981     return error;
982 }
983
984 /* Returns a network device that has 'in4' as its IP address, if one exists,
985  * otherwise a null pointer. */
986 struct netdev *
987 netdev_find_dev_by_in4(const struct in_addr *in4)
988 {
989     struct netdev *netdev;
990     struct svec dev_list = SVEC_EMPTY_INITIALIZER;
991     size_t i;
992
993     netdev_enumerate(&dev_list);
994     for (i = 0; i < dev_list.n; i++) {
995         const char *name = dev_list.names[i];
996         struct in_addr dev_in4;
997
998         if (!netdev_open_default(name, &netdev)
999             && !netdev_get_in4(netdev, &dev_in4, NULL)
1000             && dev_in4.s_addr == in4->s_addr) {
1001             goto exit;
1002         }
1003         netdev_close(netdev);
1004     }
1005     netdev = NULL;
1006
1007 exit:
1008     svec_destroy(&dev_list);
1009     return netdev;
1010 }
1011 \f
1012 /* Initializes 'netdev_dev' as a netdev device named 'name' of the
1013  * specified 'netdev_class'.
1014  *
1015  * This function adds 'netdev_dev' to a netdev-owned shash, so it is
1016  * very important that 'netdev_dev' only be freed after calling
1017  * the refcount drops to zero.  */
1018 void
1019 netdev_dev_init(struct netdev_dev *netdev_dev, const char *name,
1020                 const struct netdev_class *netdev_class)
1021 {
1022     assert(!shash_find(&netdev_dev_shash, name));
1023
1024     memset(netdev_dev, 0, sizeof *netdev_dev);
1025     netdev_dev->netdev_class = netdev_class;
1026     netdev_dev->name = xstrdup(name);
1027     netdev_dev->node = shash_add(&netdev_dev_shash, name, netdev_dev);
1028 }
1029
1030 /* Undoes the results of initialization.
1031  *
1032  * Normally this function does not need to be called as netdev_close has
1033  * the same effect when the refcount drops to zero.
1034  * However, it may be called by providers due to an error on creation
1035  * that occurs after initialization.  It this case netdev_close() would
1036  * never be called. */
1037 void
1038 netdev_dev_uninit(struct netdev_dev *netdev_dev, bool destroy)
1039 {
1040     char *name = netdev_dev->name;
1041
1042     assert(!netdev_dev->ref_cnt);
1043
1044     shash_delete(&netdev_dev_shash, netdev_dev->node);
1045     update_device_args(netdev_dev, NULL);
1046
1047     if (destroy) {
1048         netdev_dev->netdev_class->destroy(netdev_dev);
1049     }
1050     free(name);
1051 }
1052
1053 /* Returns the class type of 'netdev_dev'.
1054  *
1055  * The caller must not free the returned value. */
1056 const char *
1057 netdev_dev_get_type(const struct netdev_dev *netdev_dev)
1058 {
1059     return netdev_dev->netdev_class->type;
1060 }
1061
1062 /* Returns the class associated with 'netdev_dev'. */
1063 const struct netdev_class *
1064 netdev_dev_get_class(const struct netdev_dev *netdev_dev)
1065 {
1066     return netdev_dev->netdev_class;
1067 }
1068
1069 /* Returns the name of 'netdev_dev'.
1070  *
1071  * The caller must not free the returned value. */
1072 const char *
1073 netdev_dev_get_name(const struct netdev_dev *netdev_dev)
1074 {
1075     return netdev_dev->name;
1076 }
1077
1078 /* Returns the netdev_dev with 'name' or NULL if there is none.
1079  *
1080  * The caller must not free the returned value. */
1081 struct netdev_dev *
1082 netdev_dev_from_name(const char *name)
1083 {
1084     return shash_find_data(&netdev_dev_shash, name);
1085 }
1086
1087 /* Fills 'device_list' with devices that match 'netdev_class'.
1088  *
1089  * The caller is responsible for initializing and destroying 'device_list'
1090  * but the contained netdev_devs must not be freed. */
1091 void
1092 netdev_dev_get_devices(const struct netdev_class *netdev_class,
1093                        struct shash *device_list)
1094 {
1095     struct shash_node *node;
1096     SHASH_FOR_EACH (node, &netdev_dev_shash) {
1097         struct netdev_dev *dev = node->data;
1098
1099         if (dev->netdev_class == netdev_class) {
1100             shash_add(device_list, node->name, node->data);
1101         }
1102     }
1103 }
1104
1105 /* Initializes 'netdev' as a instance of the netdev_dev.
1106  *
1107  * This function adds 'netdev' to a netdev-owned linked list, so it is very
1108  * important that 'netdev' only be freed after calling netdev_close(). */
1109 void
1110 netdev_init(struct netdev *netdev, struct netdev_dev *netdev_dev)
1111 {
1112     memset(netdev, 0, sizeof *netdev);
1113     netdev->netdev_dev = netdev_dev;
1114     list_push_back(&netdev_list, &netdev->node);
1115 }
1116
1117 /* Undoes the results of initialization.
1118  *
1119  * Normally this function only needs to be called from netdev_close().
1120  * However, it may be called by providers due to an error on opening
1121  * that occurs after initialization.  It this case netdev_close() would
1122  * never be called. */
1123 void
1124 netdev_uninit(struct netdev *netdev, bool close)
1125 {
1126     /* Restore flags that we changed, if any. */
1127     int error = restore_flags(netdev);
1128     list_remove(&netdev->node);
1129     if (error) {
1130         VLOG_WARN("failed to restore network device flags on %s: %s",
1131                   netdev_get_name(netdev), strerror(error));
1132     }
1133
1134     if (close) {
1135         netdev_get_dev(netdev)->netdev_class->close(netdev);
1136     }
1137 }
1138
1139
1140 /* Returns the class type of 'netdev'.  
1141  *
1142  * The caller must not free the returned value. */
1143 const char *
1144 netdev_get_type(const struct netdev *netdev)
1145 {
1146     return netdev_get_dev(netdev)->netdev_class->type;
1147 }
1148
1149 struct netdev_dev *
1150 netdev_get_dev(const struct netdev *netdev)
1151 {
1152     return netdev->netdev_dev;
1153 }
1154
1155 /* Initializes 'notifier' as a netdev notifier for 'netdev', for which
1156  * notification will consist of calling 'cb', with auxiliary data 'aux'. */
1157 void
1158 netdev_notifier_init(struct netdev_notifier *notifier, struct netdev *netdev,
1159                      void (*cb)(struct netdev_notifier *), void *aux)
1160 {
1161     notifier->netdev = netdev;
1162     notifier->cb = cb;
1163     notifier->aux = aux;
1164 }
1165 \f
1166 /* Tracks changes in the status of a set of network devices. */
1167 struct netdev_monitor {
1168     struct shash polled_netdevs;
1169     struct shash changed_netdevs;
1170 };
1171
1172 /* Creates and returns a new structure for monitor changes in the status of
1173  * network devices. */
1174 struct netdev_monitor *
1175 netdev_monitor_create(void)
1176 {
1177     struct netdev_monitor *monitor = xmalloc(sizeof *monitor);
1178     shash_init(&monitor->polled_netdevs);
1179     shash_init(&monitor->changed_netdevs);
1180     return monitor;
1181 }
1182
1183 /* Destroys 'monitor'. */
1184 void
1185 netdev_monitor_destroy(struct netdev_monitor *monitor)
1186 {
1187     if (monitor) {
1188         struct shash_node *node;
1189
1190         SHASH_FOR_EACH (node, &monitor->polled_netdevs) {
1191             struct netdev_notifier *notifier = node->data;
1192             netdev_get_dev(notifier->netdev)->netdev_class->poll_remove(
1193                     notifier);
1194         }
1195
1196         shash_destroy(&monitor->polled_netdevs);
1197         shash_destroy(&monitor->changed_netdevs);
1198         free(monitor);
1199     }
1200 }
1201
1202 static void
1203 netdev_monitor_cb(struct netdev_notifier *notifier)
1204 {
1205     struct netdev_monitor *monitor = notifier->aux;
1206     const char *name = netdev_get_name(notifier->netdev);
1207     if (!shash_find(&monitor->changed_netdevs, name)) {
1208         shash_add(&monitor->changed_netdevs, name, NULL);
1209     }
1210 }
1211
1212 /* Attempts to add 'netdev' as a netdev monitored by 'monitor'.  Returns 0 if
1213  * successful, otherwise a positive errno value.
1214  *
1215  * Adding a given 'netdev' to a monitor multiple times is equivalent to adding
1216  * it once. */
1217 int
1218 netdev_monitor_add(struct netdev_monitor *monitor, struct netdev *netdev)
1219 {
1220     const char *netdev_name = netdev_get_name(netdev);
1221     int error = 0;
1222     if (!shash_find(&monitor->polled_netdevs, netdev_name)
1223             && netdev_get_dev(netdev)->netdev_class->poll_add)
1224     {
1225         struct netdev_notifier *notifier;
1226         error = netdev_get_dev(netdev)->netdev_class->poll_add(netdev,
1227                     netdev_monitor_cb, monitor, &notifier);
1228         if (!error) {
1229             assert(notifier->netdev == netdev);
1230             shash_add(&monitor->polled_netdevs, netdev_name, notifier);
1231         }
1232     }
1233     return error;
1234 }
1235
1236 /* Removes 'netdev' from the set of netdevs monitored by 'monitor'.  (This has
1237  * no effect if 'netdev' is not in the set of devices monitored by
1238  * 'monitor'.) */
1239 void
1240 netdev_monitor_remove(struct netdev_monitor *monitor, struct netdev *netdev)
1241 {
1242     const char *netdev_name = netdev_get_name(netdev);
1243     struct shash_node *node;
1244
1245     node = shash_find(&monitor->polled_netdevs, netdev_name);
1246     if (node) {
1247         /* Cancel future notifications. */
1248         struct netdev_notifier *notifier = node->data;
1249         netdev_get_dev(netdev)->netdev_class->poll_remove(notifier);
1250         shash_delete(&monitor->polled_netdevs, node);
1251
1252         /* Drop any pending notification. */
1253         node = shash_find(&monitor->changed_netdevs, netdev_name);
1254         if (node) {
1255             shash_delete(&monitor->changed_netdevs, node);
1256         }
1257     }
1258 }
1259
1260 /* Checks for changes to netdevs in the set monitored by 'monitor'.  If any of
1261  * the attributes (Ethernet address, carrier status, speed or peer-advertised
1262  * speed, flags, etc.) of a network device monitored by 'monitor' has changed,
1263  * sets '*devnamep' to the name of a device that has changed and returns 0.
1264  * The caller is responsible for freeing '*devnamep' (with free()).
1265  *
1266  * If no devices have changed, sets '*devnamep' to NULL and returns EAGAIN.
1267  */
1268 int
1269 netdev_monitor_poll(struct netdev_monitor *monitor, char **devnamep)
1270 {
1271     struct shash_node *node = shash_first(&monitor->changed_netdevs);
1272     if (!node) {
1273         *devnamep = NULL;
1274         return EAGAIN;
1275     } else {
1276         *devnamep = xstrdup(node->name);
1277         shash_delete(&monitor->changed_netdevs, node);
1278         return 0;
1279     }
1280 }
1281
1282 /* Registers with the poll loop to wake up from the next call to poll_block()
1283  * when netdev_monitor_poll(monitor) would indicate that a device has
1284  * changed. */
1285 void
1286 netdev_monitor_poll_wait(const struct netdev_monitor *monitor)
1287 {
1288     if (!shash_is_empty(&monitor->changed_netdevs)) {
1289         poll_immediate_wake();
1290     } else {
1291         /* XXX Nothing needed here for netdev_linux, but maybe other netdev
1292          * classes need help. */
1293     }
1294 }
1295 \f
1296 /* Restore the network device flags on 'netdev' to those that were active
1297  * before we changed them.  Returns 0 if successful, otherwise a positive
1298  * errno value.
1299  *
1300  * To avoid reentry, the caller must ensure that fatal signals are blocked. */
1301 static int
1302 restore_flags(struct netdev *netdev)
1303 {
1304     if (netdev->changed_flags) {
1305         enum netdev_flags restore = netdev->save_flags & netdev->changed_flags;
1306         enum netdev_flags old_flags;
1307         return netdev_get_dev(netdev)->netdev_class->update_flags(netdev,
1308                                            netdev->changed_flags & ~restore,
1309                                            restore, &old_flags);
1310     }
1311     return 0;
1312 }
1313
1314 /* Close all netdevs on shutdown so they can do any needed cleanup such as
1315  * destroying devices, restoring flags, etc. */
1316 static void
1317 close_all_netdevs(void *aux OVS_UNUSED)
1318 {
1319     struct netdev *netdev, *next;
1320     LIST_FOR_EACH_SAFE(netdev, next, struct netdev, node, &netdev_list) {
1321         netdev_close(netdev);
1322     }
1323 }