1 /* 2 * Copyright (C) 2007-2012 B.A.T.M.A.N. contributors: 3 * 4 * Marek Lindner, Simon Wunderlich 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of version 2 of the GNU General Public 8 * License as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 18 * 02110-1301, USA 19 * 20 */ 21 22 #include "main.h" 23 #include "hard-interface.h" 24 #include "soft-interface.h" 25 #include "send.h" 26 #include "translation-table.h" 27 #include "routing.h" 28 #include "bat_sysfs.h" 29 #include "originator.h" 30 #include "hash.h" 31 #include "bridge_loop_avoidance.h" 32 33 #include <linux/if_arp.h> 34 35 void hardif_free_rcu(struct rcu_head *rcu) 36 { 37 struct hard_iface *hard_iface; 38 39 hard_iface = container_of(rcu, struct hard_iface, rcu); 40 dev_put(hard_iface->net_dev); 41 kfree(hard_iface); 42 } 43 44 struct hard_iface *hardif_get_by_netdev(const struct net_device *net_dev) 45 { 46 struct hard_iface *hard_iface; 47 48 rcu_read_lock(); 49 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 50 if (hard_iface->net_dev == net_dev && 51 atomic_inc_not_zero(&hard_iface->refcount)) 52 goto out; 53 } 54 55 hard_iface = NULL; 56 57 out: 58 rcu_read_unlock(); 59 return hard_iface; 60 } 61 62 static int is_valid_iface(const struct net_device *net_dev) 63 { 64 if (net_dev->flags & IFF_LOOPBACK) 65 return 0; 66 67 if (net_dev->type != ARPHRD_ETHER) 68 return 0; 69 70 if (net_dev->addr_len != ETH_ALEN) 71 return 0; 72 73 /* no batman over batman */ 74 if (softif_is_valid(net_dev)) 75 return 0; 76 77 /* Device is being bridged */ 78 /* if (net_dev->priv_flags & IFF_BRIDGE_PORT) 79 return 0; */ 80 81 return 1; 82 } 83 84 static struct hard_iface *hardif_get_active(const struct net_device *soft_iface) 85 { 86 struct hard_iface *hard_iface; 87 88 rcu_read_lock(); 89 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 90 if (hard_iface->soft_iface != soft_iface) 91 continue; 92 93 if (hard_iface->if_status == IF_ACTIVE && 94 atomic_inc_not_zero(&hard_iface->refcount)) 95 goto out; 96 } 97 98 hard_iface = NULL; 99 100 out: 101 rcu_read_unlock(); 102 return hard_iface; 103 } 104 105 static void primary_if_update_addr(struct bat_priv *bat_priv, 106 struct hard_iface *oldif) 107 { 108 struct vis_packet *vis_packet; 109 struct hard_iface *primary_if; 110 111 primary_if = primary_if_get_selected(bat_priv); 112 if (!primary_if) 113 goto out; 114 115 vis_packet = (struct vis_packet *) 116 bat_priv->my_vis_info->skb_packet->data; 117 memcpy(vis_packet->vis_orig, primary_if->net_dev->dev_addr, ETH_ALEN); 118 memcpy(vis_packet->sender_orig, 119 primary_if->net_dev->dev_addr, ETH_ALEN); 120 121 bla_update_orig_address(bat_priv, primary_if, oldif); 122 out: 123 if (primary_if) 124 hardif_free_ref(primary_if); 125 } 126 127 static void primary_if_select(struct bat_priv *bat_priv, 128 struct hard_iface *new_hard_iface) 129 { 130 struct hard_iface *curr_hard_iface; 131 132 ASSERT_RTNL(); 133 134 if (new_hard_iface && !atomic_inc_not_zero(&new_hard_iface->refcount)) 135 new_hard_iface = NULL; 136 137 curr_hard_iface = rcu_dereference_protected(bat_priv->primary_if, 1); 138 rcu_assign_pointer(bat_priv->primary_if, new_hard_iface); 139 140 if (!new_hard_iface) 141 goto out; 142 143 bat_priv->bat_algo_ops->bat_primary_iface_set(new_hard_iface); 144 primary_if_update_addr(bat_priv, curr_hard_iface); 145 146 out: 147 if (curr_hard_iface) 148 hardif_free_ref(curr_hard_iface); 149 } 150 151 static bool hardif_is_iface_up(const struct hard_iface *hard_iface) 152 { 153 if (hard_iface->net_dev->flags & IFF_UP) 154 return true; 155 156 return false; 157 } 158 159 static void check_known_mac_addr(const struct net_device *net_dev) 160 { 161 const struct hard_iface *hard_iface; 162 163 rcu_read_lock(); 164 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 165 if ((hard_iface->if_status != IF_ACTIVE) && 166 (hard_iface->if_status != IF_TO_BE_ACTIVATED)) 167 continue; 168 169 if (hard_iface->net_dev == net_dev) 170 continue; 171 172 if (!compare_eth(hard_iface->net_dev->dev_addr, 173 net_dev->dev_addr)) 174 continue; 175 176 pr_warn("The newly added mac address (%pM) already exists on: %s\n", 177 net_dev->dev_addr, hard_iface->net_dev->name); 178 pr_warn("It is strongly recommended to keep mac addresses unique to avoid problems!\n"); 179 } 180 rcu_read_unlock(); 181 } 182 183 int hardif_min_mtu(struct net_device *soft_iface) 184 { 185 const struct bat_priv *bat_priv = netdev_priv(soft_iface); 186 const struct hard_iface *hard_iface; 187 /* allow big frames if all devices are capable to do so 188 * (have MTU > 1500 + BAT_HEADER_LEN) */ 189 int min_mtu = ETH_DATA_LEN; 190 191 if (atomic_read(&bat_priv->fragmentation)) 192 goto out; 193 194 rcu_read_lock(); 195 list_for_each_entry_rcu(hard_iface, &hardif_list, list) { 196 if ((hard_iface->if_status != IF_ACTIVE) && 197 (hard_iface->if_status != IF_TO_BE_ACTIVATED)) 198 continue; 199 200 if (hard_iface->soft_iface != soft_iface) 201 continue; 202 203 min_mtu = min_t(int, hard_iface->net_dev->mtu - BAT_HEADER_LEN, 204 min_mtu); 205 } 206 rcu_read_unlock(); 207 out: 208 return min_mtu; 209 } 210 211 /* adjusts the MTU if a new interface with a smaller MTU appeared. */ 212 void update_min_mtu(struct net_device *soft_iface) 213 { 214 int min_mtu; 215 216 min_mtu = hardif_min_mtu(soft_iface); 217 if (soft_iface->mtu != min_mtu) 218 soft_iface->mtu = min_mtu; 219 } 220 221 static void hardif_activate_interface(struct hard_iface *hard_iface) 222 { 223 struct bat_priv *bat_priv; 224 struct hard_iface *primary_if = NULL; 225 226 if (hard_iface->if_status != IF_INACTIVE) 227 goto out; 228 229 bat_priv = netdev_priv(hard_iface->soft_iface); 230 231 bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface); 232 hard_iface->if_status = IF_TO_BE_ACTIVATED; 233 234 /** 235 * the first active interface becomes our primary interface or 236 * the next active interface after the old primary interface was removed 237 */ 238 primary_if = primary_if_get_selected(bat_priv); 239 if (!primary_if) 240 primary_if_select(bat_priv, hard_iface); 241 242 bat_info(hard_iface->soft_iface, "Interface activated: %s\n", 243 hard_iface->net_dev->name); 244 245 update_min_mtu(hard_iface->soft_iface); 246 247 out: 248 if (primary_if) 249 hardif_free_ref(primary_if); 250 } 251 252 static void hardif_deactivate_interface(struct hard_iface *hard_iface) 253 { 254 if ((hard_iface->if_status != IF_ACTIVE) && 255 (hard_iface->if_status != IF_TO_BE_ACTIVATED)) 256 return; 257 258 hard_iface->if_status = IF_INACTIVE; 259 260 bat_info(hard_iface->soft_iface, "Interface deactivated: %s\n", 261 hard_iface->net_dev->name); 262 263 update_min_mtu(hard_iface->soft_iface); 264 } 265 266 int hardif_enable_interface(struct hard_iface *hard_iface, 267 const char *iface_name) 268 { 269 struct bat_priv *bat_priv; 270 struct net_device *soft_iface; 271 int ret; 272 273 if (hard_iface->if_status != IF_NOT_IN_USE) 274 goto out; 275 276 if (!atomic_inc_not_zero(&hard_iface->refcount)) 277 goto out; 278 279 /* hard-interface is part of a bridge */ 280 if (hard_iface->net_dev->priv_flags & IFF_BRIDGE_PORT) 281 pr_err("You are about to enable batman-adv on '%s' which already is part of a bridge. Unless you know exactly what you are doing this is probably wrong and won't work the way you think it would.\n", 282 hard_iface->net_dev->name); 283 284 soft_iface = dev_get_by_name(&init_net, iface_name); 285 286 if (!soft_iface) { 287 soft_iface = softif_create(iface_name); 288 289 if (!soft_iface) { 290 ret = -ENOMEM; 291 goto err; 292 } 293 294 /* dev_get_by_name() increases the reference counter for us */ 295 dev_hold(soft_iface); 296 } 297 298 if (!softif_is_valid(soft_iface)) { 299 pr_err("Can't create batman mesh interface %s: already exists as regular interface\n", 300 soft_iface->name); 301 ret = -EINVAL; 302 goto err_dev; 303 } 304 305 hard_iface->soft_iface = soft_iface; 306 bat_priv = netdev_priv(hard_iface->soft_iface); 307 308 ret = bat_priv->bat_algo_ops->bat_iface_enable(hard_iface); 309 if (ret < 0) { 310 ret = -ENOMEM; 311 goto err_dev; 312 } 313 314 hard_iface->if_num = bat_priv->num_ifaces; 315 bat_priv->num_ifaces++; 316 hard_iface->if_status = IF_INACTIVE; 317 orig_hash_add_if(hard_iface, bat_priv->num_ifaces); 318 319 hard_iface->batman_adv_ptype.type = __constant_htons(ETH_P_BATMAN); 320 hard_iface->batman_adv_ptype.func = batman_skb_recv; 321 hard_iface->batman_adv_ptype.dev = hard_iface->net_dev; 322 dev_add_pack(&hard_iface->batman_adv_ptype); 323 324 atomic_set(&hard_iface->frag_seqno, 1); 325 bat_info(hard_iface->soft_iface, "Adding interface: %s\n", 326 hard_iface->net_dev->name); 327 328 if (atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu < 329 ETH_DATA_LEN + BAT_HEADER_LEN) 330 bat_info(hard_iface->soft_iface, 331 "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. Packets going over this interface will be fragmented on layer2 which could impact the performance. Setting the MTU to %zi would solve the problem.\n", 332 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 333 ETH_DATA_LEN + BAT_HEADER_LEN); 334 335 if (!atomic_read(&bat_priv->fragmentation) && hard_iface->net_dev->mtu < 336 ETH_DATA_LEN + BAT_HEADER_LEN) 337 bat_info(hard_iface->soft_iface, 338 "The MTU of interface %s is too small (%i) to handle the transport of batman-adv packets. If you experience problems getting traffic through try increasing the MTU to %zi.\n", 339 hard_iface->net_dev->name, hard_iface->net_dev->mtu, 340 ETH_DATA_LEN + BAT_HEADER_LEN); 341 342 if (hardif_is_iface_up(hard_iface)) 343 hardif_activate_interface(hard_iface); 344 else 345 bat_err(hard_iface->soft_iface, 346 "Not using interface %s (retrying later): interface not active\n", 347 hard_iface->net_dev->name); 348 349 /* begin scheduling originator messages on that interface */ 350 schedule_bat_ogm(hard_iface); 351 352 out: 353 return 0; 354 355 err_dev: 356 dev_put(soft_iface); 357 err: 358 hardif_free_ref(hard_iface); 359 return ret; 360 } 361 362 void hardif_disable_interface(struct hard_iface *hard_iface) 363 { 364 struct bat_priv *bat_priv = netdev_priv(hard_iface->soft_iface); 365 struct hard_iface *primary_if = NULL; 366 367 if (hard_iface->if_status == IF_ACTIVE) 368 hardif_deactivate_interface(hard_iface); 369 370 if (hard_iface->if_status != IF_INACTIVE) 371 goto out; 372 373 bat_info(hard_iface->soft_iface, "Removing interface: %s\n", 374 hard_iface->net_dev->name); 375 dev_remove_pack(&hard_iface->batman_adv_ptype); 376 377 bat_priv->num_ifaces--; 378 orig_hash_del_if(hard_iface, bat_priv->num_ifaces); 379 380 primary_if = primary_if_get_selected(bat_priv); 381 if (hard_iface == primary_if) { 382 struct hard_iface *new_if; 383 384 new_if = hardif_get_active(hard_iface->soft_iface); 385 primary_if_select(bat_priv, new_if); 386 387 if (new_if) 388 hardif_free_ref(new_if); 389 } 390 391 bat_priv->bat_algo_ops->bat_iface_disable(hard_iface); 392 hard_iface->if_status = IF_NOT_IN_USE; 393 394 /* delete all references to this hard_iface */ 395 purge_orig_ref(bat_priv); 396 purge_outstanding_packets(bat_priv, hard_iface); 397 dev_put(hard_iface->soft_iface); 398 399 /* nobody uses this interface anymore */ 400 if (!bat_priv->num_ifaces) 401 softif_destroy(hard_iface->soft_iface); 402 403 hard_iface->soft_iface = NULL; 404 hardif_free_ref(hard_iface); 405 406 out: 407 if (primary_if) 408 hardif_free_ref(primary_if); 409 } 410 411 static struct hard_iface *hardif_add_interface(struct net_device *net_dev) 412 { 413 struct hard_iface *hard_iface; 414 int ret; 415 416 ASSERT_RTNL(); 417 418 ret = is_valid_iface(net_dev); 419 if (ret != 1) 420 goto out; 421 422 dev_hold(net_dev); 423 424 hard_iface = kmalloc(sizeof(*hard_iface), GFP_ATOMIC); 425 if (!hard_iface) 426 goto release_dev; 427 428 ret = sysfs_add_hardif(&hard_iface->hardif_obj, net_dev); 429 if (ret) 430 goto free_if; 431 432 hard_iface->if_num = -1; 433 hard_iface->net_dev = net_dev; 434 hard_iface->soft_iface = NULL; 435 hard_iface->if_status = IF_NOT_IN_USE; 436 INIT_LIST_HEAD(&hard_iface->list); 437 /* extra reference for return */ 438 atomic_set(&hard_iface->refcount, 2); 439 440 check_known_mac_addr(hard_iface->net_dev); 441 list_add_tail_rcu(&hard_iface->list, &hardif_list); 442 443 /** 444 * This can't be called via a bat_priv callback because 445 * we have no bat_priv yet. 446 */ 447 atomic_set(&hard_iface->seqno, 1); 448 hard_iface->packet_buff = NULL; 449 450 return hard_iface; 451 452 free_if: 453 kfree(hard_iface); 454 release_dev: 455 dev_put(net_dev); 456 out: 457 return NULL; 458 } 459 460 static void hardif_remove_interface(struct hard_iface *hard_iface) 461 { 462 ASSERT_RTNL(); 463 464 /* first deactivate interface */ 465 if (hard_iface->if_status != IF_NOT_IN_USE) 466 hardif_disable_interface(hard_iface); 467 468 if (hard_iface->if_status != IF_NOT_IN_USE) 469 return; 470 471 hard_iface->if_status = IF_TO_BE_REMOVED; 472 sysfs_del_hardif(&hard_iface->hardif_obj); 473 hardif_free_ref(hard_iface); 474 } 475 476 void hardif_remove_interfaces(void) 477 { 478 struct hard_iface *hard_iface, *hard_iface_tmp; 479 480 rtnl_lock(); 481 list_for_each_entry_safe(hard_iface, hard_iface_tmp, 482 &hardif_list, list) { 483 list_del_rcu(&hard_iface->list); 484 hardif_remove_interface(hard_iface); 485 } 486 rtnl_unlock(); 487 } 488 489 static int hard_if_event(struct notifier_block *this, 490 unsigned long event, void *ptr) 491 { 492 struct net_device *net_dev = ptr; 493 struct hard_iface *hard_iface = hardif_get_by_netdev(net_dev); 494 struct hard_iface *primary_if = NULL; 495 struct bat_priv *bat_priv; 496 497 if (!hard_iface && event == NETDEV_REGISTER) 498 hard_iface = hardif_add_interface(net_dev); 499 500 if (!hard_iface) 501 goto out; 502 503 switch (event) { 504 case NETDEV_UP: 505 hardif_activate_interface(hard_iface); 506 break; 507 case NETDEV_GOING_DOWN: 508 case NETDEV_DOWN: 509 hardif_deactivate_interface(hard_iface); 510 break; 511 case NETDEV_UNREGISTER: 512 list_del_rcu(&hard_iface->list); 513 514 hardif_remove_interface(hard_iface); 515 break; 516 case NETDEV_CHANGEMTU: 517 if (hard_iface->soft_iface) 518 update_min_mtu(hard_iface->soft_iface); 519 break; 520 case NETDEV_CHANGEADDR: 521 if (hard_iface->if_status == IF_NOT_IN_USE) 522 goto hardif_put; 523 524 check_known_mac_addr(hard_iface->net_dev); 525 526 bat_priv = netdev_priv(hard_iface->soft_iface); 527 bat_priv->bat_algo_ops->bat_iface_update_mac(hard_iface); 528 529 primary_if = primary_if_get_selected(bat_priv); 530 if (!primary_if) 531 goto hardif_put; 532 533 if (hard_iface == primary_if) 534 primary_if_update_addr(bat_priv, NULL); 535 break; 536 default: 537 break; 538 } 539 540 hardif_put: 541 hardif_free_ref(hard_iface); 542 out: 543 if (primary_if) 544 hardif_free_ref(primary_if); 545 return NOTIFY_DONE; 546 } 547 548 /* This function returns true if the interface represented by ifindex is a 549 * 802.11 wireless device */ 550 bool is_wifi_iface(int ifindex) 551 { 552 struct net_device *net_device = NULL; 553 bool ret = false; 554 555 if (ifindex == NULL_IFINDEX) 556 goto out; 557 558 net_device = dev_get_by_index(&init_net, ifindex); 559 if (!net_device) 560 goto out; 561 562 #ifdef CONFIG_WIRELESS_EXT 563 /* pre-cfg80211 drivers have to implement WEXT, so it is possible to 564 * check for wireless_handlers != NULL */ 565 if (net_device->wireless_handlers) 566 ret = true; 567 else 568 #endif 569 /* cfg80211 drivers have to set ieee80211_ptr */ 570 if (net_device->ieee80211_ptr) 571 ret = true; 572 out: 573 if (net_device) 574 dev_put(net_device); 575 return ret; 576 } 577 578 struct notifier_block hard_if_notifier = { 579 .notifier_call = hard_if_event, 580 }; 581