1// SPDX-License-Identifier: GPL-2.0 2/* Copyright (C) B.A.T.M.A.N. contributors: 3 * 4 * Marek Lindner, Simon Wunderlich 5 */ 6 7#include "bat_iv_ogm.h" 8#include "main.h" 9 10#include <linux/atomic.h> 11#include <linux/bitmap.h> 12#include <linux/bitops.h> 13#include <linux/bug.h> 14#include <linux/byteorder/generic.h> 15#include <linux/cache.h> 16#include <linux/container_of.h> 17#include <linux/errno.h> 18#include <linux/etherdevice.h> 19#include <linux/gfp.h> 20#include <linux/if_ether.h> 21#include <linux/init.h> 22#include <linux/jiffies.h> 23#include <linux/kref.h> 24#include <linux/list.h> 25#include <linux/lockdep.h> 26#include <linux/mutex.h> 27#include <linux/netdevice.h> 28#include <linux/netlink.h> 29#include <linux/pkt_sched.h> 30#include <linux/printk.h> 31#include <linux/random.h> 32#include <linux/rculist.h> 33#include <linux/rcupdate.h> 34#include <linux/skbuff.h> 35#include <linux/slab.h> 36#include <linux/spinlock.h> 37#include <linux/stddef.h> 38#include <linux/string.h> 39#include <linux/types.h> 40#include <linux/workqueue.h> 41#include <net/genetlink.h> 42#include <net/netlink.h> 43#include <uapi/linux/batadv_packet.h> 44#include <uapi/linux/batman_adv.h> 45 46#include "bat_algo.h" 47#include "bitarray.h" 48#include "gateway_client.h" 49#include "hard-interface.h" 50#include "hash.h" 51#include "log.h" 52#include "netlink.h" 53#include "network-coding.h" 54#include "originator.h" 55#include "routing.h" 56#include "send.h" 57#include "translation-table.h" 58#include "tvlv.h" 59 60static void batadv_iv_send_outstanding_bat_ogm_packet(struct work_struct *work); 61 62/** 63 * enum batadv_dup_status - duplicate status 64 */ 65enum batadv_dup_status { 66 /** @BATADV_NO_DUP: the packet is no duplicate */ 67 BATADV_NO_DUP = 0, 68 69 /** 70 * @BATADV_ORIG_DUP: OGM is a duplicate in the originator (but not for 71 * the neighbor) 72 */ 73 BATADV_ORIG_DUP, 74 75 /** @BATADV_NEIGH_DUP: OGM is a duplicate for the neighbor */ 76 BATADV_NEIGH_DUP, 77 78 /** 79 * @BATADV_PROTECTED: originator is currently protected (after reboot) 80 */ 81 BATADV_PROTECTED, 82}; 83 84/** 85 * batadv_ring_buffer_set() - update the ring buffer with the given value 86 * @lq_recv: pointer to the ring buffer 87 * @lq_index: index to store the value at 88 * @value: value to store in the ring buffer 89 */ 90static void batadv_ring_buffer_set(u8 lq_recv[], u8 *lq_index, u8 value) 91{ 92 lq_recv[*lq_index] = value; 93 *lq_index = (*lq_index + 1) % BATADV_TQ_GLOBAL_WINDOW_SIZE; 94} 95 96/** 97 * batadv_ring_buffer_avg() - compute the average of all non-zero values stored 98 * in the given ring buffer 99 * @lq_recv: pointer to the ring buffer 100 * 101 * Return: computed average value. 102 */ 103static u8 batadv_ring_buffer_avg(const u8 lq_recv[]) 104{ 105 const u8 *ptr; 106 u16 count = 0; 107 u16 i = 0; 108 u16 sum = 0; 109 110 ptr = lq_recv; 111 112 while (i < BATADV_TQ_GLOBAL_WINDOW_SIZE) { 113 if (*ptr != 0) { 114 count++; 115 sum += *ptr; 116 } 117 118 i++; 119 ptr++; 120 } 121 122 if (count == 0) 123 return 0; 124 125 return (u8)(sum / count); 126} 127 128/** 129 * batadv_iv_ogm_orig_get() - retrieve or create (if does not exist) an 130 * originator 131 * @bat_priv: the bat priv with all the soft interface information 132 * @addr: mac address of the originator 133 * 134 * Return: the originator object corresponding to the passed mac address or NULL 135 * on failure. 136 * If the object does not exist, it is created and initialised. 137 */ 138static struct batadv_orig_node * 139batadv_iv_ogm_orig_get(struct batadv_priv *bat_priv, const u8 *addr) 140{ 141 struct batadv_orig_node *orig_node; 142 int hash_added; 143 144 orig_node = batadv_orig_hash_find(bat_priv, addr); 145 if (orig_node) 146 return orig_node; 147 148 orig_node = batadv_orig_node_new(bat_priv, addr); 149 if (!orig_node) 150 return NULL; 151 152 spin_lock_init(&orig_node->bat_iv.ogm_cnt_lock); 153 154 kref_get(&orig_node->refcount); 155 hash_added = batadv_hash_add(bat_priv->orig_hash, batadv_compare_orig, 156 batadv_choose_orig, orig_node, 157 &orig_node->hash_entry); 158 if (hash_added != 0) 159 goto free_orig_node_hash; 160 161 return orig_node; 162 163free_orig_node_hash: 164 /* reference for batadv_hash_add */ 165 batadv_orig_node_put(orig_node); 166 /* reference from batadv_orig_node_new */ 167 batadv_orig_node_put(orig_node); 168 169 return NULL; 170} 171 172static struct batadv_neigh_node * 173batadv_iv_ogm_neigh_new(struct batadv_hard_iface *hard_iface, 174 const u8 *neigh_addr, 175 struct batadv_orig_node *orig_node, 176 struct batadv_orig_node *orig_neigh) 177{ 178 struct batadv_neigh_node *neigh_node; 179 180 neigh_node = batadv_neigh_node_get_or_create(orig_node, 181 hard_iface, neigh_addr); 182 if (!neigh_node) 183 goto out; 184 185 neigh_node->orig_node = orig_neigh; 186 187out: 188 return neigh_node; 189} 190 191static int batadv_iv_ogm_iface_enable(struct batadv_hard_iface *hard_iface) 192{ 193 struct batadv_ogm_packet *batadv_ogm_packet; 194 unsigned char *ogm_buff; 195 u32 random_seqno; 196 197 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex); 198 199 /* randomize initial seqno to avoid collision */ 200 get_random_bytes(&random_seqno, sizeof(random_seqno)); 201 atomic_set(&hard_iface->bat_iv.ogm_seqno, random_seqno); 202 203 hard_iface->bat_iv.ogm_buff_len = BATADV_OGM_HLEN; 204 ogm_buff = kmalloc(hard_iface->bat_iv.ogm_buff_len, GFP_ATOMIC); 205 if (!ogm_buff) { 206 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex); 207 return -ENOMEM; 208 } 209 210 hard_iface->bat_iv.ogm_buff = ogm_buff; 211 212 batadv_ogm_packet = (struct batadv_ogm_packet *)ogm_buff; 213 batadv_ogm_packet->packet_type = BATADV_IV_OGM; 214 batadv_ogm_packet->version = BATADV_COMPAT_VERSION; 215 batadv_ogm_packet->ttl = 2; 216 batadv_ogm_packet->flags = BATADV_NO_FLAGS; 217 batadv_ogm_packet->reserved = 0; 218 batadv_ogm_packet->tq = BATADV_TQ_MAX_VALUE; 219 220 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex); 221 222 return 0; 223} 224 225static void batadv_iv_ogm_iface_disable(struct batadv_hard_iface *hard_iface) 226{ 227 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex); 228 229 kfree(hard_iface->bat_iv.ogm_buff); 230 hard_iface->bat_iv.ogm_buff = NULL; 231 232 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex); 233} 234 235static void batadv_iv_ogm_iface_update_mac(struct batadv_hard_iface *hard_iface) 236{ 237 struct batadv_ogm_packet *batadv_ogm_packet; 238 void *ogm_buff; 239 240 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex); 241 242 ogm_buff = hard_iface->bat_iv.ogm_buff; 243 if (!ogm_buff) 244 goto unlock; 245 246 batadv_ogm_packet = ogm_buff; 247 ether_addr_copy(batadv_ogm_packet->orig, 248 hard_iface->net_dev->dev_addr); 249 ether_addr_copy(batadv_ogm_packet->prev_sender, 250 hard_iface->net_dev->dev_addr); 251 252unlock: 253 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex); 254} 255 256static void 257batadv_iv_ogm_primary_iface_set(struct batadv_hard_iface *hard_iface) 258{ 259 struct batadv_ogm_packet *batadv_ogm_packet; 260 void *ogm_buff; 261 262 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex); 263 264 ogm_buff = hard_iface->bat_iv.ogm_buff; 265 if (!ogm_buff) 266 goto unlock; 267 268 batadv_ogm_packet = ogm_buff; 269 batadv_ogm_packet->ttl = BATADV_TTL; 270 271unlock: 272 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex); 273} 274 275/* when do we schedule our own ogm to be sent */ 276static unsigned long 277batadv_iv_ogm_emit_send_time(const struct batadv_priv *bat_priv) 278{ 279 unsigned int msecs; 280 281 msecs = atomic_read(&bat_priv->orig_interval) - BATADV_JITTER; 282 msecs += get_random_u32_below(2 * BATADV_JITTER); 283 284 return jiffies + msecs_to_jiffies(msecs); 285} 286 287/* when do we schedule a ogm packet to be sent */ 288static unsigned long batadv_iv_ogm_fwd_send_time(void) 289{ 290 return jiffies + msecs_to_jiffies(get_random_u32_below(BATADV_JITTER / 2)); 291} 292 293/* apply hop penalty for a normal link */ 294static u8 batadv_hop_penalty(u8 tq, const struct batadv_priv *bat_priv) 295{ 296 int hop_penalty = atomic_read(&bat_priv->hop_penalty); 297 int new_tq; 298 299 new_tq = tq * (BATADV_TQ_MAX_VALUE - hop_penalty); 300 new_tq /= BATADV_TQ_MAX_VALUE; 301 302 return new_tq; 303} 304 305/** 306 * batadv_iv_ogm_aggr_packet() - checks if there is another OGM attached 307 * @buff_pos: current position in the skb 308 * @packet_len: total length of the skb 309 * @ogm_packet: potential OGM in buffer 310 * 311 * Return: true if there is enough space for another OGM, false otherwise. 312 */ 313static bool 314batadv_iv_ogm_aggr_packet(int buff_pos, int packet_len, 315 const struct batadv_ogm_packet *ogm_packet) 316{ 317 int next_buff_pos = 0; 318 319 /* check if there is enough space for the header */ 320 next_buff_pos += buff_pos + sizeof(*ogm_packet); 321 if (next_buff_pos > packet_len) 322 return false; 323 324 /* check if there is enough space for the optional TVLV */ 325 next_buff_pos += ntohs(ogm_packet->tvlv_len); 326 327 return (next_buff_pos <= packet_len) && 328 (next_buff_pos <= BATADV_MAX_AGGREGATION_BYTES); 329} 330 331/* send a batman ogm to a given interface */ 332static void batadv_iv_ogm_send_to_if(struct batadv_forw_packet *forw_packet, 333 struct batadv_hard_iface *hard_iface) 334{ 335 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 336 const char *fwd_str; 337 u8 packet_num; 338 s16 buff_pos; 339 struct batadv_ogm_packet *batadv_ogm_packet; 340 struct sk_buff *skb; 341 u8 *packet_pos; 342 343 if (hard_iface->if_status != BATADV_IF_ACTIVE) 344 return; 345 346 packet_num = 0; 347 buff_pos = 0; 348 packet_pos = forw_packet->skb->data; 349 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos; 350 351 /* adjust all flags and log packets */ 352 while (batadv_iv_ogm_aggr_packet(buff_pos, forw_packet->packet_len, 353 batadv_ogm_packet)) { 354 /* we might have aggregated direct link packets with an 355 * ordinary base packet 356 */ 357 if (forw_packet->direct_link_flags & BIT(packet_num) && 358 forw_packet->if_incoming == hard_iface) 359 batadv_ogm_packet->flags |= BATADV_DIRECTLINK; 360 else 361 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK; 362 363 if (packet_num > 0 || !forw_packet->own) 364 fwd_str = "Forwarding"; 365 else 366 fwd_str = "Sending own"; 367 368 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 369 "%s %spacket (originator %pM, seqno %u, TQ %d, TTL %d, IDF %s) on interface %s [%pM]\n", 370 fwd_str, (packet_num > 0 ? "aggregated " : ""), 371 batadv_ogm_packet->orig, 372 ntohl(batadv_ogm_packet->seqno), 373 batadv_ogm_packet->tq, batadv_ogm_packet->ttl, 374 ((batadv_ogm_packet->flags & BATADV_DIRECTLINK) ? 375 "on" : "off"), 376 hard_iface->net_dev->name, 377 hard_iface->net_dev->dev_addr); 378 379 buff_pos += BATADV_OGM_HLEN; 380 buff_pos += ntohs(batadv_ogm_packet->tvlv_len); 381 packet_num++; 382 packet_pos = forw_packet->skb->data + buff_pos; 383 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_pos; 384 } 385 386 /* create clone because function is called more than once */ 387 skb = skb_clone(forw_packet->skb, GFP_ATOMIC); 388 if (skb) { 389 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_TX); 390 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_TX_BYTES, 391 skb->len + ETH_HLEN); 392 batadv_send_broadcast_skb(skb, hard_iface); 393 } 394} 395 396/* send a batman ogm packet */ 397static void batadv_iv_ogm_emit(struct batadv_forw_packet *forw_packet) 398{ 399 struct net_device *soft_iface; 400 401 if (!forw_packet->if_incoming) { 402 pr_err("Error - can't forward packet: incoming iface not specified\n"); 403 return; 404 } 405 406 soft_iface = forw_packet->if_incoming->soft_iface; 407 408 if (WARN_ON(!forw_packet->if_outgoing)) 409 return; 410 411 if (forw_packet->if_outgoing->soft_iface != soft_iface) { 412 pr_warn("%s: soft interface switch for queued OGM\n", __func__); 413 return; 414 } 415 416 if (forw_packet->if_incoming->if_status != BATADV_IF_ACTIVE) 417 return; 418 419 /* only for one specific outgoing interface */ 420 batadv_iv_ogm_send_to_if(forw_packet, forw_packet->if_outgoing); 421} 422 423/** 424 * batadv_iv_ogm_can_aggregate() - find out if an OGM can be aggregated on an 425 * existing forward packet 426 * @new_bat_ogm_packet: OGM packet to be aggregated 427 * @bat_priv: the bat priv with all the soft interface information 428 * @packet_len: (total) length of the OGM 429 * @send_time: timestamp (jiffies) when the packet is to be sent 430 * @directlink: true if this is a direct link packet 431 * @if_incoming: interface where the packet was received 432 * @if_outgoing: interface for which the retransmission should be considered 433 * @forw_packet: the forwarded packet which should be checked 434 * 435 * Return: true if new_packet can be aggregated with forw_packet 436 */ 437static bool 438batadv_iv_ogm_can_aggregate(const struct batadv_ogm_packet *new_bat_ogm_packet, 439 struct batadv_priv *bat_priv, 440 int packet_len, unsigned long send_time, 441 bool directlink, 442 const struct batadv_hard_iface *if_incoming, 443 const struct batadv_hard_iface *if_outgoing, 444 const struct batadv_forw_packet *forw_packet) 445{ 446 struct batadv_ogm_packet *batadv_ogm_packet; 447 int aggregated_bytes = forw_packet->packet_len + packet_len; 448 struct batadv_hard_iface *primary_if = NULL; 449 bool res = false; 450 unsigned long aggregation_end_time; 451 452 batadv_ogm_packet = (struct batadv_ogm_packet *)forw_packet->skb->data; 453 aggregation_end_time = send_time; 454 aggregation_end_time += msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS); 455 456 /* we can aggregate the current packet to this aggregated packet 457 * if: 458 * 459 * - the send time is within our MAX_AGGREGATION_MS time 460 * - the resulting packet won't be bigger than 461 * MAX_AGGREGATION_BYTES 462 * otherwise aggregation is not possible 463 */ 464 if (!time_before(send_time, forw_packet->send_time) || 465 !time_after_eq(aggregation_end_time, forw_packet->send_time)) 466 return false; 467 468 if (aggregated_bytes > BATADV_MAX_AGGREGATION_BYTES) 469 return false; 470 471 /* packet is not leaving on the same interface. */ 472 if (forw_packet->if_outgoing != if_outgoing) 473 return false; 474 475 /* check aggregation compatibility 476 * -> direct link packets are broadcasted on 477 * their interface only 478 * -> aggregate packet if the current packet is 479 * a "global" packet as well as the base 480 * packet 481 */ 482 primary_if = batadv_primary_if_get_selected(bat_priv); 483 if (!primary_if) 484 return false; 485 486 /* packets without direct link flag and high TTL 487 * are flooded through the net 488 */ 489 if (!directlink && 490 !(batadv_ogm_packet->flags & BATADV_DIRECTLINK) && 491 batadv_ogm_packet->ttl != 1 && 492 493 /* own packets originating non-primary 494 * interfaces leave only that interface 495 */ 496 (!forw_packet->own || 497 forw_packet->if_incoming == primary_if)) { 498 res = true; 499 goto out; 500 } 501 502 /* if the incoming packet is sent via this one 503 * interface only - we still can aggregate 504 */ 505 if (directlink && 506 new_bat_ogm_packet->ttl == 1 && 507 forw_packet->if_incoming == if_incoming && 508 509 /* packets from direct neighbors or 510 * own secondary interface packets 511 * (= secondary interface packets in general) 512 */ 513 (batadv_ogm_packet->flags & BATADV_DIRECTLINK || 514 (forw_packet->own && 515 forw_packet->if_incoming != primary_if))) { 516 res = true; 517 goto out; 518 } 519 520out: 521 batadv_hardif_put(primary_if); 522 return res; 523} 524 525/** 526 * batadv_iv_ogm_aggregate_new() - create a new aggregated packet and add this 527 * packet to it. 528 * @packet_buff: pointer to the OGM 529 * @packet_len: (total) length of the OGM 530 * @send_time: timestamp (jiffies) when the packet is to be sent 531 * @direct_link: whether this OGM has direct link status 532 * @if_incoming: interface where the packet was received 533 * @if_outgoing: interface for which the retransmission should be considered 534 * @own_packet: true if it is a self-generated ogm 535 */ 536static void batadv_iv_ogm_aggregate_new(const unsigned char *packet_buff, 537 int packet_len, unsigned long send_time, 538 bool direct_link, 539 struct batadv_hard_iface *if_incoming, 540 struct batadv_hard_iface *if_outgoing, 541 int own_packet) 542{ 543 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 544 struct batadv_forw_packet *forw_packet_aggr; 545 struct sk_buff *skb; 546 unsigned char *skb_buff; 547 unsigned int skb_size; 548 atomic_t *queue_left = own_packet ? NULL : &bat_priv->batman_queue_left; 549 550 if (atomic_read(&bat_priv->aggregated_ogms) && 551 packet_len < BATADV_MAX_AGGREGATION_BYTES) 552 skb_size = BATADV_MAX_AGGREGATION_BYTES; 553 else 554 skb_size = packet_len; 555 556 skb_size += ETH_HLEN; 557 558 skb = netdev_alloc_skb_ip_align(NULL, skb_size); 559 if (!skb) 560 return; 561 562 forw_packet_aggr = batadv_forw_packet_alloc(if_incoming, if_outgoing, 563 queue_left, bat_priv, skb); 564 if (!forw_packet_aggr) { 565 kfree_skb(skb); 566 return; 567 } 568 569 forw_packet_aggr->skb->priority = TC_PRIO_CONTROL; 570 skb_reserve(forw_packet_aggr->skb, ETH_HLEN); 571 572 skb_buff = skb_put(forw_packet_aggr->skb, packet_len); 573 forw_packet_aggr->packet_len = packet_len; 574 memcpy(skb_buff, packet_buff, packet_len); 575 576 forw_packet_aggr->own = own_packet; 577 forw_packet_aggr->direct_link_flags = BATADV_NO_FLAGS; 578 forw_packet_aggr->send_time = send_time; 579 580 /* save packet direct link flag status */ 581 if (direct_link) 582 forw_packet_aggr->direct_link_flags |= 1; 583 584 INIT_DELAYED_WORK(&forw_packet_aggr->delayed_work, 585 batadv_iv_send_outstanding_bat_ogm_packet); 586 587 batadv_forw_packet_ogmv1_queue(bat_priv, forw_packet_aggr, send_time); 588} 589 590/* aggregate a new packet into the existing ogm packet */ 591static void batadv_iv_ogm_aggregate(struct batadv_forw_packet *forw_packet_aggr, 592 const unsigned char *packet_buff, 593 int packet_len, bool direct_link) 594{ 595 unsigned long new_direct_link_flag; 596 597 skb_put_data(forw_packet_aggr->skb, packet_buff, packet_len); 598 forw_packet_aggr->packet_len += packet_len; 599 forw_packet_aggr->num_packets++; 600 601 /* save packet direct link flag status */ 602 if (direct_link) { 603 new_direct_link_flag = BIT(forw_packet_aggr->num_packets); 604 forw_packet_aggr->direct_link_flags |= new_direct_link_flag; 605 } 606} 607 608/** 609 * batadv_iv_ogm_queue_add() - queue up an OGM for transmission 610 * @bat_priv: the bat priv with all the soft interface information 611 * @packet_buff: pointer to the OGM 612 * @packet_len: (total) length of the OGM 613 * @if_incoming: interface where the packet was received 614 * @if_outgoing: interface for which the retransmission should be considered 615 * @own_packet: true if it is a self-generated ogm 616 * @send_time: timestamp (jiffies) when the packet is to be sent 617 */ 618static void batadv_iv_ogm_queue_add(struct batadv_priv *bat_priv, 619 unsigned char *packet_buff, 620 int packet_len, 621 struct batadv_hard_iface *if_incoming, 622 struct batadv_hard_iface *if_outgoing, 623 int own_packet, unsigned long send_time) 624{ 625 /* _aggr -> pointer to the packet we want to aggregate with 626 * _pos -> pointer to the position in the queue 627 */ 628 struct batadv_forw_packet *forw_packet_aggr = NULL; 629 struct batadv_forw_packet *forw_packet_pos = NULL; 630 struct batadv_ogm_packet *batadv_ogm_packet; 631 bool direct_link; 632 unsigned long max_aggregation_jiffies; 633 634 batadv_ogm_packet = (struct batadv_ogm_packet *)packet_buff; 635 direct_link = !!(batadv_ogm_packet->flags & BATADV_DIRECTLINK); 636 max_aggregation_jiffies = msecs_to_jiffies(BATADV_MAX_AGGREGATION_MS); 637 638 /* find position for the packet in the forward queue */ 639 spin_lock_bh(&bat_priv->forw_bat_list_lock); 640 /* own packets are not to be aggregated */ 641 if (atomic_read(&bat_priv->aggregated_ogms) && !own_packet) { 642 hlist_for_each_entry(forw_packet_pos, 643 &bat_priv->forw_bat_list, list) { 644 if (batadv_iv_ogm_can_aggregate(batadv_ogm_packet, 645 bat_priv, packet_len, 646 send_time, direct_link, 647 if_incoming, 648 if_outgoing, 649 forw_packet_pos)) { 650 forw_packet_aggr = forw_packet_pos; 651 break; 652 } 653 } 654 } 655 656 /* nothing to aggregate with - either aggregation disabled or no 657 * suitable aggregation packet found 658 */ 659 if (!forw_packet_aggr) { 660 /* the following section can run without the lock */ 661 spin_unlock_bh(&bat_priv->forw_bat_list_lock); 662 663 /* if we could not aggregate this packet with one of the others 664 * we hold it back for a while, so that it might be aggregated 665 * later on 666 */ 667 if (!own_packet && atomic_read(&bat_priv->aggregated_ogms)) 668 send_time += max_aggregation_jiffies; 669 670 batadv_iv_ogm_aggregate_new(packet_buff, packet_len, 671 send_time, direct_link, 672 if_incoming, if_outgoing, 673 own_packet); 674 } else { 675 batadv_iv_ogm_aggregate(forw_packet_aggr, packet_buff, 676 packet_len, direct_link); 677 spin_unlock_bh(&bat_priv->forw_bat_list_lock); 678 } 679} 680 681static void batadv_iv_ogm_forward(struct batadv_orig_node *orig_node, 682 const struct ethhdr *ethhdr, 683 struct batadv_ogm_packet *batadv_ogm_packet, 684 bool is_single_hop_neigh, 685 bool is_from_best_next_hop, 686 struct batadv_hard_iface *if_incoming, 687 struct batadv_hard_iface *if_outgoing) 688{ 689 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 690 u16 tvlv_len; 691 692 if (batadv_ogm_packet->ttl <= 1) { 693 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, "ttl exceeded\n"); 694 return; 695 } 696 697 if (!is_from_best_next_hop) { 698 /* Mark the forwarded packet when it is not coming from our 699 * best next hop. We still need to forward the packet for our 700 * neighbor link quality detection to work in case the packet 701 * originated from a single hop neighbor. Otherwise we can 702 * simply drop the ogm. 703 */ 704 if (is_single_hop_neigh) 705 batadv_ogm_packet->flags |= BATADV_NOT_BEST_NEXT_HOP; 706 else 707 return; 708 } 709 710 tvlv_len = ntohs(batadv_ogm_packet->tvlv_len); 711 712 batadv_ogm_packet->ttl--; 713 ether_addr_copy(batadv_ogm_packet->prev_sender, ethhdr->h_source); 714 715 /* apply hop penalty */ 716 batadv_ogm_packet->tq = batadv_hop_penalty(batadv_ogm_packet->tq, 717 bat_priv); 718 719 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 720 "Forwarding packet: tq: %i, ttl: %i\n", 721 batadv_ogm_packet->tq, batadv_ogm_packet->ttl); 722 723 if (is_single_hop_neigh) 724 batadv_ogm_packet->flags |= BATADV_DIRECTLINK; 725 else 726 batadv_ogm_packet->flags &= ~BATADV_DIRECTLINK; 727 728 batadv_iv_ogm_queue_add(bat_priv, (unsigned char *)batadv_ogm_packet, 729 BATADV_OGM_HLEN + tvlv_len, 730 if_incoming, if_outgoing, 0, 731 batadv_iv_ogm_fwd_send_time()); 732} 733 734/** 735 * batadv_iv_ogm_slide_own_bcast_window() - bitshift own OGM broadcast windows 736 * for the given interface 737 * @hard_iface: the interface for which the windows have to be shifted 738 */ 739static void 740batadv_iv_ogm_slide_own_bcast_window(struct batadv_hard_iface *hard_iface) 741{ 742 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 743 struct batadv_hashtable *hash = bat_priv->orig_hash; 744 struct hlist_head *head; 745 struct batadv_orig_node *orig_node; 746 struct batadv_orig_ifinfo *orig_ifinfo; 747 unsigned long *word; 748 u32 i; 749 u8 *w; 750 751 for (i = 0; i < hash->size; i++) { 752 head = &hash->table[i]; 753 754 rcu_read_lock(); 755 hlist_for_each_entry_rcu(orig_node, head, hash_entry) { 756 hlist_for_each_entry_rcu(orig_ifinfo, 757 &orig_node->ifinfo_list, 758 list) { 759 if (orig_ifinfo->if_outgoing != hard_iface) 760 continue; 761 762 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock); 763 word = orig_ifinfo->bat_iv.bcast_own; 764 batadv_bit_get_packet(bat_priv, word, 1, 0); 765 w = &orig_ifinfo->bat_iv.bcast_own_sum; 766 *w = bitmap_weight(word, 767 BATADV_TQ_LOCAL_WINDOW_SIZE); 768 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock); 769 } 770 } 771 rcu_read_unlock(); 772 } 773} 774 775/** 776 * batadv_iv_ogm_schedule_buff() - schedule submission of hardif ogm buffer 777 * @hard_iface: interface whose ogm buffer should be transmitted 778 */ 779static void batadv_iv_ogm_schedule_buff(struct batadv_hard_iface *hard_iface) 780{ 781 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 782 unsigned char **ogm_buff = &hard_iface->bat_iv.ogm_buff; 783 struct batadv_ogm_packet *batadv_ogm_packet; 784 struct batadv_hard_iface *primary_if, *tmp_hard_iface; 785 int *ogm_buff_len = &hard_iface->bat_iv.ogm_buff_len; 786 u32 seqno; 787 u16 tvlv_len = 0; 788 unsigned long send_time; 789 790 lockdep_assert_held(&hard_iface->bat_iv.ogm_buff_mutex); 791 792 /* interface already disabled by batadv_iv_ogm_iface_disable */ 793 if (!*ogm_buff) 794 return; 795 796 /* the interface gets activated here to avoid race conditions between 797 * the moment of activating the interface in 798 * hardif_activate_interface() where the originator mac is set and 799 * outdated packets (especially uninitialized mac addresses) in the 800 * packet queue 801 */ 802 if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED) 803 hard_iface->if_status = BATADV_IF_ACTIVE; 804 805 primary_if = batadv_primary_if_get_selected(bat_priv); 806 807 if (hard_iface == primary_if) { 808 /* tt changes have to be committed before the tvlv data is 809 * appended as it may alter the tt tvlv container 810 */ 811 batadv_tt_local_commit_changes(bat_priv); 812 tvlv_len = batadv_tvlv_container_ogm_append(bat_priv, ogm_buff, 813 ogm_buff_len, 814 BATADV_OGM_HLEN); 815 } 816 817 batadv_ogm_packet = (struct batadv_ogm_packet *)(*ogm_buff); 818 batadv_ogm_packet->tvlv_len = htons(tvlv_len); 819 820 /* change sequence number to network order */ 821 seqno = (u32)atomic_read(&hard_iface->bat_iv.ogm_seqno); 822 batadv_ogm_packet->seqno = htonl(seqno); 823 atomic_inc(&hard_iface->bat_iv.ogm_seqno); 824 825 batadv_iv_ogm_slide_own_bcast_window(hard_iface); 826 827 send_time = batadv_iv_ogm_emit_send_time(bat_priv); 828 829 if (hard_iface != primary_if) { 830 /* OGMs from secondary interfaces are only scheduled on their 831 * respective interfaces. 832 */ 833 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff, *ogm_buff_len, 834 hard_iface, hard_iface, 1, send_time); 835 goto out; 836 } 837 838 /* OGMs from primary interfaces are scheduled on all 839 * interfaces. 840 */ 841 rcu_read_lock(); 842 list_for_each_entry_rcu(tmp_hard_iface, &batadv_hardif_list, list) { 843 if (tmp_hard_iface->soft_iface != hard_iface->soft_iface) 844 continue; 845 846 if (!kref_get_unless_zero(&tmp_hard_iface->refcount)) 847 continue; 848 849 batadv_iv_ogm_queue_add(bat_priv, *ogm_buff, 850 *ogm_buff_len, hard_iface, 851 tmp_hard_iface, 1, send_time); 852 853 batadv_hardif_put(tmp_hard_iface); 854 } 855 rcu_read_unlock(); 856 857out: 858 batadv_hardif_put(primary_if); 859} 860 861static void batadv_iv_ogm_schedule(struct batadv_hard_iface *hard_iface) 862{ 863 if (hard_iface->if_status == BATADV_IF_NOT_IN_USE || 864 hard_iface->if_status == BATADV_IF_TO_BE_REMOVED) 865 return; 866 867 mutex_lock(&hard_iface->bat_iv.ogm_buff_mutex); 868 batadv_iv_ogm_schedule_buff(hard_iface); 869 mutex_unlock(&hard_iface->bat_iv.ogm_buff_mutex); 870} 871 872/** 873 * batadv_iv_orig_ifinfo_sum() - Get bcast_own sum for originator over interface 874 * @orig_node: originator which reproadcasted the OGMs directly 875 * @if_outgoing: interface which transmitted the original OGM and received the 876 * direct rebroadcast 877 * 878 * Return: Number of replied (rebroadcasted) OGMs which were transmitted by 879 * an originator and directly (without intermediate hop) received by a specific 880 * interface 881 */ 882static u8 batadv_iv_orig_ifinfo_sum(struct batadv_orig_node *orig_node, 883 struct batadv_hard_iface *if_outgoing) 884{ 885 struct batadv_orig_ifinfo *orig_ifinfo; 886 u8 sum; 887 888 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_outgoing); 889 if (!orig_ifinfo) 890 return 0; 891 892 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock); 893 sum = orig_ifinfo->bat_iv.bcast_own_sum; 894 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock); 895 896 batadv_orig_ifinfo_put(orig_ifinfo); 897 898 return sum; 899} 900 901/** 902 * batadv_iv_ogm_orig_update() - use OGM to update corresponding data in an 903 * originator 904 * @bat_priv: the bat priv with all the soft interface information 905 * @orig_node: the orig node who originally emitted the ogm packet 906 * @orig_ifinfo: ifinfo for the outgoing interface of the orig_node 907 * @ethhdr: Ethernet header of the OGM 908 * @batadv_ogm_packet: the ogm packet 909 * @if_incoming: interface where the packet was received 910 * @if_outgoing: interface for which the retransmission should be considered 911 * @dup_status: the duplicate status of this ogm packet. 912 */ 913static void 914batadv_iv_ogm_orig_update(struct batadv_priv *bat_priv, 915 struct batadv_orig_node *orig_node, 916 struct batadv_orig_ifinfo *orig_ifinfo, 917 const struct ethhdr *ethhdr, 918 const struct batadv_ogm_packet *batadv_ogm_packet, 919 struct batadv_hard_iface *if_incoming, 920 struct batadv_hard_iface *if_outgoing, 921 enum batadv_dup_status dup_status) 922{ 923 struct batadv_neigh_ifinfo *neigh_ifinfo = NULL; 924 struct batadv_neigh_ifinfo *router_ifinfo = NULL; 925 struct batadv_neigh_node *neigh_node = NULL; 926 struct batadv_neigh_node *tmp_neigh_node = NULL; 927 struct batadv_neigh_node *router = NULL; 928 u8 sum_orig, sum_neigh; 929 u8 *neigh_addr; 930 u8 tq_avg; 931 932 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 933 "%s(): Searching and updating originator entry of received packet\n", 934 __func__); 935 936 rcu_read_lock(); 937 hlist_for_each_entry_rcu(tmp_neigh_node, 938 &orig_node->neigh_list, list) { 939 neigh_addr = tmp_neigh_node->addr; 940 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) && 941 tmp_neigh_node->if_incoming == if_incoming && 942 kref_get_unless_zero(&tmp_neigh_node->refcount)) { 943 if (WARN(neigh_node, "too many matching neigh_nodes")) 944 batadv_neigh_node_put(neigh_node); 945 neigh_node = tmp_neigh_node; 946 continue; 947 } 948 949 if (dup_status != BATADV_NO_DUP) 950 continue; 951 952 /* only update the entry for this outgoing interface */ 953 neigh_ifinfo = batadv_neigh_ifinfo_get(tmp_neigh_node, 954 if_outgoing); 955 if (!neigh_ifinfo) 956 continue; 957 958 spin_lock_bh(&tmp_neigh_node->ifinfo_lock); 959 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv, 960 &neigh_ifinfo->bat_iv.tq_index, 0); 961 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv); 962 neigh_ifinfo->bat_iv.tq_avg = tq_avg; 963 spin_unlock_bh(&tmp_neigh_node->ifinfo_lock); 964 965 batadv_neigh_ifinfo_put(neigh_ifinfo); 966 neigh_ifinfo = NULL; 967 } 968 969 if (!neigh_node) { 970 struct batadv_orig_node *orig_tmp; 971 972 orig_tmp = batadv_iv_ogm_orig_get(bat_priv, ethhdr->h_source); 973 if (!orig_tmp) 974 goto unlock; 975 976 neigh_node = batadv_iv_ogm_neigh_new(if_incoming, 977 ethhdr->h_source, 978 orig_node, orig_tmp); 979 980 batadv_orig_node_put(orig_tmp); 981 if (!neigh_node) 982 goto unlock; 983 } else { 984 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 985 "Updating existing last-hop neighbor of originator\n"); 986 } 987 988 rcu_read_unlock(); 989 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing); 990 if (!neigh_ifinfo) 991 goto out; 992 993 neigh_node->last_seen = jiffies; 994 995 spin_lock_bh(&neigh_node->ifinfo_lock); 996 batadv_ring_buffer_set(neigh_ifinfo->bat_iv.tq_recv, 997 &neigh_ifinfo->bat_iv.tq_index, 998 batadv_ogm_packet->tq); 999 tq_avg = batadv_ring_buffer_avg(neigh_ifinfo->bat_iv.tq_recv); 1000 neigh_ifinfo->bat_iv.tq_avg = tq_avg; 1001 spin_unlock_bh(&neigh_node->ifinfo_lock); 1002 1003 if (dup_status == BATADV_NO_DUP) { 1004 orig_ifinfo->last_ttl = batadv_ogm_packet->ttl; 1005 neigh_ifinfo->last_ttl = batadv_ogm_packet->ttl; 1006 } 1007 1008 /* if this neighbor already is our next hop there is nothing 1009 * to change 1010 */ 1011 router = batadv_orig_router_get(orig_node, if_outgoing); 1012 if (router == neigh_node) 1013 goto out; 1014 1015 if (router) { 1016 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing); 1017 if (!router_ifinfo) 1018 goto out; 1019 1020 /* if this neighbor does not offer a better TQ we won't 1021 * consider it 1022 */ 1023 if (router_ifinfo->bat_iv.tq_avg > neigh_ifinfo->bat_iv.tq_avg) 1024 goto out; 1025 } 1026 1027 /* if the TQ is the same and the link not more symmetric we 1028 * won't consider it either 1029 */ 1030 if (router_ifinfo && 1031 neigh_ifinfo->bat_iv.tq_avg == router_ifinfo->bat_iv.tq_avg) { 1032 sum_orig = batadv_iv_orig_ifinfo_sum(router->orig_node, 1033 router->if_incoming); 1034 sum_neigh = batadv_iv_orig_ifinfo_sum(neigh_node->orig_node, 1035 neigh_node->if_incoming); 1036 if (sum_orig >= sum_neigh) 1037 goto out; 1038 } 1039 1040 batadv_update_route(bat_priv, orig_node, if_outgoing, neigh_node); 1041 goto out; 1042 1043unlock: 1044 rcu_read_unlock(); 1045out: 1046 batadv_neigh_node_put(neigh_node); 1047 batadv_neigh_node_put(router); 1048 batadv_neigh_ifinfo_put(neigh_ifinfo); 1049 batadv_neigh_ifinfo_put(router_ifinfo); 1050} 1051 1052/** 1053 * batadv_iv_ogm_calc_tq() - calculate tq for current received ogm packet 1054 * @orig_node: the orig node who originally emitted the ogm packet 1055 * @orig_neigh_node: the orig node struct of the neighbor who sent the packet 1056 * @batadv_ogm_packet: the ogm packet 1057 * @if_incoming: interface where the packet was received 1058 * @if_outgoing: interface for which the retransmission should be considered 1059 * 1060 * Return: true if the link can be considered bidirectional, false otherwise 1061 */ 1062static bool batadv_iv_ogm_calc_tq(struct batadv_orig_node *orig_node, 1063 struct batadv_orig_node *orig_neigh_node, 1064 struct batadv_ogm_packet *batadv_ogm_packet, 1065 struct batadv_hard_iface *if_incoming, 1066 struct batadv_hard_iface *if_outgoing) 1067{ 1068 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 1069 struct batadv_neigh_node *neigh_node = NULL, *tmp_neigh_node; 1070 struct batadv_neigh_ifinfo *neigh_ifinfo; 1071 u8 total_count; 1072 u8 orig_eq_count, neigh_rq_count, neigh_rq_inv, tq_own; 1073 unsigned int tq_iface_hop_penalty = BATADV_TQ_MAX_VALUE; 1074 unsigned int neigh_rq_inv_cube, neigh_rq_max_cube; 1075 unsigned int tq_asym_penalty, inv_asym_penalty; 1076 unsigned int combined_tq; 1077 bool ret = false; 1078 1079 /* find corresponding one hop neighbor */ 1080 rcu_read_lock(); 1081 hlist_for_each_entry_rcu(tmp_neigh_node, 1082 &orig_neigh_node->neigh_list, list) { 1083 if (!batadv_compare_eth(tmp_neigh_node->addr, 1084 orig_neigh_node->orig)) 1085 continue; 1086 1087 if (tmp_neigh_node->if_incoming != if_incoming) 1088 continue; 1089 1090 if (!kref_get_unless_zero(&tmp_neigh_node->refcount)) 1091 continue; 1092 1093 neigh_node = tmp_neigh_node; 1094 break; 1095 } 1096 rcu_read_unlock(); 1097 1098 if (!neigh_node) 1099 neigh_node = batadv_iv_ogm_neigh_new(if_incoming, 1100 orig_neigh_node->orig, 1101 orig_neigh_node, 1102 orig_neigh_node); 1103 1104 if (!neigh_node) 1105 goto out; 1106 1107 /* if orig_node is direct neighbor update neigh_node last_seen */ 1108 if (orig_node == orig_neigh_node) 1109 neigh_node->last_seen = jiffies; 1110 1111 orig_node->last_seen = jiffies; 1112 1113 /* find packet count of corresponding one hop neighbor */ 1114 orig_eq_count = batadv_iv_orig_ifinfo_sum(orig_neigh_node, if_incoming); 1115 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, if_outgoing); 1116 if (neigh_ifinfo) { 1117 neigh_rq_count = neigh_ifinfo->bat_iv.real_packet_count; 1118 batadv_neigh_ifinfo_put(neigh_ifinfo); 1119 } else { 1120 neigh_rq_count = 0; 1121 } 1122 1123 /* pay attention to not get a value bigger than 100 % */ 1124 if (orig_eq_count > neigh_rq_count) 1125 total_count = neigh_rq_count; 1126 else 1127 total_count = orig_eq_count; 1128 1129 /* if we have too few packets (too less data) we set tq_own to zero 1130 * if we receive too few packets it is not considered bidirectional 1131 */ 1132 if (total_count < BATADV_TQ_LOCAL_BIDRECT_SEND_MINIMUM || 1133 neigh_rq_count < BATADV_TQ_LOCAL_BIDRECT_RECV_MINIMUM) 1134 tq_own = 0; 1135 else 1136 /* neigh_node->real_packet_count is never zero as we 1137 * only purge old information when getting new 1138 * information 1139 */ 1140 tq_own = (BATADV_TQ_MAX_VALUE * total_count) / neigh_rq_count; 1141 1142 /* 1 - ((1-x) ** 3), normalized to TQ_MAX_VALUE this does 1143 * affect the nearly-symmetric links only a little, but 1144 * punishes asymmetric links more. This will give a value 1145 * between 0 and TQ_MAX_VALUE 1146 */ 1147 neigh_rq_inv = BATADV_TQ_LOCAL_WINDOW_SIZE - neigh_rq_count; 1148 neigh_rq_inv_cube = neigh_rq_inv * neigh_rq_inv * neigh_rq_inv; 1149 neigh_rq_max_cube = BATADV_TQ_LOCAL_WINDOW_SIZE * 1150 BATADV_TQ_LOCAL_WINDOW_SIZE * 1151 BATADV_TQ_LOCAL_WINDOW_SIZE; 1152 inv_asym_penalty = BATADV_TQ_MAX_VALUE * neigh_rq_inv_cube; 1153 inv_asym_penalty /= neigh_rq_max_cube; 1154 tq_asym_penalty = BATADV_TQ_MAX_VALUE - inv_asym_penalty; 1155 tq_iface_hop_penalty -= atomic_read(&if_incoming->hop_penalty); 1156 1157 /* penalize if the OGM is forwarded on the same interface. WiFi 1158 * interfaces and other half duplex devices suffer from throughput 1159 * drops as they can't send and receive at the same time. 1160 */ 1161 if (if_outgoing && if_incoming == if_outgoing && 1162 batadv_is_wifi_hardif(if_outgoing)) 1163 tq_iface_hop_penalty = batadv_hop_penalty(tq_iface_hop_penalty, 1164 bat_priv); 1165 1166 combined_tq = batadv_ogm_packet->tq * 1167 tq_own * 1168 tq_asym_penalty * 1169 tq_iface_hop_penalty; 1170 combined_tq /= BATADV_TQ_MAX_VALUE * 1171 BATADV_TQ_MAX_VALUE * 1172 BATADV_TQ_MAX_VALUE; 1173 batadv_ogm_packet->tq = combined_tq; 1174 1175 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1176 "bidirectional: orig = %pM neigh = %pM => own_bcast = %2i, real recv = %2i, local tq: %3i, asym_penalty: %3i, iface_hop_penalty: %3i, total tq: %3i, if_incoming = %s, if_outgoing = %s\n", 1177 orig_node->orig, orig_neigh_node->orig, total_count, 1178 neigh_rq_count, tq_own, tq_asym_penalty, 1179 tq_iface_hop_penalty, batadv_ogm_packet->tq, 1180 if_incoming->net_dev->name, 1181 if_outgoing ? if_outgoing->net_dev->name : "DEFAULT"); 1182 1183 /* if link has the minimum required transmission quality 1184 * consider it bidirectional 1185 */ 1186 if (batadv_ogm_packet->tq >= BATADV_TQ_TOTAL_BIDRECT_LIMIT) 1187 ret = true; 1188 1189out: 1190 batadv_neigh_node_put(neigh_node); 1191 return ret; 1192} 1193 1194/** 1195 * batadv_iv_ogm_update_seqnos() - process a batman packet for all interfaces, 1196 * adjust the sequence number and find out whether it is a duplicate 1197 * @ethhdr: ethernet header of the packet 1198 * @batadv_ogm_packet: OGM packet to be considered 1199 * @if_incoming: interface on which the OGM packet was received 1200 * @if_outgoing: interface for which the retransmission should be considered 1201 * 1202 * Return: duplicate status as enum batadv_dup_status 1203 */ 1204static enum batadv_dup_status 1205batadv_iv_ogm_update_seqnos(const struct ethhdr *ethhdr, 1206 const struct batadv_ogm_packet *batadv_ogm_packet, 1207 const struct batadv_hard_iface *if_incoming, 1208 struct batadv_hard_iface *if_outgoing) 1209{ 1210 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 1211 struct batadv_orig_node *orig_node; 1212 struct batadv_orig_ifinfo *orig_ifinfo = NULL; 1213 struct batadv_neigh_node *neigh_node; 1214 struct batadv_neigh_ifinfo *neigh_ifinfo; 1215 bool is_dup; 1216 s32 seq_diff; 1217 bool need_update = false; 1218 int set_mark; 1219 enum batadv_dup_status ret = BATADV_NO_DUP; 1220 u32 seqno = ntohl(batadv_ogm_packet->seqno); 1221 u8 *neigh_addr; 1222 u8 packet_count; 1223 unsigned long *bitmap; 1224 1225 orig_node = batadv_iv_ogm_orig_get(bat_priv, batadv_ogm_packet->orig); 1226 if (!orig_node) 1227 return BATADV_NO_DUP; 1228 1229 orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing); 1230 if (WARN_ON(!orig_ifinfo)) { 1231 batadv_orig_node_put(orig_node); 1232 return 0; 1233 } 1234 1235 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock); 1236 seq_diff = seqno - orig_ifinfo->last_real_seqno; 1237 1238 /* signalize caller that the packet is to be dropped. */ 1239 if (!hlist_empty(&orig_node->neigh_list) && 1240 batadv_window_protected(bat_priv, seq_diff, 1241 BATADV_TQ_LOCAL_WINDOW_SIZE, 1242 &orig_ifinfo->batman_seqno_reset, NULL)) { 1243 ret = BATADV_PROTECTED; 1244 goto out; 1245 } 1246 1247 rcu_read_lock(); 1248 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) { 1249 neigh_ifinfo = batadv_neigh_ifinfo_new(neigh_node, 1250 if_outgoing); 1251 if (!neigh_ifinfo) 1252 continue; 1253 1254 neigh_addr = neigh_node->addr; 1255 is_dup = batadv_test_bit(neigh_ifinfo->bat_iv.real_bits, 1256 orig_ifinfo->last_real_seqno, 1257 seqno); 1258 1259 if (batadv_compare_eth(neigh_addr, ethhdr->h_source) && 1260 neigh_node->if_incoming == if_incoming) { 1261 set_mark = 1; 1262 if (is_dup) 1263 ret = BATADV_NEIGH_DUP; 1264 } else { 1265 set_mark = 0; 1266 if (is_dup && ret != BATADV_NEIGH_DUP) 1267 ret = BATADV_ORIG_DUP; 1268 } 1269 1270 /* if the window moved, set the update flag. */ 1271 bitmap = neigh_ifinfo->bat_iv.real_bits; 1272 need_update |= batadv_bit_get_packet(bat_priv, bitmap, 1273 seq_diff, set_mark); 1274 1275 packet_count = bitmap_weight(bitmap, 1276 BATADV_TQ_LOCAL_WINDOW_SIZE); 1277 neigh_ifinfo->bat_iv.real_packet_count = packet_count; 1278 batadv_neigh_ifinfo_put(neigh_ifinfo); 1279 } 1280 rcu_read_unlock(); 1281 1282 if (need_update) { 1283 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1284 "%s updating last_seqno: old %u, new %u\n", 1285 if_outgoing ? if_outgoing->net_dev->name : "DEFAULT", 1286 orig_ifinfo->last_real_seqno, seqno); 1287 orig_ifinfo->last_real_seqno = seqno; 1288 } 1289 1290out: 1291 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock); 1292 batadv_orig_node_put(orig_node); 1293 batadv_orig_ifinfo_put(orig_ifinfo); 1294 return ret; 1295} 1296 1297/** 1298 * batadv_iv_ogm_process_per_outif() - process a batman iv OGM for an outgoing 1299 * interface 1300 * @skb: the skb containing the OGM 1301 * @ogm_offset: offset from skb->data to start of ogm header 1302 * @orig_node: the (cached) orig node for the originator of this OGM 1303 * @if_incoming: the interface where this packet was received 1304 * @if_outgoing: the interface for which the packet should be considered 1305 */ 1306static void 1307batadv_iv_ogm_process_per_outif(const struct sk_buff *skb, int ogm_offset, 1308 struct batadv_orig_node *orig_node, 1309 struct batadv_hard_iface *if_incoming, 1310 struct batadv_hard_iface *if_outgoing) 1311{ 1312 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 1313 struct batadv_hardif_neigh_node *hardif_neigh = NULL; 1314 struct batadv_neigh_node *router = NULL; 1315 struct batadv_neigh_node *router_router = NULL; 1316 struct batadv_orig_node *orig_neigh_node; 1317 struct batadv_orig_ifinfo *orig_ifinfo; 1318 struct batadv_neigh_node *orig_neigh_router = NULL; 1319 struct batadv_neigh_ifinfo *router_ifinfo = NULL; 1320 struct batadv_ogm_packet *ogm_packet; 1321 enum batadv_dup_status dup_status; 1322 bool is_from_best_next_hop = false; 1323 bool is_single_hop_neigh = false; 1324 bool sameseq, similar_ttl; 1325 struct sk_buff *skb_priv; 1326 struct ethhdr *ethhdr; 1327 u8 *prev_sender; 1328 bool is_bidirect; 1329 1330 /* create a private copy of the skb, as some functions change tq value 1331 * and/or flags. 1332 */ 1333 skb_priv = skb_copy(skb, GFP_ATOMIC); 1334 if (!skb_priv) 1335 return; 1336 1337 ethhdr = eth_hdr(skb_priv); 1338 ogm_packet = (struct batadv_ogm_packet *)(skb_priv->data + ogm_offset); 1339 1340 dup_status = batadv_iv_ogm_update_seqnos(ethhdr, ogm_packet, 1341 if_incoming, if_outgoing); 1342 if (batadv_compare_eth(ethhdr->h_source, ogm_packet->orig)) 1343 is_single_hop_neigh = true; 1344 1345 if (dup_status == BATADV_PROTECTED) { 1346 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1347 "Drop packet: packet within seqno protection time (sender: %pM)\n", 1348 ethhdr->h_source); 1349 goto out; 1350 } 1351 1352 if (ogm_packet->tq == 0) { 1353 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1354 "Drop packet: originator packet with tq equal 0\n"); 1355 goto out; 1356 } 1357 1358 if (is_single_hop_neigh) { 1359 hardif_neigh = batadv_hardif_neigh_get(if_incoming, 1360 ethhdr->h_source); 1361 if (hardif_neigh) 1362 hardif_neigh->last_seen = jiffies; 1363 } 1364 1365 router = batadv_orig_router_get(orig_node, if_outgoing); 1366 if (router) { 1367 router_router = batadv_orig_router_get(router->orig_node, 1368 if_outgoing); 1369 router_ifinfo = batadv_neigh_ifinfo_get(router, if_outgoing); 1370 } 1371 1372 if ((router_ifinfo && router_ifinfo->bat_iv.tq_avg != 0) && 1373 (batadv_compare_eth(router->addr, ethhdr->h_source))) 1374 is_from_best_next_hop = true; 1375 1376 prev_sender = ogm_packet->prev_sender; 1377 /* avoid temporary routing loops */ 1378 if (router && router_router && 1379 (batadv_compare_eth(router->addr, prev_sender)) && 1380 !(batadv_compare_eth(ogm_packet->orig, prev_sender)) && 1381 (batadv_compare_eth(router->addr, router_router->addr))) { 1382 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1383 "Drop packet: ignoring all rebroadcast packets that may make me loop (sender: %pM)\n", 1384 ethhdr->h_source); 1385 goto out; 1386 } 1387 1388 if (if_outgoing == BATADV_IF_DEFAULT) 1389 batadv_tvlv_ogm_receive(bat_priv, ogm_packet, orig_node); 1390 1391 /* if sender is a direct neighbor the sender mac equals 1392 * originator mac 1393 */ 1394 if (is_single_hop_neigh) 1395 orig_neigh_node = orig_node; 1396 else 1397 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv, 1398 ethhdr->h_source); 1399 1400 if (!orig_neigh_node) 1401 goto out; 1402 1403 /* Update nc_nodes of the originator */ 1404 batadv_nc_update_nc_node(bat_priv, orig_node, orig_neigh_node, 1405 ogm_packet, is_single_hop_neigh); 1406 1407 orig_neigh_router = batadv_orig_router_get(orig_neigh_node, 1408 if_outgoing); 1409 1410 /* drop packet if sender is not a direct neighbor and if we 1411 * don't route towards it 1412 */ 1413 if (!is_single_hop_neigh && !orig_neigh_router) { 1414 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1415 "Drop packet: OGM via unknown neighbor!\n"); 1416 goto out_neigh; 1417 } 1418 1419 is_bidirect = batadv_iv_ogm_calc_tq(orig_node, orig_neigh_node, 1420 ogm_packet, if_incoming, 1421 if_outgoing); 1422 1423 /* update ranking if it is not a duplicate or has the same 1424 * seqno and similar ttl as the non-duplicate 1425 */ 1426 orig_ifinfo = batadv_orig_ifinfo_new(orig_node, if_outgoing); 1427 if (!orig_ifinfo) 1428 goto out_neigh; 1429 1430 sameseq = orig_ifinfo->last_real_seqno == ntohl(ogm_packet->seqno); 1431 similar_ttl = (orig_ifinfo->last_ttl - 3) <= ogm_packet->ttl; 1432 1433 if (is_bidirect && (dup_status == BATADV_NO_DUP || 1434 (sameseq && similar_ttl))) { 1435 batadv_iv_ogm_orig_update(bat_priv, orig_node, 1436 orig_ifinfo, ethhdr, 1437 ogm_packet, if_incoming, 1438 if_outgoing, dup_status); 1439 } 1440 batadv_orig_ifinfo_put(orig_ifinfo); 1441 1442 /* only forward for specific interface, not for the default one. */ 1443 if (if_outgoing == BATADV_IF_DEFAULT) 1444 goto out_neigh; 1445 1446 /* is single hop (direct) neighbor */ 1447 if (is_single_hop_neigh) { 1448 /* OGMs from secondary interfaces should only scheduled once 1449 * per interface where it has been received, not multiple times 1450 */ 1451 if (ogm_packet->ttl <= 2 && 1452 if_incoming != if_outgoing) { 1453 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1454 "Drop packet: OGM from secondary interface and wrong outgoing interface\n"); 1455 goto out_neigh; 1456 } 1457 /* mark direct link on incoming interface */ 1458 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet, 1459 is_single_hop_neigh, 1460 is_from_best_next_hop, if_incoming, 1461 if_outgoing); 1462 1463 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1464 "Forwarding packet: rebroadcast neighbor packet with direct link flag\n"); 1465 goto out_neigh; 1466 } 1467 1468 /* multihop originator */ 1469 if (!is_bidirect) { 1470 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1471 "Drop packet: not received via bidirectional link\n"); 1472 goto out_neigh; 1473 } 1474 1475 if (dup_status == BATADV_NEIGH_DUP) { 1476 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1477 "Drop packet: duplicate packet received\n"); 1478 goto out_neigh; 1479 } 1480 1481 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1482 "Forwarding packet: rebroadcast originator packet\n"); 1483 batadv_iv_ogm_forward(orig_node, ethhdr, ogm_packet, 1484 is_single_hop_neigh, is_from_best_next_hop, 1485 if_incoming, if_outgoing); 1486 1487out_neigh: 1488 if (orig_neigh_node && !is_single_hop_neigh) 1489 batadv_orig_node_put(orig_neigh_node); 1490out: 1491 batadv_neigh_ifinfo_put(router_ifinfo); 1492 batadv_neigh_node_put(router); 1493 batadv_neigh_node_put(router_router); 1494 batadv_neigh_node_put(orig_neigh_router); 1495 batadv_hardif_neigh_put(hardif_neigh); 1496 1497 consume_skb(skb_priv); 1498} 1499 1500/** 1501 * batadv_iv_ogm_process_reply() - Check OGM for direct reply and process it 1502 * @ogm_packet: rebroadcast OGM packet to process 1503 * @if_incoming: the interface where this packet was received 1504 * @orig_node: originator which reproadcasted the OGMs 1505 * @if_incoming_seqno: OGM sequence number when rebroadcast was received 1506 */ 1507static void batadv_iv_ogm_process_reply(struct batadv_ogm_packet *ogm_packet, 1508 struct batadv_hard_iface *if_incoming, 1509 struct batadv_orig_node *orig_node, 1510 u32 if_incoming_seqno) 1511{ 1512 struct batadv_orig_ifinfo *orig_ifinfo; 1513 s32 bit_pos; 1514 u8 *weight; 1515 1516 /* neighbor has to indicate direct link and it has to 1517 * come via the corresponding interface 1518 */ 1519 if (!(ogm_packet->flags & BATADV_DIRECTLINK)) 1520 return; 1521 1522 if (!batadv_compare_eth(if_incoming->net_dev->dev_addr, 1523 ogm_packet->orig)) 1524 return; 1525 1526 orig_ifinfo = batadv_orig_ifinfo_get(orig_node, if_incoming); 1527 if (!orig_ifinfo) 1528 return; 1529 1530 /* save packet seqno for bidirectional check */ 1531 spin_lock_bh(&orig_node->bat_iv.ogm_cnt_lock); 1532 bit_pos = if_incoming_seqno - 2; 1533 bit_pos -= ntohl(ogm_packet->seqno); 1534 batadv_set_bit(orig_ifinfo->bat_iv.bcast_own, bit_pos); 1535 weight = &orig_ifinfo->bat_iv.bcast_own_sum; 1536 *weight = bitmap_weight(orig_ifinfo->bat_iv.bcast_own, 1537 BATADV_TQ_LOCAL_WINDOW_SIZE); 1538 spin_unlock_bh(&orig_node->bat_iv.ogm_cnt_lock); 1539 1540 batadv_orig_ifinfo_put(orig_ifinfo); 1541} 1542 1543/** 1544 * batadv_iv_ogm_process() - process an incoming batman iv OGM 1545 * @skb: the skb containing the OGM 1546 * @ogm_offset: offset to the OGM which should be processed (for aggregates) 1547 * @if_incoming: the interface where this packet was received 1548 */ 1549static void batadv_iv_ogm_process(const struct sk_buff *skb, int ogm_offset, 1550 struct batadv_hard_iface *if_incoming) 1551{ 1552 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 1553 struct batadv_orig_node *orig_neigh_node, *orig_node; 1554 struct batadv_hard_iface *hard_iface; 1555 struct batadv_ogm_packet *ogm_packet; 1556 u32 if_incoming_seqno; 1557 bool has_directlink_flag; 1558 struct ethhdr *ethhdr; 1559 bool is_my_oldorig = false; 1560 bool is_my_addr = false; 1561 bool is_my_orig = false; 1562 1563 ogm_packet = (struct batadv_ogm_packet *)(skb->data + ogm_offset); 1564 ethhdr = eth_hdr(skb); 1565 1566 /* Silently drop when the batman packet is actually not a 1567 * correct packet. 1568 * 1569 * This might happen if a packet is padded (e.g. Ethernet has a 1570 * minimum frame length of 64 byte) and the aggregation interprets 1571 * it as an additional length. 1572 * 1573 * TODO: A more sane solution would be to have a bit in the 1574 * batadv_ogm_packet to detect whether the packet is the last 1575 * packet in an aggregation. Here we expect that the padding 1576 * is always zero (or not 0x01) 1577 */ 1578 if (ogm_packet->packet_type != BATADV_IV_OGM) 1579 return; 1580 1581 /* could be changed by schedule_own_packet() */ 1582 if_incoming_seqno = atomic_read(&if_incoming->bat_iv.ogm_seqno); 1583 1584 if (ogm_packet->flags & BATADV_DIRECTLINK) 1585 has_directlink_flag = true; 1586 else 1587 has_directlink_flag = false; 1588 1589 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1590 "Received BATMAN packet via NB: %pM, IF: %s [%pM] (from OG: %pM, via prev OG: %pM, seqno %u, tq %d, TTL %d, V %d, IDF %d)\n", 1591 ethhdr->h_source, if_incoming->net_dev->name, 1592 if_incoming->net_dev->dev_addr, ogm_packet->orig, 1593 ogm_packet->prev_sender, ntohl(ogm_packet->seqno), 1594 ogm_packet->tq, ogm_packet->ttl, 1595 ogm_packet->version, has_directlink_flag); 1596 1597 rcu_read_lock(); 1598 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 1599 if (hard_iface->if_status != BATADV_IF_ACTIVE) 1600 continue; 1601 1602 if (hard_iface->soft_iface != if_incoming->soft_iface) 1603 continue; 1604 1605 if (batadv_compare_eth(ethhdr->h_source, 1606 hard_iface->net_dev->dev_addr)) 1607 is_my_addr = true; 1608 1609 if (batadv_compare_eth(ogm_packet->orig, 1610 hard_iface->net_dev->dev_addr)) 1611 is_my_orig = true; 1612 1613 if (batadv_compare_eth(ogm_packet->prev_sender, 1614 hard_iface->net_dev->dev_addr)) 1615 is_my_oldorig = true; 1616 } 1617 rcu_read_unlock(); 1618 1619 if (is_my_addr) { 1620 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1621 "Drop packet: received my own broadcast (sender: %pM)\n", 1622 ethhdr->h_source); 1623 return; 1624 } 1625 1626 if (is_my_orig) { 1627 orig_neigh_node = batadv_iv_ogm_orig_get(bat_priv, 1628 ethhdr->h_source); 1629 if (!orig_neigh_node) 1630 return; 1631 1632 batadv_iv_ogm_process_reply(ogm_packet, if_incoming, 1633 orig_neigh_node, if_incoming_seqno); 1634 1635 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1636 "Drop packet: originator packet from myself (via neighbor)\n"); 1637 batadv_orig_node_put(orig_neigh_node); 1638 return; 1639 } 1640 1641 if (is_my_oldorig) { 1642 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1643 "Drop packet: ignoring all rebroadcast echos (sender: %pM)\n", 1644 ethhdr->h_source); 1645 return; 1646 } 1647 1648 if (ogm_packet->flags & BATADV_NOT_BEST_NEXT_HOP) { 1649 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 1650 "Drop packet: ignoring all packets not forwarded from the best next hop (sender: %pM)\n", 1651 ethhdr->h_source); 1652 return; 1653 } 1654 1655 orig_node = batadv_iv_ogm_orig_get(bat_priv, ogm_packet->orig); 1656 if (!orig_node) 1657 return; 1658 1659 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node, 1660 if_incoming, BATADV_IF_DEFAULT); 1661 1662 rcu_read_lock(); 1663 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 1664 if (hard_iface->if_status != BATADV_IF_ACTIVE) 1665 continue; 1666 1667 if (hard_iface->soft_iface != bat_priv->soft_iface) 1668 continue; 1669 1670 if (!kref_get_unless_zero(&hard_iface->refcount)) 1671 continue; 1672 1673 batadv_iv_ogm_process_per_outif(skb, ogm_offset, orig_node, 1674 if_incoming, hard_iface); 1675 1676 batadv_hardif_put(hard_iface); 1677 } 1678 rcu_read_unlock(); 1679 1680 batadv_orig_node_put(orig_node); 1681} 1682 1683static void batadv_iv_send_outstanding_bat_ogm_packet(struct work_struct *work) 1684{ 1685 struct delayed_work *delayed_work; 1686 struct batadv_forw_packet *forw_packet; 1687 struct batadv_priv *bat_priv; 1688 bool dropped = false; 1689 1690 delayed_work = to_delayed_work(work); 1691 forw_packet = container_of(delayed_work, struct batadv_forw_packet, 1692 delayed_work); 1693 bat_priv = netdev_priv(forw_packet->if_incoming->soft_iface); 1694 1695 if (atomic_read(&bat_priv->mesh_state) == BATADV_MESH_DEACTIVATING) { 1696 dropped = true; 1697 goto out; 1698 } 1699 1700 batadv_iv_ogm_emit(forw_packet); 1701 1702 /* we have to have at least one packet in the queue to determine the 1703 * queues wake up time unless we are shutting down. 1704 * 1705 * only re-schedule if this is the "original" copy, e.g. the OGM of the 1706 * primary interface should only be rescheduled once per period, but 1707 * this function will be called for the forw_packet instances of the 1708 * other secondary interfaces as well. 1709 */ 1710 if (forw_packet->own && 1711 forw_packet->if_incoming == forw_packet->if_outgoing) 1712 batadv_iv_ogm_schedule(forw_packet->if_incoming); 1713 1714out: 1715 /* do we get something for free()? */ 1716 if (batadv_forw_packet_steal(forw_packet, 1717 &bat_priv->forw_bat_list_lock)) 1718 batadv_forw_packet_free(forw_packet, dropped); 1719} 1720 1721static int batadv_iv_ogm_receive(struct sk_buff *skb, 1722 struct batadv_hard_iface *if_incoming) 1723{ 1724 struct batadv_priv *bat_priv = netdev_priv(if_incoming->soft_iface); 1725 struct batadv_ogm_packet *ogm_packet; 1726 u8 *packet_pos; 1727 int ogm_offset; 1728 bool res; 1729 int ret = NET_RX_DROP; 1730 1731 res = batadv_check_management_packet(skb, if_incoming, BATADV_OGM_HLEN); 1732 if (!res) 1733 goto free_skb; 1734 1735 /* did we receive a B.A.T.M.A.N. IV OGM packet on an interface 1736 * that does not have B.A.T.M.A.N. IV enabled ? 1737 */ 1738 if (bat_priv->algo_ops->iface.enable != batadv_iv_ogm_iface_enable) 1739 goto free_skb; 1740 1741 batadv_inc_counter(bat_priv, BATADV_CNT_MGMT_RX); 1742 batadv_add_counter(bat_priv, BATADV_CNT_MGMT_RX_BYTES, 1743 skb->len + ETH_HLEN); 1744 1745 ogm_offset = 0; 1746 ogm_packet = (struct batadv_ogm_packet *)skb->data; 1747 1748 /* unpack the aggregated packets and process them one by one */ 1749 while (batadv_iv_ogm_aggr_packet(ogm_offset, skb_headlen(skb), 1750 ogm_packet)) { 1751 batadv_iv_ogm_process(skb, ogm_offset, if_incoming); 1752 1753 ogm_offset += BATADV_OGM_HLEN; 1754 ogm_offset += ntohs(ogm_packet->tvlv_len); 1755 1756 packet_pos = skb->data + ogm_offset; 1757 ogm_packet = (struct batadv_ogm_packet *)packet_pos; 1758 } 1759 1760 ret = NET_RX_SUCCESS; 1761 1762free_skb: 1763 if (ret == NET_RX_SUCCESS) 1764 consume_skb(skb); 1765 else 1766 kfree_skb(skb); 1767 1768 return ret; 1769} 1770 1771/** 1772 * batadv_iv_ogm_neigh_get_tq_avg() - Get the TQ average for a neighbour on a 1773 * given outgoing interface. 1774 * @neigh_node: Neighbour of interest 1775 * @if_outgoing: Outgoing interface of interest 1776 * @tq_avg: Pointer of where to store the TQ average 1777 * 1778 * Return: False if no average TQ available, otherwise true. 1779 */ 1780static bool 1781batadv_iv_ogm_neigh_get_tq_avg(struct batadv_neigh_node *neigh_node, 1782 struct batadv_hard_iface *if_outgoing, 1783 u8 *tq_avg) 1784{ 1785 struct batadv_neigh_ifinfo *n_ifinfo; 1786 1787 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing); 1788 if (!n_ifinfo) 1789 return false; 1790 1791 *tq_avg = n_ifinfo->bat_iv.tq_avg; 1792 batadv_neigh_ifinfo_put(n_ifinfo); 1793 1794 return true; 1795} 1796 1797/** 1798 * batadv_iv_ogm_orig_dump_subentry() - Dump an originator subentry into a 1799 * message 1800 * @msg: Netlink message to dump into 1801 * @portid: Port making netlink request 1802 * @seq: Sequence number of netlink message 1803 * @bat_priv: The bat priv with all the soft interface information 1804 * @if_outgoing: Limit dump to entries with this outgoing interface 1805 * @orig_node: Originator to dump 1806 * @neigh_node: Single hops neighbour 1807 * @best: Is the best originator 1808 * 1809 * Return: Error code, or 0 on success 1810 */ 1811static int 1812batadv_iv_ogm_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq, 1813 struct batadv_priv *bat_priv, 1814 struct batadv_hard_iface *if_outgoing, 1815 struct batadv_orig_node *orig_node, 1816 struct batadv_neigh_node *neigh_node, 1817 bool best) 1818{ 1819 void *hdr; 1820 u8 tq_avg; 1821 unsigned int last_seen_msecs; 1822 1823 last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen); 1824 1825 if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node, if_outgoing, &tq_avg)) 1826 return 0; 1827 1828 if (if_outgoing != BATADV_IF_DEFAULT && 1829 if_outgoing != neigh_node->if_incoming) 1830 return 0; 1831 1832 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, 1833 NLM_F_MULTI, BATADV_CMD_GET_ORIGINATORS); 1834 if (!hdr) 1835 return -ENOBUFS; 1836 1837 if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, 1838 orig_node->orig) || 1839 nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, 1840 neigh_node->addr) || 1841 nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, 1842 neigh_node->if_incoming->net_dev->name) || 1843 nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, 1844 neigh_node->if_incoming->net_dev->ifindex) || 1845 nla_put_u8(msg, BATADV_ATTR_TQ, tq_avg) || 1846 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, 1847 last_seen_msecs)) 1848 goto nla_put_failure; 1849 1850 if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) 1851 goto nla_put_failure; 1852 1853 genlmsg_end(msg, hdr); 1854 return 0; 1855 1856 nla_put_failure: 1857 genlmsg_cancel(msg, hdr); 1858 return -EMSGSIZE; 1859} 1860 1861/** 1862 * batadv_iv_ogm_orig_dump_entry() - Dump an originator entry into a message 1863 * @msg: Netlink message to dump into 1864 * @portid: Port making netlink request 1865 * @seq: Sequence number of netlink message 1866 * @bat_priv: The bat priv with all the soft interface information 1867 * @if_outgoing: Limit dump to entries with this outgoing interface 1868 * @orig_node: Originator to dump 1869 * @sub_s: Number of sub entries to skip 1870 * 1871 * This function assumes the caller holds rcu_read_lock(). 1872 * 1873 * Return: Error code, or 0 on success 1874 */ 1875static int 1876batadv_iv_ogm_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq, 1877 struct batadv_priv *bat_priv, 1878 struct batadv_hard_iface *if_outgoing, 1879 struct batadv_orig_node *orig_node, int *sub_s) 1880{ 1881 struct batadv_neigh_node *neigh_node_best; 1882 struct batadv_neigh_node *neigh_node; 1883 int sub = 0; 1884 bool best; 1885 u8 tq_avg_best; 1886 1887 neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing); 1888 if (!neigh_node_best) 1889 goto out; 1890 1891 if (!batadv_iv_ogm_neigh_get_tq_avg(neigh_node_best, if_outgoing, 1892 &tq_avg_best)) 1893 goto out; 1894 1895 if (tq_avg_best == 0) 1896 goto out; 1897 1898 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) { 1899 if (sub++ < *sub_s) 1900 continue; 1901 1902 best = (neigh_node == neigh_node_best); 1903 1904 if (batadv_iv_ogm_orig_dump_subentry(msg, portid, seq, 1905 bat_priv, if_outgoing, 1906 orig_node, neigh_node, 1907 best)) { 1908 batadv_neigh_node_put(neigh_node_best); 1909 1910 *sub_s = sub - 1; 1911 return -EMSGSIZE; 1912 } 1913 } 1914 1915 out: 1916 batadv_neigh_node_put(neigh_node_best); 1917 1918 *sub_s = 0; 1919 return 0; 1920} 1921 1922/** 1923 * batadv_iv_ogm_orig_dump_bucket() - Dump an originator bucket into a 1924 * message 1925 * @msg: Netlink message to dump into 1926 * @portid: Port making netlink request 1927 * @seq: Sequence number of netlink message 1928 * @bat_priv: The bat priv with all the soft interface information 1929 * @if_outgoing: Limit dump to entries with this outgoing interface 1930 * @head: Bucket to be dumped 1931 * @idx_s: Number of entries to be skipped 1932 * @sub: Number of sub entries to be skipped 1933 * 1934 * Return: Error code, or 0 on success 1935 */ 1936static int 1937batadv_iv_ogm_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq, 1938 struct batadv_priv *bat_priv, 1939 struct batadv_hard_iface *if_outgoing, 1940 struct hlist_head *head, int *idx_s, int *sub) 1941{ 1942 struct batadv_orig_node *orig_node; 1943 int idx = 0; 1944 1945 rcu_read_lock(); 1946 hlist_for_each_entry_rcu(orig_node, head, hash_entry) { 1947 if (idx++ < *idx_s) 1948 continue; 1949 1950 if (batadv_iv_ogm_orig_dump_entry(msg, portid, seq, bat_priv, 1951 if_outgoing, orig_node, 1952 sub)) { 1953 rcu_read_unlock(); 1954 *idx_s = idx - 1; 1955 return -EMSGSIZE; 1956 } 1957 } 1958 rcu_read_unlock(); 1959 1960 *idx_s = 0; 1961 *sub = 0; 1962 return 0; 1963} 1964 1965/** 1966 * batadv_iv_ogm_orig_dump() - Dump the originators into a message 1967 * @msg: Netlink message to dump into 1968 * @cb: Control block containing additional options 1969 * @bat_priv: The bat priv with all the soft interface information 1970 * @if_outgoing: Limit dump to entries with this outgoing interface 1971 */ 1972static void 1973batadv_iv_ogm_orig_dump(struct sk_buff *msg, struct netlink_callback *cb, 1974 struct batadv_priv *bat_priv, 1975 struct batadv_hard_iface *if_outgoing) 1976{ 1977 struct batadv_hashtable *hash = bat_priv->orig_hash; 1978 struct hlist_head *head; 1979 int bucket = cb->args[0]; 1980 int idx = cb->args[1]; 1981 int sub = cb->args[2]; 1982 int portid = NETLINK_CB(cb->skb).portid; 1983 1984 while (bucket < hash->size) { 1985 head = &hash->table[bucket]; 1986 1987 if (batadv_iv_ogm_orig_dump_bucket(msg, portid, 1988 cb->nlh->nlmsg_seq, 1989 bat_priv, if_outgoing, head, 1990 &idx, &sub)) 1991 break; 1992 1993 bucket++; 1994 } 1995 1996 cb->args[0] = bucket; 1997 cb->args[1] = idx; 1998 cb->args[2] = sub; 1999} 2000 2001/** 2002 * batadv_iv_ogm_neigh_diff() - calculate tq difference of two neighbors 2003 * @neigh1: the first neighbor object of the comparison 2004 * @if_outgoing1: outgoing interface for the first neighbor 2005 * @neigh2: the second neighbor object of the comparison 2006 * @if_outgoing2: outgoing interface for the second neighbor 2007 * @diff: pointer to integer receiving the calculated difference 2008 * 2009 * The content of *@diff is only valid when this function returns true. 2010 * It is less, equal to or greater than 0 if the metric via neigh1 is lower, 2011 * the same as or higher than the metric via neigh2 2012 * 2013 * Return: true when the difference could be calculated, false otherwise 2014 */ 2015static bool batadv_iv_ogm_neigh_diff(struct batadv_neigh_node *neigh1, 2016 struct batadv_hard_iface *if_outgoing1, 2017 struct batadv_neigh_node *neigh2, 2018 struct batadv_hard_iface *if_outgoing2, 2019 int *diff) 2020{ 2021 struct batadv_neigh_ifinfo *neigh1_ifinfo, *neigh2_ifinfo; 2022 u8 tq1, tq2; 2023 bool ret = true; 2024 2025 neigh1_ifinfo = batadv_neigh_ifinfo_get(neigh1, if_outgoing1); 2026 neigh2_ifinfo = batadv_neigh_ifinfo_get(neigh2, if_outgoing2); 2027 2028 if (!neigh1_ifinfo || !neigh2_ifinfo) { 2029 ret = false; 2030 goto out; 2031 } 2032 2033 tq1 = neigh1_ifinfo->bat_iv.tq_avg; 2034 tq2 = neigh2_ifinfo->bat_iv.tq_avg; 2035 *diff = (int)tq1 - (int)tq2; 2036 2037out: 2038 batadv_neigh_ifinfo_put(neigh1_ifinfo); 2039 batadv_neigh_ifinfo_put(neigh2_ifinfo); 2040 2041 return ret; 2042} 2043 2044/** 2045 * batadv_iv_ogm_neigh_dump_neigh() - Dump a neighbour into a netlink message 2046 * @msg: Netlink message to dump into 2047 * @portid: Port making netlink request 2048 * @seq: Sequence number of netlink message 2049 * @hardif_neigh: Neighbour to be dumped 2050 * 2051 * Return: Error code, or 0 on success 2052 */ 2053static int 2054batadv_iv_ogm_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq, 2055 struct batadv_hardif_neigh_node *hardif_neigh) 2056{ 2057 void *hdr; 2058 unsigned int last_seen_msecs; 2059 2060 last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen); 2061 2062 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, 2063 NLM_F_MULTI, BATADV_CMD_GET_NEIGHBORS); 2064 if (!hdr) 2065 return -ENOBUFS; 2066 2067 if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, 2068 hardif_neigh->addr) || 2069 nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, 2070 hardif_neigh->if_incoming->net_dev->name) || 2071 nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, 2072 hardif_neigh->if_incoming->net_dev->ifindex) || 2073 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, 2074 last_seen_msecs)) 2075 goto nla_put_failure; 2076 2077 genlmsg_end(msg, hdr); 2078 return 0; 2079 2080 nla_put_failure: 2081 genlmsg_cancel(msg, hdr); 2082 return -EMSGSIZE; 2083} 2084 2085/** 2086 * batadv_iv_ogm_neigh_dump_hardif() - Dump the neighbours of a hard interface 2087 * into a message 2088 * @msg: Netlink message to dump into 2089 * @portid: Port making netlink request 2090 * @seq: Sequence number of netlink message 2091 * @bat_priv: The bat priv with all the soft interface information 2092 * @hard_iface: Hard interface to dump the neighbours for 2093 * @idx_s: Number of entries to skip 2094 * 2095 * This function assumes the caller holds rcu_read_lock(). 2096 * 2097 * Return: Error code, or 0 on success 2098 */ 2099static int 2100batadv_iv_ogm_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq, 2101 struct batadv_priv *bat_priv, 2102 struct batadv_hard_iface *hard_iface, 2103 int *idx_s) 2104{ 2105 struct batadv_hardif_neigh_node *hardif_neigh; 2106 int idx = 0; 2107 2108 hlist_for_each_entry_rcu(hardif_neigh, 2109 &hard_iface->neigh_list, list) { 2110 if (idx++ < *idx_s) 2111 continue; 2112 2113 if (batadv_iv_ogm_neigh_dump_neigh(msg, portid, seq, 2114 hardif_neigh)) { 2115 *idx_s = idx - 1; 2116 return -EMSGSIZE; 2117 } 2118 } 2119 2120 *idx_s = 0; 2121 return 0; 2122} 2123 2124/** 2125 * batadv_iv_ogm_neigh_dump() - Dump the neighbours into a message 2126 * @msg: Netlink message to dump into 2127 * @cb: Control block containing additional options 2128 * @bat_priv: The bat priv with all the soft interface information 2129 * @single_hardif: Limit dump to this hard interface 2130 */ 2131static void 2132batadv_iv_ogm_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb, 2133 struct batadv_priv *bat_priv, 2134 struct batadv_hard_iface *single_hardif) 2135{ 2136 struct batadv_hard_iface *hard_iface; 2137 int i_hardif = 0; 2138 int i_hardif_s = cb->args[0]; 2139 int idx = cb->args[1]; 2140 int portid = NETLINK_CB(cb->skb).portid; 2141 2142 rcu_read_lock(); 2143 if (single_hardif) { 2144 if (i_hardif_s == 0) { 2145 if (batadv_iv_ogm_neigh_dump_hardif(msg, portid, 2146 cb->nlh->nlmsg_seq, 2147 bat_priv, 2148 single_hardif, 2149 &idx) == 0) 2150 i_hardif++; 2151 } 2152 } else { 2153 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, 2154 list) { 2155 if (hard_iface->soft_iface != bat_priv->soft_iface) 2156 continue; 2157 2158 if (i_hardif++ < i_hardif_s) 2159 continue; 2160 2161 if (batadv_iv_ogm_neigh_dump_hardif(msg, portid, 2162 cb->nlh->nlmsg_seq, 2163 bat_priv, 2164 hard_iface, &idx)) { 2165 i_hardif--; 2166 break; 2167 } 2168 } 2169 } 2170 rcu_read_unlock(); 2171 2172 cb->args[0] = i_hardif; 2173 cb->args[1] = idx; 2174} 2175 2176/** 2177 * batadv_iv_ogm_neigh_cmp() - compare the metrics of two neighbors 2178 * @neigh1: the first neighbor object of the comparison 2179 * @if_outgoing1: outgoing interface for the first neighbor 2180 * @neigh2: the second neighbor object of the comparison 2181 * @if_outgoing2: outgoing interface for the second neighbor 2182 * 2183 * Return: a value less, equal to or greater than 0 if the metric via neigh1 is 2184 * lower, the same as or higher than the metric via neigh2 2185 */ 2186static int batadv_iv_ogm_neigh_cmp(struct batadv_neigh_node *neigh1, 2187 struct batadv_hard_iface *if_outgoing1, 2188 struct batadv_neigh_node *neigh2, 2189 struct batadv_hard_iface *if_outgoing2) 2190{ 2191 bool ret; 2192 int diff; 2193 2194 ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2, 2195 if_outgoing2, &diff); 2196 if (!ret) 2197 return 0; 2198 2199 return diff; 2200} 2201 2202/** 2203 * batadv_iv_ogm_neigh_is_sob() - check if neigh1 is similarly good or better 2204 * than neigh2 from the metric prospective 2205 * @neigh1: the first neighbor object of the comparison 2206 * @if_outgoing1: outgoing interface for the first neighbor 2207 * @neigh2: the second neighbor object of the comparison 2208 * @if_outgoing2: outgoing interface for the second neighbor 2209 * 2210 * Return: true if the metric via neigh1 is equally good or better than 2211 * the metric via neigh2, false otherwise. 2212 */ 2213static bool 2214batadv_iv_ogm_neigh_is_sob(struct batadv_neigh_node *neigh1, 2215 struct batadv_hard_iface *if_outgoing1, 2216 struct batadv_neigh_node *neigh2, 2217 struct batadv_hard_iface *if_outgoing2) 2218{ 2219 bool ret; 2220 int diff; 2221 2222 ret = batadv_iv_ogm_neigh_diff(neigh1, if_outgoing1, neigh2, 2223 if_outgoing2, &diff); 2224 if (!ret) 2225 return false; 2226 2227 ret = diff > -BATADV_TQ_SIMILARITY_THRESHOLD; 2228 return ret; 2229} 2230 2231static void batadv_iv_iface_enabled(struct batadv_hard_iface *hard_iface) 2232{ 2233 /* begin scheduling originator messages on that interface */ 2234 batadv_iv_ogm_schedule(hard_iface); 2235} 2236 2237/** 2238 * batadv_iv_init_sel_class() - initialize GW selection class 2239 * @bat_priv: the bat priv with all the soft interface information 2240 */ 2241static void batadv_iv_init_sel_class(struct batadv_priv *bat_priv) 2242{ 2243 /* set default TQ difference threshold to 20 */ 2244 atomic_set(&bat_priv->gw.sel_class, 20); 2245} 2246 2247static struct batadv_gw_node * 2248batadv_iv_gw_get_best_gw_node(struct batadv_priv *bat_priv) 2249{ 2250 struct batadv_neigh_node *router; 2251 struct batadv_neigh_ifinfo *router_ifinfo; 2252 struct batadv_gw_node *gw_node, *curr_gw = NULL; 2253 u64 max_gw_factor = 0; 2254 u64 tmp_gw_factor = 0; 2255 u8 max_tq = 0; 2256 u8 tq_avg; 2257 struct batadv_orig_node *orig_node; 2258 2259 rcu_read_lock(); 2260 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) { 2261 orig_node = gw_node->orig_node; 2262 router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT); 2263 if (!router) 2264 continue; 2265 2266 router_ifinfo = batadv_neigh_ifinfo_get(router, 2267 BATADV_IF_DEFAULT); 2268 if (!router_ifinfo) 2269 goto next; 2270 2271 if (!kref_get_unless_zero(&gw_node->refcount)) 2272 goto next; 2273 2274 tq_avg = router_ifinfo->bat_iv.tq_avg; 2275 2276 switch (atomic_read(&bat_priv->gw.sel_class)) { 2277 case 1: /* fast connection */ 2278 tmp_gw_factor = tq_avg * tq_avg; 2279 tmp_gw_factor *= gw_node->bandwidth_down; 2280 tmp_gw_factor *= 100 * 100; 2281 tmp_gw_factor >>= 18; 2282 2283 if (tmp_gw_factor > max_gw_factor || 2284 (tmp_gw_factor == max_gw_factor && 2285 tq_avg > max_tq)) { 2286 batadv_gw_node_put(curr_gw); 2287 curr_gw = gw_node; 2288 kref_get(&curr_gw->refcount); 2289 } 2290 break; 2291 2292 default: /* 2: stable connection (use best statistic) 2293 * 3: fast-switch (use best statistic but change as 2294 * soon as a better gateway appears) 2295 * XX: late-switch (use best statistic but change as 2296 * soon as a better gateway appears which has 2297 * $routing_class more tq points) 2298 */ 2299 if (tq_avg > max_tq) { 2300 batadv_gw_node_put(curr_gw); 2301 curr_gw = gw_node; 2302 kref_get(&curr_gw->refcount); 2303 } 2304 break; 2305 } 2306 2307 if (tq_avg > max_tq) 2308 max_tq = tq_avg; 2309 2310 if (tmp_gw_factor > max_gw_factor) 2311 max_gw_factor = tmp_gw_factor; 2312 2313 batadv_gw_node_put(gw_node); 2314 2315next: 2316 batadv_neigh_node_put(router); 2317 batadv_neigh_ifinfo_put(router_ifinfo); 2318 } 2319 rcu_read_unlock(); 2320 2321 return curr_gw; 2322} 2323 2324static bool batadv_iv_gw_is_eligible(struct batadv_priv *bat_priv, 2325 struct batadv_orig_node *curr_gw_orig, 2326 struct batadv_orig_node *orig_node) 2327{ 2328 struct batadv_neigh_ifinfo *router_orig_ifinfo = NULL; 2329 struct batadv_neigh_ifinfo *router_gw_ifinfo = NULL; 2330 struct batadv_neigh_node *router_gw = NULL; 2331 struct batadv_neigh_node *router_orig = NULL; 2332 u8 gw_tq_avg, orig_tq_avg; 2333 bool ret = false; 2334 2335 /* dynamic re-election is performed only on fast or late switch */ 2336 if (atomic_read(&bat_priv->gw.sel_class) <= 2) 2337 return false; 2338 2339 router_gw = batadv_orig_router_get(curr_gw_orig, BATADV_IF_DEFAULT); 2340 if (!router_gw) { 2341 ret = true; 2342 goto out; 2343 } 2344 2345 router_gw_ifinfo = batadv_neigh_ifinfo_get(router_gw, 2346 BATADV_IF_DEFAULT); 2347 if (!router_gw_ifinfo) { 2348 ret = true; 2349 goto out; 2350 } 2351 2352 router_orig = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT); 2353 if (!router_orig) 2354 goto out; 2355 2356 router_orig_ifinfo = batadv_neigh_ifinfo_get(router_orig, 2357 BATADV_IF_DEFAULT); 2358 if (!router_orig_ifinfo) 2359 goto out; 2360 2361 gw_tq_avg = router_gw_ifinfo->bat_iv.tq_avg; 2362 orig_tq_avg = router_orig_ifinfo->bat_iv.tq_avg; 2363 2364 /* the TQ value has to be better */ 2365 if (orig_tq_avg < gw_tq_avg) 2366 goto out; 2367 2368 /* if the routing class is greater than 3 the value tells us how much 2369 * greater the TQ value of the new gateway must be 2370 */ 2371 if ((atomic_read(&bat_priv->gw.sel_class) > 3) && 2372 (orig_tq_avg - gw_tq_avg < atomic_read(&bat_priv->gw.sel_class))) 2373 goto out; 2374 2375 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 2376 "Restarting gateway selection: better gateway found (tq curr: %i, tq new: %i)\n", 2377 gw_tq_avg, orig_tq_avg); 2378 2379 ret = true; 2380out: 2381 batadv_neigh_ifinfo_put(router_gw_ifinfo); 2382 batadv_neigh_ifinfo_put(router_orig_ifinfo); 2383 batadv_neigh_node_put(router_gw); 2384 batadv_neigh_node_put(router_orig); 2385 2386 return ret; 2387} 2388 2389/** 2390 * batadv_iv_gw_dump_entry() - Dump a gateway into a message 2391 * @msg: Netlink message to dump into 2392 * @portid: Port making netlink request 2393 * @cb: Control block containing additional options 2394 * @bat_priv: The bat priv with all the soft interface information 2395 * @gw_node: Gateway to be dumped 2396 * 2397 * Return: Error code, or 0 on success 2398 */ 2399static int batadv_iv_gw_dump_entry(struct sk_buff *msg, u32 portid, 2400 struct netlink_callback *cb, 2401 struct batadv_priv *bat_priv, 2402 struct batadv_gw_node *gw_node) 2403{ 2404 struct batadv_neigh_ifinfo *router_ifinfo = NULL; 2405 struct batadv_neigh_node *router; 2406 struct batadv_gw_node *curr_gw = NULL; 2407 int ret = 0; 2408 void *hdr; 2409 2410 router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT); 2411 if (!router) 2412 goto out; 2413 2414 router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); 2415 if (!router_ifinfo) 2416 goto out; 2417 2418 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 2419 2420 hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq, 2421 &batadv_netlink_family, NLM_F_MULTI, 2422 BATADV_CMD_GET_GATEWAYS); 2423 if (!hdr) { 2424 ret = -ENOBUFS; 2425 goto out; 2426 } 2427 2428 genl_dump_check_consistent(cb, hdr); 2429 2430 ret = -EMSGSIZE; 2431 2432 if (curr_gw == gw_node) 2433 if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) { 2434 genlmsg_cancel(msg, hdr); 2435 goto out; 2436 } 2437 2438 if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, 2439 gw_node->orig_node->orig) || 2440 nla_put_u8(msg, BATADV_ATTR_TQ, router_ifinfo->bat_iv.tq_avg) || 2441 nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN, 2442 router->addr) || 2443 nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, 2444 router->if_incoming->net_dev->name) || 2445 nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, 2446 router->if_incoming->net_dev->ifindex) || 2447 nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN, 2448 gw_node->bandwidth_down) || 2449 nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP, 2450 gw_node->bandwidth_up)) { 2451 genlmsg_cancel(msg, hdr); 2452 goto out; 2453 } 2454 2455 genlmsg_end(msg, hdr); 2456 ret = 0; 2457 2458out: 2459 batadv_gw_node_put(curr_gw); 2460 batadv_neigh_ifinfo_put(router_ifinfo); 2461 batadv_neigh_node_put(router); 2462 return ret; 2463} 2464 2465/** 2466 * batadv_iv_gw_dump() - Dump gateways into a message 2467 * @msg: Netlink message to dump into 2468 * @cb: Control block containing additional options 2469 * @bat_priv: The bat priv with all the soft interface information 2470 */ 2471static void batadv_iv_gw_dump(struct sk_buff *msg, struct netlink_callback *cb, 2472 struct batadv_priv *bat_priv) 2473{ 2474 int portid = NETLINK_CB(cb->skb).portid; 2475 struct batadv_gw_node *gw_node; 2476 int idx_skip = cb->args[0]; 2477 int idx = 0; 2478 2479 spin_lock_bh(&bat_priv->gw.list_lock); 2480 cb->seq = bat_priv->gw.generation << 1 | 1; 2481 2482 hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) { 2483 if (idx++ < idx_skip) 2484 continue; 2485 2486 if (batadv_iv_gw_dump_entry(msg, portid, cb, bat_priv, 2487 gw_node)) { 2488 idx_skip = idx - 1; 2489 goto unlock; 2490 } 2491 } 2492 2493 idx_skip = idx; 2494unlock: 2495 spin_unlock_bh(&bat_priv->gw.list_lock); 2496 2497 cb->args[0] = idx_skip; 2498} 2499 2500static struct batadv_algo_ops batadv_batman_iv __read_mostly = { 2501 .name = "BATMAN_IV", 2502 .iface = { 2503 .enable = batadv_iv_ogm_iface_enable, 2504 .enabled = batadv_iv_iface_enabled, 2505 .disable = batadv_iv_ogm_iface_disable, 2506 .update_mac = batadv_iv_ogm_iface_update_mac, 2507 .primary_set = batadv_iv_ogm_primary_iface_set, 2508 }, 2509 .neigh = { 2510 .cmp = batadv_iv_ogm_neigh_cmp, 2511 .is_similar_or_better = batadv_iv_ogm_neigh_is_sob, 2512 .dump = batadv_iv_ogm_neigh_dump, 2513 }, 2514 .orig = { 2515 .dump = batadv_iv_ogm_orig_dump, 2516 }, 2517 .gw = { 2518 .init_sel_class = batadv_iv_init_sel_class, 2519 .sel_class_max = BATADV_TQ_MAX_VALUE, 2520 .get_best_gw_node = batadv_iv_gw_get_best_gw_node, 2521 .is_eligible = batadv_iv_gw_is_eligible, 2522 .dump = batadv_iv_gw_dump, 2523 }, 2524}; 2525 2526/** 2527 * batadv_iv_init() - B.A.T.M.A.N. IV initialization function 2528 * 2529 * Return: 0 on success or negative error number in case of failure 2530 */ 2531int __init batadv_iv_init(void) 2532{ 2533 int ret; 2534 2535 /* batman originator packet */ 2536 ret = batadv_recv_handler_register(BATADV_IV_OGM, 2537 batadv_iv_ogm_receive); 2538 if (ret < 0) 2539 goto out; 2540 2541 ret = batadv_algo_register(&batadv_batman_iv); 2542 if (ret < 0) 2543 goto handler_unregister; 2544 2545 goto out; 2546 2547handler_unregister: 2548 batadv_recv_handler_unregister(BATADV_IV_OGM); 2549out: 2550 return ret; 2551} 2552