1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) B.A.T.M.A.N. contributors: 3 * 4 * Marek Lindner, Simon Wunderlich 5 */ 6 7 #include "soft-interface.h" 8 #include "main.h" 9 10 #include <linux/atomic.h> 11 #include <linux/byteorder/generic.h> 12 #include <linux/cache.h> 13 #include <linux/compiler.h> 14 #include <linux/cpumask.h> 15 #include <linux/errno.h> 16 #include <linux/etherdevice.h> 17 #include <linux/ethtool.h> 18 #include <linux/gfp.h> 19 #include <linux/if_ether.h> 20 #include <linux/if_vlan.h> 21 #include <linux/jiffies.h> 22 #include <linux/kernel.h> 23 #include <linux/kref.h> 24 #include <linux/list.h> 25 #include <linux/lockdep.h> 26 #include <linux/netdevice.h> 27 #include <linux/netlink.h> 28 #include <linux/percpu.h> 29 #include <linux/random.h> 30 #include <linux/rculist.h> 31 #include <linux/rcupdate.h> 32 #include <linux/skbuff.h> 33 #include <linux/slab.h> 34 #include <linux/socket.h> 35 #include <linux/spinlock.h> 36 #include <linux/stddef.h> 37 #include <linux/string.h> 38 #include <linux/types.h> 39 #include <net/net_namespace.h> 40 #include <net/netlink.h> 41 #include <uapi/linux/batadv_packet.h> 42 #include <uapi/linux/batman_adv.h> 43 44 #include "bat_algo.h" 45 #include "bridge_loop_avoidance.h" 46 #include "distributed-arp-table.h" 47 #include "gateway_client.h" 48 #include "hard-interface.h" 49 #include "multicast.h" 50 #include "network-coding.h" 51 #include "originator.h" 52 #include "send.h" 53 #include "translation-table.h" 54 55 /** 56 * batadv_skb_head_push() - Increase header size and move (push) head pointer 57 * @skb: packet buffer which should be modified 58 * @len: number of bytes to add 59 * 60 * Return: 0 on success or negative error number in case of failure 61 */ 62 int batadv_skb_head_push(struct sk_buff *skb, unsigned int len) 63 { 64 int result; 65 66 /* TODO: We must check if we can release all references to non-payload 67 * data using __skb_header_release in our skbs to allow skb_cow_header 68 * to work optimally. This means that those skbs are not allowed to read 69 * or write any data which is before the current position of skb->data 70 * after that call and thus allow other skbs with the same data buffer 71 * to write freely in that area. 72 */ 73 result = skb_cow_head(skb, len); 74 if (result < 0) 75 return result; 76 77 skb_push(skb, len); 78 return 0; 79 } 80 81 static int batadv_interface_open(struct net_device *dev) 82 { 83 netif_start_queue(dev); 84 return 0; 85 } 86 87 static int batadv_interface_release(struct net_device *dev) 88 { 89 netif_stop_queue(dev); 90 return 0; 91 } 92 93 /** 94 * batadv_sum_counter() - Sum the cpu-local counters for index 'idx' 95 * @bat_priv: the bat priv with all the soft interface information 96 * @idx: index of counter to sum up 97 * 98 * Return: sum of all cpu-local counters 99 */ 100 static u64 batadv_sum_counter(struct batadv_priv *bat_priv, size_t idx) 101 { 102 u64 *counters, sum = 0; 103 int cpu; 104 105 for_each_possible_cpu(cpu) { 106 counters = per_cpu_ptr(bat_priv->bat_counters, cpu); 107 sum += counters[idx]; 108 } 109 110 return sum; 111 } 112 113 static struct net_device_stats *batadv_interface_stats(struct net_device *dev) 114 { 115 struct batadv_priv *bat_priv = netdev_priv(dev); 116 struct net_device_stats *stats = &dev->stats; 117 118 stats->tx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_TX); 119 stats->tx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_TX_BYTES); 120 stats->tx_dropped = batadv_sum_counter(bat_priv, BATADV_CNT_TX_DROPPED); 121 stats->rx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_RX); 122 stats->rx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_RX_BYTES); 123 return stats; 124 } 125 126 static int batadv_interface_set_mac_addr(struct net_device *dev, void *p) 127 { 128 struct batadv_priv *bat_priv = netdev_priv(dev); 129 struct batadv_softif_vlan *vlan; 130 struct sockaddr *addr = p; 131 u8 old_addr[ETH_ALEN]; 132 133 if (!is_valid_ether_addr(addr->sa_data)) 134 return -EADDRNOTAVAIL; 135 136 ether_addr_copy(old_addr, dev->dev_addr); 137 ether_addr_copy(dev->dev_addr, addr->sa_data); 138 139 /* only modify transtable if it has been initialized before */ 140 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) 141 return 0; 142 143 rcu_read_lock(); 144 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 145 batadv_tt_local_remove(bat_priv, old_addr, vlan->vid, 146 "mac address changed", false); 147 batadv_tt_local_add(dev, addr->sa_data, vlan->vid, 148 BATADV_NULL_IFINDEX, BATADV_NO_MARK); 149 } 150 rcu_read_unlock(); 151 152 return 0; 153 } 154 155 static int batadv_interface_change_mtu(struct net_device *dev, int new_mtu) 156 { 157 /* check ranges */ 158 if (new_mtu < 68 || new_mtu > batadv_hardif_min_mtu(dev)) 159 return -EINVAL; 160 161 dev->mtu = new_mtu; 162 163 return 0; 164 } 165 166 /** 167 * batadv_interface_set_rx_mode() - set the rx mode of a device 168 * @dev: registered network device to modify 169 * 170 * We do not actually need to set any rx filters for the virtual batman 171 * soft interface. However a dummy handler enables a user to set static 172 * multicast listeners for instance. 173 */ 174 static void batadv_interface_set_rx_mode(struct net_device *dev) 175 { 176 } 177 178 static netdev_tx_t batadv_interface_tx(struct sk_buff *skb, 179 struct net_device *soft_iface) 180 { 181 struct ethhdr *ethhdr; 182 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 183 struct batadv_hard_iface *primary_if = NULL; 184 struct batadv_bcast_packet *bcast_packet; 185 static const u8 stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00, 186 0x00, 0x00}; 187 static const u8 ectp_addr[ETH_ALEN] = {0xCF, 0x00, 0x00, 0x00, 188 0x00, 0x00}; 189 enum batadv_dhcp_recipient dhcp_rcp = BATADV_DHCP_NO; 190 u8 *dst_hint = NULL, chaddr[ETH_ALEN]; 191 struct vlan_ethhdr *vhdr; 192 unsigned int header_len = 0; 193 int data_len = skb->len, ret; 194 unsigned long brd_delay = 0; 195 bool do_bcast = false, client_added; 196 unsigned short vid; 197 u32 seqno; 198 int gw_mode; 199 enum batadv_forw_mode forw_mode = BATADV_FORW_SINGLE; 200 struct batadv_orig_node *mcast_single_orig = NULL; 201 int network_offset = ETH_HLEN; 202 __be16 proto; 203 204 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) 205 goto dropped; 206 207 /* reset control block to avoid left overs from previous users */ 208 memset(skb->cb, 0, sizeof(struct batadv_skb_cb)); 209 210 netif_trans_update(soft_iface); 211 vid = batadv_get_vid(skb, 0); 212 213 skb_reset_mac_header(skb); 214 ethhdr = eth_hdr(skb); 215 216 proto = ethhdr->h_proto; 217 218 switch (ntohs(proto)) { 219 case ETH_P_8021Q: 220 if (!pskb_may_pull(skb, sizeof(*vhdr))) 221 goto dropped; 222 vhdr = vlan_eth_hdr(skb); 223 proto = vhdr->h_vlan_encapsulated_proto; 224 225 /* drop batman-in-batman packets to prevent loops */ 226 if (proto != htons(ETH_P_BATMAN)) { 227 network_offset += VLAN_HLEN; 228 break; 229 } 230 231 fallthrough; 232 case ETH_P_BATMAN: 233 goto dropped; 234 } 235 236 skb_set_network_header(skb, network_offset); 237 238 if (batadv_bla_tx(bat_priv, skb, vid)) 239 goto dropped; 240 241 /* skb->data might have been reallocated by batadv_bla_tx() */ 242 ethhdr = eth_hdr(skb); 243 244 /* Register the client MAC in the transtable */ 245 if (!is_multicast_ether_addr(ethhdr->h_source) && 246 !batadv_bla_is_loopdetect_mac(ethhdr->h_source)) { 247 client_added = batadv_tt_local_add(soft_iface, ethhdr->h_source, 248 vid, skb->skb_iif, 249 skb->mark); 250 if (!client_added) 251 goto dropped; 252 } 253 254 /* Snoop address candidates from DHCPACKs for early DAT filling */ 255 batadv_dat_snoop_outgoing_dhcp_ack(bat_priv, skb, proto, vid); 256 257 /* don't accept stp packets. STP does not help in meshes. 258 * better use the bridge loop avoidance ... 259 * 260 * The same goes for ECTP sent at least by some Cisco Switches, 261 * it might confuse the mesh when used with bridge loop avoidance. 262 */ 263 if (batadv_compare_eth(ethhdr->h_dest, stp_addr)) 264 goto dropped; 265 266 if (batadv_compare_eth(ethhdr->h_dest, ectp_addr)) 267 goto dropped; 268 269 gw_mode = atomic_read(&bat_priv->gw.mode); 270 if (is_multicast_ether_addr(ethhdr->h_dest)) { 271 /* if gw mode is off, broadcast every packet */ 272 if (gw_mode == BATADV_GW_MODE_OFF) { 273 do_bcast = true; 274 goto send; 275 } 276 277 dhcp_rcp = batadv_gw_dhcp_recipient_get(skb, &header_len, 278 chaddr); 279 /* skb->data may have been modified by 280 * batadv_gw_dhcp_recipient_get() 281 */ 282 ethhdr = eth_hdr(skb); 283 /* if gw_mode is on, broadcast any non-DHCP message. 284 * All the DHCP packets are going to be sent as unicast 285 */ 286 if (dhcp_rcp == BATADV_DHCP_NO) { 287 do_bcast = true; 288 goto send; 289 } 290 291 if (dhcp_rcp == BATADV_DHCP_TO_CLIENT) 292 dst_hint = chaddr; 293 else if ((gw_mode == BATADV_GW_MODE_SERVER) && 294 (dhcp_rcp == BATADV_DHCP_TO_SERVER)) 295 /* gateways should not forward any DHCP message if 296 * directed to a DHCP server 297 */ 298 goto dropped; 299 300 send: 301 if (do_bcast && !is_broadcast_ether_addr(ethhdr->h_dest)) { 302 forw_mode = batadv_mcast_forw_mode(bat_priv, skb, 303 &mcast_single_orig); 304 if (forw_mode == BATADV_FORW_NONE) 305 goto dropped; 306 307 if (forw_mode == BATADV_FORW_SINGLE || 308 forw_mode == BATADV_FORW_SOME) 309 do_bcast = false; 310 } 311 } 312 313 batadv_skb_set_priority(skb, 0); 314 315 /* ethernet packet should be broadcasted */ 316 if (do_bcast) { 317 primary_if = batadv_primary_if_get_selected(bat_priv); 318 if (!primary_if) 319 goto dropped; 320 321 /* in case of ARP request, we do not immediately broadcasti the 322 * packet, instead we first wait for DAT to try to retrieve the 323 * correct ARP entry 324 */ 325 if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb)) 326 brd_delay = msecs_to_jiffies(ARP_REQ_DELAY); 327 328 if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0) 329 goto dropped; 330 331 bcast_packet = (struct batadv_bcast_packet *)skb->data; 332 bcast_packet->version = BATADV_COMPAT_VERSION; 333 bcast_packet->ttl = BATADV_TTL - 1; 334 335 /* batman packet type: broadcast */ 336 bcast_packet->packet_type = BATADV_BCAST; 337 bcast_packet->reserved = 0; 338 339 /* hw address of first interface is the orig mac because only 340 * this mac is known throughout the mesh 341 */ 342 ether_addr_copy(bcast_packet->orig, 343 primary_if->net_dev->dev_addr); 344 345 /* set broadcast sequence number */ 346 seqno = atomic_inc_return(&bat_priv->bcast_seqno); 347 bcast_packet->seqno = htonl(seqno); 348 349 batadv_send_bcast_packet(bat_priv, skb, brd_delay, true); 350 /* unicast packet */ 351 } else { 352 /* DHCP packets going to a server will use the GW feature */ 353 if (dhcp_rcp == BATADV_DHCP_TO_SERVER) { 354 ret = batadv_gw_out_of_range(bat_priv, skb); 355 if (ret) 356 goto dropped; 357 ret = batadv_send_skb_via_gw(bat_priv, skb, vid); 358 } else if (mcast_single_orig) { 359 ret = batadv_mcast_forw_send_orig(bat_priv, skb, vid, 360 mcast_single_orig); 361 } else if (forw_mode == BATADV_FORW_SOME) { 362 ret = batadv_mcast_forw_send(bat_priv, skb, vid); 363 } else { 364 if (batadv_dat_snoop_outgoing_arp_request(bat_priv, 365 skb)) 366 goto dropped; 367 368 batadv_dat_snoop_outgoing_arp_reply(bat_priv, skb); 369 370 ret = batadv_send_skb_via_tt(bat_priv, skb, dst_hint, 371 vid); 372 } 373 if (ret != NET_XMIT_SUCCESS) 374 goto dropped_freed; 375 } 376 377 batadv_inc_counter(bat_priv, BATADV_CNT_TX); 378 batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len); 379 goto end; 380 381 dropped: 382 kfree_skb(skb); 383 dropped_freed: 384 batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED); 385 end: 386 if (mcast_single_orig) 387 batadv_orig_node_put(mcast_single_orig); 388 if (primary_if) 389 batadv_hardif_put(primary_if); 390 return NETDEV_TX_OK; 391 } 392 393 /** 394 * batadv_interface_rx() - receive ethernet frame on local batman-adv interface 395 * @soft_iface: local interface which will receive the ethernet frame 396 * @skb: ethernet frame for @soft_iface 397 * @hdr_size: size of already parsed batman-adv header 398 * @orig_node: originator from which the batman-adv packet was sent 399 * 400 * Sends an ethernet frame to the receive path of the local @soft_iface. 401 * skb->data has still point to the batman-adv header with the size @hdr_size. 402 * The caller has to have parsed this header already and made sure that at least 403 * @hdr_size bytes are still available for pull in @skb. 404 * 405 * The packet may still get dropped. This can happen when the encapsulated 406 * ethernet frame is invalid or contains again an batman-adv packet. Also 407 * unicast packets will be dropped directly when it was sent between two 408 * isolated clients. 409 */ 410 void batadv_interface_rx(struct net_device *soft_iface, 411 struct sk_buff *skb, int hdr_size, 412 struct batadv_orig_node *orig_node) 413 { 414 struct batadv_bcast_packet *batadv_bcast_packet; 415 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 416 struct vlan_ethhdr *vhdr; 417 struct ethhdr *ethhdr; 418 unsigned short vid; 419 int packet_type; 420 421 batadv_bcast_packet = (struct batadv_bcast_packet *)skb->data; 422 packet_type = batadv_bcast_packet->packet_type; 423 424 skb_pull_rcsum(skb, hdr_size); 425 skb_reset_mac_header(skb); 426 427 /* clean the netfilter state now that the batman-adv header has been 428 * removed 429 */ 430 nf_reset_ct(skb); 431 432 if (unlikely(!pskb_may_pull(skb, ETH_HLEN))) 433 goto dropped; 434 435 vid = batadv_get_vid(skb, 0); 436 ethhdr = eth_hdr(skb); 437 438 switch (ntohs(ethhdr->h_proto)) { 439 case ETH_P_8021Q: 440 if (!pskb_may_pull(skb, VLAN_ETH_HLEN)) 441 goto dropped; 442 443 vhdr = (struct vlan_ethhdr *)skb->data; 444 445 /* drop batman-in-batman packets to prevent loops */ 446 if (vhdr->h_vlan_encapsulated_proto != htons(ETH_P_BATMAN)) 447 break; 448 449 fallthrough; 450 case ETH_P_BATMAN: 451 goto dropped; 452 } 453 454 /* skb->dev & skb->pkt_type are set here */ 455 skb->protocol = eth_type_trans(skb, soft_iface); 456 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_HLEN); 457 458 batadv_inc_counter(bat_priv, BATADV_CNT_RX); 459 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES, 460 skb->len + ETH_HLEN); 461 462 /* Let the bridge loop avoidance check the packet. If will 463 * not handle it, we can safely push it up. 464 */ 465 if (batadv_bla_rx(bat_priv, skb, vid, packet_type)) 466 goto out; 467 468 if (orig_node) 469 batadv_tt_add_temporary_global_entry(bat_priv, orig_node, 470 ethhdr->h_source, vid); 471 472 if (is_multicast_ether_addr(ethhdr->h_dest)) { 473 /* set the mark on broadcast packets if AP isolation is ON and 474 * the packet is coming from an "isolated" client 475 */ 476 if (batadv_vlan_ap_isola_get(bat_priv, vid) && 477 batadv_tt_global_is_isolated(bat_priv, ethhdr->h_source, 478 vid)) { 479 /* save bits in skb->mark not covered by the mask and 480 * apply the mark on the rest 481 */ 482 skb->mark &= ~bat_priv->isolation_mark_mask; 483 skb->mark |= bat_priv->isolation_mark; 484 } 485 } else if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source, 486 ethhdr->h_dest, vid)) { 487 goto dropped; 488 } 489 490 netif_rx(skb); 491 goto out; 492 493 dropped: 494 kfree_skb(skb); 495 out: 496 return; 497 } 498 499 /** 500 * batadv_softif_vlan_release() - release vlan from lists and queue for free 501 * after rcu grace period 502 * @ref: kref pointer of the vlan object 503 */ 504 static void batadv_softif_vlan_release(struct kref *ref) 505 { 506 struct batadv_softif_vlan *vlan; 507 508 vlan = container_of(ref, struct batadv_softif_vlan, refcount); 509 510 spin_lock_bh(&vlan->bat_priv->softif_vlan_list_lock); 511 hlist_del_rcu(&vlan->list); 512 spin_unlock_bh(&vlan->bat_priv->softif_vlan_list_lock); 513 514 kfree_rcu(vlan, rcu); 515 } 516 517 /** 518 * batadv_softif_vlan_put() - decrease the vlan object refcounter and 519 * possibly release it 520 * @vlan: the vlan object to release 521 */ 522 void batadv_softif_vlan_put(struct batadv_softif_vlan *vlan) 523 { 524 if (!vlan) 525 return; 526 527 kref_put(&vlan->refcount, batadv_softif_vlan_release); 528 } 529 530 /** 531 * batadv_softif_vlan_get() - get the vlan object for a specific vid 532 * @bat_priv: the bat priv with all the soft interface information 533 * @vid: the identifier of the vlan object to retrieve 534 * 535 * Return: the private data of the vlan matching the vid passed as argument or 536 * NULL otherwise. The refcounter of the returned object is incremented by 1. 537 */ 538 struct batadv_softif_vlan *batadv_softif_vlan_get(struct batadv_priv *bat_priv, 539 unsigned short vid) 540 { 541 struct batadv_softif_vlan *vlan_tmp, *vlan = NULL; 542 543 rcu_read_lock(); 544 hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) { 545 if (vlan_tmp->vid != vid) 546 continue; 547 548 if (!kref_get_unless_zero(&vlan_tmp->refcount)) 549 continue; 550 551 vlan = vlan_tmp; 552 break; 553 } 554 rcu_read_unlock(); 555 556 return vlan; 557 } 558 559 /** 560 * batadv_softif_create_vlan() - allocate the needed resources for a new vlan 561 * @bat_priv: the bat priv with all the soft interface information 562 * @vid: the VLAN identifier 563 * 564 * Return: 0 on success, a negative error otherwise. 565 */ 566 int batadv_softif_create_vlan(struct batadv_priv *bat_priv, unsigned short vid) 567 { 568 struct batadv_softif_vlan *vlan; 569 570 spin_lock_bh(&bat_priv->softif_vlan_list_lock); 571 572 vlan = batadv_softif_vlan_get(bat_priv, vid); 573 if (vlan) { 574 batadv_softif_vlan_put(vlan); 575 spin_unlock_bh(&bat_priv->softif_vlan_list_lock); 576 return -EEXIST; 577 } 578 579 vlan = kzalloc(sizeof(*vlan), GFP_ATOMIC); 580 if (!vlan) { 581 spin_unlock_bh(&bat_priv->softif_vlan_list_lock); 582 return -ENOMEM; 583 } 584 585 vlan->bat_priv = bat_priv; 586 vlan->vid = vid; 587 kref_init(&vlan->refcount); 588 589 atomic_set(&vlan->ap_isolation, 0); 590 591 kref_get(&vlan->refcount); 592 hlist_add_head_rcu(&vlan->list, &bat_priv->softif_vlan_list); 593 spin_unlock_bh(&bat_priv->softif_vlan_list_lock); 594 595 /* add a new TT local entry. This one will be marked with the NOPURGE 596 * flag 597 */ 598 batadv_tt_local_add(bat_priv->soft_iface, 599 bat_priv->soft_iface->dev_addr, vid, 600 BATADV_NULL_IFINDEX, BATADV_NO_MARK); 601 602 /* don't return reference to new softif_vlan */ 603 batadv_softif_vlan_put(vlan); 604 605 return 0; 606 } 607 608 /** 609 * batadv_softif_destroy_vlan() - remove and destroy a softif_vlan object 610 * @bat_priv: the bat priv with all the soft interface information 611 * @vlan: the object to remove 612 */ 613 static void batadv_softif_destroy_vlan(struct batadv_priv *bat_priv, 614 struct batadv_softif_vlan *vlan) 615 { 616 /* explicitly remove the associated TT local entry because it is marked 617 * with the NOPURGE flag 618 */ 619 batadv_tt_local_remove(bat_priv, bat_priv->soft_iface->dev_addr, 620 vlan->vid, "vlan interface destroyed", false); 621 622 batadv_softif_vlan_put(vlan); 623 } 624 625 /** 626 * batadv_interface_add_vid() - ndo_add_vid API implementation 627 * @dev: the netdev of the mesh interface 628 * @proto: protocol of the vlan id 629 * @vid: identifier of the new vlan 630 * 631 * Set up all the internal structures for handling the new vlan on top of the 632 * mesh interface 633 * 634 * Return: 0 on success or a negative error code in case of failure. 635 */ 636 static int batadv_interface_add_vid(struct net_device *dev, __be16 proto, 637 unsigned short vid) 638 { 639 struct batadv_priv *bat_priv = netdev_priv(dev); 640 struct batadv_softif_vlan *vlan; 641 642 /* only 802.1Q vlans are supported. 643 * batman-adv does not know how to handle other types 644 */ 645 if (proto != htons(ETH_P_8021Q)) 646 return -EINVAL; 647 648 vid |= BATADV_VLAN_HAS_TAG; 649 650 /* if a new vlan is getting created and it already exists, it means that 651 * it was not deleted yet. batadv_softif_vlan_get() increases the 652 * refcount in order to revive the object. 653 * 654 * if it does not exist then create it. 655 */ 656 vlan = batadv_softif_vlan_get(bat_priv, vid); 657 if (!vlan) 658 return batadv_softif_create_vlan(bat_priv, vid); 659 660 /* add a new TT local entry. This one will be marked with the NOPURGE 661 * flag. This must be added again, even if the vlan object already 662 * exists, because the entry was deleted by kill_vid() 663 */ 664 batadv_tt_local_add(bat_priv->soft_iface, 665 bat_priv->soft_iface->dev_addr, vid, 666 BATADV_NULL_IFINDEX, BATADV_NO_MARK); 667 668 return 0; 669 } 670 671 /** 672 * batadv_interface_kill_vid() - ndo_kill_vid API implementation 673 * @dev: the netdev of the mesh interface 674 * @proto: protocol of the vlan id 675 * @vid: identifier of the deleted vlan 676 * 677 * Destroy all the internal structures used to handle the vlan identified by vid 678 * on top of the mesh interface 679 * 680 * Return: 0 on success, -EINVAL if the specified prototype is not ETH_P_8021Q 681 * or -ENOENT if the specified vlan id wasn't registered. 682 */ 683 static int batadv_interface_kill_vid(struct net_device *dev, __be16 proto, 684 unsigned short vid) 685 { 686 struct batadv_priv *bat_priv = netdev_priv(dev); 687 struct batadv_softif_vlan *vlan; 688 689 /* only 802.1Q vlans are supported. batman-adv does not know how to 690 * handle other types 691 */ 692 if (proto != htons(ETH_P_8021Q)) 693 return -EINVAL; 694 695 vlan = batadv_softif_vlan_get(bat_priv, vid | BATADV_VLAN_HAS_TAG); 696 if (!vlan) 697 return -ENOENT; 698 699 batadv_softif_destroy_vlan(bat_priv, vlan); 700 701 /* finally free the vlan object */ 702 batadv_softif_vlan_put(vlan); 703 704 return 0; 705 } 706 707 /* batman-adv network devices have devices nesting below it and are a special 708 * "super class" of normal network devices; split their locks off into a 709 * separate class since they always nest. 710 */ 711 static struct lock_class_key batadv_netdev_xmit_lock_key; 712 static struct lock_class_key batadv_netdev_addr_lock_key; 713 714 /** 715 * batadv_set_lockdep_class_one() - Set lockdep class for a single tx queue 716 * @dev: device which owns the tx queue 717 * @txq: tx queue to modify 718 * @_unused: always NULL 719 */ 720 static void batadv_set_lockdep_class_one(struct net_device *dev, 721 struct netdev_queue *txq, 722 void *_unused) 723 { 724 lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key); 725 } 726 727 /** 728 * batadv_set_lockdep_class() - Set txq and addr_list lockdep class 729 * @dev: network device to modify 730 */ 731 static void batadv_set_lockdep_class(struct net_device *dev) 732 { 733 lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key); 734 netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL); 735 } 736 737 /** 738 * batadv_softif_init_late() - late stage initialization of soft interface 739 * @dev: registered network device to modify 740 * 741 * Return: error code on failures 742 */ 743 static int batadv_softif_init_late(struct net_device *dev) 744 { 745 struct batadv_priv *bat_priv; 746 u32 random_seqno; 747 int ret; 748 size_t cnt_len = sizeof(u64) * BATADV_CNT_NUM; 749 750 batadv_set_lockdep_class(dev); 751 752 bat_priv = netdev_priv(dev); 753 bat_priv->soft_iface = dev; 754 755 /* batadv_interface_stats() needs to be available as soon as 756 * register_netdevice() has been called 757 */ 758 bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(u64)); 759 if (!bat_priv->bat_counters) 760 return -ENOMEM; 761 762 atomic_set(&bat_priv->aggregated_ogms, 1); 763 atomic_set(&bat_priv->bonding, 0); 764 #ifdef CONFIG_BATMAN_ADV_BLA 765 atomic_set(&bat_priv->bridge_loop_avoidance, 1); 766 #endif 767 #ifdef CONFIG_BATMAN_ADV_DAT 768 atomic_set(&bat_priv->distributed_arp_table, 1); 769 #endif 770 #ifdef CONFIG_BATMAN_ADV_MCAST 771 atomic_set(&bat_priv->multicast_mode, 1); 772 atomic_set(&bat_priv->multicast_fanout, 16); 773 atomic_set(&bat_priv->mcast.num_want_all_unsnoopables, 0); 774 atomic_set(&bat_priv->mcast.num_want_all_ipv4, 0); 775 atomic_set(&bat_priv->mcast.num_want_all_ipv6, 0); 776 #endif 777 atomic_set(&bat_priv->gw.mode, BATADV_GW_MODE_OFF); 778 atomic_set(&bat_priv->gw.bandwidth_down, 100); 779 atomic_set(&bat_priv->gw.bandwidth_up, 20); 780 atomic_set(&bat_priv->orig_interval, 1000); 781 atomic_set(&bat_priv->hop_penalty, 30); 782 #ifdef CONFIG_BATMAN_ADV_DEBUG 783 atomic_set(&bat_priv->log_level, 0); 784 #endif 785 atomic_set(&bat_priv->fragmentation, 1); 786 atomic_set(&bat_priv->packet_size_max, ETH_DATA_LEN); 787 atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN); 788 atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN); 789 790 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE); 791 atomic_set(&bat_priv->bcast_seqno, 1); 792 atomic_set(&bat_priv->tt.vn, 0); 793 atomic_set(&bat_priv->tt.local_changes, 0); 794 atomic_set(&bat_priv->tt.ogm_append_cnt, 0); 795 #ifdef CONFIG_BATMAN_ADV_BLA 796 atomic_set(&bat_priv->bla.num_requests, 0); 797 #endif 798 atomic_set(&bat_priv->tp_num, 0); 799 800 bat_priv->tt.last_changeset = NULL; 801 bat_priv->tt.last_changeset_len = 0; 802 bat_priv->isolation_mark = 0; 803 bat_priv->isolation_mark_mask = 0; 804 805 /* randomize initial seqno to avoid collision */ 806 get_random_bytes(&random_seqno, sizeof(random_seqno)); 807 atomic_set(&bat_priv->frag_seqno, random_seqno); 808 809 bat_priv->primary_if = NULL; 810 811 batadv_nc_init_bat_priv(bat_priv); 812 813 if (!bat_priv->algo_ops) { 814 ret = batadv_algo_select(bat_priv, batadv_routing_algo); 815 if (ret < 0) 816 goto free_bat_counters; 817 } 818 819 ret = batadv_mesh_init(dev); 820 if (ret < 0) 821 goto free_bat_counters; 822 823 return 0; 824 825 free_bat_counters: 826 free_percpu(bat_priv->bat_counters); 827 bat_priv->bat_counters = NULL; 828 829 return ret; 830 } 831 832 /** 833 * batadv_softif_slave_add() - Add a slave interface to a batadv_soft_interface 834 * @dev: batadv_soft_interface used as master interface 835 * @slave_dev: net_device which should become the slave interface 836 * @extack: extended ACK report struct 837 * 838 * Return: 0 if successful or error otherwise. 839 */ 840 static int batadv_softif_slave_add(struct net_device *dev, 841 struct net_device *slave_dev, 842 struct netlink_ext_ack *extack) 843 { 844 struct batadv_hard_iface *hard_iface; 845 int ret = -EINVAL; 846 847 hard_iface = batadv_hardif_get_by_netdev(slave_dev); 848 if (!hard_iface || hard_iface->soft_iface) 849 goto out; 850 851 ret = batadv_hardif_enable_interface(hard_iface, dev); 852 853 out: 854 if (hard_iface) 855 batadv_hardif_put(hard_iface); 856 return ret; 857 } 858 859 /** 860 * batadv_softif_slave_del() - Delete a slave iface from a batadv_soft_interface 861 * @dev: batadv_soft_interface used as master interface 862 * @slave_dev: net_device which should be removed from the master interface 863 * 864 * Return: 0 if successful or error otherwise. 865 */ 866 static int batadv_softif_slave_del(struct net_device *dev, 867 struct net_device *slave_dev) 868 { 869 struct batadv_hard_iface *hard_iface; 870 int ret = -EINVAL; 871 872 hard_iface = batadv_hardif_get_by_netdev(slave_dev); 873 874 if (!hard_iface || hard_iface->soft_iface != dev) 875 goto out; 876 877 batadv_hardif_disable_interface(hard_iface); 878 ret = 0; 879 880 out: 881 if (hard_iface) 882 batadv_hardif_put(hard_iface); 883 return ret; 884 } 885 886 static const struct net_device_ops batadv_netdev_ops = { 887 .ndo_init = batadv_softif_init_late, 888 .ndo_open = batadv_interface_open, 889 .ndo_stop = batadv_interface_release, 890 .ndo_get_stats = batadv_interface_stats, 891 .ndo_vlan_rx_add_vid = batadv_interface_add_vid, 892 .ndo_vlan_rx_kill_vid = batadv_interface_kill_vid, 893 .ndo_set_mac_address = batadv_interface_set_mac_addr, 894 .ndo_change_mtu = batadv_interface_change_mtu, 895 .ndo_set_rx_mode = batadv_interface_set_rx_mode, 896 .ndo_start_xmit = batadv_interface_tx, 897 .ndo_validate_addr = eth_validate_addr, 898 .ndo_add_slave = batadv_softif_slave_add, 899 .ndo_del_slave = batadv_softif_slave_del, 900 }; 901 902 static void batadv_get_drvinfo(struct net_device *dev, 903 struct ethtool_drvinfo *info) 904 { 905 strscpy(info->driver, "B.A.T.M.A.N. advanced", sizeof(info->driver)); 906 strscpy(info->version, BATADV_SOURCE_VERSION, sizeof(info->version)); 907 strscpy(info->fw_version, "N/A", sizeof(info->fw_version)); 908 strscpy(info->bus_info, "batman", sizeof(info->bus_info)); 909 } 910 911 /* Inspired by drivers/net/ethernet/dlink/sundance.c:1702 912 * Declare each description string in struct.name[] to get fixed sized buffer 913 * and compile time checking for strings longer than ETH_GSTRING_LEN. 914 */ 915 static const struct { 916 const char name[ETH_GSTRING_LEN]; 917 } batadv_counters_strings[] = { 918 { "tx" }, 919 { "tx_bytes" }, 920 { "tx_dropped" }, 921 { "rx" }, 922 { "rx_bytes" }, 923 { "forward" }, 924 { "forward_bytes" }, 925 { "mgmt_tx" }, 926 { "mgmt_tx_bytes" }, 927 { "mgmt_rx" }, 928 { "mgmt_rx_bytes" }, 929 { "frag_tx" }, 930 { "frag_tx_bytes" }, 931 { "frag_rx" }, 932 { "frag_rx_bytes" }, 933 { "frag_fwd" }, 934 { "frag_fwd_bytes" }, 935 { "tt_request_tx" }, 936 { "tt_request_rx" }, 937 { "tt_response_tx" }, 938 { "tt_response_rx" }, 939 { "tt_roam_adv_tx" }, 940 { "tt_roam_adv_rx" }, 941 #ifdef CONFIG_BATMAN_ADV_DAT 942 { "dat_get_tx" }, 943 { "dat_get_rx" }, 944 { "dat_put_tx" }, 945 { "dat_put_rx" }, 946 { "dat_cached_reply_tx" }, 947 #endif 948 #ifdef CONFIG_BATMAN_ADV_NC 949 { "nc_code" }, 950 { "nc_code_bytes" }, 951 { "nc_recode" }, 952 { "nc_recode_bytes" }, 953 { "nc_buffer" }, 954 { "nc_decode" }, 955 { "nc_decode_bytes" }, 956 { "nc_decode_failed" }, 957 { "nc_sniffed" }, 958 #endif 959 }; 960 961 static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data) 962 { 963 if (stringset == ETH_SS_STATS) 964 memcpy(data, batadv_counters_strings, 965 sizeof(batadv_counters_strings)); 966 } 967 968 static void batadv_get_ethtool_stats(struct net_device *dev, 969 struct ethtool_stats *stats, u64 *data) 970 { 971 struct batadv_priv *bat_priv = netdev_priv(dev); 972 int i; 973 974 for (i = 0; i < BATADV_CNT_NUM; i++) 975 data[i] = batadv_sum_counter(bat_priv, i); 976 } 977 978 static int batadv_get_sset_count(struct net_device *dev, int stringset) 979 { 980 if (stringset == ETH_SS_STATS) 981 return BATADV_CNT_NUM; 982 983 return -EOPNOTSUPP; 984 } 985 986 static const struct ethtool_ops batadv_ethtool_ops = { 987 .get_drvinfo = batadv_get_drvinfo, 988 .get_link = ethtool_op_get_link, 989 .get_strings = batadv_get_strings, 990 .get_ethtool_stats = batadv_get_ethtool_stats, 991 .get_sset_count = batadv_get_sset_count, 992 }; 993 994 /** 995 * batadv_softif_free() - Deconstructor of batadv_soft_interface 996 * @dev: Device to cleanup and remove 997 */ 998 static void batadv_softif_free(struct net_device *dev) 999 { 1000 batadv_mesh_free(dev); 1001 1002 /* some scheduled RCU callbacks need the bat_priv struct to accomplish 1003 * their tasks. Wait for them all to be finished before freeing the 1004 * netdev and its private data (bat_priv) 1005 */ 1006 rcu_barrier(); 1007 } 1008 1009 /** 1010 * batadv_softif_init_early() - early stage initialization of soft interface 1011 * @dev: registered network device to modify 1012 */ 1013 static void batadv_softif_init_early(struct net_device *dev) 1014 { 1015 ether_setup(dev); 1016 1017 dev->netdev_ops = &batadv_netdev_ops; 1018 dev->needs_free_netdev = true; 1019 dev->priv_destructor = batadv_softif_free; 1020 dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_NETNS_LOCAL; 1021 dev->features |= NETIF_F_LLTX; 1022 dev->priv_flags |= IFF_NO_QUEUE; 1023 1024 /* can't call min_mtu, because the needed variables 1025 * have not been initialized yet 1026 */ 1027 dev->mtu = ETH_DATA_LEN; 1028 1029 /* generate random address */ 1030 eth_hw_addr_random(dev); 1031 1032 dev->ethtool_ops = &batadv_ethtool_ops; 1033 } 1034 1035 /** 1036 * batadv_softif_validate() - validate configuration of new batadv link 1037 * @tb: IFLA_INFO_DATA netlink attributes 1038 * @data: enum batadv_ifla_attrs attributes 1039 * @extack: extended ACK report struct 1040 * 1041 * Return: 0 if successful or error otherwise. 1042 */ 1043 static int batadv_softif_validate(struct nlattr *tb[], struct nlattr *data[], 1044 struct netlink_ext_ack *extack) 1045 { 1046 struct batadv_algo_ops *algo_ops; 1047 1048 if (!data) 1049 return 0; 1050 1051 if (data[IFLA_BATADV_ALGO_NAME]) { 1052 algo_ops = batadv_algo_get(nla_data(data[IFLA_BATADV_ALGO_NAME])); 1053 if (!algo_ops) 1054 return -EINVAL; 1055 } 1056 1057 return 0; 1058 } 1059 1060 /** 1061 * batadv_softif_newlink() - pre-initialize and register new batadv link 1062 * @src_net: the applicable net namespace 1063 * @dev: network device to register 1064 * @tb: IFLA_INFO_DATA netlink attributes 1065 * @data: enum batadv_ifla_attrs attributes 1066 * @extack: extended ACK report struct 1067 * 1068 * Return: 0 if successful or error otherwise. 1069 */ 1070 static int batadv_softif_newlink(struct net *src_net, struct net_device *dev, 1071 struct nlattr *tb[], struct nlattr *data[], 1072 struct netlink_ext_ack *extack) 1073 { 1074 struct batadv_priv *bat_priv = netdev_priv(dev); 1075 const char *algo_name; 1076 int err; 1077 1078 if (data && data[IFLA_BATADV_ALGO_NAME]) { 1079 algo_name = nla_data(data[IFLA_BATADV_ALGO_NAME]); 1080 err = batadv_algo_select(bat_priv, algo_name); 1081 if (err) 1082 return -EINVAL; 1083 } 1084 1085 return register_netdevice(dev); 1086 } 1087 1088 /** 1089 * batadv_softif_destroy_netlink() - deletion of batadv_soft_interface via 1090 * netlink 1091 * @soft_iface: the to-be-removed batman-adv interface 1092 * @head: list pointer 1093 */ 1094 static void batadv_softif_destroy_netlink(struct net_device *soft_iface, 1095 struct list_head *head) 1096 { 1097 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 1098 struct batadv_hard_iface *hard_iface; 1099 struct batadv_softif_vlan *vlan; 1100 1101 list_for_each_entry(hard_iface, &batadv_hardif_list, list) { 1102 if (hard_iface->soft_iface == soft_iface) 1103 batadv_hardif_disable_interface(hard_iface); 1104 } 1105 1106 /* destroy the "untagged" VLAN */ 1107 vlan = batadv_softif_vlan_get(bat_priv, BATADV_NO_FLAGS); 1108 if (vlan) { 1109 batadv_softif_destroy_vlan(bat_priv, vlan); 1110 batadv_softif_vlan_put(vlan); 1111 } 1112 1113 unregister_netdevice_queue(soft_iface, head); 1114 } 1115 1116 /** 1117 * batadv_softif_is_valid() - Check whether device is a batadv soft interface 1118 * @net_dev: device which should be checked 1119 * 1120 * Return: true when net_dev is a batman-adv interface, false otherwise 1121 */ 1122 bool batadv_softif_is_valid(const struct net_device *net_dev) 1123 { 1124 if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx) 1125 return true; 1126 1127 return false; 1128 } 1129 1130 static const struct nla_policy batadv_ifla_policy[IFLA_BATADV_MAX + 1] = { 1131 [IFLA_BATADV_ALGO_NAME] = { .type = NLA_NUL_STRING }, 1132 }; 1133 1134 struct rtnl_link_ops batadv_link_ops __read_mostly = { 1135 .kind = "batadv", 1136 .priv_size = sizeof(struct batadv_priv), 1137 .setup = batadv_softif_init_early, 1138 .maxtype = IFLA_BATADV_MAX, 1139 .policy = batadv_ifla_policy, 1140 .validate = batadv_softif_validate, 1141 .newlink = batadv_softif_newlink, 1142 .dellink = batadv_softif_destroy_netlink, 1143 }; 1144