soft-interface.c 21.9 KB
Newer Older
1
/* Copyright (C) 2007-2013 B.A.T.M.A.N. contributors:
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
 *
 * Marek Lindner, Simon Wunderlich
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of version 2 of the GNU General Public
 * License as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA
 */

#include "main.h"
#include "soft-interface.h"
#include "hard-interface.h"
23
#include "distributed-arp-table.h"
24 25
#include "routing.h"
#include "send.h"
26
#include "debugfs.h"
27 28 29 30
#include "translation-table.h"
#include "hash.h"
#include "gateway_common.h"
#include "gateway_client.h"
31
#include "sysfs.h"
32
#include "originator.h"
33 34 35 36
#include <linux/slab.h>
#include <linux/ethtool.h>
#include <linux/etherdevice.h>
#include <linux/if_vlan.h>
37
#include "bridge_loop_avoidance.h"
38
#include "network-coding.h"
39 40


41 42 43 44 45 46
static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
static void batadv_get_drvinfo(struct net_device *dev,
			       struct ethtool_drvinfo *info);
static u32 batadv_get_msglevel(struct net_device *dev);
static void batadv_set_msglevel(struct net_device *dev, u32 value);
static u32 batadv_get_link(struct net_device *dev);
47 48 49 50
static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data);
static void batadv_get_ethtool_stats(struct net_device *dev,
				     struct ethtool_stats *stats, u64 *data);
static int batadv_get_sset_count(struct net_device *dev, int stringset);
51

52 53 54 55 56 57
static const struct ethtool_ops batadv_ethtool_ops = {
	.get_settings = batadv_get_settings,
	.get_drvinfo = batadv_get_drvinfo,
	.get_msglevel = batadv_get_msglevel,
	.set_msglevel = batadv_set_msglevel,
	.get_link = batadv_get_link,
58 59 60
	.get_strings = batadv_get_strings,
	.get_ethtool_stats = batadv_get_ethtool_stats,
	.get_sset_count = batadv_get_sset_count,
61 62
};

63
int batadv_skb_head_push(struct sk_buff *skb, unsigned int len)
64 65 66
{
	int result;

67
	/* TODO: We must check if we can release all references to non-payload
68 69 70 71 72 73 74 75 76 77 78 79 80 81
	 * data using skb_header_release in our skbs to allow skb_cow_header to
	 * work optimally. This means that those skbs are not allowed to read
	 * or write any data which is before the current position of skb->data
	 * after that call and thus allow other skbs with the same data buffer
	 * to write freely in that area.
	 */
	result = skb_cow_head(skb, len);
	if (result < 0)
		return result;

	skb_push(skb, len);
	return 0;
}

82
static int batadv_interface_open(struct net_device *dev)
83 84 85 86 87
{
	netif_start_queue(dev);
	return 0;
}

88
static int batadv_interface_release(struct net_device *dev)
89 90 91 92 93
{
	netif_stop_queue(dev);
	return 0;
}

94
static struct net_device_stats *batadv_interface_stats(struct net_device *dev)
95
{
96
	struct batadv_priv *bat_priv = netdev_priv(dev);
97 98 99 100 101 102 103 104
	struct net_device_stats *stats = &bat_priv->stats;

	stats->tx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_TX);
	stats->tx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_TX_BYTES);
	stats->tx_dropped = batadv_sum_counter(bat_priv, BATADV_CNT_TX_DROPPED);
	stats->rx_packets = batadv_sum_counter(bat_priv, BATADV_CNT_RX);
	stats->rx_bytes = batadv_sum_counter(bat_priv, BATADV_CNT_RX_BYTES);
	return stats;
105 106
}

107
static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
108
{
109
	struct batadv_priv *bat_priv = netdev_priv(dev);
110
	struct sockaddr *addr = p;
111
	uint8_t old_addr[ETH_ALEN];
112 113 114 115

	if (!is_valid_ether_addr(addr->sa_data))
		return -EADDRNOTAVAIL;

116 117 118
	memcpy(old_addr, dev->dev_addr, ETH_ALEN);
	memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);

119
	/* only modify transtable if it has been initialized before */
