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