net/batman-adv/sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2010-2018  B.A.T.M.A.N. contributors:
   3  *
   4  * Marek Lindner
   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, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "sysfs.h"
  20 #include "main.h"
  21
  22 #include <linux/atomic.h>
  23 #include <linux/compiler.h>
  24 #include <linux/device.h>
  25 #include <linux/errno.h>
  26 #include <linux/gfp.h>
  27 #include <linux/if.h>
  28 #include <linux/if_vlan.h>
  29 #include <linux/kernel.h>
  30 #include <linux/kobject.h>
  31 #include <linux/kref.h>
  32 #include <linux/netdevice.h>
  33 #include <linux/printk.h>
  34 #include <linux/rculist.h>
  35 #include <linux/rcupdate.h>
  36 #include <linux/rtnetlink.h>
  37 #include <linux/slab.h>
  38 #include <linux/stddef.h>
  39 #include <linux/string.h>
  40 #include <linux/stringify.h>
  41 #include <linux/workqueue.h>
  42 #include <uapi/linux/batadv_packet.h>
  43
  44 #include "bridge_loop_avoidance.h"
  45 #include "distributed-arp-table.h"
  46 #include "gateway_client.h"
  47 #include "gateway_common.h"
  48 #include "hard-interface.h"
  49 #include "log.h"
  50 #include "network-coding.h"
  51 #include "soft-interface.h"
  52
  53 static struct net_device *batadv_kobj_to_netdev(struct kobject *obj)
  54 {
  55         struct device *dev = container_of(obj->parent, struct device, kobj);
  56
  57         return to_net_dev(dev);
  58 }
  59
  60 static struct batadv_priv *batadv_kobj_to_batpriv(struct kobject *obj)
  61 {
  62         struct net_device *net_dev = batadv_kobj_to_netdev(obj);
  63
  64         return netdev_priv(net_dev);
  65 }
  66
  67 /**
  68  * batadv_vlan_kobj_to_batpriv() - convert a vlan kobj in the associated batpriv
  69  * @obj: kobject to covert
  70  *
  71  * Return: the associated batadv_priv struct.
  72  */
  73 static struct batadv_priv *batadv_vlan_kobj_to_batpriv(struct kobject *obj)
  74 {
  75         /* VLAN specific attributes are located in the root sysfs folder if they
  76          * refer to the untagged VLAN..
  77          */
  78         if (!strcmp(BATADV_SYSFS_IF_MESH_SUBDIR, obj->name))
  79                 return batadv_kobj_to_batpriv(obj);
  80
  81         /* ..while the attributes for the tagged vlans are located in
  82          * the in the corresponding "vlan%VID" subfolder
  83          */
  84         return batadv_kobj_to_batpriv(obj->parent);
  85 }
  86
  87 /**
  88  * batadv_kobj_to_vlan() - convert a kobj in the associated softif_vlan struct
  89  * @bat_priv: the bat priv with all the soft interface information
  90  * @obj: kobject to covert
  91  *
  92  * Return: the associated softif_vlan struct if found, NULL otherwise.
  93  */
  94 static struct batadv_softif_vlan *
  95 batadv_kobj_to_vlan(struct batadv_priv *bat_priv, struct kobject *obj)
  96 {
  97         struct batadv_softif_vlan *vlan_tmp, *vlan = NULL;
  98
  99         rcu_read_lock();
 100         hlist_for_each_entry_rcu(vlan_tmp, &bat_priv->softif_vlan_list, list) {
 101                 if (vlan_tmp->kobj != obj)
 102                         continue;
 103
 104                 if (!kref_get_unless_zero(&vlan_tmp->refcount))
 105                         continue;
 106
 107                 vlan = vlan_tmp;
 108                 break;
 109         }
 110         rcu_read_unlock();
 111
 112         return vlan;
 113 }
 114
 115 #define BATADV_UEV_TYPE_VAR     "BATTYPE="
 116 #define BATADV_UEV_ACTION_VAR   "BATACTION="
 117 #define BATADV_UEV_DATA_VAR     "BATDATA="
 118
 119 static char *batadv_uev_action_str[] = {
 120         "add",
 121         "del",
 122         "change",
 123         "loopdetect",
 124 };
 125
 126 static char *batadv_uev_type_str[] = {
 127         "gw",
 128         "bla",
 129 };
 130
 131 /* Use this, if you have customized show and store functions for vlan attrs */
 132 #define BATADV_ATTR_VLAN(_name, _mode, _show, _store)   \
 133 struct batadv_attribute batadv_attr_vlan_##_name = {    \
 134         .attr = {.name = __stringify(_name),            \
 135                  .mode = _mode },                       \
 136         .show   = _show,                                \
 137         .store  = _store,                               \
 138 }
 139
 140 /* Use this, if you have customized show and store functions */
 141 #define BATADV_ATTR(_name, _mode, _show, _store)        \
 142 struct batadv_attribute batadv_attr_##_name = {         \
 143         .attr = {.name = __stringify(_name),            \
 144                  .mode = _mode },                       \
 145         .show   = _show,                                \
 146         .store  = _store,                               \
 147 }
 148
 149 #define BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func)                   \
 150 ssize_t batadv_store_##_name(struct kobject *kobj,                      \
 151                              struct attribute *attr, char *buff,        \
 152                              size_t count)                              \
 153 {                                                                       \
 154         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);       \
 155         struct batadv_priv *bat_priv = netdev_priv(net_dev);            \
 156                                                                         \
 157         return __batadv_store_bool_attr(buff, count, _post_func, attr,  \
 158                                         &bat_priv->_name, net_dev);     \
 159 }
 160
 161 #define BATADV_ATTR_SIF_SHOW_BOOL(_name)                                \
 162 ssize_t batadv_show_##_name(struct kobject *kobj,                       \
 163                             struct attribute *attr, char *buff)         \
 164 {                                                                       \
 165         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);    \
 166                                                                         \
 167         return sprintf(buff, "%s\n",                                    \
 168                        atomic_read(&bat_priv->_name) == 0 ?             \
 169                        "disabled" : "enabled");                         \
 170 }                                                                       \
 171
 172 /* Use this, if you are going to turn a [name] in the soft-interface
 173  * (bat_priv) on or off
 174  */
 175 #define BATADV_ATTR_SIF_BOOL(_name, _mode, _post_func)                  \
 176         static BATADV_ATTR_SIF_STORE_BOOL(_name, _post_func)            \
 177         static BATADV_ATTR_SIF_SHOW_BOOL(_name)                         \
 178         static BATADV_ATTR(_name, _mode, batadv_show_##_name,           \
 179                            batadv_store_##_name)
 180
 181 #define BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func) \
 182 ssize_t batadv_store_##_name(struct kobject *kobj,                      \
 183                              struct attribute *attr, char *buff,        \
 184                              size_t count)                              \
 185 {                                                                       \
 186         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);       \
 187         struct batadv_priv *bat_priv = netdev_priv(net_dev);            \
 188                                                                         \
 189         return __batadv_store_uint_attr(buff, count, _min, _max,        \
 190                                         _post_func, attr,               \
 191                                         &bat_priv->_var, net_dev,       \
 192                                         NULL);  \
 193 }
 194
 195 #define BATADV_ATTR_SIF_SHOW_UINT(_name, _var)                          \
 196 ssize_t batadv_show_##_name(struct kobject *kobj,                       \
 197                             struct attribute *attr, char *buff)         \
 198 {                                                                       \
 199         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);    \
 200                                                                         \
 201         return sprintf(buff, "%i\n", atomic_read(&bat_priv->_var));     \
 202 }                                                                       \
 203
 204 /* Use this, if you are going to set [name] in the soft-interface
 205  * (bat_priv) to an unsigned integer value
 206  */
 207 #define BATADV_ATTR_SIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
 208         static BATADV_ATTR_SIF_STORE_UINT(_name, _var, _min, _max, _post_func)\
 209         static BATADV_ATTR_SIF_SHOW_UINT(_name, _var)                   \
 210         static BATADV_ATTR(_name, _mode, batadv_show_##_name,           \
 211                            batadv_store_##_name)
 212
 213 #define BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func)                  \
 214 ssize_t batadv_store_vlan_##_name(struct kobject *kobj,                 \
 215                                   struct attribute *attr, char *buff,   \
 216                                   size_t count)                         \
 217 {                                                                       \
 218         struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
 219         struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
 220                                                               kobj);    \
 221         size_t res = __batadv_store_bool_attr(buff, count, _post_func,  \
 222                                               attr, &vlan->_name,       \
 223                                               bat_priv->soft_iface);    \
 224                                                                         \
 225         batadv_softif_vlan_put(vlan);                                   \
 226         return res;                                                     \
 227 }
 228
 229 #define BATADV_ATTR_VLAN_SHOW_BOOL(_name)                               \
 230 ssize_t batadv_show_vlan_##_name(struct kobject *kobj,                  \
 231                                  struct attribute *attr, char *buff)    \
 232 {                                                                       \
 233         struct batadv_priv *bat_priv = batadv_vlan_kobj_to_batpriv(kobj);\
 234         struct batadv_softif_vlan *vlan = batadv_kobj_to_vlan(bat_priv, \
 235                                                               kobj);    \
 236         size_t res = sprintf(buff, "%s\n",                              \
 237                              atomic_read(&vlan->_name) == 0 ?           \
 238                              "disabled" : "enabled");                   \
 239                                                                         \
 240         batadv_softif_vlan_put(vlan);                                   \
 241         return res;                                                     \
 242 }
 243
 244 /* Use this, if you are going to turn a [name] in the vlan struct on or off */
 245 #define BATADV_ATTR_VLAN_BOOL(_name, _mode, _post_func)                 \
 246         static BATADV_ATTR_VLAN_STORE_BOOL(_name, _post_func)           \
 247         static BATADV_ATTR_VLAN_SHOW_BOOL(_name)                        \
 248         static BATADV_ATTR_VLAN(_name, _mode, batadv_show_vlan_##_name, \
 249                                 batadv_store_vlan_##_name)
 250
 251 #define BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min, _max, _post_func) \
 252 ssize_t batadv_store_##_name(struct kobject *kobj,                      \
 253                              struct attribute *attr, char *buff,        \
 254                              size_t count)                              \
 255 {                                                                       \
 256         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);       \
 257         struct batadv_hard_iface *hard_iface;                           \
 258         ssize_t length;                                                 \
 259                                                                         \
 260         hard_iface = batadv_hardif_get_by_netdev(net_dev);              \
 261         if (!hard_iface)                                                \
 262                 return 0;                                               \
 263                                                                         \
 264         length = __batadv_store_uint_attr(buff, count, _min, _max,      \
 265                                           _post_func, attr,             \
 266                                           &hard_iface->_var,            \
 267                                           hard_iface->soft_iface,       \
 268                                           net_dev);                     \
 269                                                                         \
 270         batadv_hardif_put(hard_iface);                          \
 271         return length;                                                  \
 272 }
 273
 274 #define BATADV_ATTR_HIF_SHOW_UINT(_name, _var)                          \
 275 ssize_t batadv_show_##_name(struct kobject *kobj,                       \
 276                             struct attribute *attr, char *buff)         \
 277 {                                                                       \
 278         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);       \
 279         struct batadv_hard_iface *hard_iface;                           \
 280         ssize_t length;                                                 \
 281                                                                         \
 282         hard_iface = batadv_hardif_get_by_netdev(net_dev);              \
 283         if (!hard_iface)                                                \
 284                 return 0;                                               \
 285                                                                         \
 286         length = sprintf(buff, "%i\n", atomic_read(&hard_iface->_var)); \
 287                                                                         \
 288         batadv_hardif_put(hard_iface);                          \
 289         return length;                                                  \
 290 }
 291
 292 /* Use this, if you are going to set [name] in hard_iface to an
 293  * unsigned integer value
 294  */
 295 #define BATADV_ATTR_HIF_UINT(_name, _var, _mode, _min, _max, _post_func)\
 296         static BATADV_ATTR_HIF_STORE_UINT(_name, _var, _min,            \
 297                                           _max, _post_func)             \
 298         static BATADV_ATTR_HIF_SHOW_UINT(_name, _var)                   \
 299         static BATADV_ATTR(_name, _mode, batadv_show_##_name,           \
 300                            batadv_store_##_name)
 301
 302 static int batadv_store_bool_attr(char *buff, size_t count,
 303                                   struct net_device *net_dev,
 304                                   const char *attr_name, atomic_t *attr,
 305                                   bool *changed)
 306 {
 307         int enabled = -1;
 308
 309         *changed = false;
 310
 311         if (buff[count - 1] == '\n')
 312                 buff[count - 1] = '\0';
 313
 314         if ((strncmp(buff, "1", 2) == 0) ||
 315             (strncmp(buff, "enable", 7) == 0) ||
 316             (strncmp(buff, "enabled", 8) == 0))
 317                 enabled = 1;
 318
 319         if ((strncmp(buff, "0", 2) == 0) ||
 320             (strncmp(buff, "disable", 8) == 0) ||
 321             (strncmp(buff, "disabled", 9) == 0))
 322                 enabled = 0;
 323
 324         if (enabled < 0) {
 325                 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
 326                             attr_name, buff);
 327                 return -EINVAL;
 328         }
 329
 330         if (atomic_read(attr) == enabled)
 331                 return count;
 332
 333         batadv_info(net_dev, "%s: Changing from: %s to: %s\n", attr_name,
 334                     atomic_read(attr) == 1 ? "enabled" : "disabled",
 335                     enabled == 1 ? "enabled" : "disabled");
 336
 337         *changed = true;
 338
 339         atomic_set(attr, (unsigned int)enabled);
 340         return count;
 341 }
 342
 343 static inline ssize_t
 344 __batadv_store_bool_attr(char *buff, size_t count,
 345                          void (*post_func)(struct net_device *),
 346                          struct attribute *attr,
 347                          atomic_t *attr_store, struct net_device *net_dev)
 348 {
 349         bool changed;
 350         int ret;
 351
 352         ret = batadv_store_bool_attr(buff, count, net_dev, attr->name,
 353                                      attr_store, &changed);
 354         if (post_func && changed)
 355                 post_func(net_dev);
 356
 357         return ret;
 358 }
 359
 360 static int batadv_store_uint_attr(const char *buff, size_t count,
 361                                   struct net_device *net_dev,
 362                                   struct net_device *slave_dev,
 363                                   const char *attr_name,
 364                                   unsigned int min, unsigned int max,
 365                                   atomic_t *attr)
 366 {
 367         char ifname[IFNAMSIZ + 3] = "";
 368         unsigned long uint_val;
 369         int ret;
 370
 371         ret = kstrtoul(buff, 10, &uint_val);
 372         if (ret) {
 373                 batadv_info(net_dev, "%s: Invalid parameter received: %s\n",
 374                             attr_name, buff);
 375                 return -EINVAL;
 376         }
 377
 378         if (uint_val < min) {
 379                 batadv_info(net_dev, "%s: Value is too small: %lu min: %u\n",
 380                             attr_name, uint_val, min);
 381                 return -EINVAL;
 382         }
 383
 384         if (uint_val > max) {
 385                 batadv_info(net_dev, "%s: Value is too big: %lu max: %u\n",
 386                             attr_name, uint_val, max);
 387                 return -EINVAL;
 388         }
 389
 390         if (atomic_read(attr) == uint_val)
 391                 return count;
 392
 393         if (slave_dev)
 394                 snprintf(ifname, sizeof(ifname), "%s: ", slave_dev->name);
 395
 396         batadv_info(net_dev, "%s: %sChanging from: %i to: %lu\n",
 397                     attr_name, ifname, atomic_read(attr), uint_val);
 398
 399         atomic_set(attr, uint_val);
 400         return count;
 401 }
 402
 403 static ssize_t __batadv_store_uint_attr(const char *buff, size_t count,
 404                                         int min, int max,
 405                                         void (*post_func)(struct net_device *),
 406                                         const struct attribute *attr,
 407                                         atomic_t *attr_store,
 408                                         struct net_device *net_dev,
 409                                         struct net_device *slave_dev)
 410 {
 411         int ret;
 412
 413         ret = batadv_store_uint_attr(buff, count, net_dev, slave_dev,
 414                                      attr->name, min, max, attr_store);
 415         if (post_func && ret)
 416                 post_func(net_dev);
 417
 418         return ret;
 419 }
 420
 421 static ssize_t batadv_show_bat_algo(struct kobject *kobj,
 422                                     struct attribute *attr, char *buff)
 423 {
 424         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 425
 426         return sprintf(buff, "%s\n", bat_priv->algo_ops->name);
 427 }
 428
 429 static void batadv_post_gw_reselect(struct net_device *net_dev)
 430 {
 431         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 432
 433         batadv_gw_reselect(bat_priv);
 434 }
 435
 436 static ssize_t batadv_show_gw_mode(struct kobject *kobj, struct attribute *attr,
 437                                    char *buff)
 438 {
 439         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 440         int bytes_written;
 441
 442         /* GW mode is not available if the routing algorithm in use does not
 443          * implement the GW API
 444          */
 445         if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 446             !bat_priv->algo_ops->gw.is_eligible)
 447                 return -ENOENT;
 448
 449         switch (atomic_read(&bat_priv->gw.mode)) {
 450         case BATADV_GW_MODE_CLIENT:
 451                 bytes_written = sprintf(buff, "%s\n",
 452                                         BATADV_GW_MODE_CLIENT_NAME);
 453                 break;
 454         case BATADV_GW_MODE_SERVER:
 455                 bytes_written = sprintf(buff, "%s\n",
 456                                         BATADV_GW_MODE_SERVER_NAME);
 457                 break;
 458         default:
 459                 bytes_written = sprintf(buff, "%s\n",
 460                                         BATADV_GW_MODE_OFF_NAME);
 461                 break;
 462         }
 463
 464         return bytes_written;
 465 }
 466
 467 static ssize_t batadv_store_gw_mode(struct kobject *kobj,
 468                                     struct attribute *attr, char *buff,
 469                                     size_t count)
 470 {
 471         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 472         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 473         char *curr_gw_mode_str;
 474         int gw_mode_tmp = -1;
 475
 476         /* toggling GW mode is allowed only if the routing algorithm in use
 477          * provides the GW API
 478          */
 479         if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 480             !bat_priv->algo_ops->gw.is_eligible)
 481                 return -EINVAL;
 482
 483         if (buff[count - 1] == '\n')
 484                 buff[count - 1] = '\0';
 485
 486         if (strncmp(buff, BATADV_GW_MODE_OFF_NAME,
 487                     strlen(BATADV_GW_MODE_OFF_NAME)) == 0)
 488                 gw_mode_tmp = BATADV_GW_MODE_OFF;
 489
 490         if (strncmp(buff, BATADV_GW_MODE_CLIENT_NAME,
 491                     strlen(BATADV_GW_MODE_CLIENT_NAME)) == 0)
 492                 gw_mode_tmp = BATADV_GW_MODE_CLIENT;
 493
 494         if (strncmp(buff, BATADV_GW_MODE_SERVER_NAME,
 495                     strlen(BATADV_GW_MODE_SERVER_NAME)) == 0)
 496                 gw_mode_tmp = BATADV_GW_MODE_SERVER;
 497
 498         if (gw_mode_tmp < 0) {
 499                 batadv_info(net_dev,
 500                             "Invalid parameter for 'gw mode' setting received: %s\n",
 501                             buff);
 502                 return -EINVAL;
 503         }
 504
 505         if (atomic_read(&bat_priv->gw.mode) == gw_mode_tmp)
 506                 return count;
 507
 508         switch (atomic_read(&bat_priv->gw.mode)) {
 509         case BATADV_GW_MODE_CLIENT:
 510                 curr_gw_mode_str = BATADV_GW_MODE_CLIENT_NAME;
 511                 break;
 512         case BATADV_GW_MODE_SERVER:
 513                 curr_gw_mode_str = BATADV_GW_MODE_SERVER_NAME;
 514                 break;
 515         default:
 516                 curr_gw_mode_str = BATADV_GW_MODE_OFF_NAME;
 517                 break;
 518         }
 519
 520         batadv_info(net_dev, "Changing gw mode from: %s to: %s\n",
 521                     curr_gw_mode_str, buff);
 522
 523         /* Invoking batadv_gw_reselect() is not enough to really de-select the
 524          * current GW. It will only instruct the gateway client code to perform
 525          * a re-election the next time that this is needed.
 526          *
 527          * When gw client mode is being switched off the current GW must be
 528          * de-selected explicitly otherwise no GW_ADD uevent is thrown on
 529          * client mode re-activation. This is operation is performed in
 530          * batadv_gw_check_client_stop().
 531          */
 532         batadv_gw_reselect(bat_priv);
 533         /* always call batadv_gw_check_client_stop() before changing the gateway
 534          * state
 535          */
 536         batadv_gw_check_client_stop(bat_priv);
 537         atomic_set(&bat_priv->gw.mode, (unsigned int)gw_mode_tmp);
 538         batadv_gw_tvlv_container_update(bat_priv);
 539         return count;
 540 }
 541
 542 static ssize_t batadv_show_gw_sel_class(struct kobject *kobj,
 543                                         struct attribute *attr, char *buff)
 544 {
 545         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 546
 547         /* GW selection class is not available if the routing algorithm in use
 548          * does not implement the GW API
 549          */
 550         if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 551             !bat_priv->algo_ops->gw.is_eligible)
 552                 return -ENOENT;
 553
 554         if (bat_priv->algo_ops->gw.show_sel_class)
 555                 return bat_priv->algo_ops->gw.show_sel_class(bat_priv, buff);
 556
 557         return sprintf(buff, "%i\n", atomic_read(&bat_priv->gw.sel_class));
 558 }
 559
 560 static ssize_t batadv_store_gw_sel_class(struct kobject *kobj,
 561                                          struct attribute *attr, char *buff,
 562                                          size_t count)
 563 {
 564         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 565
 566         /* setting the GW selection class is allowed only if the routing
 567          * algorithm in use implements the GW API
 568          */
 569         if (!bat_priv->algo_ops->gw.get_best_gw_node ||
 570             !bat_priv->algo_ops->gw.is_eligible)
 571                 return -EINVAL;
 572
 573         if (buff[count - 1] == '\n')
 574                 buff[count - 1] = '\0';
 575
 576         if (bat_priv->algo_ops->gw.store_sel_class)
 577                 return bat_priv->algo_ops->gw.store_sel_class(bat_priv, buff,
 578                                                               count);
 579
 580         return __batadv_store_uint_attr(buff, count, 1, BATADV_TQ_MAX_VALUE,
 581                                         batadv_post_gw_reselect, attr,
 582                                         &bat_priv->gw.sel_class,
 583                                         bat_priv->soft_iface, NULL);
 584 }
 585
 586 static ssize_t batadv_show_gw_bwidth(struct kobject *kobj,
 587                                      struct attribute *attr, char *buff)
 588 {
 589         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 590         u32 down, up;
 591
 592         down = atomic_read(&bat_priv->gw.bandwidth_down);
 593         up = atomic_read(&bat_priv->gw.bandwidth_up);
 594
 595         return sprintf(buff, "%u.%u/%u.%u MBit\n", down / 10,
 596                        down % 10, up / 10, up % 10);
 597 }
 598
 599 static ssize_t batadv_store_gw_bwidth(struct kobject *kobj,
 600                                       struct attribute *attr, char *buff,
 601                                       size_t count)
 602 {
 603         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 604
 605         if (buff[count - 1] == '\n')
 606                 buff[count - 1] = '\0';
 607
 608         return batadv_gw_bandwidth_set(net_dev, buff, count);
 609 }
 610
 611 /**
 612  * batadv_show_isolation_mark() - print the current isolation mark/mask
 613  * @kobj: kobject representing the private mesh sysfs directory
 614  * @attr: the batman-adv attribute the user is interacting with
 615  * @buff: the buffer that will contain the data to send back to the user
 616  *
 617  * Return: the number of bytes written into 'buff' on success or a negative
 618  * error code in case of failure
 619  */
 620 static ssize_t batadv_show_isolation_mark(struct kobject *kobj,
 621                                           struct attribute *attr, char *buff)
 622 {
 623         struct batadv_priv *bat_priv = batadv_kobj_to_batpriv(kobj);
 624
 625         return sprintf(buff, "%#.8x/%#.8x\n", bat_priv->isolation_mark,
 626                        bat_priv->isolation_mark_mask);
 627 }
 628
 629 /**
 630  * batadv_store_isolation_mark() - parse and store the isolation mark/mask
 631  *  entered by the user
 632  * @kobj: kobject representing the private mesh sysfs directory
 633  * @attr: the batman-adv attribute the user is interacting with
 634  * @buff: the buffer containing the user data
 635  * @count: number of bytes in the buffer
 636  *
 637  * Return: 'count' on success or a negative error code in case of failure
 638  */
 639 static ssize_t batadv_store_isolation_mark(struct kobject *kobj,
 640                                            struct attribute *attr, char *buff,
 641                                            size_t count)
 642 {
 643         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 644         struct batadv_priv *bat_priv = netdev_priv(net_dev);
 645         u32 mark, mask;
 646         char *mask_ptr;
 647
 648         /* parse the mask if it has been specified, otherwise assume the mask is
 649          * the biggest possible
 650          */
 651         mask = 0xFFFFFFFF;
 652         mask_ptr = strchr(buff, '/');
 653         if (mask_ptr) {
 654                 *mask_ptr = '\0';
 655                 mask_ptr++;
 656
 657                 /* the mask must be entered in hex base as it is going to be a
 658                  * bitmask and not a prefix length
 659                  */
 660                 if (kstrtou32(mask_ptr, 16, &mask) < 0)
 661                         return -EINVAL;
 662         }
 663
 664         /* the mark can be entered in any base */
 665         if (kstrtou32(buff, 0, &mark) < 0)
 666                 return -EINVAL;
 667
 668         bat_priv->isolation_mark_mask = mask;
 669         /* erase bits not covered by the mask */
 670         bat_priv->isolation_mark = mark & bat_priv->isolation_mark_mask;
 671
 672         batadv_info(net_dev,
 673                     "New skb mark for extended isolation: %#.8x/%#.8x\n",
 674                     bat_priv->isolation_mark, bat_priv->isolation_mark_mask);
 675
 676         return count;
 677 }
 678
 679 BATADV_ATTR_SIF_BOOL(aggregated_ogms, 0644, NULL);
 680 BATADV_ATTR_SIF_BOOL(bonding, 0644, NULL);
 681 #ifdef CONFIG_BATMAN_ADV_BLA
 682 BATADV_ATTR_SIF_BOOL(bridge_loop_avoidance, 0644, batadv_bla_status_update);
 683 #endif
 684 #ifdef CONFIG_BATMAN_ADV_DAT
 685 BATADV_ATTR_SIF_BOOL(distributed_arp_table, 0644, batadv_dat_status_update);
 686 #endif
 687 BATADV_ATTR_SIF_BOOL(fragmentation, 0644, batadv_update_min_mtu);
 688 static BATADV_ATTR(routing_algo, 0444, batadv_show_bat_algo, NULL);
 689 static BATADV_ATTR(gw_mode, 0644, batadv_show_gw_mode, batadv_store_gw_mode);
 690 BATADV_ATTR_SIF_UINT(orig_interval, orig_interval, 0644, 2 * BATADV_JITTER,
 691                      INT_MAX, NULL);
 692 BATADV_ATTR_SIF_UINT(hop_penalty, hop_penalty, 0644, 0, BATADV_TQ_MAX_VALUE,
 693                      NULL);
 694 static BATADV_ATTR(gw_sel_class, 0644, batadv_show_gw_sel_class,
 695                    batadv_store_gw_sel_class);
 696 static BATADV_ATTR(gw_bandwidth, 0644, batadv_show_gw_bwidth,
 697                    batadv_store_gw_bwidth);
 698 #ifdef CONFIG_BATMAN_ADV_MCAST
 699 BATADV_ATTR_SIF_BOOL(multicast_mode, 0644, NULL);
 700 #endif
 701 #ifdef CONFIG_BATMAN_ADV_DEBUG
 702 BATADV_ATTR_SIF_UINT(log_level, log_level, 0644, 0, BATADV_DBG_ALL, NULL);
 703 #endif
 704 #ifdef CONFIG_BATMAN_ADV_NC
 705 BATADV_ATTR_SIF_BOOL(network_coding, 0644, batadv_nc_status_update);
 706 #endif
 707 static BATADV_ATTR(isolation_mark, 0644, batadv_show_isolation_mark,
 708                    batadv_store_isolation_mark);
 709
 710 static struct batadv_attribute *batadv_mesh_attrs[] = {
 711         &batadv_attr_aggregated_ogms,
 712         &batadv_attr_bonding,
 713 #ifdef CONFIG_BATMAN_ADV_BLA
 714         &batadv_attr_bridge_loop_avoidance,
 715 #endif
 716 #ifdef CONFIG_BATMAN_ADV_DAT
 717         &batadv_attr_distributed_arp_table,
 718 #endif
 719 #ifdef CONFIG_BATMAN_ADV_MCAST
 720         &batadv_attr_multicast_mode,
 721 #endif
 722         &batadv_attr_fragmentation,
 723         &batadv_attr_routing_algo,
 724         &batadv_attr_gw_mode,
 725         &batadv_attr_orig_interval,
 726         &batadv_attr_hop_penalty,
 727         &batadv_attr_gw_sel_class,
 728         &batadv_attr_gw_bandwidth,
 729 #ifdef CONFIG_BATMAN_ADV_DEBUG
 730         &batadv_attr_log_level,
 731 #endif
 732 #ifdef CONFIG_BATMAN_ADV_NC
 733         &batadv_attr_network_coding,
 734 #endif
 735         &batadv_attr_isolation_mark,
 736         NULL,
 737 };
 738
 739 BATADV_ATTR_VLAN_BOOL(ap_isolation, 0644, NULL);
 740
 741 /* array of vlan specific sysfs attributes */
 742 static struct batadv_attribute *batadv_vlan_attrs[] = {
 743         &batadv_attr_vlan_ap_isolation,
 744         NULL,
 745 };
 746
 747 /**
 748  * batadv_sysfs_add_meshif() - Add soft interface specific sysfs entries
 749  * @dev: netdev struct of the soft interface
 750  *
 751  * Return: 0 on success or negative error number in case of failure
 752  */
 753 int batadv_sysfs_add_meshif(struct net_device *dev)
 754 {
 755         struct kobject *batif_kobject = &dev->dev.kobj;
 756         struct batadv_priv *bat_priv = netdev_priv(dev);
 757         struct batadv_attribute **bat_attr;
 758         int err;
 759
 760         bat_priv->mesh_obj = kobject_create_and_add(BATADV_SYSFS_IF_MESH_SUBDIR,
 761                                                     batif_kobject);
 762         if (!bat_priv->mesh_obj) {
 763                 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
 764                            BATADV_SYSFS_IF_MESH_SUBDIR);
 765                 goto out;
 766         }
 767
 768         for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr) {
 769                 err = sysfs_create_file(bat_priv->mesh_obj,
 770                                         &((*bat_attr)->attr));
 771                 if (err) {
 772                         batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
 773                                    dev->name, BATADV_SYSFS_IF_MESH_SUBDIR,
 774                                    ((*bat_attr)->attr).name);
 775                         goto rem_attr;
 776                 }
 777         }
 778
 779         return 0;
 780
 781 rem_attr:
 782         for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
 783                 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
 784
 785         kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
 786         kobject_del(bat_priv->mesh_obj);
 787         kobject_put(bat_priv->mesh_obj);
 788         bat_priv->mesh_obj = NULL;
 789 out:
 790         return -ENOMEM;
 791 }
 792
 793 /**
 794  * batadv_sysfs_del_meshif() - Remove soft interface specific sysfs entries
 795  * @dev: netdev struct of the soft interface
 796  */
 797 void batadv_sysfs_del_meshif(struct net_device *dev)
 798 {
 799         struct batadv_priv *bat_priv = netdev_priv(dev);
 800         struct batadv_attribute **bat_attr;
 801
 802         for (bat_attr = batadv_mesh_attrs; *bat_attr; ++bat_attr)
 803                 sysfs_remove_file(bat_priv->mesh_obj, &((*bat_attr)->attr));
 804
 805         kobject_uevent(bat_priv->mesh_obj, KOBJ_REMOVE);
 806         kobject_del(bat_priv->mesh_obj);
 807         kobject_put(bat_priv->mesh_obj);
 808         bat_priv->mesh_obj = NULL;
 809 }
 810
 811 /**
 812  * batadv_sysfs_add_vlan() - add all the needed sysfs objects for the new vlan
 813  * @dev: netdev of the mesh interface
 814  * @vlan: private data of the newly added VLAN interface
 815  *
 816  * Return: 0 on success and -ENOMEM if any of the structure allocations fails.
 817  */
 818 int batadv_sysfs_add_vlan(struct net_device *dev,
 819                           struct batadv_softif_vlan *vlan)
 820 {
 821         char vlan_subdir[sizeof(BATADV_SYSFS_VLAN_SUBDIR_PREFIX) + 5];
 822         struct batadv_priv *bat_priv = netdev_priv(dev);
 823         struct batadv_attribute **bat_attr;
 824         int err;
 825
 826         if (vlan->vid & BATADV_VLAN_HAS_TAG) {
 827                 sprintf(vlan_subdir, BATADV_SYSFS_VLAN_SUBDIR_PREFIX "%hu",
 828                         vlan->vid & VLAN_VID_MASK);
 829
 830                 vlan->kobj = kobject_create_and_add(vlan_subdir,
 831                                                     bat_priv->mesh_obj);
 832                 if (!vlan->kobj) {
 833                         batadv_err(dev, "Can't add sysfs directory: %s/%s\n",
 834                                    dev->name, vlan_subdir);
 835                         goto out;
 836                 }
 837         } else {
 838                 /* the untagged LAN uses the root folder to store its "VLAN
 839                  * specific attributes"
 840                  */
 841                 vlan->kobj = bat_priv->mesh_obj;
 842                 kobject_get(bat_priv->mesh_obj);
 843         }
 844
 845         for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr) {
 846                 err = sysfs_create_file(vlan->kobj,
 847                                         &((*bat_attr)->attr));
 848                 if (err) {
 849                         batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
 850                                    dev->name, vlan_subdir,
 851                                    ((*bat_attr)->attr).name);
 852                         goto rem_attr;
 853                 }
 854         }
 855
 856         return 0;
 857
 858 rem_attr:
 859         for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
 860                 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
 861
 862         if (vlan->kobj != bat_priv->mesh_obj) {
 863                 kobject_uevent(vlan->kobj, KOBJ_REMOVE);
 864                 kobject_del(vlan->kobj);
 865         }
 866         kobject_put(vlan->kobj);
 867         vlan->kobj = NULL;
 868 out:
 869         return -ENOMEM;
 870 }
 871
 872 /**
 873  * batadv_sysfs_del_vlan() - remove all the sysfs objects for a given VLAN
 874  * @bat_priv: the bat priv with all the soft interface information
 875  * @vlan: the private data of the VLAN to destroy
 876  */
 877 void batadv_sysfs_del_vlan(struct batadv_priv *bat_priv,
 878                            struct batadv_softif_vlan *vlan)
 879 {
 880         struct batadv_attribute **bat_attr;
 881
 882         for (bat_attr = batadv_vlan_attrs; *bat_attr; ++bat_attr)
 883                 sysfs_remove_file(vlan->kobj, &((*bat_attr)->attr));
 884
 885         if (vlan->kobj != bat_priv->mesh_obj) {
 886                 kobject_uevent(vlan->kobj, KOBJ_REMOVE);
 887                 kobject_del(vlan->kobj);
 888         }
 889         kobject_put(vlan->kobj);
 890         vlan->kobj = NULL;
 891 }
 892
 893 static ssize_t batadv_show_mesh_iface(struct kobject *kobj,
 894                                       struct attribute *attr, char *buff)
 895 {
 896         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
 897         struct batadv_hard_iface *hard_iface;
 898         ssize_t length;
 899         const char *ifname;
 900
 901         hard_iface = batadv_hardif_get_by_netdev(net_dev);
 902         if (!hard_iface)
 903                 return 0;
 904
 905         if (hard_iface->if_status == BATADV_IF_NOT_IN_USE)
 906                 ifname =  "none";
 907         else
 908                 ifname = hard_iface->soft_iface->name;
 909
 910         length = sprintf(buff, "%s\n", ifname);
 911
 912         batadv_hardif_put(hard_iface);
 913
 914         return length;
 915 }
 916
 917 /**
 918  * batadv_store_mesh_iface_finish() - store new hardif mesh_iface state
 919  * @net_dev: netdevice to add/remove to/from batman-adv soft-interface
 920  * @ifname: name of soft-interface to modify
 921  *
 922  * Changes the parts of the hard+soft interface which can not be modified under
 923  * sysfs lock (to prevent deadlock situations).
 924  *
 925  * Return: 0 on success, 0 < on failure
 926  */
 927 static int batadv_store_mesh_iface_finish(struct net_device *net_dev,
 928                                           char ifname[IFNAMSIZ])
 929 {
 930         struct net *net = dev_net(net_dev);
 931         struct batadv_hard_iface *hard_iface;
 932         int status_tmp;
 933         int ret = 0;
 934
 935         ASSERT_RTNL();
 936
 937         hard_iface = batadv_hardif_get_by_netdev(net_dev);
 938         if (!hard_iface)
 939                 return 0;
 940
 941         if (strncmp(ifname, "none", 4) == 0)
 942                 status_tmp = BATADV_IF_NOT_IN_USE;
 943         else
 944                 status_tmp = BATADV_IF_I_WANT_YOU;
 945
 946         if (hard_iface->if_status == status_tmp)
 947                 goto out;
 948
 949         if (hard_iface->soft_iface &&
 950             strncmp(hard_iface->soft_iface->name, ifname, IFNAMSIZ) == 0)
 951                 goto out;
 952
 953         if (status_tmp == BATADV_IF_NOT_IN_USE) {
 954                 batadv_hardif_disable_interface(hard_iface,
 955                                                 BATADV_IF_CLEANUP_AUTO);
 956                 goto out;
 957         }
 958
 959         /* if the interface already is in use */
 960         if (hard_iface->if_status != BATADV_IF_NOT_IN_USE)
 961                 batadv_hardif_disable_interface(hard_iface,
 962                                                 BATADV_IF_CLEANUP_AUTO);
 963
 964         ret = batadv_hardif_enable_interface(hard_iface, net, ifname);
 965 out:
 966         batadv_hardif_put(hard_iface);
 967         return ret;
 968 }
 969
 970 /**
 971  * batadv_store_mesh_iface_work() - store new hardif mesh_iface state
 972  * @work: work queue item
 973  *
 974  * Changes the parts of the hard+soft interface which can not be modified under
 975  * sysfs lock (to prevent deadlock situations).
 976  */
 977 static void batadv_store_mesh_iface_work(struct work_struct *work)
 978 {
 979         struct batadv_store_mesh_work *store_work;
 980         int ret;
 981
 982         store_work = container_of(work, struct batadv_store_mesh_work, work);
 983
 984         rtnl_lock();
 985         ret = batadv_store_mesh_iface_finish(store_work->net_dev,
 986                                              store_work->soft_iface_name);
 987         rtnl_unlock();
 988
 989         if (ret < 0)
 990                 pr_err("Failed to store new mesh_iface state %s for %s: %d\n",
 991                        store_work->soft_iface_name, store_work->net_dev->name,
 992                        ret);
 993
 994         dev_put(store_work->net_dev);
 995         kfree(store_work);
 996 }
 997
 998 static ssize_t batadv_store_mesh_iface(struct kobject *kobj,
 999                                        struct attribute *attr, char *buff,
1000                                        size_t count)
1001 {
1002         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1003         struct batadv_store_mesh_work *store_work;
1004
1005         if (buff[count - 1] == '\n')
1006                 buff[count - 1] = '\0';
1007
1008         if (strlen(buff) >= IFNAMSIZ) {
1009                 pr_err("Invalid parameter for 'mesh_iface' setting received: interface name too long '%s'\n",
1010                        buff);
1011                 return -EINVAL;
1012         }
1013
1014         store_work = kmalloc(sizeof(*store_work), GFP_KERNEL);
1015         if (!store_work)
1016                 return -ENOMEM;
1017
1018         dev_hold(net_dev);
1019         INIT_WORK(&store_work->work, batadv_store_mesh_iface_work);
1020         store_work->net_dev = net_dev;
1021         strlcpy(store_work->soft_iface_name, buff,
1022                 sizeof(store_work->soft_iface_name));
1023
1024         queue_work(batadv_event_workqueue, &store_work->work);
1025
1026         return count;
1027 }
1028
1029 static ssize_t batadv_show_iface_status(struct kobject *kobj,
1030                                         struct attribute *attr, char *buff)
1031 {
1032         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1033         struct batadv_hard_iface *hard_iface;
1034         ssize_t length;
1035
1036         hard_iface = batadv_hardif_get_by_netdev(net_dev);
1037         if (!hard_iface)
1038                 return 0;
1039
1040         switch (hard_iface->if_status) {
1041         case BATADV_IF_TO_BE_REMOVED:
1042                 length = sprintf(buff, "disabling\n");
1043                 break;
1044         case BATADV_IF_INACTIVE:
1045                 length = sprintf(buff, "inactive\n");
1046                 break;
1047         case BATADV_IF_ACTIVE:
1048                 length = sprintf(buff, "active\n");
1049                 break;
1050         case BATADV_IF_TO_BE_ACTIVATED:
1051                 length = sprintf(buff, "enabling\n");
1052                 break;
1053         case BATADV_IF_NOT_IN_USE:
1054         default:
1055                 length = sprintf(buff, "not in use\n");
1056                 break;
1057         }
1058
1059         batadv_hardif_put(hard_iface);
1060
1061         return length;
1062 }
1063
1064 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
1065
1066 /**
1067  * batadv_store_throughput_override() - parse and store throughput override
1068  *  entered by the user
1069  * @kobj: kobject representing the private mesh sysfs directory
1070  * @attr: the batman-adv attribute the user is interacting with
1071  * @buff: the buffer containing the user data
1072  * @count: number of bytes in the buffer
1073  *
1074  * Return: 'count' on success or a negative error code in case of failure
1075  */
1076 static ssize_t batadv_store_throughput_override(struct kobject *kobj,
1077                                                 struct attribute *attr,
1078                                                 char *buff, size_t count)
1079 {
1080         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1081         struct batadv_hard_iface *hard_iface;
1082         u32 tp_override;
1083         u32 old_tp_override;
1084         bool ret;
1085
1086         hard_iface = batadv_hardif_get_by_netdev(net_dev);
1087         if (!hard_iface)
1088                 return -EINVAL;
1089
1090         if (buff[count - 1] == '\n')
1091                 buff[count - 1] = '\0';
1092
1093         ret = batadv_parse_throughput(net_dev, buff, "throughput_override",
1094                                       &tp_override);
1095         if (!ret)
1096                 return count;
1097
1098         old_tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
1099         if (old_tp_override == tp_override)
1100                 goto out;
1101
1102         batadv_info(hard_iface->soft_iface,
1103                     "%s: %s: Changing from: %u.%u MBit to: %u.%u MBit\n",
1104                     "throughput_override", net_dev->name,
1105                     old_tp_override / 10, old_tp_override % 10,
1106                     tp_override / 10, tp_override % 10);
1107
1108         atomic_set(&hard_iface->bat_v.throughput_override, tp_override);
1109
1110 out:
1111         batadv_hardif_put(hard_iface);
1112         return count;
1113 }
1114
1115 static ssize_t batadv_show_throughput_override(struct kobject *kobj,
1116                                                struct attribute *attr,
1117                                                char *buff)
1118 {
1119         struct net_device *net_dev = batadv_kobj_to_netdev(kobj);
1120         struct batadv_hard_iface *hard_iface;
1121         u32 tp_override;
1122
1123         hard_iface = batadv_hardif_get_by_netdev(net_dev);
1124         if (!hard_iface)
1125                 return -EINVAL;
1126
1127         tp_override = atomic_read(&hard_iface->bat_v.throughput_override);
1128
1129         return sprintf(buff, "%u.%u MBit\n", tp_override / 10,
1130                        tp_override % 10);
1131 }
1132
1133 #endif
1134
1135 static BATADV_ATTR(mesh_iface, 0644, batadv_show_mesh_iface,
1136                    batadv_store_mesh_iface);
1137 static BATADV_ATTR(iface_status, 0444, batadv_show_iface_status, NULL);
1138 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
1139 BATADV_ATTR_HIF_UINT(elp_interval, bat_v.elp_interval, 0644,
1140                      2 * BATADV_JITTER, INT_MAX, NULL);
1141 static BATADV_ATTR(throughput_override, 0644, batadv_show_throughput_override,
1142                    batadv_store_throughput_override);
1143 #endif
1144
1145 static struct batadv_attribute *batadv_batman_attrs[] = {
1146         &batadv_attr_mesh_iface,
1147         &batadv_attr_iface_status,
1148 #ifdef CONFIG_BATMAN_ADV_BATMAN_V
1149         &batadv_attr_elp_interval,
1150         &batadv_attr_throughput_override,
1151 #endif
1152         NULL,
1153 };
1154
1155 /**
1156  * batadv_sysfs_add_hardif() - Add hard interface specific sysfs entries
1157  * @hardif_obj: address where to store the pointer to new sysfs folder
1158  * @dev: netdev struct of the hard interface
1159  *
1160  * Return: 0 on success or negative error number in case of failure
1161  */
1162 int batadv_sysfs_add_hardif(struct kobject **hardif_obj, struct net_device *dev)
1163 {
1164         struct kobject *hardif_kobject = &dev->dev.kobj;
1165         struct batadv_attribute **bat_attr;
1166         int err;
1167
1168         *hardif_obj = kobject_create_and_add(BATADV_SYSFS_IF_BAT_SUBDIR,
1169                                              hardif_kobject);
1170
1171         if (!*hardif_obj) {
1172                 batadv_err(dev, "Can't add sysfs directory: %s/%s\n", dev->name,
1173                            BATADV_SYSFS_IF_BAT_SUBDIR);
1174                 goto out;
1175         }
1176
1177         for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr) {
1178                 err = sysfs_create_file(*hardif_obj, &((*bat_attr)->attr));
1179                 if (err) {
1180                         batadv_err(dev, "Can't add sysfs file: %s/%s/%s\n",
1181                                    dev->name, BATADV_SYSFS_IF_BAT_SUBDIR,
1182                                    ((*bat_attr)->attr).name);
1183                         goto rem_attr;
1184                 }
1185         }
1186
1187         return 0;
1188
1189 rem_attr:
1190         for (bat_attr = batadv_batman_attrs; *bat_attr; ++bat_attr)
1191                 sysfs_remove_file(*hardif_obj, &((*bat_attr)->attr));
1192 out:
1193         return -ENOMEM;
1194 }
1195
1196 /**
1197  * batadv_sysfs_del_hardif() - Remove hard interface specific sysfs entries
1198  * @hardif_obj: address to the pointer to which stores batman-adv sysfs folder
1199  *  of the hard interface
1200  */
1201 void batadv_sysfs_del_hardif(struct kobject **hardif_obj)
1202 {
1203         kobject_uevent(*hardif_obj, KOBJ_REMOVE);
1204         kobject_del(*hardif_obj);
1205         kobject_put(*hardif_obj);
1206         *hardif_obj = NULL;
1207 }
1208
1209 /**
1210  * batadv_throw_uevent() - Send an uevent with batman-adv specific env data
1211  * @bat_priv: the bat priv with all the soft interface information
1212  * @type: subsystem type of event. Stored in uevent's BATTYPE
1213  * @action: action type of event. Stored in uevent's BATACTION
1214  * @data: string with additional information to the event (ignored for
1215  *  BATADV_UEV_DEL). Stored in uevent's BATDATA
1216  *
1217  * Return: 0 on success or negative error number in case of failure
1218  */
1219 int batadv_throw_uevent(struct batadv_priv *bat_priv, enum batadv_uev_type type,
1220                         enum batadv_uev_action action, const char *data)
1221 {
1222         int ret = -ENOMEM;
1223         struct kobject *bat_kobj;
1224         char *uevent_env[4] = { NULL, NULL, NULL, NULL };
1225
1226         bat_kobj = &bat_priv->soft_iface->dev.kobj;
1227
1228         uevent_env[0] = kasprintf(GFP_ATOMIC,
1229                                   "%s%s", BATADV_UEV_TYPE_VAR,
1230                                   batadv_uev_type_str[type]);
1231         if (!uevent_env[0])
1232                 goto out;
1233
1234         uevent_env[1] = kasprintf(GFP_ATOMIC,
1235                                   "%s%s", BATADV_UEV_ACTION_VAR,
1236                                   batadv_uev_action_str[action]);
1237         if (!uevent_env[1])
1238                 goto out;
1239
1240         /* If the event is DEL, ignore the data field */
1241         if (action != BATADV_UEV_DEL) {
1242                 uevent_env[2] = kasprintf(GFP_ATOMIC,
1243                                           "%s%s", BATADV_UEV_DATA_VAR, data);
1244                 if (!uevent_env[2])
1245                         goto out;
1246         }
1247
1248         ret = kobject_uevent_env(bat_kobj, KOBJ_CHANGE, uevent_env);
1249 out:
1250         kfree(uevent_env[0]);
1251         kfree(uevent_env[1]);
1252         kfree(uevent_env[2]);
1253
1254         if (ret)
1255                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
1256                            "Impossible to send uevent for (%s,%s,%s) event (err: %d)\n",
1257                            batadv_uev_type_str[type],
1258                            batadv_uev_action_str[action],
1259                            (action == BATADV_UEV_DEL ? "NULL" : data), ret);
1260         return ret;
1261 }