120
	if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) {
121
		batadv_tt_local_remove(bat_priv, old_addr,
122
				       "mac address changed", false);
123
		batadv_tt_local_add(dev, addr->sa_data, BATADV_NULL_IFINDEX);
124 125 126 127 128
	}

	return 0;
}

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 134 135 136 137 138 139
		return -EINVAL;

	dev->mtu = new_mtu;

	return 0;
}

140 141
static int batadv_interface_tx(struct sk_buff *skb,
			       struct net_device *soft_iface)
142 143
{
	struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
144 145
	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
	struct batadv_hard_iface *primary_if = NULL;
146
	struct batadv_bcast_packet *bcast_packet;
147
	struct vlan_ethhdr *vhdr;
A
Antonio Quartulli 已提交
148
	__be16 ethertype = __constant_htons(ETH_P_BATMAN);
149 150 151 152
	static const uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00,
						   0x00, 0x00};
	static const uint8_t ectp_addr[ETH_ALEN] = {0xCF, 0x00, 0x00, 0x00,
						    0x00, 0x00};
153
	unsigned int header_len = 0;
154
	int data_len = skb->len, ret;
155
	unsigned short vid __maybe_unused = BATADV_NO_FLAGS;
156
	bool do_bcast = false;
157
	uint32_t seqno;
158
	unsigned long brd_delay = 1;
159

160
	if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
161 162 163 164 165 166 167 168
		goto dropped;

	soft_iface->trans_start = jiffies;

	switch (ntohs(ethhdr->h_proto)) {
	case ETH_P_8021Q:
		vhdr = (struct vlan_ethhdr *)skb->data;
		vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
169
		vid |= BATADV_VLAN_HAS_TAG;
170

171
		if (vhdr->h_vlan_encapsulated_proto != ethertype)
172 173 174
			break;

		/* fall through */
A
Antonio Quartulli 已提交
175
	case ETH_P_BATMAN:
176
		goto dropped;
177
	}
178

179
	if (batadv_bla_tx(bat_priv, skb, vid))
180 181
		goto dropped;

182 183 184
	/* skb->data might have been reallocated by batadv_bla_tx() */
	ethhdr = (struct ethhdr *)skb->data;

185
	/* Register the client MAC in the transtable */
186 187
	if (!is_multicast_ether_addr(ethhdr->h_source))
		batadv_tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
188

189 190
	/* don't accept stp packets. STP does not help in meshes.
	 * better use the bridge loop avoidance ...
191 192 193
	 *
	 * The same goes for ECTP sent at least by some Cisco Switches,
	 * it might confuse the mesh when used with bridge loop avoidance.
194
	 */
195
	if (batadv_compare_eth(ethhdr->h_dest, stp_addr))
196 197
		goto dropped;

198 199 200
	if (batadv_compare_eth(ethhdr->h_dest, ectp_addr))
		goto dropped;

201 202
	if (is_multicast_ether_addr(ethhdr->h_dest)) {
		do_bcast = true;
203

204
		switch (atomic_read(&bat_priv->gw_mode)) {
205
		case BATADV_GW_MODE_SERVER:
206
			/* gateway servers should not send dhcp
207 208
			 * requests into the mesh
			 */
209
			ret = batadv_gw_is_dhcp_target(skb, &header_len);
210 211 212
			if (ret)
				goto dropped;
			break;
213
		case BATADV_GW_MODE_CLIENT:
214
			/* gateway clients should send dhcp requests
215 216
			 * via unicast to their gateway
			 */
217
			ret = batadv_gw_is_dhcp_target(skb, &header_len);
218 219 220
			if (ret)
				do_bcast = false;
			break;
221
		case BATADV_GW_MODE_OFF:
222 223 224
		default:
			break;
		}
225 226 227 228

		/* reminder: ethhdr might have become unusable from here on
		 * (batadv_gw_is_dhcp_target() might have reallocated skb data)
		 */
229 230
	}

231 232
	batadv_skb_set_priority(skb, 0);

