1// SPDX-License-Identifier: GPL-2.0 2/* Copyright (C) B.A.T.M.A.N. contributors: 3 * 4 * Linus L��ssing, Marek Lindner 5 */ 6 7#include "bat_v.h" 8#include "main.h" 9 10#include <linux/atomic.h> 11#include <linux/cache.h> 12#include <linux/errno.h> 13#include <linux/if_ether.h> 14#include <linux/init.h> 15#include <linux/jiffies.h> 16#include <linux/kref.h> 17#include <linux/limits.h> 18#include <linux/list.h> 19#include <linux/minmax.h> 20#include <linux/netdevice.h> 21#include <linux/netlink.h> 22#include <linux/rculist.h> 23#include <linux/rcupdate.h> 24#include <linux/skbuff.h> 25#include <linux/spinlock.h> 26#include <linux/stddef.h> 27#include <linux/types.h> 28#include <linux/workqueue.h> 29#include <net/genetlink.h> 30#include <net/netlink.h> 31#include <uapi/linux/batadv_packet.h> 32#include <uapi/linux/batman_adv.h> 33 34#include "bat_algo.h" 35#include "bat_v_elp.h" 36#include "bat_v_ogm.h" 37#include "gateway_client.h" 38#include "hard-interface.h" 39#include "hash.h" 40#include "log.h" 41#include "netlink.h" 42#include "originator.h" 43 44static void batadv_v_iface_activate(struct batadv_hard_iface *hard_iface) 45{ 46 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 47 struct batadv_hard_iface *primary_if; 48 49 primary_if = batadv_primary_if_get_selected(bat_priv); 50 51 if (primary_if) { 52 batadv_v_elp_iface_activate(primary_if, hard_iface); 53 batadv_hardif_put(primary_if); 54 } 55 56 /* B.A.T.M.A.N. V does not use any queuing mechanism, therefore it can 57 * set the interface as ACTIVE right away, without any risk of race 58 * condition 59 */ 60 if (hard_iface->if_status == BATADV_IF_TO_BE_ACTIVATED) 61 hard_iface->if_status = BATADV_IF_ACTIVE; 62} 63 64static int batadv_v_iface_enable(struct batadv_hard_iface *hard_iface) 65{ 66 int ret; 67 68 ret = batadv_v_elp_iface_enable(hard_iface); 69 if (ret < 0) 70 return ret; 71 72 ret = batadv_v_ogm_iface_enable(hard_iface); 73 if (ret < 0) 74 batadv_v_elp_iface_disable(hard_iface); 75 76 return ret; 77} 78 79static void batadv_v_iface_disable(struct batadv_hard_iface *hard_iface) 80{ 81 batadv_v_ogm_iface_disable(hard_iface); 82 batadv_v_elp_iface_disable(hard_iface); 83} 84 85static void batadv_v_primary_iface_set(struct batadv_hard_iface *hard_iface) 86{ 87 batadv_v_elp_primary_iface_set(hard_iface); 88 batadv_v_ogm_primary_iface_set(hard_iface); 89} 90 91/** 92 * batadv_v_iface_update_mac() - react to hard-interface MAC address change 93 * @hard_iface: the modified interface 94 * 95 * If the modified interface is the primary one, update the originator 96 * address in the ELP and OGM messages to reflect the new MAC address. 97 */ 98static void batadv_v_iface_update_mac(struct batadv_hard_iface *hard_iface) 99{ 100 struct batadv_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 101 struct batadv_hard_iface *primary_if; 102 103 primary_if = batadv_primary_if_get_selected(bat_priv); 104 if (primary_if != hard_iface) 105 goto out; 106 107 batadv_v_primary_iface_set(hard_iface); 108out: 109 batadv_hardif_put(primary_if); 110} 111 112static void 113batadv_v_hardif_neigh_init(struct batadv_hardif_neigh_node *hardif_neigh) 114{ 115 ewma_throughput_init(&hardif_neigh->bat_v.throughput); 116 INIT_WORK(&hardif_neigh->bat_v.metric_work, 117 batadv_v_elp_throughput_metric_update); 118} 119 120/** 121 * batadv_v_neigh_dump_neigh() - Dump a neighbour into a message 122 * @msg: Netlink message to dump into 123 * @portid: Port making netlink request 124 * @seq: Sequence number of netlink message 125 * @hardif_neigh: Neighbour to dump 126 * 127 * Return: Error code, or 0 on success 128 */ 129static int 130batadv_v_neigh_dump_neigh(struct sk_buff *msg, u32 portid, u32 seq, 131 struct batadv_hardif_neigh_node *hardif_neigh) 132{ 133 void *hdr; 134 unsigned int last_seen_msecs; 135 u32 throughput; 136 137 last_seen_msecs = jiffies_to_msecs(jiffies - hardif_neigh->last_seen); 138 throughput = ewma_throughput_read(&hardif_neigh->bat_v.throughput); 139 throughput = throughput * 100; 140 141 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI, 142 BATADV_CMD_GET_NEIGHBORS); 143 if (!hdr) 144 return -ENOBUFS; 145 146 if (nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, 147 hardif_neigh->addr) || 148 nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, 149 hardif_neigh->if_incoming->net_dev->name) || 150 nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, 151 hardif_neigh->if_incoming->net_dev->ifindex) || 152 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, 153 last_seen_msecs) || 154 nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput)) 155 goto nla_put_failure; 156 157 genlmsg_end(msg, hdr); 158 return 0; 159 160 nla_put_failure: 161 genlmsg_cancel(msg, hdr); 162 return -EMSGSIZE; 163} 164 165/** 166 * batadv_v_neigh_dump_hardif() - Dump the neighbours of a hard interface into 167 * a message 168 * @msg: Netlink message to dump into 169 * @portid: Port making netlink request 170 * @seq: Sequence number of netlink message 171 * @bat_priv: The bat priv with all the soft interface information 172 * @hard_iface: The hard interface to be dumped 173 * @idx_s: Entries to be skipped 174 * 175 * This function assumes the caller holds rcu_read_lock(). 176 * 177 * Return: Error code, or 0 on success 178 */ 179static int 180batadv_v_neigh_dump_hardif(struct sk_buff *msg, u32 portid, u32 seq, 181 struct batadv_priv *bat_priv, 182 struct batadv_hard_iface *hard_iface, 183 int *idx_s) 184{ 185 struct batadv_hardif_neigh_node *hardif_neigh; 186 int idx = 0; 187 188 hlist_for_each_entry_rcu(hardif_neigh, 189 &hard_iface->neigh_list, list) { 190 if (idx++ < *idx_s) 191 continue; 192 193 if (batadv_v_neigh_dump_neigh(msg, portid, seq, hardif_neigh)) { 194 *idx_s = idx - 1; 195 return -EMSGSIZE; 196 } 197 } 198 199 *idx_s = 0; 200 return 0; 201} 202 203/** 204 * batadv_v_neigh_dump() - Dump the neighbours of a hard interface into a 205 * message 206 * @msg: Netlink message to dump into 207 * @cb: Control block containing additional options 208 * @bat_priv: The bat priv with all the soft interface information 209 * @single_hardif: Limit dumping to this hard interface 210 */ 211static void 212batadv_v_neigh_dump(struct sk_buff *msg, struct netlink_callback *cb, 213 struct batadv_priv *bat_priv, 214 struct batadv_hard_iface *single_hardif) 215{ 216 struct batadv_hard_iface *hard_iface; 217 int i_hardif = 0; 218 int i_hardif_s = cb->args[0]; 219 int idx = cb->args[1]; 220 int portid = NETLINK_CB(cb->skb).portid; 221 222 rcu_read_lock(); 223 if (single_hardif) { 224 if (i_hardif_s == 0) { 225 if (batadv_v_neigh_dump_hardif(msg, portid, 226 cb->nlh->nlmsg_seq, 227 bat_priv, single_hardif, 228 &idx) == 0) 229 i_hardif++; 230 } 231 } else { 232 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 233 if (hard_iface->soft_iface != bat_priv->soft_iface) 234 continue; 235 236 if (i_hardif++ < i_hardif_s) 237 continue; 238 239 if (batadv_v_neigh_dump_hardif(msg, portid, 240 cb->nlh->nlmsg_seq, 241 bat_priv, hard_iface, 242 &idx)) { 243 i_hardif--; 244 break; 245 } 246 } 247 } 248 rcu_read_unlock(); 249 250 cb->args[0] = i_hardif; 251 cb->args[1] = idx; 252} 253 254/** 255 * batadv_v_orig_dump_subentry() - Dump an originator subentry into a message 256 * @msg: Netlink message to dump into 257 * @portid: Port making netlink request 258 * @seq: Sequence number of netlink message 259 * @bat_priv: The bat priv with all the soft interface information 260 * @if_outgoing: Limit dump to entries with this outgoing interface 261 * @orig_node: Originator to dump 262 * @neigh_node: Single hops neighbour 263 * @best: Is the best originator 264 * 265 * Return: Error code, or 0 on success 266 */ 267static int 268batadv_v_orig_dump_subentry(struct sk_buff *msg, u32 portid, u32 seq, 269 struct batadv_priv *bat_priv, 270 struct batadv_hard_iface *if_outgoing, 271 struct batadv_orig_node *orig_node, 272 struct batadv_neigh_node *neigh_node, 273 bool best) 274{ 275 struct batadv_neigh_ifinfo *n_ifinfo; 276 unsigned int last_seen_msecs; 277 u32 throughput; 278 void *hdr; 279 280 n_ifinfo = batadv_neigh_ifinfo_get(neigh_node, if_outgoing); 281 if (!n_ifinfo) 282 return 0; 283 284 throughput = n_ifinfo->bat_v.throughput * 100; 285 286 batadv_neigh_ifinfo_put(n_ifinfo); 287 288 last_seen_msecs = jiffies_to_msecs(jiffies - orig_node->last_seen); 289 290 if (if_outgoing != BATADV_IF_DEFAULT && 291 if_outgoing != neigh_node->if_incoming) 292 return 0; 293 294 hdr = genlmsg_put(msg, portid, seq, &batadv_netlink_family, NLM_F_MULTI, 295 BATADV_CMD_GET_ORIGINATORS); 296 if (!hdr) 297 return -ENOBUFS; 298 299 if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, orig_node->orig) || 300 nla_put(msg, BATADV_ATTR_NEIGH_ADDRESS, ETH_ALEN, 301 neigh_node->addr) || 302 nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, 303 neigh_node->if_incoming->net_dev->name) || 304 nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, 305 neigh_node->if_incoming->net_dev->ifindex) || 306 nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, throughput) || 307 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, 308 last_seen_msecs)) 309 goto nla_put_failure; 310 311 if (best && nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) 312 goto nla_put_failure; 313 314 genlmsg_end(msg, hdr); 315 return 0; 316 317 nla_put_failure: 318 genlmsg_cancel(msg, hdr); 319 return -EMSGSIZE; 320} 321 322/** 323 * batadv_v_orig_dump_entry() - Dump an originator entry into a message 324 * @msg: Netlink message to dump into 325 * @portid: Port making netlink request 326 * @seq: Sequence number of netlink message 327 * @bat_priv: The bat priv with all the soft interface information 328 * @if_outgoing: Limit dump to entries with this outgoing interface 329 * @orig_node: Originator to dump 330 * @sub_s: Number of sub entries to skip 331 * 332 * This function assumes the caller holds rcu_read_lock(). 333 * 334 * Return: Error code, or 0 on success 335 */ 336static int 337batadv_v_orig_dump_entry(struct sk_buff *msg, u32 portid, u32 seq, 338 struct batadv_priv *bat_priv, 339 struct batadv_hard_iface *if_outgoing, 340 struct batadv_orig_node *orig_node, int *sub_s) 341{ 342 struct batadv_neigh_node *neigh_node_best; 343 struct batadv_neigh_node *neigh_node; 344 int sub = 0; 345 bool best; 346 347 neigh_node_best = batadv_orig_router_get(orig_node, if_outgoing); 348 if (!neigh_node_best) 349 goto out; 350 351 hlist_for_each_entry_rcu(neigh_node, &orig_node->neigh_list, list) { 352 if (sub++ < *sub_s) 353 continue; 354 355 best = (neigh_node == neigh_node_best); 356 357 if (batadv_v_orig_dump_subentry(msg, portid, seq, bat_priv, 358 if_outgoing, orig_node, 359 neigh_node, best)) { 360 batadv_neigh_node_put(neigh_node_best); 361 362 *sub_s = sub - 1; 363 return -EMSGSIZE; 364 } 365 } 366 367 out: 368 batadv_neigh_node_put(neigh_node_best); 369 370 *sub_s = 0; 371 return 0; 372} 373 374/** 375 * batadv_v_orig_dump_bucket() - Dump an originator bucket into a message 376 * @msg: Netlink message to dump into 377 * @portid: Port making netlink request 378 * @seq: Sequence number of netlink message 379 * @bat_priv: The bat priv with all the soft interface information 380 * @if_outgoing: Limit dump to entries with this outgoing interface 381 * @head: Bucket to be dumped 382 * @idx_s: Number of entries to be skipped 383 * @sub: Number of sub entries to be skipped 384 * 385 * Return: Error code, or 0 on success 386 */ 387static int 388batadv_v_orig_dump_bucket(struct sk_buff *msg, u32 portid, u32 seq, 389 struct batadv_priv *bat_priv, 390 struct batadv_hard_iface *if_outgoing, 391 struct hlist_head *head, int *idx_s, int *sub) 392{ 393 struct batadv_orig_node *orig_node; 394 int idx = 0; 395 396 rcu_read_lock(); 397 hlist_for_each_entry_rcu(orig_node, head, hash_entry) { 398 if (idx++ < *idx_s) 399 continue; 400 401 if (batadv_v_orig_dump_entry(msg, portid, seq, bat_priv, 402 if_outgoing, orig_node, sub)) { 403 rcu_read_unlock(); 404 *idx_s = idx - 1; 405 return -EMSGSIZE; 406 } 407 } 408 rcu_read_unlock(); 409 410 *idx_s = 0; 411 *sub = 0; 412 return 0; 413} 414 415/** 416 * batadv_v_orig_dump() - Dump the originators into a message 417 * @msg: Netlink message to dump into 418 * @cb: Control block containing additional options 419 * @bat_priv: The bat priv with all the soft interface information 420 * @if_outgoing: Limit dump to entries with this outgoing interface 421 */ 422static void 423batadv_v_orig_dump(struct sk_buff *msg, struct netlink_callback *cb, 424 struct batadv_priv *bat_priv, 425 struct batadv_hard_iface *if_outgoing) 426{ 427 struct batadv_hashtable *hash = bat_priv->orig_hash; 428 struct hlist_head *head; 429 int bucket = cb->args[0]; 430 int idx = cb->args[1]; 431 int sub = cb->args[2]; 432 int portid = NETLINK_CB(cb->skb).portid; 433 434 while (bucket < hash->size) { 435 head = &hash->table[bucket]; 436 437 if (batadv_v_orig_dump_bucket(msg, portid, 438 cb->nlh->nlmsg_seq, 439 bat_priv, if_outgoing, head, &idx, 440 &sub)) 441 break; 442 443 bucket++; 444 } 445 446 cb->args[0] = bucket; 447 cb->args[1] = idx; 448 cb->args[2] = sub; 449} 450 451static int batadv_v_neigh_cmp(struct batadv_neigh_node *neigh1, 452 struct batadv_hard_iface *if_outgoing1, 453 struct batadv_neigh_node *neigh2, 454 struct batadv_hard_iface *if_outgoing2) 455{ 456 struct batadv_neigh_ifinfo *ifinfo1, *ifinfo2; 457 int ret = 0; 458 459 ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1); 460 if (!ifinfo1) 461 goto err_ifinfo1; 462 463 ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2); 464 if (!ifinfo2) 465 goto err_ifinfo2; 466 467 ret = ifinfo1->bat_v.throughput - ifinfo2->bat_v.throughput; 468 469 batadv_neigh_ifinfo_put(ifinfo2); 470err_ifinfo2: 471 batadv_neigh_ifinfo_put(ifinfo1); 472err_ifinfo1: 473 return ret; 474} 475 476static bool batadv_v_neigh_is_sob(struct batadv_neigh_node *neigh1, 477 struct batadv_hard_iface *if_outgoing1, 478 struct batadv_neigh_node *neigh2, 479 struct batadv_hard_iface *if_outgoing2) 480{ 481 struct batadv_neigh_ifinfo *ifinfo1, *ifinfo2; 482 u32 threshold; 483 bool ret = false; 484 485 ifinfo1 = batadv_neigh_ifinfo_get(neigh1, if_outgoing1); 486 if (!ifinfo1) 487 goto err_ifinfo1; 488 489 ifinfo2 = batadv_neigh_ifinfo_get(neigh2, if_outgoing2); 490 if (!ifinfo2) 491 goto err_ifinfo2; 492 493 threshold = ifinfo1->bat_v.throughput / 4; 494 threshold = ifinfo1->bat_v.throughput - threshold; 495 496 ret = ifinfo2->bat_v.throughput > threshold; 497 498 batadv_neigh_ifinfo_put(ifinfo2); 499err_ifinfo2: 500 batadv_neigh_ifinfo_put(ifinfo1); 501err_ifinfo1: 502 return ret; 503} 504 505/** 506 * batadv_v_init_sel_class() - initialize GW selection class 507 * @bat_priv: the bat priv with all the soft interface information 508 */ 509static void batadv_v_init_sel_class(struct batadv_priv *bat_priv) 510{ 511 /* set default throughput difference threshold to 5Mbps */ 512 atomic_set(&bat_priv->gw.sel_class, 50); 513} 514 515/** 516 * batadv_v_gw_throughput_get() - retrieve the GW-bandwidth for a given GW 517 * @gw_node: the GW to retrieve the metric for 518 * @bw: the pointer where the metric will be stored. The metric is computed as 519 * the minimum between the GW advertised throughput and the path throughput to 520 * it in the mesh 521 * 522 * Return: 0 on success, -1 on failure 523 */ 524static int batadv_v_gw_throughput_get(struct batadv_gw_node *gw_node, u32 *bw) 525{ 526 struct batadv_neigh_ifinfo *router_ifinfo = NULL; 527 struct batadv_orig_node *orig_node; 528 struct batadv_neigh_node *router; 529 int ret = -1; 530 531 orig_node = gw_node->orig_node; 532 router = batadv_orig_router_get(orig_node, BATADV_IF_DEFAULT); 533 if (!router) 534 goto out; 535 536 router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); 537 if (!router_ifinfo) 538 goto out; 539 540 /* the GW metric is computed as the minimum between the path throughput 541 * to reach the GW itself and the advertised bandwidth. 542 * This gives us an approximation of the effective throughput that the 543 * client can expect via this particular GW node 544 */ 545 *bw = router_ifinfo->bat_v.throughput; 546 *bw = min_t(u32, *bw, gw_node->bandwidth_down); 547 548 ret = 0; 549out: 550 batadv_neigh_node_put(router); 551 batadv_neigh_ifinfo_put(router_ifinfo); 552 553 return ret; 554} 555 556/** 557 * batadv_v_gw_get_best_gw_node() - retrieve the best GW node 558 * @bat_priv: the bat priv with all the soft interface information 559 * 560 * Return: the GW node having the best GW-metric, NULL if no GW is known 561 */ 562static struct batadv_gw_node * 563batadv_v_gw_get_best_gw_node(struct batadv_priv *bat_priv) 564{ 565 struct batadv_gw_node *gw_node, *curr_gw = NULL; 566 u32 max_bw = 0, bw; 567 568 rcu_read_lock(); 569 hlist_for_each_entry_rcu(gw_node, &bat_priv->gw.gateway_list, list) { 570 if (!kref_get_unless_zero(&gw_node->refcount)) 571 continue; 572 573 if (batadv_v_gw_throughput_get(gw_node, &bw) < 0) 574 goto next; 575 576 if (curr_gw && bw <= max_bw) 577 goto next; 578 579 batadv_gw_node_put(curr_gw); 580 581 curr_gw = gw_node; 582 kref_get(&curr_gw->refcount); 583 max_bw = bw; 584 585next: 586 batadv_gw_node_put(gw_node); 587 } 588 rcu_read_unlock(); 589 590 return curr_gw; 591} 592 593/** 594 * batadv_v_gw_is_eligible() - check if a originator would be selected as GW 595 * @bat_priv: the bat priv with all the soft interface information 596 * @curr_gw_orig: originator representing the currently selected GW 597 * @orig_node: the originator representing the new candidate 598 * 599 * Return: true if orig_node can be selected as current GW, false otherwise 600 */ 601static bool batadv_v_gw_is_eligible(struct batadv_priv *bat_priv, 602 struct batadv_orig_node *curr_gw_orig, 603 struct batadv_orig_node *orig_node) 604{ 605 struct batadv_gw_node *curr_gw, *orig_gw = NULL; 606 u32 gw_throughput, orig_throughput, threshold; 607 bool ret = false; 608 609 threshold = atomic_read(&bat_priv->gw.sel_class); 610 611 curr_gw = batadv_gw_node_get(bat_priv, curr_gw_orig); 612 if (!curr_gw) { 613 ret = true; 614 goto out; 615 } 616 617 if (batadv_v_gw_throughput_get(curr_gw, &gw_throughput) < 0) { 618 ret = true; 619 goto out; 620 } 621 622 orig_gw = batadv_gw_node_get(bat_priv, orig_node); 623 if (!orig_gw) 624 goto out; 625 626 if (batadv_v_gw_throughput_get(orig_gw, &orig_throughput) < 0) 627 goto out; 628 629 if (orig_throughput < gw_throughput) 630 goto out; 631 632 if ((orig_throughput - gw_throughput) < threshold) 633 goto out; 634 635 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 636 "Restarting gateway selection: better gateway found (throughput curr: %u, throughput new: %u)\n", 637 gw_throughput, orig_throughput); 638 639 ret = true; 640out: 641 batadv_gw_node_put(curr_gw); 642 batadv_gw_node_put(orig_gw); 643 644 return ret; 645} 646 647/** 648 * batadv_v_gw_dump_entry() - Dump a gateway into a message 649 * @msg: Netlink message to dump into 650 * @portid: Port making netlink request 651 * @cb: Control block containing additional options 652 * @bat_priv: The bat priv with all the soft interface information 653 * @gw_node: Gateway to be dumped 654 * 655 * Return: Error code, or 0 on success 656 */ 657static int batadv_v_gw_dump_entry(struct sk_buff *msg, u32 portid, 658 struct netlink_callback *cb, 659 struct batadv_priv *bat_priv, 660 struct batadv_gw_node *gw_node) 661{ 662 struct batadv_neigh_ifinfo *router_ifinfo = NULL; 663 struct batadv_neigh_node *router; 664 struct batadv_gw_node *curr_gw = NULL; 665 int ret = 0; 666 void *hdr; 667 668 router = batadv_orig_router_get(gw_node->orig_node, BATADV_IF_DEFAULT); 669 if (!router) 670 goto out; 671 672 router_ifinfo = batadv_neigh_ifinfo_get(router, BATADV_IF_DEFAULT); 673 if (!router_ifinfo) 674 goto out; 675 676 curr_gw = batadv_gw_get_selected_gw_node(bat_priv); 677 678 hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq, 679 &batadv_netlink_family, NLM_F_MULTI, 680 BATADV_CMD_GET_GATEWAYS); 681 if (!hdr) { 682 ret = -ENOBUFS; 683 goto out; 684 } 685 686 genl_dump_check_consistent(cb, hdr); 687 688 ret = -EMSGSIZE; 689 690 if (curr_gw == gw_node) { 691 if (nla_put_flag(msg, BATADV_ATTR_FLAG_BEST)) { 692 genlmsg_cancel(msg, hdr); 693 goto out; 694 } 695 } 696 697 if (nla_put(msg, BATADV_ATTR_ORIG_ADDRESS, ETH_ALEN, 698 gw_node->orig_node->orig)) { 699 genlmsg_cancel(msg, hdr); 700 goto out; 701 } 702 703 if (nla_put_u32(msg, BATADV_ATTR_THROUGHPUT, 704 router_ifinfo->bat_v.throughput)) { 705 genlmsg_cancel(msg, hdr); 706 goto out; 707 } 708 709 if (nla_put(msg, BATADV_ATTR_ROUTER, ETH_ALEN, router->addr)) { 710 genlmsg_cancel(msg, hdr); 711 goto out; 712 } 713 714 if (nla_put_string(msg, BATADV_ATTR_HARD_IFNAME, 715 router->if_incoming->net_dev->name)) { 716 genlmsg_cancel(msg, hdr); 717 goto out; 718 } 719 720 if (nla_put_u32(msg, BATADV_ATTR_HARD_IFINDEX, 721 router->if_incoming->net_dev->ifindex)) { 722 genlmsg_cancel(msg, hdr); 723 goto out; 724 } 725 726 if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_DOWN, 727 gw_node->bandwidth_down)) { 728 genlmsg_cancel(msg, hdr); 729 goto out; 730 } 731 732 if (nla_put_u32(msg, BATADV_ATTR_BANDWIDTH_UP, gw_node->bandwidth_up)) { 733 genlmsg_cancel(msg, hdr); 734 goto out; 735 } 736 737 genlmsg_end(msg, hdr); 738 ret = 0; 739 740out: 741 batadv_gw_node_put(curr_gw); 742 batadv_neigh_ifinfo_put(router_ifinfo); 743 batadv_neigh_node_put(router); 744 return ret; 745} 746 747/** 748 * batadv_v_gw_dump() - Dump gateways into a message 749 * @msg: Netlink message to dump into 750 * @cb: Control block containing additional options 751 * @bat_priv: The bat priv with all the soft interface information 752 */ 753static void batadv_v_gw_dump(struct sk_buff *msg, struct netlink_callback *cb, 754 struct batadv_priv *bat_priv) 755{ 756 int portid = NETLINK_CB(cb->skb).portid; 757 struct batadv_gw_node *gw_node; 758 int idx_skip = cb->args[0]; 759 int idx = 0; 760 761 spin_lock_bh(&bat_priv->gw.list_lock); 762 cb->seq = bat_priv->gw.generation << 1 | 1; 763 764 hlist_for_each_entry(gw_node, &bat_priv->gw.gateway_list, list) { 765 if (idx++ < idx_skip) 766 continue; 767 768 if (batadv_v_gw_dump_entry(msg, portid, cb, bat_priv, 769 gw_node)) { 770 idx_skip = idx - 1; 771 goto unlock; 772 } 773 } 774 775 idx_skip = idx; 776unlock: 777 spin_unlock_bh(&bat_priv->gw.list_lock); 778 779 cb->args[0] = idx_skip; 780} 781 782static struct batadv_algo_ops batadv_batman_v __read_mostly = { 783 .name = "BATMAN_V", 784 .iface = { 785 .activate = batadv_v_iface_activate, 786 .enable = batadv_v_iface_enable, 787 .disable = batadv_v_iface_disable, 788 .update_mac = batadv_v_iface_update_mac, 789 .primary_set = batadv_v_primary_iface_set, 790 }, 791 .neigh = { 792 .hardif_init = batadv_v_hardif_neigh_init, 793 .cmp = batadv_v_neigh_cmp, 794 .is_similar_or_better = batadv_v_neigh_is_sob, 795 .dump = batadv_v_neigh_dump, 796 }, 797 .orig = { 798 .dump = batadv_v_orig_dump, 799 }, 800 .gw = { 801 .init_sel_class = batadv_v_init_sel_class, 802 .sel_class_max = U32_MAX, 803 .get_best_gw_node = batadv_v_gw_get_best_gw_node, 804 .is_eligible = batadv_v_gw_is_eligible, 805 .dump = batadv_v_gw_dump, 806 }, 807}; 808 809/** 810 * batadv_v_hardif_init() - initialize the algorithm specific fields in the 811 * hard-interface object 812 * @hard_iface: the hard-interface to initialize 813 */ 814void batadv_v_hardif_init(struct batadv_hard_iface *hard_iface) 815{ 816 /* enable link throughput auto-detection by setting the throughput 817 * override to zero 818 */ 819 atomic_set(&hard_iface->bat_v.throughput_override, 0); 820 atomic_set(&hard_iface->bat_v.elp_interval, 500); 821 822 hard_iface->bat_v.aggr_len = 0; 823 skb_queue_head_init(&hard_iface->bat_v.aggr_list); 824 INIT_DELAYED_WORK(&hard_iface->bat_v.aggr_wq, 825 batadv_v_ogm_aggr_work); 826} 827 828/** 829 * batadv_v_mesh_init() - initialize the B.A.T.M.A.N. V private resources for a 830 * mesh 831 * @bat_priv: the object representing the mesh interface to initialise 832 * 833 * Return: 0 on success or a negative error code otherwise 834 */ 835int batadv_v_mesh_init(struct batadv_priv *bat_priv) 836{ 837 int ret = 0; 838 839 ret = batadv_v_ogm_init(bat_priv); 840 if (ret < 0) 841 return ret; 842 843 return 0; 844} 845 846/** 847 * batadv_v_mesh_free() - free the B.A.T.M.A.N. V private resources for a mesh 848 * @bat_priv: the object representing the mesh interface to free 849 */ 850void batadv_v_mesh_free(struct batadv_priv *bat_priv) 851{ 852 batadv_v_ogm_free(bat_priv); 853} 854 855/** 856 * batadv_v_init() - B.A.T.M.A.N. V initialization function 857 * 858 * Description: Takes care of initializing all the subcomponents. 859 * It is invoked upon module load only. 860 * 861 * Return: 0 on success or a negative error code otherwise 862 */ 863int __init batadv_v_init(void) 864{ 865 int ret; 866 867 /* B.A.T.M.A.N. V echo location protocol packet */ 868 ret = batadv_recv_handler_register(BATADV_ELP, 869 batadv_v_elp_packet_recv); 870 if (ret < 0) 871 return ret; 872 873 ret = batadv_recv_handler_register(BATADV_OGM2, 874 batadv_v_ogm_packet_recv); 875 if (ret < 0) 876 goto elp_unregister; 877 878 ret = batadv_algo_register(&batadv_batman_v); 879 if (ret < 0) 880 goto ogm_unregister; 881 882 return ret; 883 884ogm_unregister: 885 batadv_recv_handler_unregister(BATADV_OGM2); 886 887elp_unregister: 888 batadv_recv_handler_unregister(BATADV_ELP); 889 890 return ret; 891} 892