datapath/dp_sysfs_dp.c

   1 /*
   2  * Copyright (c) 2009, 2010 Nicira Networks.
   3  * Distributed under the terms of the GNU GPL version 2.
   4  *
   5  * Significant portions of this file may be copied from parts of the Linux
   6  * kernel, by Linus Torvalds and others.
   7  */
   8
   9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11 #include <linux/version.h>
  12
  13 /*
  14  *      Sysfs attributes of bridge for Open vSwitch
  15  *
  16  *  This has been shamelessly copied from the kernel sources.
  17  */
  18
  19 #include <linux/capability.h>
  20 #include <linux/device.h>
  21 #include <linux/kernel.h>
  22 #include <linux/netdevice.h>
  23 #include <linux/if_bridge.h>
  24 #include <linux/rtnetlink.h>
  25 #include <linux/version.h>
  26
  27 #include "dp_sysfs.h"
  28 #include "datapath.h"
  29 #include "vport-internal_dev.h"
  30
  31 #ifdef CONFIG_SYSFS
  32
  33 /* Hack to attempt to build on more platforms. */
  34 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,21)
  35 #define INTERNAL_DEVICE_ATTR CLASS_DEVICE_ATTR
  36 #define DEVICE_PARAMS struct class_device *d
  37 #define DEVICE_ARGS d
  38 #define DEV_ATTR(NAME) class_device_attr_##NAME
  39 #else
  40 #define INTERNAL_DEVICE_ATTR DEVICE_ATTR
  41 #define DEVICE_PARAMS struct device *d, struct device_attribute *attr
  42 #define DEVICE_ARGS d, attr
  43 #define DEV_ATTR(NAME) dev_attr_##NAME
  44 #endif
  45
  46 static struct datapath *sysfs_get_dp(struct net_device *netdev)
  47 {
  48         struct vport *vport = internal_dev_get_vport(netdev);
  49         return vport ? vport->dp : NULL;
  50 }
  51 /*
  52  * Common code for storing bridge parameters.
  53  */
  54 static ssize_t store_bridge_parm(DEVICE_PARAMS,
  55                                  const char *buf, size_t len,
  56                                  void (*set)(struct datapath *, unsigned long))
  57 {
  58         char *endp;
  59         unsigned long val;
  60         ssize_t result = len;
  61
  62         if (!capable(CAP_NET_ADMIN))
  63                 return -EPERM;
  64
  65         val = simple_strtoul(buf, &endp, 0);
  66         if (endp == buf)
  67                 return -EINVAL;
  68
  69         /* xxx We use a default value of 0 for all fields.  If the caller is
  70          * xxx attempting to set the value to our default, just silently
  71          * xxx ignore the request.
  72          */
  73         if (val != 0) {
  74                 struct datapath *dp;
  75
  76                 rcu_read_lock();
  77
  78                 dp = sysfs_get_dp(to_net_dev(d));
  79                 if (dp)
  80                         printk("%s: xxx writing dp parms not supported yet!\n",
  81                                dp_name(dp));
  82                 else
  83                         result = -ENODEV;
  84
  85                 rcu_read_unlock();
  86         }
  87
  88         return result;
  89 }
  90
  91
  92 static ssize_t show_forward_delay(DEVICE_PARAMS, char *buf)
  93 {
  94         return sprintf(buf, "%d\n", 0);
  95 }
  96
  97 static void set_forward_delay(struct datapath *dp, unsigned long val)
  98 {
  99         printk("%s: xxx attempt to set_forward_delay()\n", dp_name(dp));
 100 }
 101
 102 static ssize_t store_forward_delay(DEVICE_PARAMS,
 103                                    const char *buf, size_t len)
 104 {
 105         return store_bridge_parm(DEVICE_ARGS, buf, len, set_forward_delay);
 106 }
 107 static INTERNAL_DEVICE_ATTR(forward_delay, S_IRUGO | S_IWUSR,
 108                    show_forward_delay, store_forward_delay);
 109
 110 static ssize_t show_hello_time(DEVICE_PARAMS, char *buf)
 111 {
 112         return sprintf(buf, "%d\n", 0);
 113 }
 114
 115 static void set_hello_time(struct datapath *dp, unsigned long val)
 116 {
 117         printk("%s: xxx attempt to set_hello_time()\n", dp_name(dp));
 118 }
 119
 120 static ssize_t store_hello_time(DEVICE_PARAMS,
 121                                 const char *buf,
 122                                 size_t len)
 123 {
 124         return store_bridge_parm(DEVICE_ARGS, buf, len, set_hello_time);
 125 }
 126 static INTERNAL_DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time,
 127                    store_hello_time);
 128
 129 static ssize_t show_max_age(DEVICE_PARAMS, char *buf)
 130 {
 131         return sprintf(buf, "%d\n", 0);
 132 }
 133
 134 static void set_max_age(struct datapath *dp, unsigned long val)
 135 {
 136         printk("%s: xxx attempt to set_max_age()\n", dp_name(dp));
 137 }
 138
 139 static ssize_t store_max_age(DEVICE_PARAMS,
 140                              const char *buf, size_t len)
 141 {
 142         return store_bridge_parm(DEVICE_ARGS, buf, len, set_max_age);
 143 }
 144 static INTERNAL_DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age, store_max_age);
 145
 146 static ssize_t show_ageing_time(DEVICE_PARAMS, char *buf)
 147 {
 148         return sprintf(buf, "%d\n", 0);
 149 }
 150
 151 static void set_ageing_time(struct datapath *dp, unsigned long val)
 152 {
 153         printk("%s: xxx attempt to set_ageing_time()\n", dp_name(dp));
 154 }
 155
 156 static ssize_t store_ageing_time(DEVICE_PARAMS,
 157                                  const char *buf, size_t len)
 158 {
 159         return store_bridge_parm(DEVICE_ARGS, buf, len, set_ageing_time);
 160 }
 161 static INTERNAL_DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time,
 162                    store_ageing_time);
 163
 164 static ssize_t show_stp_state(DEVICE_PARAMS, char *buf)
 165 {
 166         return sprintf(buf, "%d\n", 0);
 167 }
 168
 169
 170 static ssize_t store_stp_state(DEVICE_PARAMS,
 171                                const char *buf,
 172                                size_t len)
 173 {
 174         struct datapath *dp;
 175         ssize_t result = len;
 176
 177         rcu_read_lock();
 178
 179         dp = sysfs_get_dp(to_net_dev(d));
 180         if (dp)
 181                 printk("%s: xxx attempt to set_stp_state()\n", dp_name(dp));
 182         else
 183                 result = -ENODEV;
 184
 185         rcu_read_unlock();
 186
 187         return result;
 188 }
 189 static INTERNAL_DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state,
 190                    store_stp_state);
 191
 192 static ssize_t show_priority(DEVICE_PARAMS, char *buf)
 193 {
 194         return sprintf(buf, "%d\n", 0);
 195 }
 196
 197 static void set_priority(struct datapath *dp, unsigned long val)
 198 {
 199         printk("%s: xxx attempt to set_priority()\n", dp_name(dp));
 200 }
 201
 202 static ssize_t store_priority(DEVICE_PARAMS,
 203                                const char *buf, size_t len)
 204 {
 205         return store_bridge_parm(DEVICE_ARGS, buf, len, set_priority);
 206 }
 207 static INTERNAL_DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority, store_priority);
 208
 209 static ssize_t show_root_id(DEVICE_PARAMS, char *buf)
 210 {
 211         return sprintf(buf, "0000.010203040506\n");
 212 }
 213 static INTERNAL_DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL);
 214
 215 static ssize_t show_bridge_id(DEVICE_PARAMS, char *buf)
 216 {
 217         struct vport *vport;
 218         ssize_t result;
 219
 220         rcu_read_lock();
 221
 222         vport = internal_dev_get_vport(to_net_dev(d));
 223         if (vport) {
 224                 const unsigned char *addr;
 225
 226                 addr = vport_get_addr(vport);
 227                 result = sprintf(buf, "%.2x%.2x.%.2x%.2x%.2x%.2x%.2x%.2x\n",
 228                                  0, 0, addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
 229         } else
 230                 result = -ENODEV;
 231
 232         rcu_read_unlock();
 233
 234         return result;
 235 }
 236 static INTERNAL_DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL);
 237
 238 static ssize_t show_root_port(DEVICE_PARAMS, char *buf)
 239 {
 240         return sprintf(buf, "%d\n", 0);
 241 }
 242 static INTERNAL_DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL);
 243
 244 static ssize_t show_root_path_cost(DEVICE_PARAMS, char *buf)
 245 {
 246         return sprintf(buf, "%d\n", 0);
 247 }
 248 static INTERNAL_DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL);
 249
 250 static ssize_t show_topology_change(DEVICE_PARAMS, char *buf)
 251 {
 252         return sprintf(buf, "%d\n", 0);
 253 }
 254 static INTERNAL_DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL);
 255
 256 static ssize_t show_topology_change_detected(DEVICE_PARAMS, char *buf)
 257 {
 258         return sprintf(buf, "%d\n", 0);
 259 }
 260 static INTERNAL_DEVICE_ATTR(topology_change_detected, S_IRUGO,
 261                    show_topology_change_detected, NULL);
 262
 263 static ssize_t show_hello_timer(DEVICE_PARAMS, char *buf)
 264 {
 265         return sprintf(buf, "%d\n", 0);
 266 }
 267 static INTERNAL_DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL);
 268
 269 static ssize_t show_tcn_timer(DEVICE_PARAMS, char *buf)
 270 {
 271         return sprintf(buf, "%d\n", 0);
 272 }
 273 static INTERNAL_DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL);
 274
 275 static ssize_t show_topology_change_timer(DEVICE_PARAMS, char *buf)
 276 {
 277         return sprintf(buf, "%d\n", 0);
 278 }
 279 static INTERNAL_DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer,
 280                    NULL);
 281
 282 static ssize_t show_gc_timer(DEVICE_PARAMS, char *buf)
 283 {
 284         return sprintf(buf, "%d\n", 0);
 285 }
 286 static INTERNAL_DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL);
 287
 288 static ssize_t show_group_addr(DEVICE_PARAMS, char *buf)
 289 {
 290         return sprintf(buf, "00:01:02:03:04:05\n");
 291 }
 292
 293 static ssize_t store_group_addr(DEVICE_PARAMS,
 294                                 const char *buf, size_t len)
 295 {
 296         struct datapath *dp;
 297         ssize_t result = len;
 298
 299         rcu_read_lock();
 300
 301         dp = sysfs_get_dp(to_net_dev(d));
 302         if (dp)
 303                 printk("%s: xxx attempt to store_group_addr()\n", dp_name(dp));
 304         else
 305                 result = -ENODEV;
 306
 307         rcu_read_unlock();
 308
 309         return result;
 310 }
 311
 312 static INTERNAL_DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR,
 313                    show_group_addr, store_group_addr);
 314
 315 static struct attribute *bridge_attrs[] = {
 316         &DEV_ATTR(forward_delay).attr,
 317         &DEV_ATTR(hello_time).attr,
 318         &DEV_ATTR(max_age).attr,
 319         &DEV_ATTR(ageing_time).attr,
 320         &DEV_ATTR(stp_state).attr,
 321         &DEV_ATTR(priority).attr,
 322         &DEV_ATTR(bridge_id).attr,
 323         &DEV_ATTR(root_id).attr,
 324         &DEV_ATTR(root_path_cost).attr,
 325         &DEV_ATTR(root_port).attr,
 326         &DEV_ATTR(topology_change).attr,
 327         &DEV_ATTR(topology_change_detected).attr,
 328         &DEV_ATTR(hello_timer).attr,
 329         &DEV_ATTR(tcn_timer).attr,
 330         &DEV_ATTR(topology_change_timer).attr,
 331         &DEV_ATTR(gc_timer).attr,
 332         &DEV_ATTR(group_addr).attr,
 333         NULL
 334 };
 335
 336 static struct attribute_group bridge_group = {
 337         .name = SYSFS_BRIDGE_ATTR, /* "bridge" */
 338         .attrs = bridge_attrs,
 339 };
 340
 341 /*
 342  * Add entries in sysfs onto the existing network class device
 343  * for the bridge.
 344  *   Adds a attribute group "bridge" containing tuning parameters.
 345  *   Sub directory to hold links to interfaces.
 346  *
 347  * Note: the ifobj exists only to be a subdirectory
 348  *   to hold links.  The ifobj exists in the same data structure
 349  *   as its parent the bridge so reference counting works.
 350  */
 351 int dp_sysfs_add_dp(struct datapath *dp)
 352 {
 353         struct kobject *kobj =
 354                 vport_get_kobj(rtnl_dereference(dp->ports[ODPP_LOCAL]));
 355         int err;
 356
 357         /* Create /sys/class/net/<devname>/bridge directory. */
 358         err = sysfs_create_group(kobj, &bridge_group);
 359         if (err) {
 360                 pr_info("%s: can't create group %s/%s\n",
 361                         __func__, dp_name(dp), bridge_group.name);
 362                 goto out1;
 363         }
 364
 365         /* Create /sys/class/net/<devname>/brif directory. */
 366         err = kobject_add(&dp->ifobj, kobj, SYSFS_BRIDGE_PORT_SUBDIR);
 367         if (err) {
 368                 pr_info("%s: can't add kobject (directory) %s/%s\n",
 369                         __FUNCTION__, dp_name(dp), kobject_name(&dp->ifobj));
 370                 goto out2;
 371         }
 372         kobject_uevent(&dp->ifobj, KOBJ_ADD);
 373         return 0;
 374
 375  out2:
 376         sysfs_remove_group(kobj, &bridge_group);
 377  out1:
 378         return err;
 379 }
 380
 381 int dp_sysfs_del_dp(struct datapath *dp)
 382 {
 383         struct kobject *kobj =
 384                 vport_get_kobj(rtnl_dereference(dp->ports[ODPP_LOCAL]));
 385
 386         kobject_del(&dp->ifobj);
 387         sysfs_remove_group(kobj, &bridge_group);
 388
 389         return 0;
 390 }
 391 #else /* !CONFIG_SYSFS */
 392 int dp_sysfs_add_dp(struct datapath *dp) { return 0; }
 393 int dp_sysfs_del_dp(struct datapath *dp) { return 0; }
 394 int dp_sysfs_add_if(struct vport *p) { return 0; }
 395 int dp_sysfs_del_if(struct vport *p) { return 0; }
 396 #endif /* !CONFIG_SYSFS */