datapath.c revision bb6f9a708d4067713afae2e9eb2637f6b4c01ecb
1/* 2 * Copyright (c) 2007-2013 Nicira, Inc. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of version 2 of the GNU General Public 6 * License as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, but 9 * WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program; if not, write to the Free Software 15 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 16 * 02110-1301, USA 17 */ 18 19#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 20 21#include <linux/init.h> 22#include <linux/module.h> 23#include <linux/if_arp.h> 24#include <linux/if_vlan.h> 25#include <linux/in.h> 26#include <linux/ip.h> 27#include <linux/jhash.h> 28#include <linux/delay.h> 29#include <linux/time.h> 30#include <linux/etherdevice.h> 31#include <linux/genetlink.h> 32#include <linux/kernel.h> 33#include <linux/kthread.h> 34#include <linux/mutex.h> 35#include <linux/percpu.h> 36#include <linux/rcupdate.h> 37#include <linux/tcp.h> 38#include <linux/udp.h> 39#include <linux/ethtool.h> 40#include <linux/wait.h> 41#include <asm/div64.h> 42#include <linux/highmem.h> 43#include <linux/netfilter_bridge.h> 44#include <linux/netfilter_ipv4.h> 45#include <linux/inetdevice.h> 46#include <linux/list.h> 47#include <linux/lockdep.h> 48#include <linux/openvswitch.h> 49#include <linux/rculist.h> 50#include <linux/dmi.h> 51#include <linux/workqueue.h> 52#include <net/genetlink.h> 53#include <net/net_namespace.h> 54#include <net/netns/generic.h> 55 56#include "datapath.h" 57#include "flow.h" 58#include "flow_table.h" 59#include "flow_netlink.h" 60#include "vport-internal_dev.h" 61#include "vport-netdev.h" 62 63int ovs_net_id __read_mostly; 64 65static void ovs_notify(struct genl_family *family, 66 struct sk_buff *skb, struct genl_info *info) 67{ 68 genl_notify(family, skb, genl_info_net(info), info->snd_portid, 69 0, info->nlhdr, GFP_KERNEL); 70} 71 72/** 73 * DOC: Locking: 74 * 75 * All writes e.g. Writes to device state (add/remove datapath, port, set 76 * operations on vports, etc.), Writes to other state (flow table 77 * modifications, set miscellaneous datapath parameters, etc.) are protected 78 * by ovs_lock. 79 * 80 * Reads are protected by RCU. 81 * 82 * There are a few special cases (mostly stats) that have their own 83 * synchronization but they nest under all of above and don't interact with 84 * each other. 85 * 86 * The RTNL lock nests inside ovs_mutex. 87 */ 88 89static DEFINE_MUTEX(ovs_mutex); 90 91void ovs_lock(void) 92{ 93 mutex_lock(&ovs_mutex); 94} 95 96void ovs_unlock(void) 97{ 98 mutex_unlock(&ovs_mutex); 99} 100 101#ifdef CONFIG_LOCKDEP 102int lockdep_ovsl_is_held(void) 103{ 104 if (debug_locks) 105 return lockdep_is_held(&ovs_mutex); 106 else 107 return 1; 108} 109#endif 110 111static struct vport *new_vport(const struct vport_parms *); 112static int queue_gso_packets(struct datapath *dp, struct sk_buff *, 113 const struct dp_upcall_info *); 114static int queue_userspace_packet(struct datapath *dp, struct sk_buff *, 115 const struct dp_upcall_info *); 116 117/* Must be called with rcu_read_lock or ovs_mutex. */ 118static struct datapath *get_dp(struct net *net, int dp_ifindex) 119{ 120 struct datapath *dp = NULL; 121 struct net_device *dev; 122 123 rcu_read_lock(); 124 dev = dev_get_by_index_rcu(net, dp_ifindex); 125 if (dev) { 126 struct vport *vport = ovs_internal_dev_get_vport(dev); 127 if (vport) 128 dp = vport->dp; 129 } 130 rcu_read_unlock(); 131 132 return dp; 133} 134 135/* Must be called with rcu_read_lock or ovs_mutex. */ 136static const char *ovs_dp_name(const struct datapath *dp) 137{ 138 struct vport *vport = ovs_vport_ovsl_rcu(dp, OVSP_LOCAL); 139 return vport->ops->get_name(vport); 140} 141 142static int get_dpifindex(struct datapath *dp) 143{ 144 struct vport *local; 145 int ifindex; 146 147 rcu_read_lock(); 148 149 local = ovs_vport_rcu(dp, OVSP_LOCAL); 150 if (local) 151 ifindex = netdev_vport_priv(local)->dev->ifindex; 152 else 153 ifindex = 0; 154 155 rcu_read_unlock(); 156 157 return ifindex; 158} 159 160static void destroy_dp_rcu(struct rcu_head *rcu) 161{ 162 struct datapath *dp = container_of(rcu, struct datapath, rcu); 163 164 free_percpu(dp->stats_percpu); 165 release_net(ovs_dp_get_net(dp)); 166 kfree(dp->ports); 167 kfree(dp); 168} 169 170static struct hlist_head *vport_hash_bucket(const struct datapath *dp, 171 u16 port_no) 172{ 173 return &dp->ports[port_no & (DP_VPORT_HASH_BUCKETS - 1)]; 174} 175 176/* Called with ovs_mutex or RCU read lock. */ 177struct vport *ovs_lookup_vport(const struct datapath *dp, u16 port_no) 178{ 179 struct vport *vport; 180 struct hlist_head *head; 181 182 head = vport_hash_bucket(dp, port_no); 183 hlist_for_each_entry_rcu(vport, head, dp_hash_node) { 184 if (vport->port_no == port_no) 185 return vport; 186 } 187 return NULL; 188} 189 190/* Called with ovs_mutex. */ 191static struct vport *new_vport(const struct vport_parms *parms) 192{ 193 struct vport *vport; 194 195 vport = ovs_vport_add(parms); 196 if (!IS_ERR(vport)) { 197 struct datapath *dp = parms->dp; 198 struct hlist_head *head = vport_hash_bucket(dp, vport->port_no); 199 200 hlist_add_head_rcu(&vport->dp_hash_node, head); 201 } 202 return vport; 203} 204 205void ovs_dp_detach_port(struct vport *p) 206{ 207 ASSERT_OVSL(); 208 209 /* First drop references to device. */ 210 hlist_del_rcu(&p->dp_hash_node); 211 212 /* Then destroy it. */ 213 ovs_vport_del(p); 214} 215 216/* Must be called with rcu_read_lock. */ 217void ovs_dp_process_received_packet(struct vport *p, struct sk_buff *skb) 218{ 219 struct datapath *dp = p->dp; 220 struct sw_flow *flow; 221 struct dp_stats_percpu *stats; 222 struct sw_flow_key key; 223 u64 *stats_counter; 224 u32 n_mask_hit; 225 int error; 226 227 stats = this_cpu_ptr(dp->stats_percpu); 228 229 /* Extract flow from 'skb' into 'key'. */ 230 error = ovs_flow_extract(skb, p->port_no, &key); 231 if (unlikely(error)) { 232 kfree_skb(skb); 233 return; 234 } 235 236 /* Look up flow. */ 237 flow = ovs_flow_tbl_lookup_stats(&dp->table, &key, &n_mask_hit); 238 if (unlikely(!flow)) { 239 struct dp_upcall_info upcall; 240 241 upcall.cmd = OVS_PACKET_CMD_MISS; 242 upcall.key = &key; 243 upcall.userdata = NULL; 244 upcall.portid = p->upcall_portid; 245 ovs_dp_upcall(dp, skb, &upcall); 246 consume_skb(skb); 247 stats_counter = &stats->n_missed; 248 goto out; 249 } 250 251 OVS_CB(skb)->flow = flow; 252 OVS_CB(skb)->pkt_key = &key; 253 254 ovs_flow_stats_update(OVS_CB(skb)->flow, skb); 255 ovs_execute_actions(dp, skb); 256 stats_counter = &stats->n_hit; 257 258out: 259 /* Update datapath statistics. */ 260 u64_stats_update_begin(&stats->syncp); 261 (*stats_counter)++; 262 stats->n_mask_hit += n_mask_hit; 263 u64_stats_update_end(&stats->syncp); 264} 265 266static struct genl_family dp_packet_genl_family = { 267 .id = GENL_ID_GENERATE, 268 .hdrsize = sizeof(struct ovs_header), 269 .name = OVS_PACKET_FAMILY, 270 .version = OVS_PACKET_VERSION, 271 .maxattr = OVS_PACKET_ATTR_MAX, 272 .netnsok = true, 273 .parallel_ops = true, 274}; 275 276int ovs_dp_upcall(struct datapath *dp, struct sk_buff *skb, 277 const struct dp_upcall_info *upcall_info) 278{ 279 struct dp_stats_percpu *stats; 280 int err; 281 282 if (upcall_info->portid == 0) { 283 err = -ENOTCONN; 284 goto err; 285 } 286 287 if (!skb_is_gso(skb)) 288 err = queue_userspace_packet(dp, skb, upcall_info); 289 else 290 err = queue_gso_packets(dp, skb, upcall_info); 291 if (err) 292 goto err; 293 294 return 0; 295 296err: 297 stats = this_cpu_ptr(dp->stats_percpu); 298 299 u64_stats_update_begin(&stats->syncp); 300 stats->n_lost++; 301 u64_stats_update_end(&stats->syncp); 302 303 return err; 304} 305 306static int queue_gso_packets(struct datapath *dp, struct sk_buff *skb, 307 const struct dp_upcall_info *upcall_info) 308{ 309 unsigned short gso_type = skb_shinfo(skb)->gso_type; 310 struct dp_upcall_info later_info; 311 struct sw_flow_key later_key; 312 struct sk_buff *segs, *nskb; 313 int err; 314 315 segs = __skb_gso_segment(skb, NETIF_F_SG, false); 316 if (IS_ERR(segs)) 317 return PTR_ERR(segs); 318 319 /* Queue all of the segments. */ 320 skb = segs; 321 do { 322 err = queue_userspace_packet(dp, skb, upcall_info); 323 if (err) 324 break; 325 326 if (skb == segs && gso_type & SKB_GSO_UDP) { 327 /* The initial flow key extracted by ovs_flow_extract() 328 * in this case is for a first fragment, so we need to 329 * properly mark later fragments. 330 */ 331 later_key = *upcall_info->key; 332 later_key.ip.frag = OVS_FRAG_TYPE_LATER; 333 334 later_info = *upcall_info; 335 later_info.key = &later_key; 336 upcall_info = &later_info; 337 } 338 } while ((skb = skb->next)); 339 340 /* Free all of the segments. */ 341 skb = segs; 342 do { 343 nskb = skb->next; 344 if (err) 345 kfree_skb(skb); 346 else 347 consume_skb(skb); 348 } while ((skb = nskb)); 349 return err; 350} 351 352static size_t key_attr_size(void) 353{ 354 return nla_total_size(4) /* OVS_KEY_ATTR_PRIORITY */ 355 + nla_total_size(0) /* OVS_KEY_ATTR_TUNNEL */ 356 + nla_total_size(8) /* OVS_TUNNEL_KEY_ATTR_ID */ 357 + nla_total_size(4) /* OVS_TUNNEL_KEY_ATTR_IPV4_SRC */ 358 + nla_total_size(4) /* OVS_TUNNEL_KEY_ATTR_IPV4_DST */ 359 + nla_total_size(1) /* OVS_TUNNEL_KEY_ATTR_TOS */ 360 + nla_total_size(1) /* OVS_TUNNEL_KEY_ATTR_TTL */ 361 + nla_total_size(0) /* OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT */ 362 + nla_total_size(0) /* OVS_TUNNEL_KEY_ATTR_CSUM */ 363 + nla_total_size(4) /* OVS_KEY_ATTR_IN_PORT */ 364 + nla_total_size(4) /* OVS_KEY_ATTR_SKB_MARK */ 365 + nla_total_size(12) /* OVS_KEY_ATTR_ETHERNET */ 366 + nla_total_size(2) /* OVS_KEY_ATTR_ETHERTYPE */ 367 + nla_total_size(4) /* OVS_KEY_ATTR_8021Q */ 368 + nla_total_size(0) /* OVS_KEY_ATTR_ENCAP */ 369 + nla_total_size(2) /* OVS_KEY_ATTR_ETHERTYPE */ 370 + nla_total_size(40) /* OVS_KEY_ATTR_IPV6 */ 371 + nla_total_size(2) /* OVS_KEY_ATTR_ICMPV6 */ 372 + nla_total_size(28); /* OVS_KEY_ATTR_ND */ 373} 374 375static size_t upcall_msg_size(const struct nlattr *userdata, 376 unsigned int hdrlen) 377{ 378 size_t size = NLMSG_ALIGN(sizeof(struct ovs_header)) 379 + nla_total_size(hdrlen) /* OVS_PACKET_ATTR_PACKET */ 380 + nla_total_size(key_attr_size()); /* OVS_PACKET_ATTR_KEY */ 381 382 /* OVS_PACKET_ATTR_USERDATA */ 383 if (userdata) 384 size += NLA_ALIGN(userdata->nla_len); 385 386 return size; 387} 388 389static int queue_userspace_packet(struct datapath *dp, struct sk_buff *skb, 390 const struct dp_upcall_info *upcall_info) 391{ 392 struct ovs_header *upcall; 393 struct sk_buff *nskb = NULL; 394 struct sk_buff *user_skb; /* to be queued to userspace */ 395 struct nlattr *nla; 396 struct genl_info info = { 397 .dst_sk = ovs_dp_get_net(dp)->genl_sock, 398 .snd_portid = upcall_info->portid, 399 }; 400 size_t len; 401 unsigned int hlen; 402 int err, dp_ifindex; 403 404 dp_ifindex = get_dpifindex(dp); 405 if (!dp_ifindex) 406 return -ENODEV; 407 408 if (vlan_tx_tag_present(skb)) { 409 nskb = skb_clone(skb, GFP_ATOMIC); 410 if (!nskb) 411 return -ENOMEM; 412 413 nskb = __vlan_put_tag(nskb, nskb->vlan_proto, vlan_tx_tag_get(nskb)); 414 if (!nskb) 415 return -ENOMEM; 416 417 nskb->vlan_tci = 0; 418 skb = nskb; 419 } 420 421 if (nla_attr_size(skb->len) > USHRT_MAX) { 422 err = -EFBIG; 423 goto out; 424 } 425 426 /* Complete checksum if needed */ 427 if (skb->ip_summed == CHECKSUM_PARTIAL && 428 (err = skb_checksum_help(skb))) 429 goto out; 430 431 /* Older versions of OVS user space enforce alignment of the last 432 * Netlink attribute to NLA_ALIGNTO which would require extensive 433 * padding logic. Only perform zerocopy if padding is not required. 434 */ 435 if (dp->user_features & OVS_DP_F_UNALIGNED) 436 hlen = skb_zerocopy_headlen(skb); 437 else 438 hlen = skb->len; 439 440 len = upcall_msg_size(upcall_info->userdata, hlen); 441 user_skb = genlmsg_new_unicast(len, &info, GFP_ATOMIC); 442 if (!user_skb) { 443 err = -ENOMEM; 444 goto out; 445 } 446 447 upcall = genlmsg_put(user_skb, 0, 0, &dp_packet_genl_family, 448 0, upcall_info->cmd); 449 upcall->dp_ifindex = dp_ifindex; 450 451 nla = nla_nest_start(user_skb, OVS_PACKET_ATTR_KEY); 452 ovs_nla_put_flow(upcall_info->key, upcall_info->key, user_skb); 453 nla_nest_end(user_skb, nla); 454 455 if (upcall_info->userdata) 456 __nla_put(user_skb, OVS_PACKET_ATTR_USERDATA, 457 nla_len(upcall_info->userdata), 458 nla_data(upcall_info->userdata)); 459 460 /* Only reserve room for attribute header, packet data is added 461 * in skb_zerocopy() */ 462 if (!(nla = nla_reserve(user_skb, OVS_PACKET_ATTR_PACKET, 0))) { 463 err = -ENOBUFS; 464 goto out; 465 } 466 nla->nla_len = nla_attr_size(skb->len); 467 468 err = skb_zerocopy(user_skb, skb, skb->len, hlen); 469 if (err) 470 goto out; 471 472 /* Pad OVS_PACKET_ATTR_PACKET if linear copy was performed */ 473 if (!(dp->user_features & OVS_DP_F_UNALIGNED)) { 474 size_t plen = NLA_ALIGN(user_skb->len) - user_skb->len; 475 476 if (plen > 0) 477 memset(skb_put(user_skb, plen), 0, plen); 478 } 479 480 ((struct nlmsghdr *) user_skb->data)->nlmsg_len = user_skb->len; 481 482 err = genlmsg_unicast(ovs_dp_get_net(dp), user_skb, upcall_info->portid); 483out: 484 if (err) 485 skb_tx_error(skb); 486 kfree_skb(nskb); 487 return err; 488} 489 490static int ovs_packet_cmd_execute(struct sk_buff *skb, struct genl_info *info) 491{ 492 struct ovs_header *ovs_header = info->userhdr; 493 struct nlattr **a = info->attrs; 494 struct sw_flow_actions *acts; 495 struct sk_buff *packet; 496 struct sw_flow *flow; 497 struct datapath *dp; 498 struct ethhdr *eth; 499 int len; 500 int err; 501 502 err = -EINVAL; 503 if (!a[OVS_PACKET_ATTR_PACKET] || !a[OVS_PACKET_ATTR_KEY] || 504 !a[OVS_PACKET_ATTR_ACTIONS]) 505 goto err; 506 507 len = nla_len(a[OVS_PACKET_ATTR_PACKET]); 508 packet = __dev_alloc_skb(NET_IP_ALIGN + len, GFP_KERNEL); 509 err = -ENOMEM; 510 if (!packet) 511 goto err; 512 skb_reserve(packet, NET_IP_ALIGN); 513 514 nla_memcpy(__skb_put(packet, len), a[OVS_PACKET_ATTR_PACKET], len); 515 516 skb_reset_mac_header(packet); 517 eth = eth_hdr(packet); 518 519 /* Normally, setting the skb 'protocol' field would be handled by a 520 * call to eth_type_trans(), but it assumes there's a sending 521 * device, which we may not have. */ 522 if (ntohs(eth->h_proto) >= ETH_P_802_3_MIN) 523 packet->protocol = eth->h_proto; 524 else 525 packet->protocol = htons(ETH_P_802_2); 526 527 /* Build an sw_flow for sending this packet. */ 528 flow = ovs_flow_alloc(); 529 err = PTR_ERR(flow); 530 if (IS_ERR(flow)) 531 goto err_kfree_skb; 532 533 err = ovs_flow_extract(packet, -1, &flow->key); 534 if (err) 535 goto err_flow_free; 536 537 err = ovs_nla_get_flow_metadata(flow, a[OVS_PACKET_ATTR_KEY]); 538 if (err) 539 goto err_flow_free; 540 acts = ovs_nla_alloc_flow_actions(nla_len(a[OVS_PACKET_ATTR_ACTIONS])); 541 err = PTR_ERR(acts); 542 if (IS_ERR(acts)) 543 goto err_flow_free; 544 545 err = ovs_nla_copy_actions(a[OVS_PACKET_ATTR_ACTIONS], 546 &flow->key, 0, &acts); 547 rcu_assign_pointer(flow->sf_acts, acts); 548 if (err) 549 goto err_flow_free; 550 551 OVS_CB(packet)->flow = flow; 552 OVS_CB(packet)->pkt_key = &flow->key; 553 packet->priority = flow->key.phy.priority; 554 packet->mark = flow->key.phy.skb_mark; 555 556 rcu_read_lock(); 557 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 558 err = -ENODEV; 559 if (!dp) 560 goto err_unlock; 561 562 local_bh_disable(); 563 err = ovs_execute_actions(dp, packet); 564 local_bh_enable(); 565 rcu_read_unlock(); 566 567 ovs_flow_free(flow, false); 568 return err; 569 570err_unlock: 571 rcu_read_unlock(); 572err_flow_free: 573 ovs_flow_free(flow, false); 574err_kfree_skb: 575 kfree_skb(packet); 576err: 577 return err; 578} 579 580static const struct nla_policy packet_policy[OVS_PACKET_ATTR_MAX + 1] = { 581 [OVS_PACKET_ATTR_PACKET] = { .len = ETH_HLEN }, 582 [OVS_PACKET_ATTR_KEY] = { .type = NLA_NESTED }, 583 [OVS_PACKET_ATTR_ACTIONS] = { .type = NLA_NESTED }, 584}; 585 586static const struct genl_ops dp_packet_genl_ops[] = { 587 { .cmd = OVS_PACKET_CMD_EXECUTE, 588 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 589 .policy = packet_policy, 590 .doit = ovs_packet_cmd_execute 591 } 592}; 593 594static void get_dp_stats(struct datapath *dp, struct ovs_dp_stats *stats, 595 struct ovs_dp_megaflow_stats *mega_stats) 596{ 597 int i; 598 599 memset(mega_stats, 0, sizeof(*mega_stats)); 600 601 stats->n_flows = ovs_flow_tbl_count(&dp->table); 602 mega_stats->n_masks = ovs_flow_tbl_num_masks(&dp->table); 603 604 stats->n_hit = stats->n_missed = stats->n_lost = 0; 605 606 for_each_possible_cpu(i) { 607 const struct dp_stats_percpu *percpu_stats; 608 struct dp_stats_percpu local_stats; 609 unsigned int start; 610 611 percpu_stats = per_cpu_ptr(dp->stats_percpu, i); 612 613 do { 614 start = u64_stats_fetch_begin_irq(&percpu_stats->syncp); 615 local_stats = *percpu_stats; 616 } while (u64_stats_fetch_retry_irq(&percpu_stats->syncp, start)); 617 618 stats->n_hit += local_stats.n_hit; 619 stats->n_missed += local_stats.n_missed; 620 stats->n_lost += local_stats.n_lost; 621 mega_stats->n_mask_hit += local_stats.n_mask_hit; 622 } 623} 624 625static const struct nla_policy flow_policy[OVS_FLOW_ATTR_MAX + 1] = { 626 [OVS_FLOW_ATTR_KEY] = { .type = NLA_NESTED }, 627 [OVS_FLOW_ATTR_ACTIONS] = { .type = NLA_NESTED }, 628 [OVS_FLOW_ATTR_CLEAR] = { .type = NLA_FLAG }, 629}; 630 631static struct genl_family dp_flow_genl_family = { 632 .id = GENL_ID_GENERATE, 633 .hdrsize = sizeof(struct ovs_header), 634 .name = OVS_FLOW_FAMILY, 635 .version = OVS_FLOW_VERSION, 636 .maxattr = OVS_FLOW_ATTR_MAX, 637 .netnsok = true, 638 .parallel_ops = true, 639}; 640 641static struct genl_multicast_group ovs_dp_flow_multicast_group = { 642 .name = OVS_FLOW_MCGROUP 643}; 644 645static size_t ovs_flow_cmd_msg_size(const struct sw_flow_actions *acts) 646{ 647 return NLMSG_ALIGN(sizeof(struct ovs_header)) 648 + nla_total_size(key_attr_size()) /* OVS_FLOW_ATTR_KEY */ 649 + nla_total_size(key_attr_size()) /* OVS_FLOW_ATTR_MASK */ 650 + nla_total_size(sizeof(struct ovs_flow_stats)) /* OVS_FLOW_ATTR_STATS */ 651 + nla_total_size(1) /* OVS_FLOW_ATTR_TCP_FLAGS */ 652 + nla_total_size(8) /* OVS_FLOW_ATTR_USED */ 653 + nla_total_size(acts->actions_len); /* OVS_FLOW_ATTR_ACTIONS */ 654} 655 656/* Called with ovs_mutex or RCU read lock. */ 657static int ovs_flow_cmd_fill_info(struct sw_flow *flow, struct datapath *dp, 658 struct sk_buff *skb, u32 portid, 659 u32 seq, u32 flags, u8 cmd) 660{ 661 const int skb_orig_len = skb->len; 662 struct nlattr *start; 663 struct ovs_flow_stats stats; 664 __be16 tcp_flags; 665 unsigned long used; 666 struct ovs_header *ovs_header; 667 struct nlattr *nla; 668 int err; 669 670 ovs_header = genlmsg_put(skb, portid, seq, &dp_flow_genl_family, flags, cmd); 671 if (!ovs_header) 672 return -EMSGSIZE; 673 674 ovs_header->dp_ifindex = get_dpifindex(dp); 675 676 /* Fill flow key. */ 677 nla = nla_nest_start(skb, OVS_FLOW_ATTR_KEY); 678 if (!nla) 679 goto nla_put_failure; 680 681 err = ovs_nla_put_flow(&flow->unmasked_key, &flow->unmasked_key, skb); 682 if (err) 683 goto error; 684 nla_nest_end(skb, nla); 685 686 nla = nla_nest_start(skb, OVS_FLOW_ATTR_MASK); 687 if (!nla) 688 goto nla_put_failure; 689 690 err = ovs_nla_put_flow(&flow->key, &flow->mask->key, skb); 691 if (err) 692 goto error; 693 694 nla_nest_end(skb, nla); 695 696 ovs_flow_stats_get(flow, &stats, &used, &tcp_flags); 697 if (used && 698 nla_put_u64(skb, OVS_FLOW_ATTR_USED, ovs_flow_used_time(used))) 699 goto nla_put_failure; 700 701 if (stats.n_packets && 702 nla_put(skb, OVS_FLOW_ATTR_STATS, sizeof(struct ovs_flow_stats), &stats)) 703 goto nla_put_failure; 704 705 if ((u8)ntohs(tcp_flags) && 706 nla_put_u8(skb, OVS_FLOW_ATTR_TCP_FLAGS, (u8)ntohs(tcp_flags))) 707 goto nla_put_failure; 708 709 /* If OVS_FLOW_ATTR_ACTIONS doesn't fit, skip dumping the actions if 710 * this is the first flow to be dumped into 'skb'. This is unusual for 711 * Netlink but individual action lists can be longer than 712 * NLMSG_GOODSIZE and thus entirely undumpable if we didn't do this. 713 * The userspace caller can always fetch the actions separately if it 714 * really wants them. (Most userspace callers in fact don't care.) 715 * 716 * This can only fail for dump operations because the skb is always 717 * properly sized for single flows. 718 */ 719 start = nla_nest_start(skb, OVS_FLOW_ATTR_ACTIONS); 720 if (start) { 721 const struct sw_flow_actions *sf_acts; 722 723 sf_acts = rcu_dereference_ovsl(flow->sf_acts); 724 725 err = ovs_nla_put_actions(sf_acts->actions, 726 sf_acts->actions_len, skb); 727 if (!err) 728 nla_nest_end(skb, start); 729 else { 730 if (skb_orig_len) 731 goto error; 732 733 nla_nest_cancel(skb, start); 734 } 735 } else if (skb_orig_len) 736 goto nla_put_failure; 737 738 return genlmsg_end(skb, ovs_header); 739 740nla_put_failure: 741 err = -EMSGSIZE; 742error: 743 genlmsg_cancel(skb, ovs_header); 744 return err; 745} 746 747/* Must be called with ovs_mutex. */ 748static struct sk_buff *ovs_flow_cmd_alloc_info(struct sw_flow *flow, 749 struct genl_info *info) 750{ 751 size_t len; 752 753 len = ovs_flow_cmd_msg_size(ovsl_dereference(flow->sf_acts)); 754 755 return genlmsg_new_unicast(len, info, GFP_KERNEL); 756} 757 758/* Must be called with ovs_mutex. */ 759static struct sk_buff *ovs_flow_cmd_build_info(struct sw_flow *flow, 760 struct datapath *dp, 761 struct genl_info *info, 762 u8 cmd) 763{ 764 struct sk_buff *skb; 765 int retval; 766 767 skb = ovs_flow_cmd_alloc_info(flow, info); 768 if (!skb) 769 return ERR_PTR(-ENOMEM); 770 771 retval = ovs_flow_cmd_fill_info(flow, dp, skb, info->snd_portid, 772 info->snd_seq, 0, cmd); 773 BUG_ON(retval < 0); 774 return skb; 775} 776 777static int ovs_flow_cmd_new_or_set(struct sk_buff *skb, struct genl_info *info) 778{ 779 struct nlattr **a = info->attrs; 780 struct ovs_header *ovs_header = info->userhdr; 781 struct sw_flow_key key, masked_key; 782 struct sw_flow *flow = NULL; 783 struct sw_flow_mask mask; 784 struct sk_buff *reply; 785 struct datapath *dp; 786 struct sw_flow_actions *acts = NULL; 787 struct sw_flow_match match; 788 int error; 789 790 /* Extract key. */ 791 error = -EINVAL; 792 if (!a[OVS_FLOW_ATTR_KEY]) 793 goto error; 794 795 ovs_match_init(&match, &key, &mask); 796 error = ovs_nla_get_match(&match, 797 a[OVS_FLOW_ATTR_KEY], a[OVS_FLOW_ATTR_MASK]); 798 if (error) 799 goto error; 800 801 /* Validate actions. */ 802 if (a[OVS_FLOW_ATTR_ACTIONS]) { 803 acts = ovs_nla_alloc_flow_actions(nla_len(a[OVS_FLOW_ATTR_ACTIONS])); 804 error = PTR_ERR(acts); 805 if (IS_ERR(acts)) 806 goto error; 807 808 ovs_flow_mask_key(&masked_key, &key, &mask); 809 error = ovs_nla_copy_actions(a[OVS_FLOW_ATTR_ACTIONS], 810 &masked_key, 0, &acts); 811 if (error) { 812 OVS_NLERR("Flow actions may not be safe on all matching packets.\n"); 813 goto err_kfree; 814 } 815 } else if (info->genlhdr->cmd == OVS_FLOW_CMD_NEW) { 816 /* OVS_FLOW_CMD_NEW must have actions. */ 817 error = -EINVAL; 818 goto error; 819 } 820 821 ovs_lock(); 822 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 823 error = -ENODEV; 824 if (!dp) 825 goto err_unlock_ovs; 826 827 /* Check if this is a duplicate flow */ 828 flow = ovs_flow_tbl_lookup(&dp->table, &key); 829 if (!flow) { 830 /* Bail out if we're not allowed to create a new flow. */ 831 error = -ENOENT; 832 if (info->genlhdr->cmd == OVS_FLOW_CMD_SET) 833 goto err_unlock_ovs; 834 835 /* Allocate flow. */ 836 flow = ovs_flow_alloc(); 837 if (IS_ERR(flow)) { 838 error = PTR_ERR(flow); 839 goto err_unlock_ovs; 840 } 841 842 flow->key = masked_key; 843 flow->unmasked_key = key; 844 rcu_assign_pointer(flow->sf_acts, acts); 845 846 /* Put flow in bucket. */ 847 error = ovs_flow_tbl_insert(&dp->table, flow, &mask); 848 if (error) { 849 acts = NULL; 850 goto err_flow_free; 851 } 852 853 reply = ovs_flow_cmd_build_info(flow, dp, info, OVS_FLOW_CMD_NEW); 854 } else { 855 /* We found a matching flow. */ 856 /* Bail out if we're not allowed to modify an existing flow. 857 * We accept NLM_F_CREATE in place of the intended NLM_F_EXCL 858 * because Generic Netlink treats the latter as a dump 859 * request. We also accept NLM_F_EXCL in case that bug ever 860 * gets fixed. 861 */ 862 error = -EEXIST; 863 if (info->genlhdr->cmd == OVS_FLOW_CMD_NEW && 864 info->nlhdr->nlmsg_flags & (NLM_F_CREATE | NLM_F_EXCL)) 865 goto err_unlock_ovs; 866 867 /* The unmasked key has to be the same for flow updates. */ 868 if (!ovs_flow_cmp_unmasked_key(flow, &match)) 869 goto err_unlock_ovs; 870 871 /* Update actions, if present. */ 872 if (acts) { 873 struct sw_flow_actions *old_acts; 874 875 old_acts = ovsl_dereference(flow->sf_acts); 876 rcu_assign_pointer(flow->sf_acts, acts); 877 ovs_nla_free_flow_actions(old_acts); 878 } 879 reply = ovs_flow_cmd_build_info(flow, dp, info, OVS_FLOW_CMD_NEW); 880 881 /* Clear stats. */ 882 if (a[OVS_FLOW_ATTR_CLEAR]) 883 ovs_flow_stats_clear(flow); 884 } 885 ovs_unlock(); 886 887 if (!IS_ERR(reply)) 888 ovs_notify(&dp_flow_genl_family, reply, info); 889 else 890 genl_set_err(&dp_flow_genl_family, sock_net(skb->sk), 0, 891 0, PTR_ERR(reply)); 892 return 0; 893 894err_flow_free: 895 ovs_flow_free(flow, false); 896err_unlock_ovs: 897 ovs_unlock(); 898err_kfree: 899 kfree(acts); 900error: 901 return error; 902} 903 904static int ovs_flow_cmd_get(struct sk_buff *skb, struct genl_info *info) 905{ 906 struct nlattr **a = info->attrs; 907 struct ovs_header *ovs_header = info->userhdr; 908 struct sw_flow_key key; 909 struct sk_buff *reply; 910 struct sw_flow *flow; 911 struct datapath *dp; 912 struct sw_flow_match match; 913 int err; 914 915 if (!a[OVS_FLOW_ATTR_KEY]) { 916 OVS_NLERR("Flow get message rejected, Key attribute missing.\n"); 917 return -EINVAL; 918 } 919 920 ovs_match_init(&match, &key, NULL); 921 err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL); 922 if (err) 923 return err; 924 925 ovs_lock(); 926 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 927 if (!dp) { 928 err = -ENODEV; 929 goto unlock; 930 } 931 932 flow = ovs_flow_tbl_lookup(&dp->table, &key); 933 if (!flow || !ovs_flow_cmp_unmasked_key(flow, &match)) { 934 err = -ENOENT; 935 goto unlock; 936 } 937 938 reply = ovs_flow_cmd_build_info(flow, dp, info, OVS_FLOW_CMD_NEW); 939 if (IS_ERR(reply)) { 940 err = PTR_ERR(reply); 941 goto unlock; 942 } 943 944 ovs_unlock(); 945 return genlmsg_reply(reply, info); 946unlock: 947 ovs_unlock(); 948 return err; 949} 950 951static int ovs_flow_cmd_del(struct sk_buff *skb, struct genl_info *info) 952{ 953 struct nlattr **a = info->attrs; 954 struct ovs_header *ovs_header = info->userhdr; 955 struct sw_flow_key key; 956 struct sk_buff *reply; 957 struct sw_flow *flow; 958 struct datapath *dp; 959 struct sw_flow_match match; 960 int err; 961 962 ovs_lock(); 963 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 964 if (!dp) { 965 err = -ENODEV; 966 goto unlock; 967 } 968 969 if (!a[OVS_FLOW_ATTR_KEY]) { 970 err = ovs_flow_tbl_flush(&dp->table); 971 goto unlock; 972 } 973 974 ovs_match_init(&match, &key, NULL); 975 err = ovs_nla_get_match(&match, a[OVS_FLOW_ATTR_KEY], NULL); 976 if (err) 977 goto unlock; 978 979 flow = ovs_flow_tbl_lookup(&dp->table, &key); 980 if (!flow || !ovs_flow_cmp_unmasked_key(flow, &match)) { 981 err = -ENOENT; 982 goto unlock; 983 } 984 985 reply = ovs_flow_cmd_alloc_info(flow, info); 986 if (!reply) { 987 err = -ENOMEM; 988 goto unlock; 989 } 990 991 ovs_flow_tbl_remove(&dp->table, flow); 992 993 err = ovs_flow_cmd_fill_info(flow, dp, reply, info->snd_portid, 994 info->snd_seq, 0, OVS_FLOW_CMD_DEL); 995 BUG_ON(err < 0); 996 997 ovs_flow_free(flow, true); 998 ovs_unlock(); 999 1000 ovs_notify(&dp_flow_genl_family, reply, info); 1001 return 0; 1002unlock: 1003 ovs_unlock(); 1004 return err; 1005} 1006 1007static int ovs_flow_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb) 1008{ 1009 struct ovs_header *ovs_header = genlmsg_data(nlmsg_data(cb->nlh)); 1010 struct table_instance *ti; 1011 struct datapath *dp; 1012 1013 rcu_read_lock(); 1014 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 1015 if (!dp) { 1016 rcu_read_unlock(); 1017 return -ENODEV; 1018 } 1019 1020 ti = rcu_dereference(dp->table.ti); 1021 for (;;) { 1022 struct sw_flow *flow; 1023 u32 bucket, obj; 1024 1025 bucket = cb->args[0]; 1026 obj = cb->args[1]; 1027 flow = ovs_flow_tbl_dump_next(ti, &bucket, &obj); 1028 if (!flow) 1029 break; 1030 1031 if (ovs_flow_cmd_fill_info(flow, dp, skb, 1032 NETLINK_CB(cb->skb).portid, 1033 cb->nlh->nlmsg_seq, NLM_F_MULTI, 1034 OVS_FLOW_CMD_NEW) < 0) 1035 break; 1036 1037 cb->args[0] = bucket; 1038 cb->args[1] = obj; 1039 } 1040 rcu_read_unlock(); 1041 return skb->len; 1042} 1043 1044static const struct genl_ops dp_flow_genl_ops[] = { 1045 { .cmd = OVS_FLOW_CMD_NEW, 1046 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1047 .policy = flow_policy, 1048 .doit = ovs_flow_cmd_new_or_set 1049 }, 1050 { .cmd = OVS_FLOW_CMD_DEL, 1051 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1052 .policy = flow_policy, 1053 .doit = ovs_flow_cmd_del 1054 }, 1055 { .cmd = OVS_FLOW_CMD_GET, 1056 .flags = 0, /* OK for unprivileged users. */ 1057 .policy = flow_policy, 1058 .doit = ovs_flow_cmd_get, 1059 .dumpit = ovs_flow_cmd_dump 1060 }, 1061 { .cmd = OVS_FLOW_CMD_SET, 1062 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1063 .policy = flow_policy, 1064 .doit = ovs_flow_cmd_new_or_set, 1065 }, 1066}; 1067 1068static const struct nla_policy datapath_policy[OVS_DP_ATTR_MAX + 1] = { 1069 [OVS_DP_ATTR_NAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ - 1 }, 1070 [OVS_DP_ATTR_UPCALL_PID] = { .type = NLA_U32 }, 1071 [OVS_DP_ATTR_USER_FEATURES] = { .type = NLA_U32 }, 1072}; 1073 1074static struct genl_family dp_datapath_genl_family = { 1075 .id = GENL_ID_GENERATE, 1076 .hdrsize = sizeof(struct ovs_header), 1077 .name = OVS_DATAPATH_FAMILY, 1078 .version = OVS_DATAPATH_VERSION, 1079 .maxattr = OVS_DP_ATTR_MAX, 1080 .netnsok = true, 1081 .parallel_ops = true, 1082}; 1083 1084static struct genl_multicast_group ovs_dp_datapath_multicast_group = { 1085 .name = OVS_DATAPATH_MCGROUP 1086}; 1087 1088static size_t ovs_dp_cmd_msg_size(void) 1089{ 1090 size_t msgsize = NLMSG_ALIGN(sizeof(struct ovs_header)); 1091 1092 msgsize += nla_total_size(IFNAMSIZ); 1093 msgsize += nla_total_size(sizeof(struct ovs_dp_stats)); 1094 msgsize += nla_total_size(sizeof(struct ovs_dp_megaflow_stats)); 1095 msgsize += nla_total_size(sizeof(u32)); /* OVS_DP_ATTR_USER_FEATURES */ 1096 1097 return msgsize; 1098} 1099 1100/* Called with ovs_mutex or RCU read lock. */ 1101static int ovs_dp_cmd_fill_info(struct datapath *dp, struct sk_buff *skb, 1102 u32 portid, u32 seq, u32 flags, u8 cmd) 1103{ 1104 struct ovs_header *ovs_header; 1105 struct ovs_dp_stats dp_stats; 1106 struct ovs_dp_megaflow_stats dp_megaflow_stats; 1107 int err; 1108 1109 ovs_header = genlmsg_put(skb, portid, seq, &dp_datapath_genl_family, 1110 flags, cmd); 1111 if (!ovs_header) 1112 goto error; 1113 1114 ovs_header->dp_ifindex = get_dpifindex(dp); 1115 1116 err = nla_put_string(skb, OVS_DP_ATTR_NAME, ovs_dp_name(dp)); 1117 if (err) 1118 goto nla_put_failure; 1119 1120 get_dp_stats(dp, &dp_stats, &dp_megaflow_stats); 1121 if (nla_put(skb, OVS_DP_ATTR_STATS, sizeof(struct ovs_dp_stats), 1122 &dp_stats)) 1123 goto nla_put_failure; 1124 1125 if (nla_put(skb, OVS_DP_ATTR_MEGAFLOW_STATS, 1126 sizeof(struct ovs_dp_megaflow_stats), 1127 &dp_megaflow_stats)) 1128 goto nla_put_failure; 1129 1130 if (nla_put_u32(skb, OVS_DP_ATTR_USER_FEATURES, dp->user_features)) 1131 goto nla_put_failure; 1132 1133 return genlmsg_end(skb, ovs_header); 1134 1135nla_put_failure: 1136 genlmsg_cancel(skb, ovs_header); 1137error: 1138 return -EMSGSIZE; 1139} 1140 1141/* Must be called with ovs_mutex. */ 1142static struct sk_buff *ovs_dp_cmd_build_info(struct datapath *dp, 1143 struct genl_info *info, u8 cmd) 1144{ 1145 struct sk_buff *skb; 1146 int retval; 1147 1148 skb = genlmsg_new_unicast(ovs_dp_cmd_msg_size(), info, GFP_KERNEL); 1149 if (!skb) 1150 return ERR_PTR(-ENOMEM); 1151 1152 retval = ovs_dp_cmd_fill_info(dp, skb, info->snd_portid, info->snd_seq, 0, cmd); 1153 if (retval < 0) { 1154 kfree_skb(skb); 1155 return ERR_PTR(retval); 1156 } 1157 return skb; 1158} 1159 1160/* Called with rcu_read_lock or ovs_mutex. */ 1161static struct datapath *lookup_datapath(struct net *net, 1162 struct ovs_header *ovs_header, 1163 struct nlattr *a[OVS_DP_ATTR_MAX + 1]) 1164{ 1165 struct datapath *dp; 1166 1167 if (!a[OVS_DP_ATTR_NAME]) 1168 dp = get_dp(net, ovs_header->dp_ifindex); 1169 else { 1170 struct vport *vport; 1171 1172 vport = ovs_vport_locate(net, nla_data(a[OVS_DP_ATTR_NAME])); 1173 dp = vport && vport->port_no == OVSP_LOCAL ? vport->dp : NULL; 1174 } 1175 return dp ? dp : ERR_PTR(-ENODEV); 1176} 1177 1178static void ovs_dp_reset_user_features(struct sk_buff *skb, struct genl_info *info) 1179{ 1180 struct datapath *dp; 1181 1182 dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs); 1183 if (IS_ERR(dp)) 1184 return; 1185 1186 WARN(dp->user_features, "Dropping previously announced user features\n"); 1187 dp->user_features = 0; 1188} 1189 1190static void ovs_dp_change(struct datapath *dp, struct nlattr **a) 1191{ 1192 if (a[OVS_DP_ATTR_USER_FEATURES]) 1193 dp->user_features = nla_get_u32(a[OVS_DP_ATTR_USER_FEATURES]); 1194} 1195 1196static int ovs_dp_cmd_new(struct sk_buff *skb, struct genl_info *info) 1197{ 1198 struct nlattr **a = info->attrs; 1199 struct vport_parms parms; 1200 struct sk_buff *reply; 1201 struct datapath *dp; 1202 struct vport *vport; 1203 struct ovs_net *ovs_net; 1204 int err, i; 1205 1206 err = -EINVAL; 1207 if (!a[OVS_DP_ATTR_NAME] || !a[OVS_DP_ATTR_UPCALL_PID]) 1208 goto err; 1209 1210 ovs_lock(); 1211 1212 err = -ENOMEM; 1213 dp = kzalloc(sizeof(*dp), GFP_KERNEL); 1214 if (dp == NULL) 1215 goto err_unlock_ovs; 1216 1217 ovs_dp_set_net(dp, hold_net(sock_net(skb->sk))); 1218 1219 /* Allocate table. */ 1220 err = ovs_flow_tbl_init(&dp->table); 1221 if (err) 1222 goto err_free_dp; 1223 1224 dp->stats_percpu = netdev_alloc_pcpu_stats(struct dp_stats_percpu); 1225 if (!dp->stats_percpu) { 1226 err = -ENOMEM; 1227 goto err_destroy_table; 1228 } 1229 1230 dp->ports = kmalloc(DP_VPORT_HASH_BUCKETS * sizeof(struct hlist_head), 1231 GFP_KERNEL); 1232 if (!dp->ports) { 1233 err = -ENOMEM; 1234 goto err_destroy_percpu; 1235 } 1236 1237 for (i = 0; i < DP_VPORT_HASH_BUCKETS; i++) 1238 INIT_HLIST_HEAD(&dp->ports[i]); 1239 1240 /* Set up our datapath device. */ 1241 parms.name = nla_data(a[OVS_DP_ATTR_NAME]); 1242 parms.type = OVS_VPORT_TYPE_INTERNAL; 1243 parms.options = NULL; 1244 parms.dp = dp; 1245 parms.port_no = OVSP_LOCAL; 1246 parms.upcall_portid = nla_get_u32(a[OVS_DP_ATTR_UPCALL_PID]); 1247 1248 ovs_dp_change(dp, a); 1249 1250 vport = new_vport(&parms); 1251 if (IS_ERR(vport)) { 1252 err = PTR_ERR(vport); 1253 if (err == -EBUSY) 1254 err = -EEXIST; 1255 1256 if (err == -EEXIST) { 1257 /* An outdated user space instance that does not understand 1258 * the concept of user_features has attempted to create a new 1259 * datapath and is likely to reuse it. Drop all user features. 1260 */ 1261 if (info->genlhdr->version < OVS_DP_VER_FEATURES) 1262 ovs_dp_reset_user_features(skb, info); 1263 } 1264 1265 goto err_destroy_ports_array; 1266 } 1267 1268 reply = ovs_dp_cmd_build_info(dp, info, OVS_DP_CMD_NEW); 1269 err = PTR_ERR(reply); 1270 if (IS_ERR(reply)) 1271 goto err_destroy_local_port; 1272 1273 ovs_net = net_generic(ovs_dp_get_net(dp), ovs_net_id); 1274 list_add_tail_rcu(&dp->list_node, &ovs_net->dps); 1275 1276 ovs_unlock(); 1277 1278 ovs_notify(&dp_datapath_genl_family, reply, info); 1279 return 0; 1280 1281err_destroy_local_port: 1282 ovs_dp_detach_port(ovs_vport_ovsl(dp, OVSP_LOCAL)); 1283err_destroy_ports_array: 1284 kfree(dp->ports); 1285err_destroy_percpu: 1286 free_percpu(dp->stats_percpu); 1287err_destroy_table: 1288 ovs_flow_tbl_destroy(&dp->table, false); 1289err_free_dp: 1290 release_net(ovs_dp_get_net(dp)); 1291 kfree(dp); 1292err_unlock_ovs: 1293 ovs_unlock(); 1294err: 1295 return err; 1296} 1297 1298/* Called with ovs_mutex. */ 1299static void __dp_destroy(struct datapath *dp) 1300{ 1301 int i; 1302 1303 for (i = 0; i < DP_VPORT_HASH_BUCKETS; i++) { 1304 struct vport *vport; 1305 struct hlist_node *n; 1306 1307 hlist_for_each_entry_safe(vport, n, &dp->ports[i], dp_hash_node) 1308 if (vport->port_no != OVSP_LOCAL) 1309 ovs_dp_detach_port(vport); 1310 } 1311 1312 list_del_rcu(&dp->list_node); 1313 1314 /* OVSP_LOCAL is datapath internal port. We need to make sure that 1315 * all ports in datapath are destroyed first before freeing datapath. 1316 */ 1317 ovs_dp_detach_port(ovs_vport_ovsl(dp, OVSP_LOCAL)); 1318 1319 /* RCU destroy the flow table */ 1320 ovs_flow_tbl_destroy(&dp->table, true); 1321 1322 call_rcu(&dp->rcu, destroy_dp_rcu); 1323} 1324 1325static int ovs_dp_cmd_del(struct sk_buff *skb, struct genl_info *info) 1326{ 1327 struct sk_buff *reply; 1328 struct datapath *dp; 1329 int err; 1330 1331 ovs_lock(); 1332 dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs); 1333 err = PTR_ERR(dp); 1334 if (IS_ERR(dp)) 1335 goto unlock; 1336 1337 reply = ovs_dp_cmd_build_info(dp, info, OVS_DP_CMD_DEL); 1338 err = PTR_ERR(reply); 1339 if (IS_ERR(reply)) 1340 goto unlock; 1341 1342 __dp_destroy(dp); 1343 ovs_unlock(); 1344 1345 ovs_notify(&dp_datapath_genl_family, reply, info); 1346 1347 return 0; 1348unlock: 1349 ovs_unlock(); 1350 return err; 1351} 1352 1353static int ovs_dp_cmd_set(struct sk_buff *skb, struct genl_info *info) 1354{ 1355 struct sk_buff *reply; 1356 struct datapath *dp; 1357 int err; 1358 1359 ovs_lock(); 1360 dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs); 1361 err = PTR_ERR(dp); 1362 if (IS_ERR(dp)) 1363 goto unlock; 1364 1365 ovs_dp_change(dp, info->attrs); 1366 1367 reply = ovs_dp_cmd_build_info(dp, info, OVS_DP_CMD_NEW); 1368 if (IS_ERR(reply)) { 1369 err = PTR_ERR(reply); 1370 genl_set_err(&dp_datapath_genl_family, sock_net(skb->sk), 0, 1371 0, err); 1372 err = 0; 1373 goto unlock; 1374 } 1375 1376 ovs_unlock(); 1377 ovs_notify(&dp_datapath_genl_family, reply, info); 1378 1379 return 0; 1380unlock: 1381 ovs_unlock(); 1382 return err; 1383} 1384 1385static int ovs_dp_cmd_get(struct sk_buff *skb, struct genl_info *info) 1386{ 1387 struct sk_buff *reply; 1388 struct datapath *dp; 1389 int err; 1390 1391 ovs_lock(); 1392 dp = lookup_datapath(sock_net(skb->sk), info->userhdr, info->attrs); 1393 if (IS_ERR(dp)) { 1394 err = PTR_ERR(dp); 1395 goto unlock; 1396 } 1397 1398 reply = ovs_dp_cmd_build_info(dp, info, OVS_DP_CMD_NEW); 1399 if (IS_ERR(reply)) { 1400 err = PTR_ERR(reply); 1401 goto unlock; 1402 } 1403 1404 ovs_unlock(); 1405 return genlmsg_reply(reply, info); 1406 1407unlock: 1408 ovs_unlock(); 1409 return err; 1410} 1411 1412static int ovs_dp_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb) 1413{ 1414 struct ovs_net *ovs_net = net_generic(sock_net(skb->sk), ovs_net_id); 1415 struct datapath *dp; 1416 int skip = cb->args[0]; 1417 int i = 0; 1418 1419 rcu_read_lock(); 1420 list_for_each_entry_rcu(dp, &ovs_net->dps, list_node) { 1421 if (i >= skip && 1422 ovs_dp_cmd_fill_info(dp, skb, NETLINK_CB(cb->skb).portid, 1423 cb->nlh->nlmsg_seq, NLM_F_MULTI, 1424 OVS_DP_CMD_NEW) < 0) 1425 break; 1426 i++; 1427 } 1428 rcu_read_unlock(); 1429 1430 cb->args[0] = i; 1431 1432 return skb->len; 1433} 1434 1435static const struct genl_ops dp_datapath_genl_ops[] = { 1436 { .cmd = OVS_DP_CMD_NEW, 1437 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1438 .policy = datapath_policy, 1439 .doit = ovs_dp_cmd_new 1440 }, 1441 { .cmd = OVS_DP_CMD_DEL, 1442 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1443 .policy = datapath_policy, 1444 .doit = ovs_dp_cmd_del 1445 }, 1446 { .cmd = OVS_DP_CMD_GET, 1447 .flags = 0, /* OK for unprivileged users. */ 1448 .policy = datapath_policy, 1449 .doit = ovs_dp_cmd_get, 1450 .dumpit = ovs_dp_cmd_dump 1451 }, 1452 { .cmd = OVS_DP_CMD_SET, 1453 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1454 .policy = datapath_policy, 1455 .doit = ovs_dp_cmd_set, 1456 }, 1457}; 1458 1459static const struct nla_policy vport_policy[OVS_VPORT_ATTR_MAX + 1] = { 1460 [OVS_VPORT_ATTR_NAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ - 1 }, 1461 [OVS_VPORT_ATTR_STATS] = { .len = sizeof(struct ovs_vport_stats) }, 1462 [OVS_VPORT_ATTR_PORT_NO] = { .type = NLA_U32 }, 1463 [OVS_VPORT_ATTR_TYPE] = { .type = NLA_U32 }, 1464 [OVS_VPORT_ATTR_UPCALL_PID] = { .type = NLA_U32 }, 1465 [OVS_VPORT_ATTR_OPTIONS] = { .type = NLA_NESTED }, 1466}; 1467 1468struct genl_family dp_vport_genl_family = { 1469 .id = GENL_ID_GENERATE, 1470 .hdrsize = sizeof(struct ovs_header), 1471 .name = OVS_VPORT_FAMILY, 1472 .version = OVS_VPORT_VERSION, 1473 .maxattr = OVS_VPORT_ATTR_MAX, 1474 .netnsok = true, 1475 .parallel_ops = true, 1476}; 1477 1478static struct genl_multicast_group ovs_dp_vport_multicast_group = { 1479 .name = OVS_VPORT_MCGROUP 1480}; 1481 1482/* Called with ovs_mutex or RCU read lock. */ 1483static int ovs_vport_cmd_fill_info(struct vport *vport, struct sk_buff *skb, 1484 u32 portid, u32 seq, u32 flags, u8 cmd) 1485{ 1486 struct ovs_header *ovs_header; 1487 struct ovs_vport_stats vport_stats; 1488 int err; 1489 1490 ovs_header = genlmsg_put(skb, portid, seq, &dp_vport_genl_family, 1491 flags, cmd); 1492 if (!ovs_header) 1493 return -EMSGSIZE; 1494 1495 ovs_header->dp_ifindex = get_dpifindex(vport->dp); 1496 1497 if (nla_put_u32(skb, OVS_VPORT_ATTR_PORT_NO, vport->port_no) || 1498 nla_put_u32(skb, OVS_VPORT_ATTR_TYPE, vport->ops->type) || 1499 nla_put_string(skb, OVS_VPORT_ATTR_NAME, vport->ops->get_name(vport)) || 1500 nla_put_u32(skb, OVS_VPORT_ATTR_UPCALL_PID, vport->upcall_portid)) 1501 goto nla_put_failure; 1502 1503 ovs_vport_get_stats(vport, &vport_stats); 1504 if (nla_put(skb, OVS_VPORT_ATTR_STATS, sizeof(struct ovs_vport_stats), 1505 &vport_stats)) 1506 goto nla_put_failure; 1507 1508 err = ovs_vport_get_options(vport, skb); 1509 if (err == -EMSGSIZE) 1510 goto error; 1511 1512 return genlmsg_end(skb, ovs_header); 1513 1514nla_put_failure: 1515 err = -EMSGSIZE; 1516error: 1517 genlmsg_cancel(skb, ovs_header); 1518 return err; 1519} 1520 1521/* Called with ovs_mutex or RCU read lock. */ 1522struct sk_buff *ovs_vport_cmd_build_info(struct vport *vport, u32 portid, 1523 u32 seq, u8 cmd) 1524{ 1525 struct sk_buff *skb; 1526 int retval; 1527 1528 skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 1529 if (!skb) 1530 return ERR_PTR(-ENOMEM); 1531 1532 retval = ovs_vport_cmd_fill_info(vport, skb, portid, seq, 0, cmd); 1533 BUG_ON(retval < 0); 1534 1535 return skb; 1536} 1537 1538/* Called with ovs_mutex or RCU read lock. */ 1539static struct vport *lookup_vport(struct net *net, 1540 struct ovs_header *ovs_header, 1541 struct nlattr *a[OVS_VPORT_ATTR_MAX + 1]) 1542{ 1543 struct datapath *dp; 1544 struct vport *vport; 1545 1546 if (a[OVS_VPORT_ATTR_NAME]) { 1547 vport = ovs_vport_locate(net, nla_data(a[OVS_VPORT_ATTR_NAME])); 1548 if (!vport) 1549 return ERR_PTR(-ENODEV); 1550 if (ovs_header->dp_ifindex && 1551 ovs_header->dp_ifindex != get_dpifindex(vport->dp)) 1552 return ERR_PTR(-ENODEV); 1553 return vport; 1554 } else if (a[OVS_VPORT_ATTR_PORT_NO]) { 1555 u32 port_no = nla_get_u32(a[OVS_VPORT_ATTR_PORT_NO]); 1556 1557 if (port_no >= DP_MAX_PORTS) 1558 return ERR_PTR(-EFBIG); 1559 1560 dp = get_dp(net, ovs_header->dp_ifindex); 1561 if (!dp) 1562 return ERR_PTR(-ENODEV); 1563 1564 vport = ovs_vport_ovsl_rcu(dp, port_no); 1565 if (!vport) 1566 return ERR_PTR(-ENODEV); 1567 return vport; 1568 } else 1569 return ERR_PTR(-EINVAL); 1570} 1571 1572static int ovs_vport_cmd_new(struct sk_buff *skb, struct genl_info *info) 1573{ 1574 struct nlattr **a = info->attrs; 1575 struct ovs_header *ovs_header = info->userhdr; 1576 struct vport_parms parms; 1577 struct sk_buff *reply; 1578 struct vport *vport; 1579 struct datapath *dp; 1580 u32 port_no; 1581 int err; 1582 1583 err = -EINVAL; 1584 if (!a[OVS_VPORT_ATTR_NAME] || !a[OVS_VPORT_ATTR_TYPE] || 1585 !a[OVS_VPORT_ATTR_UPCALL_PID]) 1586 goto exit; 1587 1588 ovs_lock(); 1589 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 1590 err = -ENODEV; 1591 if (!dp) 1592 goto exit_unlock; 1593 1594 if (a[OVS_VPORT_ATTR_PORT_NO]) { 1595 port_no = nla_get_u32(a[OVS_VPORT_ATTR_PORT_NO]); 1596 1597 err = -EFBIG; 1598 if (port_no >= DP_MAX_PORTS) 1599 goto exit_unlock; 1600 1601 vport = ovs_vport_ovsl(dp, port_no); 1602 err = -EBUSY; 1603 if (vport) 1604 goto exit_unlock; 1605 } else { 1606 for (port_no = 1; ; port_no++) { 1607 if (port_no >= DP_MAX_PORTS) { 1608 err = -EFBIG; 1609 goto exit_unlock; 1610 } 1611 vport = ovs_vport_ovsl(dp, port_no); 1612 if (!vport) 1613 break; 1614 } 1615 } 1616 1617 parms.name = nla_data(a[OVS_VPORT_ATTR_NAME]); 1618 parms.type = nla_get_u32(a[OVS_VPORT_ATTR_TYPE]); 1619 parms.options = a[OVS_VPORT_ATTR_OPTIONS]; 1620 parms.dp = dp; 1621 parms.port_no = port_no; 1622 parms.upcall_portid = nla_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]); 1623 1624 vport = new_vport(&parms); 1625 err = PTR_ERR(vport); 1626 if (IS_ERR(vport)) 1627 goto exit_unlock; 1628 1629 err = 0; 1630 reply = ovs_vport_cmd_build_info(vport, info->snd_portid, info->snd_seq, 1631 OVS_VPORT_CMD_NEW); 1632 if (IS_ERR(reply)) { 1633 err = PTR_ERR(reply); 1634 ovs_dp_detach_port(vport); 1635 goto exit_unlock; 1636 } 1637 1638 ovs_notify(&dp_vport_genl_family, reply, info); 1639 1640exit_unlock: 1641 ovs_unlock(); 1642exit: 1643 return err; 1644} 1645 1646static int ovs_vport_cmd_set(struct sk_buff *skb, struct genl_info *info) 1647{ 1648 struct nlattr **a = info->attrs; 1649 struct sk_buff *reply; 1650 struct vport *vport; 1651 int err; 1652 1653 ovs_lock(); 1654 vport = lookup_vport(sock_net(skb->sk), info->userhdr, a); 1655 err = PTR_ERR(vport); 1656 if (IS_ERR(vport)) 1657 goto exit_unlock; 1658 1659 if (a[OVS_VPORT_ATTR_TYPE] && 1660 nla_get_u32(a[OVS_VPORT_ATTR_TYPE]) != vport->ops->type) { 1661 err = -EINVAL; 1662 goto exit_unlock; 1663 } 1664 1665 reply = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1666 if (!reply) { 1667 err = -ENOMEM; 1668 goto exit_unlock; 1669 } 1670 1671 if (a[OVS_VPORT_ATTR_OPTIONS]) { 1672 err = ovs_vport_set_options(vport, a[OVS_VPORT_ATTR_OPTIONS]); 1673 if (err) 1674 goto exit_free; 1675 } 1676 1677 if (a[OVS_VPORT_ATTR_UPCALL_PID]) 1678 vport->upcall_portid = nla_get_u32(a[OVS_VPORT_ATTR_UPCALL_PID]); 1679 1680 err = ovs_vport_cmd_fill_info(vport, reply, info->snd_portid, 1681 info->snd_seq, 0, OVS_VPORT_CMD_NEW); 1682 BUG_ON(err < 0); 1683 1684 ovs_unlock(); 1685 ovs_notify(&dp_vport_genl_family, reply, info); 1686 return 0; 1687 1688exit_free: 1689 kfree_skb(reply); 1690exit_unlock: 1691 ovs_unlock(); 1692 return err; 1693} 1694 1695static int ovs_vport_cmd_del(struct sk_buff *skb, struct genl_info *info) 1696{ 1697 struct nlattr **a = info->attrs; 1698 struct sk_buff *reply; 1699 struct vport *vport; 1700 int err; 1701 1702 ovs_lock(); 1703 vport = lookup_vport(sock_net(skb->sk), info->userhdr, a); 1704 err = PTR_ERR(vport); 1705 if (IS_ERR(vport)) 1706 goto exit_unlock; 1707 1708 if (vport->port_no == OVSP_LOCAL) { 1709 err = -EINVAL; 1710 goto exit_unlock; 1711 } 1712 1713 reply = ovs_vport_cmd_build_info(vport, info->snd_portid, 1714 info->snd_seq, OVS_VPORT_CMD_DEL); 1715 err = PTR_ERR(reply); 1716 if (IS_ERR(reply)) 1717 goto exit_unlock; 1718 1719 err = 0; 1720 ovs_dp_detach_port(vport); 1721 1722 ovs_notify(&dp_vport_genl_family, reply, info); 1723 1724exit_unlock: 1725 ovs_unlock(); 1726 return err; 1727} 1728 1729static int ovs_vport_cmd_get(struct sk_buff *skb, struct genl_info *info) 1730{ 1731 struct nlattr **a = info->attrs; 1732 struct ovs_header *ovs_header = info->userhdr; 1733 struct sk_buff *reply; 1734 struct vport *vport; 1735 int err; 1736 1737 rcu_read_lock(); 1738 vport = lookup_vport(sock_net(skb->sk), ovs_header, a); 1739 err = PTR_ERR(vport); 1740 if (IS_ERR(vport)) 1741 goto exit_unlock; 1742 1743 reply = ovs_vport_cmd_build_info(vport, info->snd_portid, 1744 info->snd_seq, OVS_VPORT_CMD_NEW); 1745 err = PTR_ERR(reply); 1746 if (IS_ERR(reply)) 1747 goto exit_unlock; 1748 1749 rcu_read_unlock(); 1750 1751 return genlmsg_reply(reply, info); 1752 1753exit_unlock: 1754 rcu_read_unlock(); 1755 return err; 1756} 1757 1758static int ovs_vport_cmd_dump(struct sk_buff *skb, struct netlink_callback *cb) 1759{ 1760 struct ovs_header *ovs_header = genlmsg_data(nlmsg_data(cb->nlh)); 1761 struct datapath *dp; 1762 int bucket = cb->args[0], skip = cb->args[1]; 1763 int i, j = 0; 1764 1765 rcu_read_lock(); 1766 dp = get_dp(sock_net(skb->sk), ovs_header->dp_ifindex); 1767 if (!dp) { 1768 rcu_read_unlock(); 1769 return -ENODEV; 1770 } 1771 for (i = bucket; i < DP_VPORT_HASH_BUCKETS; i++) { 1772 struct vport *vport; 1773 1774 j = 0; 1775 hlist_for_each_entry_rcu(vport, &dp->ports[i], dp_hash_node) { 1776 if (j >= skip && 1777 ovs_vport_cmd_fill_info(vport, skb, 1778 NETLINK_CB(cb->skb).portid, 1779 cb->nlh->nlmsg_seq, 1780 NLM_F_MULTI, 1781 OVS_VPORT_CMD_NEW) < 0) 1782 goto out; 1783 1784 j++; 1785 } 1786 skip = 0; 1787 } 1788out: 1789 rcu_read_unlock(); 1790 1791 cb->args[0] = i; 1792 cb->args[1] = j; 1793 1794 return skb->len; 1795} 1796 1797static const struct genl_ops dp_vport_genl_ops[] = { 1798 { .cmd = OVS_VPORT_CMD_NEW, 1799 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1800 .policy = vport_policy, 1801 .doit = ovs_vport_cmd_new 1802 }, 1803 { .cmd = OVS_VPORT_CMD_DEL, 1804 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1805 .policy = vport_policy, 1806 .doit = ovs_vport_cmd_del 1807 }, 1808 { .cmd = OVS_VPORT_CMD_GET, 1809 .flags = 0, /* OK for unprivileged users. */ 1810 .policy = vport_policy, 1811 .doit = ovs_vport_cmd_get, 1812 .dumpit = ovs_vport_cmd_dump 1813 }, 1814 { .cmd = OVS_VPORT_CMD_SET, 1815 .flags = GENL_ADMIN_PERM, /* Requires CAP_NET_ADMIN privilege. */ 1816 .policy = vport_policy, 1817 .doit = ovs_vport_cmd_set, 1818 }, 1819}; 1820 1821struct genl_family_and_ops { 1822 struct genl_family *family; 1823 const struct genl_ops *ops; 1824 int n_ops; 1825 const struct genl_multicast_group *group; 1826}; 1827 1828static const struct genl_family_and_ops dp_genl_families[] = { 1829 { &dp_datapath_genl_family, 1830 dp_datapath_genl_ops, ARRAY_SIZE(dp_datapath_genl_ops), 1831 &ovs_dp_datapath_multicast_group }, 1832 { &dp_vport_genl_family, 1833 dp_vport_genl_ops, ARRAY_SIZE(dp_vport_genl_ops), 1834 &ovs_dp_vport_multicast_group }, 1835 { &dp_flow_genl_family, 1836 dp_flow_genl_ops, ARRAY_SIZE(dp_flow_genl_ops), 1837 &ovs_dp_flow_multicast_group }, 1838 { &dp_packet_genl_family, 1839 dp_packet_genl_ops, ARRAY_SIZE(dp_packet_genl_ops), 1840 NULL }, 1841}; 1842 1843static void dp_unregister_genl(int n_families) 1844{ 1845 int i; 1846 1847 for (i = 0; i < n_families; i++) 1848 genl_unregister_family(dp_genl_families[i].family); 1849} 1850 1851static int dp_register_genl(void) 1852{ 1853 int n_registered; 1854 int err; 1855 int i; 1856 1857 n_registered = 0; 1858 for (i = 0; i < ARRAY_SIZE(dp_genl_families); i++) { 1859 const struct genl_family_and_ops *f = &dp_genl_families[i]; 1860 1861 f->family->ops = f->ops; 1862 f->family->n_ops = f->n_ops; 1863 f->family->mcgrps = f->group; 1864 f->family->n_mcgrps = f->group ? 1 : 0; 1865 err = genl_register_family(f->family); 1866 if (err) 1867 goto error; 1868 n_registered++; 1869 } 1870 1871 return 0; 1872 1873error: 1874 dp_unregister_genl(n_registered); 1875 return err; 1876} 1877 1878static int __net_init ovs_init_net(struct net *net) 1879{ 1880 struct ovs_net *ovs_net = net_generic(net, ovs_net_id); 1881 1882 INIT_LIST_HEAD(&ovs_net->dps); 1883 INIT_WORK(&ovs_net->dp_notify_work, ovs_dp_notify_wq); 1884 return 0; 1885} 1886 1887static void __net_exit ovs_exit_net(struct net *net) 1888{ 1889 struct datapath *dp, *dp_next; 1890 struct ovs_net *ovs_net = net_generic(net, ovs_net_id); 1891 1892 ovs_lock(); 1893 list_for_each_entry_safe(dp, dp_next, &ovs_net->dps, list_node) 1894 __dp_destroy(dp); 1895 ovs_unlock(); 1896 1897 cancel_work_sync(&ovs_net->dp_notify_work); 1898} 1899 1900static struct pernet_operations ovs_net_ops = { 1901 .init = ovs_init_net, 1902 .exit = ovs_exit_net, 1903 .id = &ovs_net_id, 1904 .size = sizeof(struct ovs_net), 1905}; 1906 1907static int __init dp_init(void) 1908{ 1909 int err; 1910 1911 BUILD_BUG_ON(sizeof(struct ovs_skb_cb) > FIELD_SIZEOF(struct sk_buff, cb)); 1912 1913 pr_info("Open vSwitch switching datapath\n"); 1914 1915 err = ovs_flow_init(); 1916 if (err) 1917 goto error; 1918 1919 err = ovs_vport_init(); 1920 if (err) 1921 goto error_flow_exit; 1922 1923 err = register_pernet_device(&ovs_net_ops); 1924 if (err) 1925 goto error_vport_exit; 1926 1927 err = register_netdevice_notifier(&ovs_dp_device_notifier); 1928 if (err) 1929 goto error_netns_exit; 1930 1931 err = dp_register_genl(); 1932 if (err < 0) 1933 goto error_unreg_notifier; 1934 1935 return 0; 1936 1937error_unreg_notifier: 1938 unregister_netdevice_notifier(&ovs_dp_device_notifier); 1939error_netns_exit: 1940 unregister_pernet_device(&ovs_net_ops); 1941error_vport_exit: 1942 ovs_vport_exit(); 1943error_flow_exit: 1944 ovs_flow_exit(); 1945error: 1946 return err; 1947} 1948 1949static void dp_cleanup(void) 1950{ 1951 dp_unregister_genl(ARRAY_SIZE(dp_genl_families)); 1952 unregister_netdevice_notifier(&ovs_dp_device_notifier); 1953 unregister_pernet_device(&ovs_net_ops); 1954 rcu_barrier(); 1955 ovs_vport_exit(); 1956 ovs_flow_exit(); 1957} 1958 1959module_init(dp_init); 1960module_exit(dp_cleanup); 1961 1962MODULE_DESCRIPTION("Open vSwitch switching datapath"); 1963MODULE_LICENSE("GPL"); 1964