233 234
	/* ethernet packet should be broadcasted */
	if (do_bcast) {
235
		primary_if = batadv_primary_if_get_selected(bat_priv);
236
		if (!primary_if)
237 238
			goto dropped;

239 240 241 242 243 244 245
		/* in case of ARP request, we do not immediately broadcasti the
		 * packet, instead we first wait for DAT to try to retrieve the
		 * correct ARP entry
		 */
		if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
			brd_delay = msecs_to_jiffies(ARP_REQ_DELAY);

246
		if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
247 248
			goto dropped;

249
		bcast_packet = (struct batadv_bcast_packet *)skb->data;
250
		bcast_packet->header.version = BATADV_COMPAT_VERSION;
251
		bcast_packet->header.ttl = BATADV_TTL;
252 253

		/* batman packet type: broadcast */
254
		bcast_packet->header.packet_type = BATADV_BCAST;
255
		bcast_packet->reserved = 0;
256 257

		/* hw address of first interface is the orig mac because only
258 259
		 * this mac is known throughout the mesh
		 */
260
		memcpy(bcast_packet->orig,
261
		       primary_if->net_dev->dev_addr, ETH_ALEN);
262 263

		/* set broadcast sequence number */
264 265
		seqno = atomic_inc_return(&bat_priv->bcast_seqno);
		bcast_packet->seqno = htonl(seqno);
266

267
		batadv_add_bcast_packet_to_list(bat_priv, skb, brd_delay);
268 269

		/* a copy is stored in the bcast list, therefore removing
270 271
		 * the original skb.
		 */
272 273 274 275
		kfree_skb(skb);

	/* unicast packet */
	} else {
276
		if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_OFF) {
277
			ret = batadv_gw_out_of_range(bat_priv, skb);
278 279 280 281
			if (ret)
				goto dropped;
		}

282 283 284 285 286
		if (batadv_dat_snoop_outgoing_arp_request(bat_priv, skb))
			goto dropped;

		batadv_dat_snoop_outgoing_arp_reply(bat_priv, skb);

287
		ret = batadv_send_skb_unicast(bat_priv, skb);
288 289 290 291
		if (ret != 0)
			goto dropped_freed;
	}

292 293
	batadv_inc_counter(bat_priv, BATADV_CNT_TX);
	batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len);
294 295 296 297 298
	goto end;

dropped:
	kfree_skb(skb);
dropped_freed:
299
	batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
300
end:
301
	if (primary_if)
302
		batadv_hardif_free_ref(primary_if);
303 304 305
	return NETDEV_TX_OK;
}

306
void batadv_interface_rx(struct net_device *soft_iface,
307
			 struct sk_buff *skb, struct batadv_hard_iface *recv_if,
308
			 int hdr_size, struct batadv_orig_node *orig_node)
309
{
310
	struct batadv_priv *bat_priv = netdev_priv(soft_iface);
311 312
	struct ethhdr *ethhdr;
	struct vlan_ethhdr *vhdr;
313
	struct batadv_header *batadv_header = (struct batadv_header *)skb->data;
314
	unsigned short vid __maybe_unused = BATADV_NO_FLAGS;
A
Antonio Quartulli 已提交
315
	__be16 ethertype = __constant_htons(ETH_P_BATMAN);
316 317
	bool is_bcast;

318
	is_bcast = (batadv_header->packet_type == BATADV_BCAST);
319 320 321 322 323 324 325 326

	/* check if enough space is available for pulling, and pull */
	if (!pskb_may_pull(skb, hdr_size))
		goto dropped;

	skb_pull_rcsum(skb, hdr_size);
	skb_reset_mac_header(skb);

327
	ethhdr = eth_hdr(skb);
328 329 330 331 332

	switch (ntohs(ethhdr->h_proto)) {
	case ETH_P_8021Q:
		vhdr = (struct vlan_ethhdr *)skb->data;
		vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
333
		vid |= BATADV_VLAN_HAS_TAG;
334

335
		if (vhdr->h_vlan_encapsulated_proto != ethertype)
336 337 338
			break;

		/* fall through */
A
Antonio Quartulli 已提交
339
	case ETH_P_BATMAN:
340 341 342 343 344 345 346 347
		goto dropped;
	}

	/* skb->dev & skb->pkt_type are set here */
	if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
		goto dropped;
	skb->protocol = eth_type_trans(skb, soft_iface);

L
Lucas De Marchi 已提交
348
	/* should not be necessary anymore as we use skb_pull_rcsum()
349
	 * TODO: please verify this and remove this TODO
350 351
	 * -- Dec 21st 2009, Simon Wunderlich
	 */
352

353
	/* skb->ip_summed = CHECKSUM_UNNECESSARY; */
354

355 356 357
	batadv_inc_counter(bat_priv, BATADV_CNT_RX);
	batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
			   skb->len + ETH_HLEN);
