~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/batman-adv/sysfs.c

Version: ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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, "", 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 }
1262 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp