[NET] core: add RFC2863 operstate

this patch adds a dormant flag to network devices, RFC2863 operstate derived
from these flags and possibility for userspace interaction. It allows drivers
to signal that a device is unusable for user traffic without disabling
queueing (and therefore the possibility for protocol establishment traffic to
flow) and a userspace supplicant (WPA, 802.1X) to mark a device unusable
without changes to the driver.

It is the result of our long discussion. However I must admit that it
represents what Jamal and I agreed on with compromises towards Krzysztof, but
Thomas and Krzysztof still disagree with some parts. Anyway I think it should
be applied.

Signed-off-by: Stefan Rompf <stefan@loplof.de>
Signed-off-by: David S. Miller <davem@davemloft.net>

4 files changed, 142 insertions, 3 deletions

diff --git a/net/core/dev.c b/net/core/dev.c
index ef56c035d44e..8763c99fcb84 100644
--- a/net/core/dev.c
+++ b/net/core/dev.c
@@ -2174,12 +2174,20 @@ unsigned dev_get_flags(const struct net_device *dev)
 
         flags = (dev->flags & ~(IFF_PROMISC |
                                 IFF_ALLMULTI |
-                                IFF_RUNNING)) | 
+                                IFF_RUNNING |
+                                IFF_LOWER_UP |
+                                IFF_DORMANT)) |
                 (dev->gflags & (IFF_PROMISC |
                                 IFF_ALLMULTI));
 
-        if (netif_running(dev) && netif_carrier_ok(dev))
-                flags |= IFF_RUNNING;
+        if (netif_running(dev)) {
+                if (netif_oper_up(dev))
+                        flags |= IFF_RUNNING;
+                if (netif_carrier_ok(dev))
+                        flags |= IFF_LOWER_UP;
+                if (netif_dormant(dev))
+                        flags |= IFF_DORMANT;
+        }
 
         return flags;
 }