358 359 360

	soft_iface->last_rx = jiffies;

361 362 363 364 365 366
	/* Let the bridge loop avoidance check the packet. If will
	 * not handle it, we can safely push it up.
	 */
	if (batadv_bla_rx(bat_priv, skb, vid, is_bcast))
		goto out;

367 368 369 370
	if (orig_node)
		batadv_tt_add_temporary_global_entry(bat_priv, orig_node,
						     ethhdr->h_source);

371
	if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source, ethhdr->h_dest))
372 373
		goto dropped;

374
	netif_rx(skb);
375
	goto out;
376 377 378 379 380 381 382

dropped:
	kfree_skb(skb);
out:
	return;
}

383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
/* batman-adv network devices have devices nesting below it and are a special
 * "super class" of normal network devices; split their locks off into a
 * separate class since they always nest.
 */
static struct lock_class_key batadv_netdev_xmit_lock_key;
static struct lock_class_key batadv_netdev_addr_lock_key;

/**
 * batadv_set_lockdep_class_one - Set lockdep class for a single tx queue
 * @dev: device which owns the tx queue
 * @txq: tx queue to modify
 * @_unused: always NULL
 */
static void batadv_set_lockdep_class_one(struct net_device *dev,
					 struct netdev_queue *txq,
					 void *_unused)
{
	lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key);
}

/**
 * batadv_set_lockdep_class - Set txq and addr_list lockdep class
 * @dev: network device to modify
 */
static void batadv_set_lockdep_class(struct net_device *dev)
{
	lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key);
	netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL);
}

413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
/**
 * batadv_softif_destroy_finish - cleans up the remains of a softif
 * @work: work queue item
 *
 * Free the parts of the soft interface which can not be removed under
 * rtnl lock (to prevent deadlock situations).
 */
static void batadv_softif_destroy_finish(struct work_struct *work)
{
	struct batadv_priv *bat_priv;
	struct net_device *soft_iface;

	bat_priv = container_of(work, struct batadv_priv,
				cleanup_work);
	soft_iface = bat_priv->soft_iface;

	batadv_sysfs_del_meshif(soft_iface);

	rtnl_lock();
	unregister_netdevice(soft_iface);
	rtnl_unlock();
}

436 437 438 439 440 441 442
/**
 * batadv_softif_init_late - late stage initialization of soft interface
 * @dev: registered network device to modify
 *
 * Returns error code on failures
 */
static int batadv_softif_init_late(struct net_device *dev)
443
{
444
	struct batadv_priv *bat_priv;
445
	int ret;
446
	size_t cnt_len = sizeof(uint64_t) * BATADV_CNT_NUM;
447

448
	batadv_set_lockdep_class(dev);
449

450 451
	bat_priv = netdev_priv(dev);
	bat_priv->soft_iface = dev;
452
	INIT_WORK(&bat_priv->cleanup_work, batadv_softif_destroy_finish);
453 454 455 456 457 458

	/* batadv_interface_stats() needs to be available as soon as
	 * register_netdevice() has been called
	 */
	bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(uint64_t));
	if (!bat_priv->bat_counters)
459
		return -ENOMEM;
460 461 462

	atomic_set(&bat_priv->aggregated_ogms, 1);
	atomic_set(&bat_priv->bonding, 0);
463
#ifdef CONFIG_BATMAN_ADV_BLA
464
	atomic_set(&bat_priv->bridge_loop_avoidance, 0);
465
#endif
466 467 468
#ifdef CONFIG_BATMAN_ADV_DAT
	atomic_set(&bat_priv->distributed_arp_table, 1);
#endif
469
	atomic_set(&bat_priv->ap_isolation, 0);
