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 "main.h" 8 9 #include <linux/atomic.h> 10 #include <linux/build_bug.h> 11 #include <linux/byteorder/generic.h> 12 #include <linux/crc32c.h> 13 #include <linux/device.h> 14 #include <linux/errno.h> 15 #include <linux/genetlink.h> 16 #include <linux/gfp.h> 17 #include <linux/if_ether.h> 18 #include <linux/if_vlan.h> 19 #include <linux/init.h> 20 #include <linux/ip.h> 21 #include <linux/ipv6.h> 22 #include <linux/kernel.h> 23 #include <linux/kobject.h> 24 #include <linux/kref.h> 25 #include <linux/list.h> 26 #include <linux/minmax.h> 27 #include <linux/module.h> 28 #include <linux/netdevice.h> 29 #include <linux/printk.h> 30 #include <linux/rculist.h> 31 #include <linux/rcupdate.h> 32 #include <linux/skbuff.h> 33 #include <linux/slab.h> 34 #include <linux/spinlock.h> 35 #include <linux/stddef.h> 36 #include <linux/string.h> 37 #include <linux/workqueue.h> 38 #include <net/dsfield.h> 39 #include <net/rtnetlink.h> 40 #include <uapi/linux/batadv_packet.h> 41 #include <uapi/linux/batman_adv.h> 42 43 #include "bat_algo.h" 44 #include "bat_iv_ogm.h" 45 #include "bat_v.h" 46 #include "bridge_loop_avoidance.h" 47 #include "distributed-arp-table.h" 48 #include "gateway_client.h" 49 #include "gateway_common.h" 50 #include "hard-interface.h" 51 #include "log.h" 52 #include "multicast.h" 53 #include "netlink.h" 54 #include "network-coding.h" 55 #include "originator.h" 56 #include "routing.h" 57 #include "send.h" 58 #include "soft-interface.h" 59 #include "tp_meter.h" 60 #include "translation-table.h" 61 62 /* List manipulations on hardif_list have to be rtnl_lock()'ed, 63 * list traversals just rcu-locked 64 */ 65 struct list_head batadv_hardif_list; 66 unsigned int batadv_hardif_generation; 67 static int (*batadv_rx_handler[256])(struct sk_buff *skb, 68 struct batadv_hard_iface *recv_if); 69 70 unsigned char batadv_broadcast_addr[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; 71 72 struct workqueue_struct *batadv_event_workqueue; 73 74 static void batadv_recv_handler_init(void); 75 76 #define BATADV_UEV_TYPE_VAR "BATTYPE=" 77 #define BATADV_UEV_ACTION_VAR "BATACTION=" 78 #define BATADV_UEV_DATA_VAR "BATDATA=" 79 80 static char *batadv_uev_action_str[] = { 81 "add", 82 "del", 83 "change", 84 "loopdetect", 85 }; 86 87 static char *batadv_uev_type_str[] = { 88 "gw", 89 "bla", 90 }; 91 92 static int __init batadv_init(void) 93 { 94 int ret; 95 96 ret = batadv_tt_cache_init(); 97 if (ret < 0) 98 return ret; 99 100 INIT_LIST_HEAD(&batadv_hardif_list); 101 batadv_algo_init(); 102 103 batadv_recv_handler_init(); 104 105 batadv_v_init(); 106 batadv_iv_init(); 107 batadv_nc_init(); 108 batadv_tp_meter_init(); 109 110 batadv_event_workqueue = create_singlethread_workqueue("bat_events"); 111 if (!batadv_event_workqueue) 112 goto err_create_wq; 113 114 register_netdevice_notifier(&batadv_hard_if_notifier); 115 rtnl_link_register(&batadv_link_ops); 116 batadv_netlink_register(); 117 118 pr_info("B.A.T.M.A.N. advanced %s (compatibility version %i) loaded\n", 119 BATADV_SOURCE_VERSION, BATADV_COMPAT_VERSION); 120 121 return 0; 122 123 err_create_wq: 124 batadv_tt_cache_destroy(); 125 126 return -ENOMEM; 127 } 128 129 static void __exit batadv_exit(void) 130 { 131 batadv_netlink_unregister(); 132 rtnl_link_unregister(&batadv_link_ops); 133 unregister_netdevice_notifier(&batadv_hard_if_notifier); 134 135 flush_workqueue(batadv_event_workqueue); 136 destroy_workqueue(batadv_event_workqueue); 137 batadv_event_workqueue = NULL; 138 139 rcu_barrier(); 140 141 batadv_tt_cache_destroy(); 142 } 143 144 /** 145 * batadv_mesh_init() - Initialize soft interface 146 * @soft_iface: netdev struct of the soft interface 147 * 148 * Return: 0 on success or negative error number in case of failure 149 */ 150 int batadv_mesh_init(struct net_device *soft_iface) 151 { 152 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 153 int ret; 154 155 spin_lock_init(&bat_priv->forw_bat_list_lock); 156 spin_lock_init(&bat_priv->forw_bcast_list_lock); 157 spin_lock_init(&bat_priv->tt.changes_list_lock); 158 spin_lock_init(&bat_priv->tt.req_list_lock); 159 spin_lock_init(&bat_priv->tt.roam_list_lock); 160 spin_lock_init(&bat_priv->tt.last_changeset_lock); 161 spin_lock_init(&bat_priv->tt.commit_lock); 162 spin_lock_init(&bat_priv->gw.list_lock); 163 #ifdef CONFIG_BATMAN_ADV_MCAST 164 spin_lock_init(&bat_priv->mcast.mla_lock); 165 spin_lock_init(&bat_priv->mcast.want_lists_lock); 166 #endif 167 spin_lock_init(&bat_priv->tvlv.container_list_lock); 168 spin_lock_init(&bat_priv->tvlv.handler_list_lock); 169 spin_lock_init(&bat_priv->softif_vlan_list_lock); 170 spin_lock_init(&bat_priv->tp_list_lock); 171 172 INIT_HLIST_HEAD(&bat_priv->forw_bat_list); 173 INIT_HLIST_HEAD(&bat_priv->forw_bcast_list); 174 INIT_HLIST_HEAD(&bat_priv->gw.gateway_list); 175 #ifdef CONFIG_BATMAN_ADV_MCAST 176 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_unsnoopables_list); 177 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv4_list); 178 INIT_HLIST_HEAD(&bat_priv->mcast.want_all_ipv6_list); 179 #endif 180 INIT_LIST_HEAD(&bat_priv->tt.changes_list); 181 INIT_HLIST_HEAD(&bat_priv->tt.req_list); 182 INIT_LIST_HEAD(&bat_priv->tt.roam_list); 183 #ifdef CONFIG_BATMAN_ADV_MCAST 184 INIT_HLIST_HEAD(&bat_priv->mcast.mla_list); 185 #endif 186 INIT_HLIST_HEAD(&bat_priv->tvlv.container_list); 187 INIT_HLIST_HEAD(&bat_priv->tvlv.handler_list); 188 INIT_HLIST_HEAD(&bat_priv->softif_vlan_list); 189 INIT_HLIST_HEAD(&bat_priv->tp_list); 190 191 bat_priv->gw.generation = 0; 192 193 ret = batadv_v_mesh_init(bat_priv); 194 if (ret < 0) 195 goto err; 196 197 ret = batadv_originator_init(bat_priv); 198 if (ret < 0) 199 goto err; 200 201 ret = batadv_tt_init(bat_priv); 202 if (ret < 0) 203 goto err; 204 205 ret = batadv_bla_init(bat_priv); 206 if (ret < 0) 207 goto err; 208 209 ret = batadv_dat_init(bat_priv); 210 if (ret < 0) 211 goto err; 212 213 ret = batadv_nc_mesh_init(bat_priv); 214 if (ret < 0) 215 goto err; 216 217 batadv_gw_init(bat_priv); 218 batadv_mcast_init(bat_priv); 219 220 atomic_set(&bat_priv->gw.reselect, 0); 221 atomic_set(&bat_priv->mesh_state, BATADV_MESH_ACTIVE); 222 223 return 0; 224 225 err: 226 batadv_mesh_free(soft_iface); 227 return ret; 228 } 229 230 /** 231 * batadv_mesh_free() - Deinitialize soft interface 232 * @soft_iface: netdev struct of the soft interface 233 */ 234 void batadv_mesh_free(struct net_device *soft_iface) 235 { 236 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 237 238 atomic_set(&bat_priv->mesh_state, BATADV_MESH_DEACTIVATING); 239 240 batadv_purge_outstanding_packets(bat_priv, NULL); 241 242 batadv_gw_node_free(bat_priv); 243 244 batadv_v_mesh_free(bat_priv); 245 batadv_nc_mesh_free(bat_priv); 246 batadv_dat_free(bat_priv); 247 batadv_bla_free(bat_priv); 248 249 batadv_mcast_free(bat_priv); 250 251 /* Free the TT and the originator tables only after having terminated 252 * all the other depending components which may use these structures for 253 * their purposes. 254 */ 255 batadv_tt_free(bat_priv); 256 257 /* Since the originator table clean up routine is accessing the TT 258 * tables as well, it has to be invoked after the TT tables have been 259 * freed and marked as empty. This ensures that no cleanup RCU callbacks 260 * accessing the TT data are scheduled for later execution. 261 */ 262 batadv_originator_free(bat_priv); 263 264 batadv_gw_free(bat_priv); 265 266 free_percpu(bat_priv->bat_counters); 267 bat_priv->bat_counters = NULL; 268 269 atomic_set(&bat_priv->mesh_state, BATADV_MESH_INACTIVE); 270 } 271 272 /** 273 * batadv_is_my_mac() - check if the given mac address belongs to any of the 274 * real interfaces in the current mesh 275 * @bat_priv: the bat priv with all the soft interface information 276 * @addr: the address to check 277 * 278 * Return: 'true' if the mac address was found, false otherwise. 279 */ 280 bool batadv_is_my_mac(struct batadv_priv *bat_priv, const u8 *addr) 281 { 282 const struct batadv_hard_iface *hard_iface; 283 bool is_my_mac = false; 284 285 rcu_read_lock(); 286 list_for_each_entry_rcu(hard_iface, &batadv_hardif_list, list) { 287 if (hard_iface->if_status != BATADV_IF_ACTIVE) 288 continue; 289 290 if (hard_iface->soft_iface != bat_priv->soft_iface) 291 continue; 292 293 if (batadv_compare_eth(hard_iface->net_dev->dev_addr, addr)) { 294 is_my_mac = true; 295 break; 296 } 297 } 298 rcu_read_unlock(); 299 return is_my_mac; 300 } 301 302 /** 303 * batadv_max_header_len() - calculate maximum encapsulation overhead for a 304 * payload packet 305 * 306 * Return: the maximum encapsulation overhead in bytes. 307 */ 308 int batadv_max_header_len(void) 309 { 310 int header_len = 0; 311 312 header_len = max_t(int, header_len, 313 sizeof(struct batadv_unicast_packet)); 314 header_len = max_t(int, header_len, 315 sizeof(struct batadv_unicast_4addr_packet)); 316 header_len = max_t(int, header_len, 317 sizeof(struct batadv_bcast_packet)); 318 319 #ifdef CONFIG_BATMAN_ADV_NC 320 header_len = max_t(int, header_len, 321 sizeof(struct batadv_coded_packet)); 322 #endif 323 324 return header_len + ETH_HLEN; 325 } 326 327 /** 328 * batadv_skb_set_priority() - sets skb priority according to packet content 329 * @skb: the packet to be sent 330 * @offset: offset to the packet content 331 * 332 * This function sets a value between 256 and 263 (802.1d priority), which 333 * can be interpreted by the cfg80211 or other drivers. 334 */ 335 void batadv_skb_set_priority(struct sk_buff *skb, int offset) 336 { 337 struct iphdr ip_hdr_tmp, *ip_hdr; 338 struct ipv6hdr ip6_hdr_tmp, *ip6_hdr; 339 struct ethhdr ethhdr_tmp, *ethhdr; 340 struct vlan_ethhdr *vhdr, vhdr_tmp; 341 u32 prio; 342 343 /* already set, do nothing */ 344 if (skb->priority >= 256 && skb->priority <= 263) 345 return; 346 347 ethhdr = skb_header_pointer(skb, offset, sizeof(*ethhdr), ðhdr_tmp); 348 if (!ethhdr) 349 return; 350 351 switch (ethhdr->h_proto) { 352 case htons(ETH_P_8021Q): 353 vhdr = skb_header_pointer(skb, offset + sizeof(*vhdr), 354 sizeof(*vhdr), &vhdr_tmp); 355 if (!vhdr) 356 return; 357 prio = ntohs(vhdr->h_vlan_TCI) & VLAN_PRIO_MASK; 358 prio = prio >> VLAN_PRIO_SHIFT; 359 break; 360 case htons(ETH_P_IP): 361 ip_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr), 362 sizeof(*ip_hdr), &ip_hdr_tmp); 363 if (!ip_hdr) 364 return; 365 prio = (ipv4_get_dsfield(ip_hdr) & 0xfc) >> 5; 366 break; 367 case htons(ETH_P_IPV6): 368 ip6_hdr = skb_header_pointer(skb, offset + sizeof(*ethhdr), 369 sizeof(*ip6_hdr), &ip6_hdr_tmp); 370 if (!ip6_hdr) 371 return; 372 prio = (ipv6_get_dsfield(ip6_hdr) & 0xfc) >> 5; 373 break; 374 default: 375 return; 376 } 377 378 skb->priority = prio + 256; 379 } 380 381 static int batadv_recv_unhandled_packet(struct sk_buff *skb, 382 struct batadv_hard_iface *recv_if) 383 { 384 kfree_skb(skb); 385 386 return NET_RX_DROP; 387 } 388 389 /* incoming packets with the batman ethertype received on any active hard 390 * interface 391 */ 392 393 /** 394 * batadv_batman_skb_recv() - Handle incoming message from an hard interface 395 * @skb: the received packet 396 * @dev: the net device that the packet was received on 397 * @ptype: packet type of incoming packet (ETH_P_BATMAN) 398 * @orig_dev: the original receive net device (e.g. bonded device) 399 * 400 * Return: NET_RX_SUCCESS on success or NET_RX_DROP in case of failure 401 */ 402 int batadv_batman_skb_recv(struct sk_buff *skb, struct net_device *dev, 403 struct packet_type *ptype, 404 struct net_device *orig_dev) 405 { 406 struct batadv_priv *bat_priv; 407 struct batadv_ogm_packet *batadv_ogm_packet; 408 struct batadv_hard_iface *hard_iface; 409 u8 idx; 410 411 hard_iface = container_of(ptype, struct batadv_hard_iface, 412 batman_adv_ptype); 413 414 /* Prevent processing a packet received on an interface which is getting 415 * shut down otherwise the packet may trigger de-reference errors 416 * further down in the receive path. 417 */ 418 if (!kref_get_unless_zero(&hard_iface->refcount)) 419 goto err_out; 420 421 skb = skb_share_check(skb, GFP_ATOMIC); 422 423 /* skb was released by skb_share_check() */ 424 if (!skb) 425 goto err_put; 426 427 /* packet should hold at least type and version */ 428 if (unlikely(!pskb_may_pull(skb, 2))) 429 goto err_free; 430 431 /* expect a valid ethernet header here. */ 432 if (unlikely(skb->mac_len != ETH_HLEN || !skb_mac_header(skb))) 433 goto err_free; 434 435 if (!hard_iface->soft_iface) 436 goto err_free; 437 438 bat_priv = netdev_priv(hard_iface->soft_iface); 439 440 if (atomic_read(&bat_priv->mesh_state) != BATADV_MESH_ACTIVE) 441 goto err_free; 442 443 /* discard frames on not active interfaces */ 444 if (hard_iface->if_status != BATADV_IF_ACTIVE) 445 goto err_free; 446 447 batadv_ogm_packet = (struct batadv_ogm_packet *)skb->data; 448 449 if (batadv_ogm_packet->version != BATADV_COMPAT_VERSION) { 450 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 451 "Drop packet: incompatible batman version (%i)\n", 452 batadv_ogm_packet->version); 453 goto err_free; 454 } 455 456 /* reset control block to avoid left overs from previous users */ 457 memset(skb->cb, 0, sizeof(struct batadv_skb_cb)); 458 459 idx = batadv_ogm_packet->packet_type; 460 (*batadv_rx_handler[idx])(skb, hard_iface); 461 462 batadv_hardif_put(hard_iface); 463 464 /* return NET_RX_SUCCESS in any case as we 465 * most probably dropped the packet for 466 * routing-logical reasons. 467 */ 468 return NET_RX_SUCCESS; 469 470 err_free: 471 kfree_skb(skb); 472 err_put: 473 batadv_hardif_put(hard_iface); 474 err_out: 475 return NET_RX_DROP; 476 } 477 478 static void batadv_recv_handler_init(void) 479 { 480 int i; 481 482 for (i = 0; i < ARRAY_SIZE(batadv_rx_handler); i++) 483 batadv_rx_handler[i] = batadv_recv_unhandled_packet; 484 485 for (i = BATADV_UNICAST_MIN; i <= BATADV_UNICAST_MAX; i++) 486 batadv_rx_handler[i] = batadv_recv_unhandled_unicast_packet; 487 488 /* compile time checks for sizes */ 489 BUILD_BUG_ON(sizeof(struct batadv_bla_claim_dst) != 6); 490 BUILD_BUG_ON(sizeof(struct batadv_ogm_packet) != 24); 491 BUILD_BUG_ON(sizeof(struct batadv_icmp_header) != 20); 492 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet) != 20); 493 BUILD_BUG_ON(sizeof(struct batadv_icmp_packet_rr) != 116); 494 BUILD_BUG_ON(sizeof(struct batadv_unicast_packet) != 10); 495 BUILD_BUG_ON(sizeof(struct batadv_unicast_4addr_packet) != 18); 496 BUILD_BUG_ON(sizeof(struct batadv_frag_packet) != 20); 497 BUILD_BUG_ON(sizeof(struct batadv_bcast_packet) != 14); 498 BUILD_BUG_ON(sizeof(struct batadv_coded_packet) != 46); 499 BUILD_BUG_ON(sizeof(struct batadv_unicast_tvlv_packet) != 20); 500 BUILD_BUG_ON(sizeof(struct batadv_tvlv_hdr) != 4); 501 BUILD_BUG_ON(sizeof(struct batadv_tvlv_gateway_data) != 8); 502 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_vlan_data) != 8); 503 BUILD_BUG_ON(sizeof(struct batadv_tvlv_tt_change) != 12); 504 BUILD_BUG_ON(sizeof(struct batadv_tvlv_roam_adv) != 8); 505 506 i = sizeof_field(struct sk_buff, cb); 507 BUILD_BUG_ON(sizeof(struct batadv_skb_cb) > i); 508 509 /* broadcast packet */ 510 batadv_rx_handler[BATADV_BCAST] = batadv_recv_bcast_packet; 511 512 /* unicast packets ... */ 513 /* unicast with 4 addresses packet */ 514 batadv_rx_handler[BATADV_UNICAST_4ADDR] = batadv_recv_unicast_packet; 515 /* unicast packet */ 516 batadv_rx_handler[BATADV_UNICAST] = batadv_recv_unicast_packet; 517 /* unicast tvlv packet */ 518 batadv_rx_handler[BATADV_UNICAST_TVLV] = batadv_recv_unicast_tvlv; 519 /* batman icmp packet */ 520 batadv_rx_handler[BATADV_ICMP] = batadv_recv_icmp_packet; 521 /* Fragmented packets */ 522 batadv_rx_handler[BATADV_UNICAST_FRAG] = batadv_recv_frag_packet; 523 } 524 525 /** 526 * batadv_recv_handler_register() - Register handler for batman-adv packet type 527 * @packet_type: batadv_packettype which should be handled 528 * @recv_handler: receive handler for the packet type 529 * 530 * Return: 0 on success or negative error number in case of failure 531 */ 532 int 533 batadv_recv_handler_register(u8 packet_type, 534 int (*recv_handler)(struct sk_buff *, 535 struct batadv_hard_iface *)) 536 { 537 int (*curr)(struct sk_buff *skb, 538 struct batadv_hard_iface *recv_if); 539 curr = batadv_rx_handler[packet_type]; 540 541 if (curr != batadv_recv_unhandled_packet && 542 curr != batadv_recv_unhandled_unicast_packet) 543 return -EBUSY; 544 545 batadv_rx_handler[packet_type] = recv_handler; 546 return 0; 547 } 548 549 /** 550 * batadv_recv_handler_unregister() - Unregister handler for packet type 551 * @packet_type: batadv_packettype which should no longer be handled 552 */ 553 void batadv_recv_handler_unregister(u8 packet_type) 554 { 555 batadv_rx_handler[packet_type] = batadv_recv_unhandled_packet; 556 } 557 558 /** 559 * batadv_skb_crc32() - calculate CRC32 of the whole packet and skip bytes in 560 * the header 561 * @skb: skb pointing to fragmented socket buffers 562 * @payload_ptr: Pointer to position inside the head buffer of the skb 563 * marking the start of the data to be CRC'ed 564 * 565 * payload_ptr must always point to an address in the skb head buffer and not to 566 * a fragment. 567 * 568 * Return: big endian crc32c of the checksummed data 569 */ 570 __be32 batadv_skb_crc32(struct sk_buff *skb, u8 *payload_ptr) 571 { 572 u32 crc = 0; 573 unsigned int from; 574 unsigned int to = skb->len; 575 struct skb_seq_state st; 576 const u8 *data; 577 unsigned int len; 578 unsigned int consumed = 0; 579 580 from = (unsigned int)(payload_ptr - skb->data); 581 582 skb_prepare_seq_read(skb, from, to, &st); 583 while ((len = skb_seq_read(consumed, &data, &st)) != 0) { 584 crc = crc32c(crc, data, len); 585 consumed += len; 586 } 587 588 return htonl(crc); 589 } 590 591 /** 592 * batadv_get_vid() - extract the VLAN identifier from skb if any 593 * @skb: the buffer containing the packet 594 * @header_len: length of the batman header preceding the ethernet header 595 * 596 * Return: VID with the BATADV_VLAN_HAS_TAG flag when the packet embedded in the 597 * skb is vlan tagged. Otherwise BATADV_NO_FLAGS. 598 */ 599 unsigned short batadv_get_vid(struct sk_buff *skb, size_t header_len) 600 { 601 struct ethhdr *ethhdr = (struct ethhdr *)(skb->data + header_len); 602 struct vlan_ethhdr *vhdr; 603 unsigned short vid; 604 605 if (ethhdr->h_proto != htons(ETH_P_8021Q)) 606 return BATADV_NO_FLAGS; 607 608 if (!pskb_may_pull(skb, header_len + VLAN_ETH_HLEN)) 609 return BATADV_NO_FLAGS; 610 611 vhdr = (struct vlan_ethhdr *)(skb->data + header_len); 612 vid = ntohs(vhdr->h_vlan_TCI) & VLAN_VID_MASK; 613 vid |= BATADV_VLAN_HAS_TAG; 614 615 return vid; 616 } 617 618 /** 619 * batadv_vlan_ap_isola_get() - return AP isolation status for the given vlan 620 * @bat_priv: the bat priv with all the soft interface information 621 * @vid: the VLAN identifier for which the AP isolation attributed as to be 622 * looked up 623 * 624 * Return: true if AP isolation is on for the VLAN identified by vid, false 625 * otherwise 626 */ 627 bool batadv_vlan_ap_isola_get(struct batadv_priv *bat_priv, unsigned short vid) 628 { 629 bool ap_isolation_enabled = false; 630 struct batadv_softif_vlan *vlan; 631 632 /* if the AP isolation is requested on a VLAN, then check for its 633 * setting in the proper VLAN private data structure 634 */ 635 vlan = batadv_softif_vlan_get(bat_priv, vid); 636 if (vlan) { 637 ap_isolation_enabled = atomic_read(&vlan->ap_isolation); 638 batadv_softif_vlan_put(vlan); 639 } 640 641 return ap_isolation_enabled; 642 } 643 644 /** 645 * batadv_throw_uevent() - Send an uevent with batman-adv specific env data 646 * @bat_priv: the bat priv with all the soft interface information 647 * @type: subsystem type of event. Stored in uevent's BATTYPE 648 * @action: action type of event. Stored in uevent's BATACTION 649 * @data: string with additional information to the event (ignored for 650 * BATADV_UEV_DEL). Stored in uevent's BATDATA 651 * 652 * Return: 0 on success or negative error number in case of failure 653 */ 654 int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type, 655 enum batadv_uev_action action, const char *data) 656 { 657 int ret = -ENOMEM; 658 struct kobject *bat_kobj; 659 char *uevent_env[4] = { NULL, NULL, NULL, NULL }; 660 661 bat_kobj = &bat_priv->soft_iface->dev.kobj; 662 663 uevent_env[0] = kasprintf(GFP_ATOMIC, 664 "%s%s", BATADV_UEV_TYPE_VAR, 665 batadv_uev_type_str[type]); 666 if (!uevent_env[0]) 667 goto out; 668 669 uevent_env[1] = kasprintf(GFP_ATOMIC, 670 "%s%s", BATADV_UEV_ACTION_VAR, 671 batadv_uev_action_str[action]); 672 if (!uevent_env[1]) 673 goto out; 674 675 /* If the event is DEL, ignore the data field */ 676 if (action != BATADV_UEV_DEL) { 677 uevent_env[2] = kasprintf(GFP_ATOMIC, 678 "%s%s", BATADV_UEV_DATA_VAR, data); 679 if (!uevent_env[2]) 680 goto out; 681 } 682 683 ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env); 684 out: 685 kfree(uevent_env[0]); 686 kfree(uevent_env[1]); 687 kfree(uevent_env[2]); 688 689 if (ret) 690 batadv_dbg(BATADV_DBG_BATMAN, bat_priv, 691 "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n", 692 batadv_uev_type_str[type], 693 batadv_uev_action_str[action], 694 (action == BATADV_UEV_DEL ? "NULL" : data), ret); 695 return ret; 696 } 697 698 module_init(batadv_init); 699 module_exit(batadv_exit); 700 701 MODULE_LICENSE("GPL"); 702 703 MODULE_AUTHOR(BATADV_DRIVER_AUTHOR); 704 MODULE_DESCRIPTION(BATADV_DRIVER_DESC); 705 MODULE_SUPPORTED_DEVICE(BATADV_DRIVER_DEVICE); 706 MODULE_VERSION(BATADV_SOURCE_VERSION); 707 MODULE_ALIAS_RTNL_LINK("batadv"); 708 MODULE_ALIAS_GENL_FAMILY(BATADV_NL_NAME); 709