}
 }
 
+/* v_opts is used to dump the options which must be equal in the whole range */
 static bool br_vlan_fill_vids(struct sk_buff *skb, u16 vid, u16 vid_range,
+                             const struct net_bridge_vlan *v_opts,
                              u16 flags)
 {
        struct bridge_vlan_info info;
            nla_put_u16(skb, BRIDGE_VLANDB_ENTRY_RANGE, vid_range))
                goto out_err;
 
+       if (v_opts && !br_vlan_opts_fill(skb, v_opts))
+               goto out_err;
+
        nla_nest_end(skb, nest);
 
        return true;
        return NLMSG_ALIGN(sizeof(struct br_vlan_msg))
                + nla_total_size(0) /* BRIDGE_VLANDB_ENTRY */
                + nla_total_size(sizeof(u16)) /* BRIDGE_VLANDB_ENTRY_RANGE */
-               + nla_total_size(sizeof(struct bridge_vlan_info)); /* BRIDGE_VLANDB_ENTRY_INFO */
+               + nla_total_size(sizeof(struct bridge_vlan_info)) /* BRIDGE_VLANDB_ENTRY_INFO */
+               + br_vlan_opts_nl_size(); /* bridge vlan options */
 }
 
 void br_vlan_notify(const struct net_bridge *br,
                    int cmd)
 {
        struct net_bridge_vlan_group *vg;
-       struct net_bridge_vlan *v;
+       struct net_bridge_vlan *v = NULL;
        struct br_vlan_msg *bvm;
        struct nlmsghdr *nlh;
        struct sk_buff *skb;
                goto out_kfree;
        }
 
-       if (!br_vlan_fill_vids(skb, vid, vid_range, flags))
+       if (!br_vlan_fill_vids(skb, vid, vid_range, v, flags))
                goto out_err;
 
        nlmsg_end(skb, nlh);
                                    const struct net_bridge_vlan *range_end)
 {
        return v_curr->vid - range_end->vid == 1 &&
-              range_end->flags == v_curr->flags;
+              range_end->flags == v_curr->flags &&
+              br_vlan_opts_eq(v_curr, range_end);
 }
 
 static int br_vlan_dump_dev(const struct net_device *dev,
                        u16 flags = br_vlan_flags(range_start, pvid);
 
                        if (!br_vlan_fill_vids(skb, range_start->vid,
-                                              range_end->vid, flags)) {
+                                              range_end->vid, range_start,
+                                              flags)) {
                                err = -EMSGSIZE;
                                break;
                        }
         */
        if (!err && range_start &&
            !br_vlan_fill_vids(skb, range_start->vid, range_end->vid,
-                              br_vlan_flags(range_start, pvid)))
+                              range_start, br_vlan_flags(range_start, pvid)))
                err = -EMSGSIZE;
 
        cb->args[1] = err ? idx : 0;
 
--- /dev/null
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (c) 2020, Nikolay Aleksandrov <nikolay@cumulusnetworks.com>
+#include <linux/kernel.h>
+#include <linux/netdevice.h>
+#include <linux/rtnetlink.h>
+#include <linux/slab.h>
+
+#include "br_private.h"
+
+/* check if the options between two vlans are equal */
+bool br_vlan_opts_eq(const struct net_bridge_vlan *v1,
+                    const struct net_bridge_vlan *v2)
+{
+       return true;
+}
+
+bool br_vlan_opts_fill(struct sk_buff *skb, const struct net_bridge_vlan *v)
+{
+       return true;
+}
+
+size_t br_vlan_opts_nl_size(void)
+{
+       return 0;
+}