470
	atomic_set(&bat_priv->gw_mode, BATADV_GW_MODE_OFF);
471
	atomic_set(&bat_priv->gw_sel_class, 20);
472 473
	atomic_set(&bat_priv->gw.bandwidth_down, 100);
	atomic_set(&bat_priv->gw.bandwidth_up, 20);
474
	atomic_set(&bat_priv->orig_interval, 1000);
475
	atomic_set(&bat_priv->hop_penalty, 30);
476
#ifdef CONFIG_BATMAN_ADV_DEBUG
477
	atomic_set(&bat_priv->log_level, 0);
478
#endif
479
	atomic_set(&bat_priv->fragmentation, 1);
480 481
	atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);
	atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);
482

483
	atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
484
	atomic_set(&bat_priv->bcast_seqno, 1);
485 486 487 488 489 490 491 492
	atomic_set(&bat_priv->tt.vn, 0);
	atomic_set(&bat_priv->tt.local_changes, 0);
	atomic_set(&bat_priv->tt.ogm_append_cnt, 0);
#ifdef CONFIG_BATMAN_ADV_BLA
	atomic_set(&bat_priv->bla.num_requests, 0);
#endif
	bat_priv->tt.last_changeset = NULL;
	bat_priv->tt.last_changeset_len = 0;
493 494 495 496

	bat_priv->primary_if = NULL;
	bat_priv->num_ifaces = 0;

497 498
	batadv_nc_init_bat_priv(bat_priv);

499
	ret = batadv_algo_select(bat_priv, batadv_routing_algo);
500
	if (ret < 0)
501
		goto free_bat_counters;
502

503
	ret = batadv_debugfs_add_meshif(dev);
504
	if (ret < 0)
505
		goto free_bat_counters;
506

507
	ret = batadv_mesh_init(dev);
508 509 510
	if (ret < 0)
		goto unreg_debugfs;

511
	return 0;
512 513

unreg_debugfs:
514
	batadv_debugfs_del_meshif(dev);
515 516
free_bat_counters:
	free_percpu(bat_priv->bat_counters);
517
	bat_priv->bat_counters = NULL;
518 519 520 521

	return ret;
}

522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573
/**
 * batadv_softif_slave_add - Add a slave interface to a batadv_soft_interface
 * @dev: batadv_soft_interface used as master interface
 * @slave_dev: net_device which should become the slave interface
 *
 * Return 0 if successful or error otherwise.
 */
static int batadv_softif_slave_add(struct net_device *dev,
				   struct net_device *slave_dev)
{
	struct batadv_hard_iface *hard_iface;
	int ret = -EINVAL;

	hard_iface = batadv_hardif_get_by_netdev(slave_dev);
	if (!hard_iface || hard_iface->soft_iface != NULL)
		goto out;

	ret = batadv_hardif_enable_interface(hard_iface, dev->name);

out:
	if (hard_iface)
		batadv_hardif_free_ref(hard_iface);
	return ret;
}

/**
 * batadv_softif_slave_del - Delete a slave iface from a batadv_soft_interface
 * @dev: batadv_soft_interface used as master interface
 * @slave_dev: net_device which should be removed from the master interface
 *
 * Return 0 if successful or error otherwise.
 */
static int batadv_softif_slave_del(struct net_device *dev,
				   struct net_device *slave_dev)
{
	struct batadv_hard_iface *hard_iface;
	int ret = -EINVAL;

	hard_iface = batadv_hardif_get_by_netdev(slave_dev);

	if (!hard_iface || hard_iface->soft_iface != dev)
		goto out;

	batadv_hardif_disable_interface(hard_iface, BATADV_IF_CLEANUP_KEEP);
	ret = 0;

out:
	if (hard_iface)
		batadv_hardif_free_ref(hard_iface);
	return ret;
}

574 575 576 577 578 579 580 581
static const struct net_device_ops batadv_netdev_ops = {
	.ndo_init = batadv_softif_init_late,
	.ndo_open = batadv_interface_open,
	.ndo_stop = batadv_interface_release,
	.ndo_get_stats = batadv_interface_stats,
	.ndo_set_mac_address = batadv_interface_set_mac_addr,
	.ndo_change_mtu = batadv_interface_change_mtu,
	.ndo_start_xmit = batadv_interface_tx,
582 583 584
	.ndo_validate_addr = eth_validate_addr,
	.ndo_add_slave = batadv_softif_slave_add,
	.ndo_del_slave = batadv_softif_slave_del,
585 586
};

