+
+ VLOG_DBG("%s: attempting to create gre device using ioctl", name);
+
+ memset(&p, 0, sizeof p);
+
+ strncpy(p.name, name, IFNAMSIZ);
+
+ p.iph.version = 4;
+ p.iph.ihl = 5;
+ p.iph.protocol = IPPROTO_GRE;
+ p.iph.saddr = config->local_ip;
+ p.iph.daddr = config->remote_ip;
+ p.iph.ttl = IPDEFTTL;
+ p.iph.tos = config->tos;
+
+ if (config->have_in_key) {
+ p.i_flags |= GRE_KEY;
+ p.i_key = config->in_key;
+ }
+ if (config->have_out_key) {
+ p.o_flags |= GRE_KEY;
+ p.o_key = config->out_key;
+ }
+
+ if (config->in_csum) {
+ p.i_flags |= GRE_CSUM;
+ }
+ if (config->out_csum) {
+ p.o_flags |= GRE_CSUM;
+ }
+
+ if (config->pmtud) {
+ p.iph.frag_off = htons(IP_DONT_FRAGMENT);
+ }
+
+ strncpy(ifr.ifr_name, create ? GRE_IOCTL_DEVICE : name, IFNAMSIZ);
+ ifr.ifr_ifru.ifru_data = (void *)&p;
+
+ if (!gre_descriptors.ioctl_fd) {
+ gre_descriptors.ioctl_fd = socket(AF_INET, SOCK_DGRAM, 0);
+ if (gre_descriptors.ioctl_fd < 0) {
+ VLOG_WARN("couldn't create gre ioctl socket: %s", strerror(errno));
+ gre_descriptors.ioctl_fd = 0;
+ return errno;
+ }
+ }
+
+ if (ioctl(gre_descriptors.ioctl_fd, create ? SIOCADDGRETAP : SIOCCHGGRETAP,
+ &ifr) < 0) {
+ VLOG_WARN("couldn't do gre ioctl: %s", strerror(errno));
+ return errno;
+ }
+
+ return 0;
+}
+
+/* The arguments are marked as unused to prevent warnings on platforms where
+ * the Netlink interface isn't supported. */
+static bool
+check_gre_device_netlink(const char *name OVS_UNUSED)
+{
+#ifdef GRE_IOCTL_ONLY
+ return false;
+#else
+ static const struct nl_policy getlink_policy[] = {
+ [IFLA_LINKINFO] = { .type = NL_A_NESTED, .optional = false },
+ };
+
+ static const struct nl_policy linkinfo_policy[] = {
+ [IFLA_INFO_KIND] = { .type = NL_A_STRING, .optional = false },
+ };
+
+ int error;
+ bool ret = false;
+ struct ofpbuf request, *reply;
+ struct ifinfomsg ifinfomsg;
+ struct nlattr *getlink_attrs[ARRAY_SIZE(getlink_policy)];
+ struct nlattr *linkinfo_attrs[ARRAY_SIZE(linkinfo_policy)];
+ struct ofpbuf linkinfo;
+ const char *device_kind;
+
+ ofpbuf_init(&request, 0);
+
+ nl_msg_put_nlmsghdr(&request, gre_descriptors.nl_sock,
+ NLMSG_LENGTH(sizeof ifinfomsg), RTM_GETLINK,
+ NLM_F_REQUEST);
+
+ memset(&ifinfomsg, 0, sizeof ifinfomsg);
+ ifinfomsg.ifi_family = AF_UNSPEC;
+ ifinfomsg.ifi_index = do_get_ifindex(name);
+ nl_msg_put(&request, &ifinfomsg, sizeof ifinfomsg);
+
+ error = nl_sock_transact(gre_descriptors.nl_sock, &request, &reply);
+ ofpbuf_uninit(&request);
+ if (error) {
+ VLOG_WARN("couldn't transact netlink socket: %s", strerror(error));
+ return false;
+ }
+
+ if (!nl_policy_parse(reply, NLMSG_HDRLEN + sizeof(struct ifinfomsg),
+ getlink_policy, getlink_attrs,
+ ARRAY_SIZE(getlink_policy))) {
+ VLOG_WARN("received bad rtnl message (getlink policy)");
+ goto error;
+ }
+
+ linkinfo.data = (void *)nl_attr_get(getlink_attrs[IFLA_LINKINFO]);
+ linkinfo.size = nl_attr_get_size(getlink_attrs[IFLA_LINKINFO]);
+ if (!nl_policy_parse(&linkinfo, 0, linkinfo_policy,
+ linkinfo_attrs, ARRAY_SIZE(linkinfo_policy))) {
+ VLOG_WARN("received bad rtnl message (linkinfo policy)");
+ goto error;
+ }
+
+ device_kind = nl_attr_get_string(linkinfo_attrs[IFLA_INFO_KIND]);
+ ret = !strcmp(device_kind, "gretap");
+
+error:
+ ofpbuf_delete(reply);
+ return ret;
+#endif
+}
+
+static bool
+check_gre_device_ioctl(const char *name)
+{
+ struct ethtool_drvinfo drvinfo;
+ int error;
+
+ memset(&drvinfo, 0, sizeof drvinfo);
+ error = netdev_linux_do_ethtool(name, (struct ethtool_cmd *)&drvinfo,
+ ETHTOOL_GDRVINFO, "ETHTOOL_GDRVINFO");
+
+ return !error && !strcmp(drvinfo.driver, "ip_gre")
+ && !strcmp(drvinfo.bus_info, "gretap");
+}
+
+static int
+setup_gre(const char *name, const struct shash *args, bool create)
+{
+ int error;
+ struct in_addr in_addr;
+ struct shash_node *node;
+ struct gre_config config;
+
+ memset(&config, 0, sizeof config);
+ config.in_csum = true;
+ config.out_csum = true;
+ config.pmtud = true;
+
+ SHASH_FOR_EACH (node, args) {
+ if (!strcmp(node->name, "remote_ip")) {
+ if (lookup_ip(node->data, &in_addr)) {
+ VLOG_WARN("bad 'remote_ip' for gre device %s ", name);
+ } else {
+ config.remote_ip = in_addr.s_addr;
+ }
+ } else if (!strcmp(node->name, "local_ip")) {
+ if (lookup_ip(node->data, &in_addr)) {
+ VLOG_WARN("bad 'local_ip' for gre device %s ", name);
+ } else {
+ config.local_ip = in_addr.s_addr;
+ }
+ } else if (!strcmp(node->name, "key")) {
+ config.have_in_key = true;
+ config.have_out_key = true;
+ config.in_key = htonl(atoi(node->data));
+ config.out_key = htonl(atoi(node->data));
+ } else if (!strcmp(node->name, "in_key")) {
+ config.have_in_key = true;
+ config.in_key = htonl(atoi(node->data));
+ } else if (!strcmp(node->name, "out_key")) {
+ config.have_out_key = true;
+ config.out_key = htonl(atoi(node->data));
+ } else if (!strcmp(node->name, "tos")) {
+ config.tos = atoi(node->data);
+ } else if (!strcmp(node->name, "csum")) {
+ if (!strcmp(node->data, "false")) {
+ config.in_csum = false;
+ config.out_csum = false;
+ }
+ } else if (!strcmp(node->name, "pmtud")) {
+ if (!strcmp(node->data, "false")) {
+ config.pmtud = false;
+ }
+ } else {
+ VLOG_WARN("unknown gre argument '%s'", node->name);
+ }
+ }
+
+ if (!config.remote_ip) {
+ VLOG_WARN("gre type requires valid 'remote_ip' argument");
+ error = EINVAL;
+ goto error;
+ }
+
+ if (!gre_descriptors.use_ioctl) {
+ error = setup_gre_netlink(name, &config, create);
+ if (error == EOPNOTSUPP) {
+ gre_descriptors.use_ioctl = true;
+ }
+ }
+ if (gre_descriptors.use_ioctl) {
+ error = setup_gre_ioctl(name, &config, create);
+ }
+
+ if (create && error == EEXIST) {
+ bool gre_device;
+
+ if (gre_descriptors.use_ioctl) {
+ gre_device = check_gre_device_ioctl(name);
+ } else {
+ gre_device = check_gre_device_netlink(name);
+ }
+
+ if (!gre_device) {
+ goto error;
+ }
+
+ VLOG_WARN("replacing existing gre device %s", name);
+ error = destroy_gre(name);
+ if (error) {
+ goto error;
+ }
+
+ if (gre_descriptors.use_ioctl) {
+ error = setup_gre_ioctl(name, &config, create);
+ } else {
+ error = setup_gre_netlink(name, &config, create);
+ }
+ }
+
+error:
+ return error;
+}
+
+/* A veth may be created using the 'command' "+<name>,<peer>". A veth may
+ * be destroyed by using the 'command' "-<name>", where <name> can be
+ * either side of the device.
+ */
+static int
+modify_veth(const char *format, ...)
+{
+ FILE *veth_file;
+ va_list args;
+ int retval;
+
+ veth_file = fopen("/sys/class/net/veth_pairs", "w");
+ if (!veth_file) {
+ VLOG_WARN_RL(&rl, "could not open veth device. Are you running a "
+ "supported XenServer with the kernel module loaded?");
+ return ENODEV;
+ }
+ setvbuf(veth_file, NULL, _IONBF, 0);
+
+ va_start(args, format);
+ retval = vfprintf(veth_file, format, args);
+ va_end(args);
+
+ fclose(veth_file);
+ if (retval < 0) {
+ VLOG_WARN_RL(&rl, "could not destroy patch: %s", strerror(errno));
+ return errno;
+ }
+
+ return 0;
+}
+
+static int
+create_patch(const char *name, const char *peer)
+{
+ int retval;
+ struct netdev_dev *peer_nd;
+
+
+ /* Only create the veth if the peer didn't already do it. */
+ peer_nd = netdev_dev_from_name(peer);
+ if (peer_nd) {
+ if (!strcmp("patch", netdev_dev_get_type(peer_nd))) {
+ struct netdev_dev_linux *ndl = netdev_dev_linux_cast(peer_nd);
+ if (!strcmp(name, ndl->state.patch.peer)) {
+ return 0;
+ } else {
+ VLOG_WARN_RL(&rl, "peer '%s' already paired with '%s'",
+ peer, ndl->state.patch.peer);
+ return EINVAL;
+ }
+ } else {
+ VLOG_WARN_RL(&rl, "peer '%s' exists and is not a patch", peer);
+ return EINVAL;
+ }
+ }
+
+ retval = modify_veth("+%s,%s", name, peer);
+ if (retval) {
+ return retval;
+ }
+
+ retval = if_up(name);
+ if (retval) {
+ return retval;
+ }
+
+ retval = if_up(peer);
+ if (retval) {
+ return retval;
+ }
+
+ return 0;
+}
+
+static int
+setup_patch(const char *name, const struct shash *args, char **peer_)
+{
+ const char *peer;
+
+ peer = shash_find_data(args, "peer");
+ if (!peer) {
+ VLOG_WARN("patch type requires valid 'peer' argument");
+ return EINVAL;
+ }
+
+ if (shash_count(args) > 1) {
+ VLOG_WARN("patch type takes only a 'peer' argument");
+ return EINVAL;
+ }
+
+ if (strlen(peer) >= IFNAMSIZ) {
+ VLOG_WARN_RL(&rl, "patch 'peer' arg too long");
+ return EINVAL;
+ }
+
+ *peer_ = xstrdup(peer);
+ return create_patch(name, peer);
+}
+
+/* Creates the netdev device of 'type' with 'name'. */
+static int
+netdev_linux_create_system(const char *name, const char *type OVS_UNUSED,
+ const struct shash *args, struct netdev_dev **netdev_devp)
+{
+ struct netdev_dev_linux *netdev_dev;