[mirror_ovs.git] / vswitchd / proc-net-compat.c

/* Copyright (c) 2009, 2010 Nicira Networks
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <config.h>
#include "proc-net-compat.h"

#ifdef HAVE_NETLINK
#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <inttypes.h>
#include <string.h>
#include "dynamic-string.h"
#include "hash.h"
#include "netlink-protocol.h"
#include "netlink.h"
#include "ofpbuf.h"
#include "openvswitch/brcompat-netlink.h"
#include "hmap.h"
#include "shash.h"
#include "svec.h"
#include "vlog.h"

VLOG_DEFINE_THIS_MODULE(proc_net_compat)

/* Netlink socket to bridge compatibility kernel module. */
static struct nl_sock *brc_sock;

/* The Generic Netlink family number used for bridge compatibility. */
static int brc_family = 0;

/* Rate limiting for log messages. */
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);

static void flush_dir(const char *dir);
static int set_proc_file(const char *dir, const char *file, const char *data);

/* Initializes the /proc/net compatibility layer.  Returns 0 if successful,
 * otherwise a positive errno value. */
int
proc_net_compat_init(void)
{
    if (!brc_sock) {
        int retval = nl_lookup_genl_family(BRC_GENL_FAMILY_NAME, &brc_family);
        if (retval) {
            return retval;
        }

        retval = nl_sock_create(NETLINK_GENERIC, 0, 0, 0, &brc_sock);
        if (retval) {
            return retval;
        }

        flush_dir("/proc/net/vlan");
        flush_dir("/proc/net/bonding");
    }
    return 0;
}

static int
set_proc_file(const char *dir, const char *file, const char *data)
{
    struct ofpbuf request;
    int retval;

    ofpbuf_init(&request, 0);
    nl_msg_put_genlmsghdr(&request, 1024, brc_family, NLM_F_REQUEST,
                          BRC_GENL_C_SET_PROC, 1);
    nl_msg_put_string(&request, BRC_GENL_A_PROC_DIR, dir);
    nl_msg_put_string(&request, BRC_GENL_A_PROC_NAME, file);
    if (data) {
        nl_msg_put_string(&request, BRC_GENL_A_PROC_DATA, data);
    }

    retval = nl_sock_transact(brc_sock, &request, NULL);
    ofpbuf_uninit(&request);
    if (retval) {
        VLOG_WARN_RL(&rl, "failed to %s /proc/%s/%s (%s)",
                     data ? "update" : "remove", dir, file, strerror(retval));
    }
    return retval;
}

static void
flush_dir(const char *dir)
{
    const char *subdir;
    struct dirent *de;
    DIR *stream;

    assert(!memcmp(dir, "/proc/", 6));
    subdir = dir + 6;

    stream = opendir(dir);
    if (!stream) {
        if (errno != ENOENT) {
            VLOG_WARN_RL(&rl, "%s: open failed (%s)", dir, strerror(errno));
        }
        return;
    }

    while ((de = readdir(stream)) != NULL) {
        if (strcmp(de->d_name, ".") && strcmp(de->d_name, "..")) {
            set_proc_file(subdir, de->d_name, NULL);
        }
    }
    closedir(stream);
}
\f
/* If 'bond' is nonnull, creates a file in /proc/net/bonding for a bond with
 * the given 'name' and the details in 'bond'.  If 'bond' is null, deletes
 * the /proc/net/bonding file with the given 'name'.
 *
 * This function has no effect unless proc_net_compat_init() has been
 * called. */