587 588 589 590 591 592 593 594
/**
 * batadv_softif_free - Deconstructor of batadv_soft_interface
 * @dev: Device to cleanup and remove
 */
static void batadv_softif_free(struct net_device *dev)
{
	batadv_debugfs_del_meshif(dev);
	batadv_mesh_free(dev);
595 596 597 598 599 600 601

	/* some scheduled RCU callbacks need the bat_priv struct to accomplish
	 * their tasks. Wait for them all to be finished before freeing the
	 * netdev and its private data (bat_priv)
	 */
	rcu_barrier();

602 603 604
	free_netdev(dev);
}

605 606 607 608 609 610 611 612 613 614 615
/**
 * batadv_softif_init_early - early stage initialization of soft interface
 * @dev: registered network device to modify
 */
static void batadv_softif_init_early(struct net_device *dev)
{
	struct batadv_priv *priv = netdev_priv(dev);

	ether_setup(dev);

	dev->netdev_ops = &batadv_netdev_ops;
616
	dev->destructor = batadv_softif_free;
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
	dev->tx_queue_len = 0;

	/* can't call min_mtu, because the needed variables
	 * have not been initialized yet
	 */
	dev->mtu = ETH_DATA_LEN;
	/* reserve more space in the skbuff for our header */
	dev->hard_header_len = BATADV_HEADER_LEN;

	/* generate random address */
	eth_hw_addr_random(dev);

	SET_ETHTOOL_OPS(dev, &batadv_ethtool_ops);

	memset(priv, 0, sizeof(*priv));
}

struct net_device *batadv_softif_create(const char *name)
{
	struct net_device *soft_iface;
	int ret;

	soft_iface = alloc_netdev(sizeof(struct batadv_priv), name,
				  batadv_softif_init_early);
	if (!soft_iface)
		return NULL;

644 645
	soft_iface->rtnl_link_ops = &batadv_link_ops;

646 647 648 649 650 651 652 653 654
	ret = register_netdevice(soft_iface);
	if (ret < 0) {
		pr_err("Unable to register the batman interface '%s': %i\n",
		       name, ret);
		free_netdev(soft_iface);
		return NULL;
	}

	return soft_iface;
655 656
}

657 658 659 660 661
/**
 * batadv_softif_destroy_sysfs - deletion of batadv_soft_interface via sysfs
 * @soft_iface: the to-be-removed batman-adv interface
 */
void batadv_softif_destroy_sysfs(struct net_device *soft_iface)
662
{
663 664 665
	struct batadv_priv *bat_priv = netdev_priv(soft_iface);

	queue_work(batadv_event_workqueue, &bat_priv->cleanup_work);
666 667
}

668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
/**
 * batadv_softif_destroy_netlink - deletion of batadv_soft_interface via netlink
 * @soft_iface: the to-be-removed batman-adv interface
 * @head: list pointer
 */
static void batadv_softif_destroy_netlink(struct net_device *soft_iface,
					  struct list_head *head)
{
	struct batadv_hard_iface *hard_iface;

	list_for_each_entry(hard_iface, &batadv_hardif_list, list) {
		if (hard_iface->soft_iface == soft_iface)
			batadv_hardif_disable_interface(hard_iface,
							BATADV_IF_CLEANUP_KEEP);
	}

	batadv_sysfs_del_meshif(soft_iface);
	unregister_netdevice_queue(soft_iface, head);
}

688
int batadv_softif_is_valid(const struct net_device *net_dev)
689
{
690
	if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
691 692 693 694 695
		return 1;

	return 0;
}

696 697 698 699 700 701 702
struct rtnl_link_ops batadv_link_ops __read_mostly = {
	.kind		= "batadv",
	.priv_size	= sizeof(struct batadv_priv),
	.setup		= batadv_softif_init_early,
	.dellink	= batadv_softif_destroy_netlink,
};

