net/batman-adv/sysfs.c

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