void
proc_net_compat_update_bond(const char *name, const struct compat_bond *bond)
{
    struct ds ds;
    int i;

    if (!brc_sock) {
        return;
    }

    if (!bond) {
        set_proc_file("net/bonding", name, NULL);
        return;
    }

    ds_init(&ds);
    ds_put_format(
        &ds,
        "Ethernet Channel Bonding Driver: ovs-vswitchd "
        VERSION BUILDNR" ("__DATE__" "__TIME__")\n"
        "Bonding Mode: source load balancing\n"
        "Primary Slave: None\n"
        "Currently Active Slave: None\n"
        "MII Status: %s\n"
        "MII Polling Interval (ms): 100\n"
        "Up Delay (ms): %d\n"
        "Down Delay (ms): %d\n"
        "\n"
        "Source load balancing info:\n",
        bond->up ? "up" : "down", bond->updelay, bond->downdelay);

    for (i = 0; i < bond->n_hashes; i++) {
        const struct compat_bond_hash *cbh = &bond->hashes[i];
        ds_put_format(&ds, " [%03d] = %s\n", cbh->hash, cbh->netdev_name);
    }

    for (i = 0; i < bond->n_slaves; i++) {
        const struct compat_bond_slave *slave = &bond->slaves[i];
        ds_put_format(
            &ds,
            "\n"
            "Slave Interface: %s\n"
            "MII Status: %s\n"
            "Link Failure Count: 0\n"
            "Permanent HW addr: "ETH_ADDR_FMT"\n",
            slave->name, slave->up ? "up" : "down",
            ETH_ADDR_ARGS(slave->mac));
    }
    set_proc_file("net/bonding", name, ds_cstr(&ds));
    ds_destroy(&ds);
}
\f
/* /proc/net/vlan compatibility.
 *
 * This is much more complex than I expected it to be. */

struct compat_vlan {
    /* Hash key. */
    struct hmap_node trunk_node; /* Hash map node. */
    char *trunk_dev;             /* Name of trunk network device. */
    int vid;                     /* VLAN number. */

    /* Auxiliary data. */
    char *vlan_dev;             /* sprintf("%s.%d", trunk_dev, vid); */
    struct svec tagged_devs;    /* Name of tagged network device(s). */
};

/* Current set of VLAN devices, indexed two different ways. */
static struct hmap vlans_by_trunk = HMAP_INITIALIZER(&vlans_by_trunk);
static struct shash vlans_by_tagged = SHASH_INITIALIZER(&vlans_by_tagged);

static bool remove_tagged_dev(struct shash_node *, const char *tagged_dev);
static void update_vlan_config(void);
static void set_vlan_proc_file(const struct compat_vlan *);
static uint32_t hash_vlan(const char *trunk_dev, uint32_t vid);

/* Updates the /proc/net/vlan compatibility layer's idea of what trunk device
 * and VLAN the given 'tagged_dev' is associated with.  If 'tagged_dev' has an
 * implicit VLAN tag, then 'trunk_dev' should be the name of a network device
 * on the same bridge that trunks that VLAN, and 'vid' should be the VLAN tag
 * number.  If 'tagged_dev' does not have an implicit VLAN tag, then
 * 'trunk_dev' should be NULL and 'vid' should be -1.
 *
 * This function has no effect unless proc_net_compat_init() has been
 * called. */
void
proc_net_compat_update_vlan(const char *tagged_dev, const char *trunk_dev,
                            int vid)
{
    struct compat_vlan *vlan;
    struct shash_node *node;

    if (!brc_sock) {
        return;
    }

    /* Find the compat_vlan that we currently have for 'tagged_dev' (if
     * any). */
    node = shash_find(&vlans_by_tagged, tagged_dev);
    vlan = node ? node->data : NULL;
    if (vid <= 0 || !trunk_dev) {
        if (vlan) {
            if (remove_tagged_dev(node, tagged_dev)) {
                update_vlan_config();
            }
        }
    } else {
        if (vlan) {
            if (!strcmp(trunk_dev, vlan->trunk_dev) && vid == vlan->vid) {
                /* No change. */
                return;
            } else {
                /* 'tagged_dev' is attached to the wrong compat_vlan.  Start
                 * by removing it from that one. */
                remove_tagged_dev(node, tagged_dev);
                node = NULL;
                vlan = NULL;
            }
        }

        /* 'tagged_dev' is not attached to any compat_vlan.  Find the
         * compat_vlan corresponding to (trunk_dev,vid) to attach it to, or
         * create a new compat_vlan if none exists for (trunk_dev,vid). */
        HMAP_FOR_EACH_WITH_HASH (vlan, struct compat_vlan, trunk_node,
                                 hash_vlan(trunk_dev, vid),
                                 &vlans_by_trunk) {
            if (!strcmp(trunk_dev, vlan->trunk_dev) && vid == vlan->vid) {
                break;
            }
        }
        if (!vlan) {
            /* Create a new compat_vlan for (trunk_dev,vid). */
            vlan = xzalloc(sizeof *vlan);
            vlan->trunk_dev = xstrdup(trunk_dev);
            vlan->vid = vid;
            vlan->vlan_dev = xasprintf("%s.%d", trunk_dev, vid);
            svec_init(&vlan->tagged_devs);
            hmap_insert(&vlans_by_trunk, &vlan->trunk_node,
                        hash_vlan(trunk_dev, vid));
            set_vlan_proc_file(vlan);
        }

        /* Attach 'tagged_dev' to 'vlan'. */
        svec_add(&vlan->tagged_devs, tagged_dev);
        shash_add(&vlans_by_tagged, tagged_dev, vlan);
        svec_sort(&vlan->tagged_devs);
        update_vlan_config();
    }
}

/* Remove 'tagged_dev' from the compat_vlan in 'node'.  If that causes the
 * compat_vlan to have no tagged_devs left, destroy the compat_vlan too. */
static bool
remove_tagged_dev(struct shash_node *node, const char *tagged_dev)
{
    struct compat_vlan *vlan = node->data;

    svec_del(&vlan->tagged_devs, tagged_dev);
    shash_delete(&vlans_by_tagged, node);
    if (!vlan->tagged_devs.n) {
        set_proc_file("net/vlan", vlan->vlan_dev, NULL);

        hmap_remove(&vlans_by_trunk, &vlan->trunk_node);
        svec_destroy(&vlan->tagged_devs);
        free(vlan->trunk_dev);
        free(vlan->vlan_dev);
        free(vlan);
        return true;
    }
    return false;
}

/* Returns a hash value for (trunk_dev,vid). */
static uint32_t
hash_vlan(const char *trunk_dev, uint32_t vid)
{
    return hash_int(vid, hash_string(trunk_dev, 0));
}

/* Update /proc/net/vlan/<vlan_dev> for 'vlan'. */
static void
set_vlan_proc_file(const struct compat_vlan *vlan)
{
    struct ds ds;

    ds_init(&ds);
    ds_put_format(
        &ds,
        "%s  VID: %d\t REORDER_HDR: 1  dev->priv_flags: 81\n"
        "         total frames received            0\n"
        "          total bytes received            0\n"
        "      Broadcast/Multicast Rcvd            0\n"
        "\n"
        "      total frames transmitted            0\n"
        "       total bytes transmitted            0\n"
        "            total headroom inc            0\n"
        "           total encap on xmit            0\n"
        "Device: %s\n"
        "INGRESS priority mappings: 0:0  1:0  2:0  3:0  4:0  5:0  6:0 7:0\n"
        "EGRESSS priority Mappings: \n",
        vlan->vlan_dev, vlan->vid, vlan->trunk_dev);
    set_proc_file("net/vlan", vlan->vlan_dev, ds_cstr(&ds));
    ds_destroy(&ds);
}

/* Update /proc/net/vlan/config. */
static void
update_vlan_config(void)
{
    struct compat_vlan *vlan;
    struct ds ds;

    ds_init(&ds);
    ds_put_cstr(&ds, "VLAN Dev name     | VLAN ID\n"
                "Name-Type: VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD\n");
    HMAP_FOR_EACH (vlan, struct compat_vlan, trunk_node, &vlans_by_trunk) {
        ds_put_format(&ds, "%-15s| %d  | %s\n",
                      vlan->vlan_dev, vlan->vid, vlan->trunk_dev);
    }
    set_proc_file("net/vlan", "config", ds_cstr(&ds));
    ds_destroy(&ds);
}
#else  /* !HAVE_NETLINK */
#include "compiler.h"

int
proc_net_compat_init(void)
{
    return 0;
}

void
proc_net_compat_update_bond(const char *name OVS_UNUSED,
                            const struct compat_bond *bond OVS_UNUSED)
{
}

void
proc_net_compat_update_vlan(const char *tagged_dev OVS_UNUSED,
                            const char *trunk_dev OVS_UNUSED,
                            int vid OVS_UNUSED)
{
}
#endif  /* !HAVE_NETLINK */
Commit	Line	Data
bfb1f2d5	1	/* Copyright (c) 2009, 2010 Nicira Networks
064af421	2	*
a14bc59f BP	3	* Licensed under the Apache License, Version 2.0 (the "License");
	4	* you may not use this file except in compliance with the License.
	5	* You may obtain a copy of the License at:
064af421	6	*
a14bc59f	7	* http://www.apache.org/licenses/LICENSE-2.0
064af421	8	*
a14bc59f BP	9	* Unless required by applicable law or agreed to in writing, software
	10	* distributed under the License is distributed on an "AS IS" BASIS,
	11	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	* See the License for the specific language governing permissions and
	13	* limitations under the License.
064af421 BP	14	*/
	15
	16	#include <config.h>
	17	#include "proc-net-compat.h"
bfb1f2d5 BP	18
bfb1f2d5 BP	19	#ifdef HAVE_NETLINK
064af421 BP	20	#include <assert.h>
	21	#include <dirent.h>
	22	#include <errno.h>
	23	#include <inttypes.h>
	24	#include <string.h>
	25	#include "dynamic-string.h"
	26	#include "hash.h"
	27	#include "netlink-protocol.h"
	28	#include "netlink.h"
	29	#include "ofpbuf.h"
	30	#include "openvswitch/brcompat-netlink.h"
	31	#include "hmap.h"
	32	#include "shash.h"
	33	#include "svec.h"
064af421 BP	34	#include "vlog.h"
064af421 BP	35
5136ce49 BP	36	VLOG_DEFINE_THIS_MODULE(proc_net_compat)
5136ce49 BP	37
064af421 BP	38	/* Netlink socket to bridge compatibility kernel module. */
	39	static struct nl_sock *brc_sock;
	40
	41	/* The Generic Netlink family number used for bridge compatibility. */
	42	static int brc_family = 0;
	43
	44	/* Rate limiting for log messages. */
	45	static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
	46
	47	static void flush_dir(const char *dir);
	48	static int set_proc_file(const char dir, const char file, const char *data);
	49
	50	/* Initializes the /proc/net compatibility layer. Returns 0 if successful,
	51	* otherwise a positive errno value. */
	52	int
	53	proc_net_compat_init(void)
	54	{
	55	if (!brc_sock) {
	56	int retval = nl_lookup_genl_family(BRC_GENL_FAMILY_NAME, &brc_family);
	57	if (retval) {
	58	return retval;
	59	}
	60
	61	retval = nl_sock_create(NETLINK_GENERIC, 0, 0, 0, &brc_sock);
	62	if (retval) {
	63	return retval;
	64	}
	65
	66	flush_dir("/proc/net/vlan");
	67	flush_dir("/proc/net/bonding");
	68	}
	69	return 0;
	70	}
	71
	72	static int
	73	set_proc_file(const char dir, const char file, const char *data)
	74	{
8e2093fc	75	struct ofpbuf request;
064af421 BP	76	int retval;
	77
	78	ofpbuf_init(&request, 0);
69123704	79	nl_msg_put_genlmsghdr(&request, 1024, brc_family, NLM_F_REQUEST,
064af421 BP	80	BRC_GENL_C_SET_PROC, 1);
	81	nl_msg_put_string(&request, BRC_GENL_A_PROC_DIR, dir);
	82	nl_msg_put_string(&request, BRC_GENL_A_PROC_NAME, file);
	83	if (data) {
	84	nl_msg_put_string(&request, BRC_GENL_A_PROC_DATA, data);
	85	}
	86
8e2093fc	87	retval = nl_sock_transact(brc_sock, &request, NULL);
064af421	88	ofpbuf_uninit(&request);
064af421 BP	89	if (retval) {
	90	VLOG_WARN_RL(&rl, "failed to %s /proc/%s/%s (%s)",
	91	data ? "update" : "remove", dir, file, strerror(retval));
	92	}
	93	return retval;
	94	}
	95
	96	static void
	97	flush_dir(const char *dir)
	98	{
	99	const char *subdir;
	100	struct dirent *de;
	101	DIR *stream;
	102
	103	assert(!memcmp(dir, "/proc/", 6));
	104	subdir = dir + 6;
	105
	106	stream = opendir(dir);
	107	if (!stream) {
	108	if (errno != ENOENT) {
	109	VLOG_WARN_RL(&rl, "%s: open failed (%s)", dir, strerror(errno));
	110	}
	111	return;
	112	}
	113
	114	while ((de = readdir(stream)) != NULL) {
	115	if (strcmp(de->d_name, ".") && strcmp(de->d_name, "..")) {
	116	set_proc_file(subdir, de->d_name, NULL);
	117	}
	118	}
	119	closedir(stream);
	120	}
	121	\f
	122	/* If 'bond' is nonnull, creates a file in /proc/net/bonding for a bond with
	123	* the given 'name' and the details in 'bond'. If 'bond' is null, deletes
	124	* the /proc/net/bonding file with the given 'name'.
	125	*
	126	* This function has no effect unless proc_net_compat_init() has been
	127	* called. */
	128	void
	129	proc_net_compat_update_bond(const char name, const struct compat_bond bond)
	130	{
	131	struct ds ds;
	132	int i;
	133
	134	if (!brc_sock) {
	135	return;
	136	}
	137
	138	if (!bond) {
	139	set_proc_file("net/bonding", name, NULL);
	140	return;
	141	}
	142
	143	ds_init(&ds);
	144	ds_put_format(
	145	&ds,
	146	"Ethernet Channel Bonding Driver: ovs-vswitchd "
	147	VERSION BUILDNR" ("__DATE__" "__TIME__")\n"
	148	"Bonding Mode: source load balancing\n"
	149	"Primary Slave: None\n"
	150	"Currently Active Slave: None\n"
	151	"MII Status: %s\n"
	152	"MII Polling Interval (ms): 100\n"
153	"Up Delay (ms): %d\n"
154	"Down Delay (ms): %d\n"
155	"\n"
156	"Source load balancing info:\n",
157	bond->up ? "up" : "down", bond->updelay, bond->downdelay);
2aebae83 BP	158
	159	for (i = 0; i < bond->n_hashes; i++) {
	160	const struct compat_bond_hash *cbh = &bond->hashes[i];
	161	ds_put_format(&ds, " [%03d] = %s\n", cbh->hash, cbh->netdev_name);
	162	}
	163
064af421 BP	164	for (i = 0; i < bond->n_slaves; i++) {
	165	const struct compat_bond_slave *slave = &bond->slaves[i];
	166	ds_put_format(
	167	&ds,
	168	"\n"
	169	"Slave Interface: %s\n"
	170	"MII Status: %s\n"
	171	"Link Failure Count: 0\n"
	172	"Permanent HW addr: "ETH_ADDR_FMT"\n",
	173	slave->name, slave->up ? "up" : "down",
	174	ETH_ADDR_ARGS(slave->mac));
	175	}
	176	set_proc_file("net/bonding", name, ds_cstr(&ds));
	177	ds_destroy(&ds);
	178	}
	179	\f
	180	/* /proc/net/vlan compatibility.
	181	*
	182	* This is much more complex than I expected it to be. */
	183
	184	struct compat_vlan {
	185	/* Hash key. */
	186	struct hmap_node trunk_node; /* Hash map node. */
	187	char trunk_dev; / Name of trunk network device. */
	188	int vid; /* VLAN number. */
	189
	190	/* Auxiliary data. */
	191	char vlan_dev; / sprintf("%s.%d", trunk_dev, vid); */
	192	struct svec tagged_devs; /* Name of tagged network device(s). */
	193	};
	194
	195	/* Current set of VLAN devices, indexed two different ways. */
	196	static struct hmap vlans_by_trunk = HMAP_INITIALIZER(&vlans_by_trunk);
	197	static struct shash vlans_by_tagged = SHASH_INITIALIZER(&vlans_by_tagged);
	198
	199	static bool remove_tagged_dev(struct shash_node , const char tagged_dev);
	200	static void update_vlan_config(void);
	201	static void set_vlan_proc_file(const struct compat_vlan *);
	202	static uint32_t hash_vlan(const char *trunk_dev, uint32_t vid);
	203
	204	/* Updates the /proc/net/vlan compatibility layer's idea of what trunk device
	205	* and VLAN the given 'tagged_dev' is associated with. If 'tagged_dev' has an
	206	* implicit VLAN tag, then 'trunk_dev' should be the name of a network device
	207	* on the same bridge that trunks that VLAN, and 'vid' should be the VLAN tag
	208	* number. If 'tagged_dev' does not have an implicit VLAN tag, then
	209	* 'trunk_dev' should be NULL and 'vid' should be -1.
	210	*
	211	* This function has no effect unless proc_net_compat_init() has been
	212	* called. */
	213	void
	214	proc_net_compat_update_vlan(const char tagged_dev, const char trunk_dev,
	215	int vid)
	216	{
	217	struct compat_vlan *vlan;
	218	struct shash_node *node;
	219
	220	if (!brc_sock) {
	221	return;
	222	}
	223
	224	/* Find the compat_vlan that we currently have for 'tagged_dev' (if
	225	* any). */
	226	node = shash_find(&vlans_by_tagged, tagged_dev);
	227	vlan = node ? node->data : NULL;
228	if (vid <= 0 \|\| !trunk_dev) {
229	if (vlan) {
230	if (remove_tagged_dev(node, tagged_dev)) {
231	update_vlan_config();
232	}
233	}
234	} else {
235	if (vlan) {
236	if (!strcmp(trunk_dev, vlan->trunk_dev) && vid == vlan->vid) {
237	/* No change. */
238	return;
239	} else {
240	/* 'tagged_dev' is attached to the wrong compat_vlan. Start
241	* by removing it from that one. */
242	remove_tagged_dev(node, tagged_dev);
243	node = NULL;
244	vlan = NULL;
245	}
246	}
247
248	/* 'tagged_dev' is not attached to any compat_vlan. Find the
249	* compat_vlan corresponding to (trunk_dev,vid) to attach it to, or
250	* create a new compat_vlan if none exists for (trunk_dev,vid). */
251	HMAP_FOR_EACH_WITH_HASH (vlan, struct compat_vlan, trunk_node,
252	hash_vlan(trunk_dev, vid),
253	&vlans_by_trunk) {
254	if (!strcmp(trunk_dev, vlan->trunk_dev) && vid == vlan->vid) {
255	break;
256	}
257	}
258	if (!vlan) {
259	/* Create a new compat_vlan for (trunk_dev,vid). */
ec6fde61	260	vlan = xzalloc(sizeof *vlan);
064af421 BP	261	vlan->trunk_dev = xstrdup(trunk_dev);
	262	vlan->vid = vid;
	263	vlan->vlan_dev = xasprintf("%s.%d", trunk_dev, vid);
	264	svec_init(&vlan->tagged_devs);
	265	hmap_insert(&vlans_by_trunk, &vlan->trunk_node,
	266	hash_vlan(trunk_dev, vid));
	267	set_vlan_proc_file(vlan);
	268	}
	269
	270	/* Attach 'tagged_dev' to 'vlan'. */
	271	svec_add(&vlan->tagged_devs, tagged_dev);
	272	shash_add(&vlans_by_tagged, tagged_dev, vlan);
	273	svec_sort(&vlan->tagged_devs);
	274	update_vlan_config();
	275	}
	276	}
	277
	278	/* Remove 'tagged_dev' from the compat_vlan in 'node'. If that causes the
	279	* compat_vlan to have no tagged_devs left, destroy the compat_vlan too. */
	280	static bool
	281	remove_tagged_dev(struct shash_node node, const char tagged_dev)
	282	{
	283	struct compat_vlan *vlan = node->data;
	284
	285	svec_del(&vlan->tagged_devs, tagged_dev);
	286	shash_delete(&vlans_by_tagged, node);
	287	if (!vlan->tagged_devs.n) {
	288	set_proc_file("net/vlan", vlan->vlan_dev, NULL);
	289
	290	hmap_remove(&vlans_by_trunk, &vlan->trunk_node);
	291	svec_destroy(&vlan->tagged_devs);
	292	free(vlan->trunk_dev);
	293	free(vlan->vlan_dev);
	294	free(vlan);
	295	return true;
	296	}
	297	return false;
	298	}
	299
	300	/* Returns a hash value for (trunk_dev,vid). */
	301	static uint32_t
	302	hash_vlan(const char *trunk_dev, uint32_t vid)
	303	{
	304	return hash_int(vid, hash_string(trunk_dev, 0));
	305	}
	306
	307	/* Update /proc/net/vlan/<vlan_dev> for 'vlan'. */
	308	static void
	309	set_vlan_proc_file(const struct compat_vlan *vlan)
	310	{
	311	struct ds ds;
	312
	313	ds_init(&ds);
	314	ds_put_format(
	315	&ds,
	316	"%s VID: %d\t REORDER_HDR: 1 dev->priv_flags: 81\n"
	317	" total frames received 0\n"
	318	" total bytes received 0\n"
	319	" Broadcast/Multicast Rcvd 0\n"
	320	"\n"
	321	" total frames transmitted 0\n"
	322	" total bytes transmitted 0\n"
	323	" total headroom inc 0\n"
	324	" total encap on xmit 0\n"
325	"Device: %s\n"
326	"INGRESS priority mappings: 0:0 1:0 2:0 3:0 4:0 5:0 6:0 7:0\n"
327	"EGRESSS priority Mappings: \n",
328	vlan->vlan_dev, vlan->vid, vlan->trunk_dev);
329	set_proc_file("net/vlan", vlan->vlan_dev, ds_cstr(&ds));
330	ds_destroy(&ds);
331	}
332
333	/* Update /proc/net/vlan/config. */
334	static void
335	update_vlan_config(void)
336	{
337	struct compat_vlan *vlan;
338	struct ds ds;
339
340	ds_init(&ds);
341	ds_put_cstr(&ds, "VLAN Dev name \| VLAN ID\n"
342	"Name-Type: VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD\n");
343	HMAP_FOR_EACH (vlan, struct compat_vlan, trunk_node, &vlans_by_trunk) {
344	ds_put_format(&ds, "%-15s\| %d \| %s\n",
345	vlan->vlan_dev, vlan->vid, vlan->trunk_dev);
346	}
347	set_proc_file("net/vlan", "config", ds_cstr(&ds));
348	ds_destroy(&ds);
349	}
bfb1f2d5 BP	350	#else /* !HAVE_NETLINK */
	351	#include "compiler.h"
	352
	353	int
	354	proc_net_compat_init(void)
	355	{
	356	return 0;
	357	}
	358
	359	void
	360	proc_net_compat_update_bond(const char *name OVS_UNUSED,
	361	const struct compat_bond *bond OVS_UNUSED)
	362	{
	363	}
	364
	365	void
	366	proc_net_compat_update_vlan(const char *tagged_dev OVS_UNUSED,
	367	const char *trunk_dev OVS_UNUSED,
	368	int vid OVS_UNUSED)
	369	{
	370	}
	371	#endif /* !HAVE_NETLINK */