batman-adv: Only increase refcounter once for alternate router
[deliverable/linux.git] / net / batman-adv / soft-interface.c
CommitLineData
9cfc7bd6 1/* Copyright (C) 2007-2012 B.A.T.M.A.N. contributors:
c6c8fea2
SE
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, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 * 02110-1301, USA
c6c8fea2
SE
18 */
19
20#include "main.h"
21#include "soft-interface.h"
22#include "hard-interface.h"
23#include "routing.h"
24#include "send.h"
b706b13b 25#include "debugfs.h"
c6c8fea2 26#include "translation-table.h"
c6c8fea2
SE
27#include "hash.h"
28#include "gateway_common.h"
29#include "gateway_client.h"
b706b13b 30#include "sysfs.h"
43676ab5 31#include "originator.h"
c6c8fea2
SE
32#include <linux/slab.h>
33#include <linux/ethtool.h>
34#include <linux/etherdevice.h>
35#include <linux/if_vlan.h>
36#include "unicast.h"
23721387 37#include "bridge_loop_avoidance.h"
c6c8fea2
SE
38
39
0294ca0d
SE
40static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd);
41static void batadv_get_drvinfo(struct net_device *dev,
42 struct ethtool_drvinfo *info);
43static u32 batadv_get_msglevel(struct net_device *dev);
44static void batadv_set_msglevel(struct net_device *dev, u32 value);
45static u32 batadv_get_link(struct net_device *dev);
f8214865
MH
46static void batadv_get_strings(struct net_device *dev, u32 stringset, u8 *data);
47static void batadv_get_ethtool_stats(struct net_device *dev,
48 struct ethtool_stats *stats, u64 *data);
49static int batadv_get_sset_count(struct net_device *dev, int stringset);
c6c8fea2 50
0294ca0d
SE
51static 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,
f8214865
MH
57 .get_strings = batadv_get_strings,
58 .get_ethtool_stats = batadv_get_ethtool_stats,
59 .get_sset_count = batadv_get_sset_count,
c6c8fea2
SE
60};
61
04b482a2 62int batadv_skb_head_push(struct sk_buff *skb, unsigned int len)
c6c8fea2
SE
63{
64 int result;
65
9cfc7bd6 66 /* TODO: We must check if we can release all references to non-payload
c6c8fea2
SE
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
0294ca0d 81static int batadv_interface_open(struct net_device *dev)
c6c8fea2
SE
82{
83 netif_start_queue(dev);
84 return 0;
85}
86
0294ca0d 87static int batadv_interface_release(struct net_device *dev)
c6c8fea2
SE
88{
89 netif_stop_queue(dev);
90 return 0;
91}
92
0294ca0d 93static struct net_device_stats *batadv_interface_stats(struct net_device *dev)
c6c8fea2 94{
56303d34 95 struct batadv_priv *bat_priv = netdev_priv(dev);
1c9b0550
ML
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;
c6c8fea2
SE
104}
105
0294ca0d 106static int batadv_interface_set_mac_addr(struct net_device *dev, void *p)
c6c8fea2 107{
56303d34 108 struct batadv_priv *bat_priv = netdev_priv(dev);
c6c8fea2 109 struct sockaddr *addr = p;
40a3eb33 110 uint8_t old_addr[ETH_ALEN];
c6c8fea2
SE
111
112 if (!is_valid_ether_addr(addr->sa_data))
113 return -EADDRNOTAVAIL;
114
40a3eb33
D
115 memcpy(old_addr, dev->dev_addr, ETH_ALEN);
116 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
117
015758d0 118 /* only modify transtable if it has been initialized before */
39c75a51 119 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_ACTIVE) {
40a3eb33 120 batadv_tt_local_remove(bat_priv, old_addr,
08c36d3e 121 "mac address changed", false);
42d0b044 122 batadv_tt_local_add(dev, addr->sa_data, BATADV_NULL_IFINDEX);
c6c8fea2
SE
123 }
124
28009a6c 125 dev->addr_assign_type &= ~NET_ADDR_RANDOM;
c6c8fea2
SE
126 return 0;
127}
128
0294ca0d 129static int batadv_interface_change_mtu(struct net_device *dev, int new_mtu)
c6c8fea2
SE
130{
131 /* check ranges */
9563877e 132 if ((new_mtu < 68) || (new_mtu > batadv_hardif_min_mtu(dev)))
c6c8fea2
SE
133 return -EINVAL;
134
135 dev->mtu = new_mtu;
136
137 return 0;
138}
139
0294ca0d
SE
140static int batadv_interface_tx(struct sk_buff *skb,
141 struct net_device *soft_iface)
c6c8fea2
SE
142{
143 struct ethhdr *ethhdr = (struct ethhdr *)skb->data;
56303d34
SE
144 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
145 struct batadv_hard_iface *primary_if = NULL;
96412690 146 struct batadv_bcast_packet *bcast_packet;
c6c8fea2 147 struct vlan_ethhdr *vhdr;
7e071c79 148 __be16 ethertype = __constant_htons(BATADV_ETH_P_BATMAN);
b1a8c04b
SW
149 static const uint8_t stp_addr[ETH_ALEN] = {0x01, 0x80, 0xC2, 0x00, 0x00,
150 0x00};
be7af5cf 151 unsigned int header_len = 0;
c6c8fea2 152 int data_len = skb->len, ret;
7a5cc242 153 short vid __maybe_unused = -1;
be7af5cf 154 bool do_bcast = false;
bbb1f90e 155 uint32_t seqno;
c6c8fea2 156
39c75a51 157 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE)
c6c8fea2
SE
158 goto dropped;
159
160 soft_iface->trans_start = jiffies;
161
162 switch (ntohs(ethhdr->h_proto)) {
163 case ETH_P_8021Q:
164 vhdr = (struct vlan_ethhdr *)skb->data;
165 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
166
7e071c79 167 if (vhdr->h_vlan_encapsulated_proto != ethertype)
c6c8fea2
SE
168 break;
169
170 /* fall through */
7e071c79 171 case BATADV_ETH_P_BATMAN:
c6c8fea2 172 goto dropped;
a7f6ee94 173 }
c6c8fea2 174
08adf151 175 if (batadv_bla_tx(bat_priv, skb, vid))
23721387
SW
176 goto dropped;
177
a73105b8 178 /* Register the client MAC in the transtable */
08c36d3e 179 batadv_tt_local_add(soft_iface, ethhdr->h_source, skb->skb_iif);
c6c8fea2 180
b1a8c04b
SW
181 /* don't accept stp packets. STP does not help in meshes.
182 * better use the bridge loop avoidance ...
183 */
1eda58bf 184 if (batadv_compare_eth(ethhdr->h_dest, stp_addr))
b1a8c04b
SW
185 goto dropped;
186
be7af5cf
ML
187 if (is_multicast_ether_addr(ethhdr->h_dest)) {
188 do_bcast = true;
c6c8fea2 189
be7af5cf 190 switch (atomic_read(&bat_priv->gw_mode)) {
cd646ab1 191 case BATADV_GW_MODE_SERVER:
be7af5cf 192 /* gateway servers should not send dhcp
9cfc7bd6
SE
193 * requests into the mesh
194 */
7cf06bc6 195 ret = batadv_gw_is_dhcp_target(skb, &header_len);
be7af5cf
ML
196 if (ret)
197 goto dropped;
198 break;
cd646ab1 199 case BATADV_GW_MODE_CLIENT:
be7af5cf 200 /* gateway clients should send dhcp requests
9cfc7bd6
SE
201 * via unicast to their gateway
202 */
7cf06bc6 203 ret = batadv_gw_is_dhcp_target(skb, &header_len);
be7af5cf
ML
204 if (ret)
205 do_bcast = false;
206 break;
cd646ab1 207 case BATADV_GW_MODE_OFF:
be7af5cf
ML
208 default:
209 break;
210 }
c6c8fea2
SE
211 }
212
213 /* ethernet packet should be broadcasted */
214 if (do_bcast) {
e5d89254 215 primary_if = batadv_primary_if_get_selected(bat_priv);
32ae9b22 216 if (!primary_if)
c6c8fea2
SE
217 goto dropped;
218
04b482a2 219 if (batadv_skb_head_push(skb, sizeof(*bcast_packet)) < 0)
c6c8fea2
SE
220 goto dropped;
221
96412690 222 bcast_packet = (struct batadv_bcast_packet *)skb->data;
7e071c79 223 bcast_packet->header.version = BATADV_COMPAT_VERSION;
42d0b044 224 bcast_packet->header.ttl = BATADV_TTL;
c6c8fea2
SE
225
226 /* batman packet type: broadcast */
acd34afa 227 bcast_packet->header.packet_type = BATADV_BCAST;
162d549c 228 bcast_packet->reserved = 0;
c6c8fea2
SE
229
230 /* hw address of first interface is the orig mac because only
9cfc7bd6
SE
231 * this mac is known throughout the mesh
232 */
c6c8fea2 233 memcpy(bcast_packet->orig,
32ae9b22 234 primary_if->net_dev->dev_addr, ETH_ALEN);
c6c8fea2
SE
235
236 /* set broadcast sequence number */
bbb1f90e
SE
237 seqno = atomic_inc_return(&bat_priv->bcast_seqno);
238 bcast_packet->seqno = htonl(seqno);
c6c8fea2 239
9455e34c 240 batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
c6c8fea2
SE
241
242 /* a copy is stored in the bcast list, therefore removing
9cfc7bd6
SE
243 * the original skb.
244 */
c6c8fea2
SE
245 kfree_skb(skb);
246
247 /* unicast packet */
248 } else {
cd646ab1 249 if (atomic_read(&bat_priv->gw_mode) != BATADV_GW_MODE_OFF) {
7cf06bc6 250 ret = batadv_gw_out_of_range(bat_priv, skb, ethhdr);
be7af5cf
ML
251 if (ret)
252 goto dropped;
253 }
254
88ed1e77 255 ret = batadv_unicast_send_skb(skb, bat_priv);
c6c8fea2
SE
256 if (ret != 0)
257 goto dropped_freed;
258 }
259
1c9b0550
ML
260 batadv_inc_counter(bat_priv, BATADV_CNT_TX);
261 batadv_add_counter(bat_priv, BATADV_CNT_TX_BYTES, data_len);
c6c8fea2
SE
262 goto end;
263
264dropped:
265 kfree_skb(skb);
266dropped_freed:
1c9b0550 267 batadv_inc_counter(bat_priv, BATADV_CNT_TX_DROPPED);
c6c8fea2 268end:
32ae9b22 269 if (primary_if)
e5d89254 270 batadv_hardif_free_ref(primary_if);
c6c8fea2
SE
271 return NETDEV_TX_OK;
272}
273
04b482a2 274void batadv_interface_rx(struct net_device *soft_iface,
56303d34 275 struct sk_buff *skb, struct batadv_hard_iface *recv_if,
37135173 276 int hdr_size, struct batadv_orig_node *orig_node)
c6c8fea2 277{
56303d34 278 struct batadv_priv *bat_priv = netdev_priv(soft_iface);
c6c8fea2
SE
279 struct ethhdr *ethhdr;
280 struct vlan_ethhdr *vhdr;
04c9f416 281 struct batadv_header *batadv_header = (struct batadv_header *)skb->data;
7a5cc242 282 short vid __maybe_unused = -1;
7e071c79 283 __be16 ethertype = __constant_htons(BATADV_ETH_P_BATMAN);
2d3f6ccc
SW
284 bool is_bcast;
285
04c9f416 286 is_bcast = (batadv_header->packet_type == BATADV_BCAST);
c6c8fea2
SE
287
288 /* check if enough space is available for pulling, and pull */
289 if (!pskb_may_pull(skb, hdr_size))
290 goto dropped;
291
292 skb_pull_rcsum(skb, hdr_size);
293 skb_reset_mac_header(skb);
294
295 ethhdr = (struct ethhdr *)skb_mac_header(skb);
296
297 switch (ntohs(ethhdr->h_proto)) {
298 case ETH_P_8021Q:
299 vhdr = (struct vlan_ethhdr *)skb->data;
300 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK;
301
7e071c79 302 if (vhdr->h_vlan_encapsulated_proto != ethertype)
c6c8fea2
SE
303 break;
304
305 /* fall through */
7e071c79 306 case BATADV_ETH_P_BATMAN:
c6c8fea2
SE
307 goto dropped;
308 }
309
c6c8fea2
SE
310 /* skb->dev & skb->pkt_type are set here */
311 if (unlikely(!pskb_may_pull(skb, ETH_HLEN)))
312 goto dropped;
313 skb->protocol = eth_type_trans(skb, soft_iface);
314
25985edc 315 /* should not be necessary anymore as we use skb_pull_rcsum()
c6c8fea2 316 * TODO: please verify this and remove this TODO
9cfc7bd6
SE
317 * -- Dec 21st 2009, Simon Wunderlich
318 */
c6c8fea2 319
9cfc7bd6 320 /* skb->ip_summed = CHECKSUM_UNNECESSARY; */
c6c8fea2 321
1c9b0550
ML
322 batadv_inc_counter(bat_priv, BATADV_CNT_RX);
323 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES,
324 skb->len + ETH_HLEN);
c6c8fea2
SE
325
326 soft_iface->last_rx = jiffies;
327
37135173
AQ
328 if (orig_node)
329 batadv_tt_add_temporary_global_entry(bat_priv, orig_node,
330 ethhdr->h_source);
331
08c36d3e 332 if (batadv_is_ap_isolated(bat_priv, ethhdr->h_source, ethhdr->h_dest))
59b699cd
AQ
333 goto dropped;
334
23721387
SW
335 /* Let the bridge loop avoidance check the packet. If will
336 * not handle it, we can safely push it up.
337 */
04c9f416 338 if (batadv_bla_rx(bat_priv, skb, vid, is_bcast))
23721387
SW
339 goto out;
340
c6c8fea2 341 netif_rx(skb);
ba85fac2 342 goto out;
c6c8fea2
SE
343
344dropped:
345 kfree_skb(skb);
346out:
347 return;
348}
349
36c1d153
SE
350/* batman-adv network devices have devices nesting below it and are a special
351 * "super class" of normal network devices; split their locks off into a
352 * separate class since they always nest.
353 */
354static struct lock_class_key batadv_netdev_xmit_lock_key;
355static struct lock_class_key batadv_netdev_addr_lock_key;
356
357/**
358 * batadv_set_lockdep_class_one - Set lockdep class for a single tx queue
359 * @dev: device which owns the tx queue
360 * @txq: tx queue to modify
361 * @_unused: always NULL
362 */
363static void batadv_set_lockdep_class_one(struct net_device *dev,
364 struct netdev_queue *txq,
365 void *_unused)
366{
367 lockdep_set_class(&txq->_xmit_lock, &batadv_netdev_xmit_lock_key);
368}
369
370/**
371 * batadv_set_lockdep_class - Set txq and addr_list lockdep class
372 * @dev: network device to modify
373 */
374static void batadv_set_lockdep_class(struct net_device *dev)
375{
376 lockdep_set_class(&dev->addr_list_lock, &batadv_netdev_addr_lock_key);
377 netdev_for_each_tx_queue(dev, batadv_set_lockdep_class_one, NULL);
378}
379
380/**
381 * batadv_softif_init - Late stage initialization of soft interface
382 * @dev: registered network device to modify
383 *
384 * Returns error code on failures
385 */
386static int batadv_softif_init(struct net_device *dev)
387{
388 batadv_set_lockdep_class(dev);
389
390 return 0;
391}
392
0294ca0d 393static const struct net_device_ops batadv_netdev_ops = {
36c1d153 394 .ndo_init = batadv_softif_init,
0294ca0d
SE
395 .ndo_open = batadv_interface_open,
396 .ndo_stop = batadv_interface_release,
397 .ndo_get_stats = batadv_interface_stats,
398 .ndo_set_mac_address = batadv_interface_set_mac_addr,
399 .ndo_change_mtu = batadv_interface_change_mtu,
400 .ndo_start_xmit = batadv_interface_tx,
c6c8fea2
SE
401 .ndo_validate_addr = eth_validate_addr
402};
c6c8fea2 403
0294ca0d 404static void batadv_interface_setup(struct net_device *dev)
c6c8fea2 405{
56303d34 406 struct batadv_priv *priv = netdev_priv(dev);
c6c8fea2
SE
407
408 ether_setup(dev);
409
0294ca0d 410 dev->netdev_ops = &batadv_netdev_ops;
c6c8fea2 411 dev->destructor = free_netdev;
af20b710 412 dev->tx_queue_len = 0;
c6c8fea2 413
9cfc7bd6 414 /* can't call min_mtu, because the needed variables
c6c8fea2
SE
415 * have not been initialized yet
416 */
417 dev->mtu = ETH_DATA_LEN;
6e215fd8 418 /* reserve more space in the skbuff for our header */
c11fdfae 419 dev->hard_header_len = BATADV_HEADER_LEN;
c6c8fea2
SE
420
421 /* generate random address */
28009a6c 422 eth_hw_addr_random(dev);
c6c8fea2 423
0294ca0d 424 SET_ETHTOOL_OPS(dev, &batadv_ethtool_ops);
c6c8fea2 425
704509b8 426 memset(priv, 0, sizeof(*priv));
c6c8fea2
SE
427}
428
04b482a2 429struct net_device *batadv_softif_create(const char *name)
c6c8fea2
SE
430{
431 struct net_device *soft_iface;
56303d34 432 struct batadv_priv *bat_priv;
c6c8fea2 433 int ret;
d69909d2 434 size_t cnt_len = sizeof(uint64_t) * BATADV_CNT_NUM;
c6c8fea2 435
0294ca0d
SE
436 soft_iface = alloc_netdev(sizeof(*bat_priv), name,
437 batadv_interface_setup);
c6c8fea2 438
320f422f 439 if (!soft_iface)
c6c8fea2 440 goto out;
c6c8fea2 441
1c9b0550
ML
442 bat_priv = netdev_priv(soft_iface);
443
444 /* batadv_interface_stats() needs to be available as soon as
445 * register_netdevice() has been called
446 */
447 bat_priv->bat_counters = __alloc_percpu(cnt_len, __alignof__(uint64_t));
448 if (!bat_priv->bat_counters)
449 goto free_soft_iface;
450
c3caf519 451 ret = register_netdevice(soft_iface);
c6c8fea2
SE
452 if (ret < 0) {
453 pr_err("Unable to register the batman interface '%s': %i\n",
454 name, ret);
1c9b0550 455 goto free_bat_counters;
c6c8fea2
SE
456 }
457
c6c8fea2
SE
458 atomic_set(&bat_priv->aggregated_ogms, 1);
459 atomic_set(&bat_priv->bonding, 0);
23721387 460 atomic_set(&bat_priv->bridge_loop_avoidance, 0);
59b699cd 461 atomic_set(&bat_priv->ap_isolation, 0);
acd34afa 462 atomic_set(&bat_priv->vis_mode, BATADV_VIS_TYPE_CLIENT_UPDATE);
cd646ab1 463 atomic_set(&bat_priv->gw_mode, BATADV_GW_MODE_OFF);
c6c8fea2
SE
464 atomic_set(&bat_priv->gw_sel_class, 20);
465 atomic_set(&bat_priv->gw_bandwidth, 41);
466 atomic_set(&bat_priv->orig_interval, 1000);
8681a1c4 467 atomic_set(&bat_priv->hop_penalty, 30);
c6c8fea2
SE
468 atomic_set(&bat_priv->log_level, 0);
469 atomic_set(&bat_priv->fragmentation, 1);
42d0b044
SE
470 atomic_set(&bat_priv->bcast_queue_left, BATADV_BCAST_QUEUE_LEN);
471 atomic_set(&bat_priv->batman_queue_left, BATADV_BATMAN_QUEUE_LEN);
c6c8fea2 472
39c75a51 473 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE);
c6c8fea2 474 atomic_set(&bat_priv->bcast_seqno, 1);
807736f6
SE
475 atomic_set(&bat_priv->tt.vn, 0);
476 atomic_set(&bat_priv->tt.local_changes, 0);
477 atomic_set(&bat_priv->tt.ogm_append_cnt, 0);
478#ifdef CONFIG_BATMAN_ADV_BLA
479 atomic_set(&bat_priv->bla.num_requests, 0);
480#endif
481 bat_priv->tt.last_changeset = NULL;
482 bat_priv->tt.last_changeset_len = 0;
483 bat_priv->tt.poss_change = false;
c6c8fea2
SE
484
485 bat_priv->primary_if = NULL;
486 bat_priv->num_ifaces = 0;
c6c8fea2 487
3193e8fd 488 ret = batadv_algo_select(bat_priv, batadv_routing_algo);
1c280471 489 if (ret < 0)
1c9b0550 490 goto unreg_soft_iface;
1c280471 491
5853e22c 492 ret = batadv_sysfs_add_meshif(soft_iface);
c6c8fea2 493 if (ret < 0)
1c9b0550 494 goto unreg_soft_iface;
c6c8fea2 495
40a072d7 496 ret = batadv_debugfs_add_meshif(soft_iface);
c6c8fea2
SE
497 if (ret < 0)
498 goto unreg_sysfs;
499
3193e8fd 500 ret = batadv_mesh_init(soft_iface);
c6c8fea2
SE
501 if (ret < 0)
502 goto unreg_debugfs;
503
504 return soft_iface;
505
506unreg_debugfs:
40a072d7 507 batadv_debugfs_del_meshif(soft_iface);
c6c8fea2 508unreg_sysfs:
5853e22c 509 batadv_sysfs_del_meshif(soft_iface);
c6c8fea2 510unreg_soft_iface:
1c9b0550 511 free_percpu(bat_priv->bat_counters);
06ba7ce2 512 unregister_netdevice(soft_iface);
c6c8fea2
SE
513 return NULL;
514
1c9b0550
ML
515free_bat_counters:
516 free_percpu(bat_priv->bat_counters);
c6c8fea2
SE
517free_soft_iface:
518 free_netdev(soft_iface);
519out:
520 return NULL;
521}
522
04b482a2 523void batadv_softif_destroy(struct net_device *soft_iface)
c6c8fea2 524{
40a072d7 525 batadv_debugfs_del_meshif(soft_iface);
5853e22c 526 batadv_sysfs_del_meshif(soft_iface);
3193e8fd 527 batadv_mesh_free(soft_iface);
c6c8fea2
SE
528 unregister_netdevice(soft_iface);
529}
530
04b482a2 531int batadv_softif_is_valid(const struct net_device *net_dev)
e44d8fe2 532{
0294ca0d 533 if (net_dev->netdev_ops->ndo_start_xmit == batadv_interface_tx)
e44d8fe2 534 return 1;
e44d8fe2
SE
535
536 return 0;
537}
538
c6c8fea2 539/* ethtool */
0294ca0d 540static int batadv_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
c6c8fea2
SE
541{
542 cmd->supported = 0;
543 cmd->advertising = 0;
70739497 544 ethtool_cmd_speed_set(cmd, SPEED_10);
c6c8fea2
SE
545 cmd->duplex = DUPLEX_FULL;
546 cmd->port = PORT_TP;
547 cmd->phy_address = 0;
548 cmd->transceiver = XCVR_INTERNAL;
549 cmd->autoneg = AUTONEG_DISABLE;
550 cmd->maxtxpkt = 0;
551 cmd->maxrxpkt = 0;
552
553 return 0;
554}
555
0294ca0d
SE
556static void batadv_get_drvinfo(struct net_device *dev,
557 struct ethtool_drvinfo *info)
c6c8fea2
SE
558{
559 strcpy(info->driver, "B.A.T.M.A.N. advanced");
42d0b044 560 strcpy(info->version, BATADV_SOURCE_VERSION);
c6c8fea2
SE
561 strcpy(info->fw_version, "N/A");
562 strcpy(info->bus_info, "batman");
563}
564
0294ca0d 565static u32 batadv_get_msglevel(struct net_device *dev)
c6c8fea2
SE
566{
567 return -EOPNOTSUPP;
568}
569
0294ca0d 570static void batadv_set_msglevel(struct net_device *dev, u32 value)
c6c8fea2
SE
571{
572}
573
0294ca0d 574static u32 batadv_get_link(struct net_device *dev)
c6c8fea2
SE
575{
576 return 1;
577}
f8214865
MH
578
579/* Inspired by drivers/net/ethernet/dlink/sundance.c:1702
580 * Declare each description string in struct.name[] to get fixed sized buffer
581 * and compile time checking for strings longer than ETH_GSTRING_LEN.
582 */
583static const struct {
584 const char name[ETH_GSTRING_LEN];
0294ca0d 585} batadv_counters_strings[] = {
1c9b0550
ML
586 { "tx" },
587 { "tx_bytes" },
588 { "tx_dropped" },
589 { "rx" },
590 { "rx_bytes" },
f8214865
MH
591 { "forward" },
592 { "forward_bytes" },
593 { "mgmt_tx" },
594 { "mgmt_tx_bytes" },
595 { "mgmt_rx" },
596 { "mgmt_rx_bytes" },
597 { "tt_request_tx" },
598 { "tt_request_rx" },
599 { "tt_response_tx" },
600 { "tt_response_rx" },
601 { "tt_roam_adv_tx" },
602 { "tt_roam_adv_rx" },
603};
604
605static void batadv_get_strings(struct net_device *dev, uint32_t stringset,
606 uint8_t *data)
607{
608 if (stringset == ETH_SS_STATS)
0294ca0d
SE
609 memcpy(data, batadv_counters_strings,
610 sizeof(batadv_counters_strings));
f8214865
MH
611}
612
613static void batadv_get_ethtool_stats(struct net_device *dev,
614 struct ethtool_stats *stats,
615 uint64_t *data)
616{
56303d34 617 struct batadv_priv *bat_priv = netdev_priv(dev);
f8214865
MH
618 int i;
619
d69909d2 620 for (i = 0; i < BATADV_CNT_NUM; i++)
f8214865
MH
621 data[i] = batadv_sum_counter(bat_priv, i);
622}
623
624static int batadv_get_sset_count(struct net_device *dev, int stringset)
625{
626 if (stringset == ETH_SS_STATS)
d69909d2 627 return BATADV_CNT_NUM;
f8214865
MH
628
629 return -EOPNOTSUPP;
630}
This page took 0.161857 seconds and 5 git commands to generate.