net/batman-adv/bat_v.c

   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
  44 static 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
  64 static 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
  79 static 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
  85 static 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  */
  98 static 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);
 108 out:
 109         batadv_hardif_put(primary_if);
 110 }
 111
 112 static void
 113 batadv_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  */
 129 static int
 130 batadv_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  */
 179 static int
 180 batadv_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  */
 211 static void
 212 batadv_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  */
 267 static int
 268 batadv_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  */
 336 static int
 337 batadv_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  */
 387 static int
 388 batadv_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  */
 422 static void
 423 batadv_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
 451 static 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);
 470 err_ifinfo2:
 471         batadv_neigh_ifinfo_put(ifinfo1);
 472 err_ifinfo1:
 473         return ret;
 474 }
 475
 476 static 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);
 499 err_ifinfo2:
 500         batadv_neigh_ifinfo_put(ifinfo1);
 501 err_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  */
 509 static 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  */
 524 static 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;
 549 out:
 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  */
 562 static struct batadv_gw_node *
 563 batadv_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
 585 next:
 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  */
 601 static 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;
 640 out:
 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  */
 657 static 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
 740 out:
 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  */
 753 static 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;
 776 unlock:
 777         spin_unlock_bh(&bat_priv->gw.list_lock);
 778
 779         cb->args[0] = idx_skip;
 780 }
 781
 782 static 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  */
 814 void 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  */
 835 int 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  */
 850 void 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  */
 863 int __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
 884 ogm_unregister:
 885         batadv_recv_handler_unregister(BATADV_OGM2);
 886
 887 elp_unregister:
 888         batadv_recv_handler_unregister(BATADV_ELP);
 889
 890         return ret;
 891 }