2 * Copyright (c) 2008, 2009 Nicira Networks.
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:
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
26 #include <linux/ethtool.h>
27 #include <linux/rtnetlink.h>
28 #include <linux/sockios.h>
30 #include <sys/ioctl.h>
33 #include "dpif-provider.h"
34 #include "netdev-linux.h"
36 #include "poll-loop.h"
41 #define THIS_MODULE VLM_dpif_linux
43 /* Datapath interface for the openvswitch Linux kernel module. */
48 /* Change notification. */
49 int local_ifindex; /* Ifindex of local port. */
50 struct svec changed_ports; /* Ports that have changed. */
51 struct linux_netdev_notifier port_notifier;
54 static struct vlog_rate_limit error_rl = VLOG_RATE_LIMIT_INIT(9999, 5);
56 static int do_ioctl(const struct dpif *, int cmd, const void *arg);
57 static int lookup_minor(const char *name, int *minor);
58 static int finish_open(struct dpif *, const char *local_ifname);
59 static int create_minor(const char *name, int minor, struct dpif **dpifp);
60 static int open_minor(int minor, struct dpif **dpifp);
61 static int make_openvswitch_device(int minor, char **fnp);
62 static void dpif_linux_port_changed(const struct linux_netdev_change *,
65 static struct dpif_linux *
66 dpif_linux_cast(const struct dpif *dpif)
68 dpif_assert_class(dpif, &dpif_linux_class);
69 return CONTAINER_OF(dpif, struct dpif_linux, dpif);
75 linux_netdev_notifier_run();
81 linux_netdev_notifier_wait();
85 dpif_linux_open(const char *name UNUSED, char *suffix, bool create,
90 minor = !strncmp(name, "dp", 2) && isdigit(name[2]) ? atoi(name + 2) : -1;
93 return create_minor(suffix, minor, dpifp);
95 /* Scan for unused minor number. */
96 for (minor = 0; minor < ODP_MAX; minor++) {
97 int error = create_minor(suffix, minor, dpifp);
103 /* All datapath numbers in use. */
107 struct dpif_linux *dpif;
108 struct odp_port port;
112 error = lookup_minor(suffix, &minor);
118 error = open_minor(minor, dpifp);
122 dpif = dpif_linux_cast(*dpifp);
124 /* We need the local port's ifindex for the poll function. Start by
125 * getting the local port's name. */
126 memset(&port, 0, sizeof port);
127 port.port = ODPP_LOCAL;
128 if (ioctl(dpif->fd, ODP_PORT_QUERY, &port)) {
130 if (error != ENODEV) {
131 VLOG_WARN("%s: probe returned unexpected error: %s",
132 dpif_name(*dpifp), strerror(error));
138 /* Then use that to finish up opening. */
139 return finish_open(&dpif->dpif, port.devname);
144 dpif_linux_close(struct dpif *dpif_)
146 struct dpif_linux *dpif = dpif_linux_cast(dpif_);
147 linux_netdev_notifier_unregister(&dpif->port_notifier);
148 svec_destroy(&dpif->changed_ports);
154 dpif_linux_delete(struct dpif *dpif_)
156 return do_ioctl(dpif_, ODP_DP_DESTROY, NULL);
160 dpif_linux_get_stats(const struct dpif *dpif_, struct odp_stats *stats)
162 return do_ioctl(dpif_, ODP_DP_STATS, stats);
166 dpif_linux_get_drop_frags(const struct dpif *dpif_, bool *drop_fragsp)
171 error = do_ioctl(dpif_, ODP_GET_DROP_FRAGS, &drop_frags);
173 *drop_fragsp = drop_frags & 1;
179 dpif_linux_set_drop_frags(struct dpif *dpif_, bool drop_frags)
181 int drop_frags_int = drop_frags;
182 return do_ioctl(dpif_, ODP_SET_DROP_FRAGS, &drop_frags_int);
186 dpif_linux_port_add(struct dpif *dpif_, const char *devname, uint16_t flags,
189 struct odp_port port;
192 memset(&port, 0, sizeof port);
193 strncpy(port.devname, devname, sizeof port.devname);
195 error = do_ioctl(dpif_, ODP_PORT_ADD, &port);
197 *port_no = port.port;
203 dpif_linux_port_del(struct dpif *dpif_, uint16_t port_no)
206 return do_ioctl(dpif_, ODP_PORT_DEL, &tmp);
210 dpif_linux_port_query_by_number(const struct dpif *dpif_, uint16_t port_no,
211 struct odp_port *port)
213 memset(port, 0, sizeof *port);
214 port->port = port_no;
215 return do_ioctl(dpif_, ODP_PORT_QUERY, port);
219 dpif_linux_port_query_by_name(const struct dpif *dpif_, const char *devname,
220 struct odp_port *port)
222 memset(port, 0, sizeof *port);
223 strncpy(port->devname, devname, sizeof port->devname);
224 return do_ioctl(dpif_, ODP_PORT_QUERY, port);
228 dpif_linux_flow_flush(struct dpif *dpif_)
230 return do_ioctl(dpif_, ODP_FLOW_FLUSH, NULL);
234 dpif_linux_port_list(const struct dpif *dpif_, struct odp_port *ports, int n)
236 struct odp_portvec pv;
241 error = do_ioctl(dpif_, ODP_PORT_LIST, &pv);
242 return error ? -error : pv.n_ports;
246 dpif_linux_port_poll(const struct dpif *dpif_, char **devnamep)
248 struct dpif_linux *dpif = dpif_linux_cast(dpif_);
251 error = linux_netdev_notifier_get_error(&dpif->port_notifier);
253 if (!dpif->changed_ports.n) {
256 *devnamep = dpif->changed_ports.names[--dpif->changed_ports.n];
258 svec_clear(&dpif->changed_ports);
264 dpif_linux_port_poll_wait(const struct dpif *dpif_)
266 struct dpif_linux *dpif = dpif_linux_cast(dpif_);
267 if (dpif->changed_ports.n
268 || linux_netdev_notifier_peek_error(&dpif->port_notifier)) {
269 poll_immediate_wake();
271 linux_netdev_notifier_wait();
276 dpif_linux_port_group_get(const struct dpif *dpif_, int group,
277 uint16_t ports[], int n)
279 struct odp_port_group pg;
282 assert(n <= UINT16_MAX);
286 error = do_ioctl(dpif_, ODP_PORT_GROUP_GET, &pg);
287 return error ? -error : pg.n_ports;
291 dpif_linux_port_group_set(struct dpif *dpif_, int group,
292 const uint16_t ports[], int n)
294 struct odp_port_group pg;
296 assert(n <= UINT16_MAX);
298 pg.ports = (uint16_t *) ports;
300 return do_ioctl(dpif_, ODP_PORT_GROUP_SET, &pg);
304 dpif_linux_flow_get(const struct dpif *dpif_, struct odp_flow flows[], int n)
306 struct odp_flowvec fv;
309 return do_ioctl(dpif_, ODP_FLOW_GET, &fv);
313 dpif_linux_flow_put(struct dpif *dpif_, struct odp_flow_put *put)
315 return do_ioctl(dpif_, ODP_FLOW_PUT, put);
319 dpif_linux_flow_del(struct dpif *dpif_, struct odp_flow *flow)
321 return do_ioctl(dpif_, ODP_FLOW_DEL, flow);
325 dpif_linux_flow_list(const struct dpif *dpif_, struct odp_flow flows[], int n)
327 struct odp_flowvec fv;
332 error = do_ioctl(dpif_, ODP_FLOW_LIST, &fv);
333 return error ? -error : fv.n_flows;
337 dpif_linux_execute(struct dpif *dpif_, uint16_t in_port,
338 const union odp_action actions[], int n_actions,
339 const struct ofpbuf *buf)
341 struct odp_execute execute;
342 memset(&execute, 0, sizeof execute);
343 execute.in_port = in_port;
344 execute.actions = (union odp_action *) actions;
345 execute.n_actions = n_actions;
346 execute.data = buf->data;
347 execute.length = buf->size;
348 return do_ioctl(dpif_, ODP_EXECUTE, &execute);
352 dpif_linux_recv_get_mask(const struct dpif *dpif_, int *listen_mask)
354 return do_ioctl(dpif_, ODP_GET_LISTEN_MASK, listen_mask);
358 dpif_linux_recv_set_mask(struct dpif *dpif_, int listen_mask)
360 return do_ioctl(dpif_, ODP_SET_LISTEN_MASK, &listen_mask);
364 dpif_linux_recv(struct dpif *dpif_, struct ofpbuf **bufp)
366 struct dpif_linux *dpif = dpif_linux_cast(dpif_);
371 buf = ofpbuf_new(65536);
372 retval = read(dpif->fd, ofpbuf_tail(buf), ofpbuf_tailroom(buf));
375 if (error != EAGAIN) {
376 VLOG_WARN_RL(&error_rl, "%s: read failed: %s",
377 dpif_name(dpif_), strerror(error));
379 } else if (retval >= sizeof(struct odp_msg)) {
380 struct odp_msg *msg = buf->data;
381 if (msg->length <= retval) {
386 VLOG_WARN_RL(&error_rl, "%s: discarding message truncated "
387 "from %zu bytes to %d",
388 dpif_name(dpif_), msg->length, retval);
391 } else if (!retval) {
392 VLOG_WARN_RL(&error_rl, "%s: unexpected end of file", dpif_name(dpif_));
395 VLOG_WARN_RL(&error_rl,
396 "%s: discarding too-short message (%d bytes)",
397 dpif_name(dpif_), retval);
407 dpif_linux_recv_wait(struct dpif *dpif_)
409 struct dpif_linux *dpif = dpif_linux_cast(dpif_);
410 poll_fd_wait(dpif->fd, POLLIN);
413 const struct dpif_class dpif_linux_class = {
414 "", /* This is the default class. */
421 dpif_linux_get_stats,
422 dpif_linux_get_drop_frags,
423 dpif_linux_set_drop_frags,
426 dpif_linux_port_query_by_number,
427 dpif_linux_port_query_by_name,
428 dpif_linux_port_list,
429 dpif_linux_port_poll,
430 dpif_linux_port_poll_wait,
431 dpif_linux_port_group_get,
432 dpif_linux_port_group_set,
436 dpif_linux_flow_flush,
437 dpif_linux_flow_list,
439 dpif_linux_recv_get_mask,
440 dpif_linux_recv_set_mask,
442 dpif_linux_recv_wait,
445 static int get_openvswitch_major(void);
446 static int get_major(const char *target, int default_major);
449 do_ioctl(const struct dpif *dpif_, int cmd, const void *arg)
451 struct dpif_linux *dpif = dpif_linux_cast(dpif_);
452 return ioctl(dpif->fd, cmd, arg) ? errno : 0;
456 lookup_minor(const char *name, int *minor)
458 struct ethtool_drvinfo drvinfo;
463 sock = socket(AF_INET, SOCK_DGRAM, 0);
465 VLOG_WARN("socket(AF_INET) failed: %s", strerror(errno));
470 memset(&ifr, 0, sizeof ifr);
471 strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
472 ifr.ifr_data = (caddr_t) &drvinfo;
474 memset(&drvinfo, 0, sizeof drvinfo);
475 drvinfo.cmd = ETHTOOL_GDRVINFO;
476 if (ioctl(sock, SIOCETHTOOL, &ifr)) {
477 VLOG_WARN("ioctl(SIOCETHTOOL) failed: %s", strerror(errno));
479 goto error_close_sock;
482 if (strcmp(drvinfo.driver, "openvswitch")) {
483 VLOG_WARN("%s is not an openvswitch device", name);
485 goto error_close_sock;
488 if (!isdigit(drvinfo.bus_info[0])) {
489 VLOG_WARN("%s ethtool info does not contain an openvswitch minor",
492 goto error_close_sock;
495 *minor = atoi(drvinfo.bus_info);
506 make_openvswitch_device(int minor, char **fnp)
508 dev_t dev = makedev(get_openvswitch_major(), minor);
509 const char dirname[] = "/dev/net";
514 sprintf(fn, "%s/dp%d", dirname, minor);
516 if (!S_ISCHR(s.st_mode)) {
517 VLOG_WARN_RL(&error_rl, "%s is not a character device, fixing",
519 } else if (s.st_rdev != dev) {
520 VLOG_WARN_RL(&error_rl,
521 "%s is device %u:%u instead of %u:%u, fixing",
522 fn, major(s.st_rdev), minor(s.st_rdev),
523 major(dev), minor(dev));
528 VLOG_WARN_RL(&error_rl, "%s: unlink failed (%s)",
529 fn, strerror(errno));
532 } else if (errno == ENOENT) {
533 if (stat(dirname, &s)) {
534 if (errno == ENOENT) {
535 if (mkdir(dirname, 0755)) {
536 VLOG_WARN_RL(&error_rl, "%s: mkdir failed (%s)",
537 dirname, strerror(errno));
541 VLOG_WARN_RL(&error_rl, "%s: stat failed (%s)",
542 dirname, strerror(errno));
547 VLOG_WARN_RL(&error_rl, "%s: stat failed (%s)", fn, strerror(errno));
551 /* The device needs to be created. */
552 if (mknod(fn, S_IFCHR | 0700, dev)) {
553 VLOG_WARN_RL(&error_rl,
554 "%s: creating character device %u:%u failed (%s)",
555 fn, major(dev), minor(dev), strerror(errno));
566 get_openvswitch_major(void)
568 static unsigned int openvswitch_major;
569 if (!openvswitch_major) {
570 enum { DEFAULT_MAJOR = 248 };
571 openvswitch_major = get_major("openvswitch", DEFAULT_MAJOR);
573 return openvswitch_major;
577 get_major(const char *target, int default_major)
579 const char fn[] = "/proc/devices";
584 file = fopen(fn, "r");
586 VLOG_ERR("opening %s failed (%s)", fn, strerror(errno));
590 for (ln = 1; fgets(line, sizeof line, file); ln++) {
594 if (!strncmp(line, "Character", 9) || line[0] == '\0') {
596 } else if (!strncmp(line, "Block", 5)) {
597 /* We only want character devices, so skip the rest of the file. */
599 } else if (sscanf(line, "%d %63s", &major, name)) {
600 if (!strcmp(name, target)) {
607 VLOG_WARN("%s:%d: syntax error", fn, ln);
613 VLOG_ERR("%s: %s major not found (is the module loaded?), using "
614 "default major %d", fn, target, default_major);
616 VLOG_INFO("using default major %d for %s", default_major, target);
617 return default_major;
621 finish_open(struct dpif *dpif_, const char *local_ifname)
623 struct dpif_linux *dpif = dpif_linux_cast(dpif_);
624 dpif->local_ifindex = if_nametoindex(local_ifname);
625 if (!dpif->local_ifindex) {
628 VLOG_WARN("could not get ifindex of %s device: %s",
629 local_ifname, strerror(errno));
636 create_minor(const char *name, int minor, struct dpif **dpifp)
638 int error = open_minor(minor, dpifp);
640 error = do_ioctl(*dpifp, ODP_DP_CREATE, name);
642 error = finish_open(*dpifp, name);
651 open_minor(int minor, struct dpif **dpifp)
657 error = make_openvswitch_device(minor, &fn);
662 fd = open(fn, O_RDONLY | O_NONBLOCK);
664 struct dpif_linux *dpif = xmalloc(sizeof *dpif);
665 error = linux_netdev_notifier_register(&dpif->port_notifier,
666 dpif_linux_port_changed, dpif);
670 name = xasprintf("dp%d", minor);
671 dpif_init(&dpif->dpif, &dpif_linux_class, name, minor, minor);
675 dpif->local_ifindex = 0;
676 svec_init(&dpif->changed_ports);
677 *dpifp = &dpif->dpif;
683 VLOG_WARN("%s: open failed (%s)", fn, strerror(error));
691 dpif_linux_port_changed(const struct linux_netdev_change *change, void *dpif_)
693 struct dpif_linux *dpif = dpif_;
695 if (change->master_ifindex == dpif->local_ifindex
696 && (change->nlmsg_type == RTM_NEWLINK
697 || change->nlmsg_type == RTM_DELLINK))
699 /* Our datapath changed, either adding a new port or deleting an
701 if (!svec_contains(&dpif->changed_ports, change->ifname)) {
702 svec_add(&dpif->changed_ports, change->ifname);
703 svec_sort(&dpif->changed_ports);