703
/* ethtool */
704
static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
705 706 707
{
	cmd->supported = 0;
	cmd->advertising = 0;
708
	ethtool_cmd_speed_set(cmd, SPEED_10);
709 710 711 712 713 714 715 716 717 718 719
	cmd->duplex = DUPLEX_FULL;
	cmd->port = PORT_TP;
	cmd->phy_address = 0;
	cmd->transceiver = XCVR_INTERNAL;
	cmd->autoneg = AUTONEG_DISABLE;
	cmd->maxtxpkt = 0;
	cmd->maxrxpkt = 0;

	return 0;
}

720 721
static void batadv_get_drvinfo(struct net_device *dev,
			       struct ethtool_drvinfo *info)
722
{
723 724 725 726
	strlcpy(info->driver, "B.A.T.M.A.N. advanced", sizeof(info->driver));
	strlcpy(info->version, BATADV_SOURCE_VERSION, sizeof(info->version));
	strlcpy(info->fw_version, "N/A", sizeof(info->fw_version));
	strlcpy(info->bus_info, "batman", sizeof(info->bus_info));
727 728
}

729
static u32 batadv_get_msglevel(struct net_device *dev)
730 731 732 733
{
	return -EOPNOTSUPP;
}

734
static void batadv_set_msglevel(struct net_device *dev, u32 value)
735 736 737
{
}

738
static u32 batadv_get_link(struct net_device *dev)
739 740 741
{
	return 1;
}
742 743 744 745 746 747 748

/* Inspired by drivers/net/ethernet/dlink/sundance.c:1702
 * Declare each description string in struct.name[] to get fixed sized buffer
 * and compile time checking for strings longer than ETH_GSTRING_LEN.
 */
static const struct {
	const char name[ETH_GSTRING_LEN];
749
} batadv_counters_strings[] = {
750 751 752 753 754
	{ "tx" },
	{ "tx_bytes" },
	{ "tx_dropped" },
	{ "rx" },
	{ "rx_bytes" },
755 756 757 758 759 760 761 762 763 764 765 766
	{ "forward" },
	{ "forward_bytes" },
	{ "mgmt_tx" },
	{ "mgmt_tx_bytes" },
	{ "mgmt_rx" },
	{ "mgmt_rx_bytes" },
	{ "tt_request_tx" },
	{ "tt_request_rx" },
	{ "tt_response_tx" },
	{ "tt_response_rx" },
	{ "tt_roam_adv_tx" },
	{ "tt_roam_adv_rx" },
767 768 769 770 771 772 773
#ifdef CONFIG_BATMAN_ADV_DAT
	{ "dat_get_tx" },
	{ "dat_get_rx" },
	{ "dat_put_tx" },
	{ "dat_put_rx" },
	{ "dat_cached_reply_tx" },
#endif
774 775 776 777 778
#ifdef CONFIG_BATMAN_ADV_NC
	{ "nc_code" },
	{ "nc_code_bytes" },
	{ "nc_recode" },
	{ "nc_recode_bytes" },
779
	{ "nc_buffer" },
780 781 782 783
	{ "nc_decode" },
	{ "nc_decode_bytes" },
	{ "nc_decode_failed" },
	{ "nc_sniffed" },
784
#endif
785 786 787 788 789 790
};

static void batadv_get_strings(struct net_device *dev, uint32_t stringset,
			       uint8_t *data)
{
	if (stringset == ETH_SS_STATS)
791 792
		memcpy(data, batadv_counters_strings,
		       sizeof(batadv_counters_strings));
793 794 795 796 797 798
}

static void batadv_get_ethtool_stats(struct net_device *dev,
				     struct ethtool_stats *stats,
				     uint64_t *data)
{
799
	struct batadv_priv *bat_priv = netdev_priv(dev);
800 801
	int i;

802
	for (i = 0; i < BATADV_CNT_NUM; i++)
803 804 805 806 807 808
		data[i] = batadv_sum_counter(bat_priv, i);
}

static int batadv_get_sset_count(struct net_device *dev, int stringset)
{
	if (stringset == ETH_SS_STATS)
809
		return BATADV_CNT_NUM;
810 811 812

	return -EOPNOTSUPP;
}