diff --git a/net/core/link_watch.c b/net/core/link_watch.c
index d43d1201275c..e82a451d330b 100644
--- a/net/core/link_watch.c
+++ b/net/core/link_watch.c
@@ -49,6 +49,45 @@ struct lw_event {
 /* Avoid kmalloc() for most systems */
 static struct lw_event singleevent;
 
+static unsigned char default_operstate(const struct net_device *dev)
+{
+        if (!netif_carrier_ok(dev))
+                return (dev->ifindex != dev->iflink ?
+                        IF_OPER_LOWERLAYERDOWN : IF_OPER_DOWN);
+
+        if (netif_dormant(dev))
+                return IF_OPER_DORMANT;
+
+        return IF_OPER_UP;
+}
+
+
+static void rfc2863_policy(struct net_device *dev)
+{
+        unsigned char operstate = default_operstate(dev);
+
+        if (operstate == dev->operstate)
+                return;
+
+        write_lock_bh(&dev_base_lock);
+
+        switch(dev->link_mode) {
+        case IF_LINK_MODE_DORMANT:
+                if (operstate == IF_OPER_UP)
+                        operstate = IF_OPER_DORMANT;
+                break;
+
+        case IF_LINK_MODE_DEFAULT:
+        default:
+                break;
+        };
+
+        dev->operstate = operstate;
+
+        write_unlock_bh(&dev_base_lock);
+}
+
+
 /* Must be called with the rtnl semaphore held */
 void linkwatch_run_queue(void)
 {
@@ -74,6 +113,7 @@ void linkwatch_run_queue(void)
                  */
                 clear_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state);
 
+                rfc2863_policy(dev);
                 if (dev->flags & IFF_UP) {
                         if (netif_carrier_ok(dev)) {
                                 WARN_ON(dev->qdisc_sleeping == &noop_qdisc);
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index e8b2acbc8ea2..21b68464cabb 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -91,6 +91,7 @@ NETDEVICE_SHOW(iflink, fmt_dec);
 NETDEVICE_SHOW(ifindex, fmt_dec);
 NETDEVICE_SHOW(features, fmt_long_hex);
 NETDEVICE_SHOW(type, fmt_dec);
+NETDEVICE_SHOW(link_mode, fmt_dec);
 
 /* use same locking rules as GIFHWADDR ioctl's */
 static ssize_t format_addr(char *buf, const unsigned char *addr, int len)
@@ -133,6 +134,43 @@ static ssize_t show_carrier(struct class_device *dev, char *buf)
         return -EINVAL;
 }
 
+static ssize_t show_dormant(struct class_device *dev, char *buf)
+{
+        struct net_device *netdev = to_net_dev(dev);
+
+        if (netif_running(netdev))
+                return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
+
+        return -EINVAL;
+}
+
+static const char *operstates[] = {
+        "unknown",
+        "notpresent", /* currently unused */
+        "down",
+        "lowerlayerdown",
+        "testing", /* currently unused */
+        "dormant",
+        "up"
+};
+
+static ssize_t show_operstate(struct class_device *dev, char *buf)
+{
+        const struct net_device *netdev = to_net_dev(dev);
+        unsigned char operstate;
+
+        read_lock(&dev_base_lock);
+        operstate = netdev->operstate;
+        if (!netif_running(netdev))
+                operstate = IF_OPER_DOWN;
+        read_unlock(&dev_base_lock);
+
+        if (operstate >= sizeof(operstates))
+                return -EINVAL; /* should not happen */
+
+        return sprintf(buf, "%s\n", operstates[operstate]);
+}
+
 /* read-write attributes */
 NETDEVICE_SHOW(mtu, fmt_dec);
 
@@ -190,9 +228,12 @@ static struct class_device_attribute net_class_attributes[] = {
         __ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
         __ATTR(features, S_IRUGO, show_features, NULL),
         __ATTR(type, S_IRUGO, show_type, NULL),
+        __ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
         __ATTR(address, S_IRUGO, show_address, NULL),
         __ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
         __ATTR(carrier, S_IRUGO, show_carrier, NULL),
+        __ATTR(dormant, S_IRUGO, show_dormant, NULL),
+        __ATTR(operstate, S_IRUGO, show_operstate, NULL),
         __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
         __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
         __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
diff --git a/net/core/rtnetlink.c b/net/core/rtnetlink.c
index eca2976abb25..1c15a907066f 100644
--- a/net/core/rtnetlink.c
+++ b/net/core/rtnetlink.c
@@ -179,6 +179,33 @@ rtattr_failure:
 }
 
 
+static void set_operstate(struct net_device *dev, unsigned char transition)
+{
+        unsigned char operstate = dev->operstate;
+
+        switch(transition) {
+        case IF_OPER_UP:
+                if ((operstate == IF_OPER_DORMANT ||
+                     operstate == IF_OPER_UNKNOWN) &&
+                    !netif_dormant(dev))
+                        operstate = IF_OPER_UP;
+                break;
+
+        case IF_OPER_DORMANT:
+                if (operstate == IF_OPER_UP ||
+                    operstate == IF_OPER_UNKNOWN)
+                        operstate = IF_OPER_DORMANT;
+                break;
+        };
+
+        if (dev->operstate != operstate) {
+                write_lock_bh(&dev_base_lock);
+                dev->operstate = operstate;
+                write_unlock_bh(&dev_base_lock);
+                netdev_state_change(dev);
+        }
+}
+
 static int rtnetlink_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
                                  int type, u32 pid, u32 seq, u32 change, 
                                  unsigned int flags)
@@ -209,6 +236,13 @@ static int rtnetlink_fill_ifinfo(struct sk_buff *skb, struct net_device *dev,
         }
 
         if (1) {
+                u8 operstate = netif_running(dev)?dev->operstate:IF_OPER_DOWN;
+                u8 link_mode = dev->link_mode;
+                RTA_PUT(skb, IFLA_OPERSTATE, sizeof(operstate), &operstate);
+                RTA_PUT(skb, IFLA_LINKMODE, sizeof(link_mode), &link_mode);
+        }
+
+        if (1) {
                 struct rtnl_link_ifmap map = {
                         .mem_start   = dev->mem_start,
                         .mem_end     = dev->mem_end,
@@ -399,6 +433,22 @@ static int do_setlink(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
                 dev->weight = *((u32 *) RTA_DATA(ida[IFLA_WEIGHT - 1]));
         }
 
+        if (ida[IFLA_OPERSTATE - 1]) {
+                if (ida[IFLA_OPERSTATE - 1]->rta_len != RTA_LENGTH(sizeof(u8)))
+                        goto out;
+
+                set_operstate(dev, *((u8 *) RTA_DATA(ida[IFLA_OPERSTATE - 1])));
+        }
+
+        if (ida[IFLA_LINKMODE - 1]) {
+                if (ida[IFLA_LINKMODE - 1]->rta_len != RTA_LENGTH(sizeof(u8)))
+                        goto out;
+
+                write_lock_bh(&dev_base_lock);
+                dev->link_mode = *((u8 *) RTA_DATA(ida[IFLA_LINKMODE - 1]));
+                write_unlock_bh(&dev_base_lock);
+        }
+
         if (ifm->ifi_index >= 0 && ida[IFLA_IFNAME - 1]) {
                 char ifname[IFNAMSIZ];