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