Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * INET     802.1Q VLAN
0004  *      Ethernet-type device handling.
0005  *
0006  * Authors: Ben Greear <greearb@candelatech.com>
0007  *              Please send support related email to: netdev@vger.kernel.org
0008  *              VLAN Home Page: http://www.candelatech.com/~greear/vlan.html
0009  *
0010  * Fixes:
0011  *              Fix for packet capture - Nick Eggleston <nick@dccinc.com>;
0012  *      Add HW acceleration hooks - David S. Miller <davem@redhat.com>;
0013  *      Correct all the locking - David S. Miller <davem@redhat.com>;
0014  *      Use hash table for VLAN groups - David S. Miller <davem@redhat.com>
0015  */
0016 
0017 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0018 
0019 #include <linux/capability.h>
0020 #include <linux/module.h>
0021 #include <linux/netdevice.h>
0022 #include <linux/skbuff.h>
0023 #include <linux/slab.h>
0024 #include <linux/init.h>
0025 #include <linux/rculist.h>
0026 #include <net/p8022.h>
0027 #include <net/arp.h>
0028 #include <linux/rtnetlink.h>
0029 #include <linux/notifier.h>
0030 #include <net/rtnetlink.h>
0031 #include <net/net_namespace.h>
0032 #include <net/netns/generic.h>
0033 #include <linux/uaccess.h>
0034 
0035 #include <linux/if_vlan.h>
0036 #include "vlan.h"
0037 #include "vlanproc.h"
0038 
0039 #define DRV_VERSION "1.8"
0040 
0041 /* Global VLAN variables */
0042 
0043 unsigned int vlan_net_id __read_mostly;
0044 
0045 const char vlan_fullname[] = "802.1Q VLAN Support";
0046 const char vlan_version[] = DRV_VERSION;
0047 
0048 /* End of global variables definitions. */
0049 
0050 static int vlan_group_prealloc_vid(struct vlan_group *vg,
0051                    __be16 vlan_proto, u16 vlan_id)
0052 {
0053     struct net_device **array;
0054     unsigned int vidx;
0055     unsigned int size;
0056     int pidx;
0057 
0058     ASSERT_RTNL();
0059 
0060     pidx  = vlan_proto_idx(vlan_proto);
0061     if (pidx < 0)
0062         return -EINVAL;
0063 
0064     vidx  = vlan_id / VLAN_GROUP_ARRAY_PART_LEN;
0065     array = vg->vlan_devices_arrays[pidx][vidx];
0066     if (array != NULL)
0067         return 0;
0068 
0069     size = sizeof(struct net_device *) * VLAN_GROUP_ARRAY_PART_LEN;
0070     array = kzalloc(size, GFP_KERNEL_ACCOUNT);
0071     if (array == NULL)
0072         return -ENOBUFS;
0073 
0074     /* paired with smp_rmb() in __vlan_group_get_device() */
0075     smp_wmb();
0076 
0077     vg->vlan_devices_arrays[pidx][vidx] = array;
0078     return 0;
0079 }
0080 
0081 static void vlan_stacked_transfer_operstate(const struct net_device *rootdev,
0082                         struct net_device *dev,
0083                         struct vlan_dev_priv *vlan)
0084 {
0085     if (!(vlan->flags & VLAN_FLAG_BRIDGE_BINDING))
0086         netif_stacked_transfer_operstate(rootdev, dev);
0087 }
0088 
0089 void unregister_vlan_dev(struct net_device *dev, struct list_head *head)
0090 {
0091     struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
0092     struct net_device *real_dev = vlan->real_dev;
0093     struct vlan_info *vlan_info;
0094     struct vlan_group *grp;
0095     u16 vlan_id = vlan->vlan_id;
0096 
0097     ASSERT_RTNL();
0098 
0099     vlan_info = rtnl_dereference(real_dev->vlan_info);
0100     BUG_ON(!vlan_info);
0101 
0102     grp = &vlan_info->grp;
0103 
0104     grp->nr_vlan_devs--;
0105 
0106     if (vlan->flags & VLAN_FLAG_MVRP)
0107         vlan_mvrp_request_leave(dev);
0108     if (vlan->flags & VLAN_FLAG_GVRP)
0109         vlan_gvrp_request_leave(dev);
0110 
0111     vlan_group_set_device(grp, vlan->vlan_proto, vlan_id, NULL);
0112 
0113     netdev_upper_dev_unlink(real_dev, dev);
0114     /* Because unregister_netdevice_queue() makes sure at least one rcu
0115      * grace period is respected before device freeing,
0116      * we dont need to call synchronize_net() here.
0117      */
0118     unregister_netdevice_queue(dev, head);
0119 
0120     if (grp->nr_vlan_devs == 0) {
0121         vlan_mvrp_uninit_applicant(real_dev);
0122         vlan_gvrp_uninit_applicant(real_dev);
0123     }
0124 
0125     vlan_vid_del(real_dev, vlan->vlan_proto, vlan_id);
0126 }
0127 
0128 int vlan_check_real_dev(struct net_device *real_dev,
0129             __be16 protocol, u16 vlan_id,
0130             struct netlink_ext_ack *extack)
0131 {
0132     const char *name = real_dev->name;
0133 
0134     if (real_dev->features & NETIF_F_VLAN_CHALLENGED) {
0135         pr_info("VLANs not supported on %s\n", name);
0136         NL_SET_ERR_MSG_MOD(extack, "VLANs not supported on device");
0137         return -EOPNOTSUPP;
0138     }
0139 
0140     if (vlan_find_dev(real_dev, protocol, vlan_id) != NULL) {
0141         NL_SET_ERR_MSG_MOD(extack, "VLAN device already exists");
0142         return -EEXIST;
0143     }
0144 
0145     return 0;
0146 }
0147 
0148 int register_vlan_dev(struct net_device *dev, struct netlink_ext_ack *extack)
0149 {
0150     struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
0151     struct net_device *real_dev = vlan->real_dev;
0152     u16 vlan_id = vlan->vlan_id;
0153     struct vlan_info *vlan_info;
0154     struct vlan_group *grp;
0155     int err;
0156 
0157     err = vlan_vid_add(real_dev, vlan->vlan_proto, vlan_id);
0158     if (err)
0159         return err;
0160 
0161     vlan_info = rtnl_dereference(real_dev->vlan_info);
0162     /* vlan_info should be there now. vlan_vid_add took care of it */
0163     BUG_ON(!vlan_info);
0164 
0165     grp = &vlan_info->grp;
0166     if (grp->nr_vlan_devs == 0) {
0167         err = vlan_gvrp_init_applicant(real_dev);
0168         if (err < 0)
0169             goto out_vid_del;
0170         err = vlan_mvrp_init_applicant(real_dev);
0171         if (err < 0)
0172             goto out_uninit_gvrp;
0173     }
0174 
0175     err = vlan_group_prealloc_vid(grp, vlan->vlan_proto, vlan_id);
0176     if (err < 0)
0177         goto out_uninit_mvrp;
0178 
0179     err = register_netdevice(dev);
0180     if (err < 0)
0181         goto out_uninit_mvrp;
0182 
0183     err = netdev_upper_dev_link(real_dev, dev, extack);
0184     if (err)
0185         goto out_unregister_netdev;
0186 
0187     vlan_stacked_transfer_operstate(real_dev, dev, vlan);
0188     linkwatch_fire_event(dev); /* _MUST_ call rfc2863_policy() */
0189 
0190     /* So, got the sucker initialized, now lets place
0191      * it into our local structure.
0192      */
0193     vlan_group_set_device(grp, vlan->vlan_proto, vlan_id, dev);
0194     grp->nr_vlan_devs++;
0195 
0196     return 0;
0197 
0198 out_unregister_netdev:
0199     unregister_netdevice(dev);
0200 out_uninit_mvrp:
0201     if (grp->nr_vlan_devs == 0)
0202         vlan_mvrp_uninit_applicant(real_dev);
0203 out_uninit_gvrp:
0204     if (grp->nr_vlan_devs == 0)
0205         vlan_gvrp_uninit_applicant(real_dev);
0206 out_vid_del:
0207     vlan_vid_del(real_dev, vlan->vlan_proto, vlan_id);
0208     return err;
0209 }
0210 
0211 /*  Attach a VLAN device to a mac address (ie Ethernet Card).
0212  *  Returns 0 if the device was created or a negative error code otherwise.
0213  */
0214 static int register_vlan_device(struct net_device *real_dev, u16 vlan_id)
0215 {
0216     struct net_device *new_dev;
0217     struct vlan_dev_priv *vlan;
0218     struct net *net = dev_net(real_dev);
0219     struct vlan_net *vn = net_generic(net, vlan_net_id);
0220     char name[IFNAMSIZ];
0221     int err;
0222 
0223     if (vlan_id >= VLAN_VID_MASK)
0224         return -ERANGE;
0225 
0226     err = vlan_check_real_dev(real_dev, htons(ETH_P_8021Q), vlan_id,
0227                   NULL);
0228     if (err < 0)
0229         return err;
0230 
0231     /* Gotta set up the fields for the device. */
0232     switch (vn->name_type) {
0233     case VLAN_NAME_TYPE_RAW_PLUS_VID:
0234         /* name will look like:  eth1.0005 */
0235         snprintf(name, IFNAMSIZ, "%s.%.4i", real_dev->name, vlan_id);
0236         break;
0237     case VLAN_NAME_TYPE_PLUS_VID_NO_PAD:
0238         /* Put our vlan.VID in the name.
0239          * Name will look like:  vlan5
0240          */
0241         snprintf(name, IFNAMSIZ, "vlan%i", vlan_id);
0242         break;
0243     case VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD:
0244         /* Put our vlan.VID in the name.
0245          * Name will look like:  eth0.5
0246          */
0247         snprintf(name, IFNAMSIZ, "%s.%i", real_dev->name, vlan_id);
0248         break;
0249     case VLAN_NAME_TYPE_PLUS_VID:
0250         /* Put our vlan.VID in the name.
0251          * Name will look like:  vlan0005
0252          */
0253     default:
0254         snprintf(name, IFNAMSIZ, "vlan%.4i", vlan_id);
0255     }
0256 
0257     new_dev = alloc_netdev(sizeof(struct vlan_dev_priv), name,
0258                    NET_NAME_UNKNOWN, vlan_setup);
0259 
0260     if (new_dev == NULL)
0261         return -ENOBUFS;
0262 
0263     dev_net_set(new_dev, net);
0264     /* need 4 bytes for extra VLAN header info,
0265      * hope the underlying device can handle it.
0266      */
0267     new_dev->mtu = real_dev->mtu;
0268 
0269     vlan = vlan_dev_priv(new_dev);
0270     vlan->vlan_proto = htons(ETH_P_8021Q);
0271     vlan->vlan_id = vlan_id;
0272     vlan->real_dev = real_dev;
0273     vlan->dent = NULL;
0274     vlan->flags = VLAN_FLAG_REORDER_HDR;
0275 
0276     new_dev->rtnl_link_ops = &vlan_link_ops;
0277     err = register_vlan_dev(new_dev, NULL);
0278     if (err < 0)
0279         goto out_free_newdev;
0280 
0281     return 0;
0282 
0283 out_free_newdev:
0284     free_netdev(new_dev);
0285     return err;
0286 }
0287 
0288 static void vlan_sync_address(struct net_device *dev,
0289                   struct net_device *vlandev)
0290 {
0291     struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);
0292 
0293     /* May be called without an actual change */
0294     if (ether_addr_equal(vlan->real_dev_addr, dev->dev_addr))
0295         return;
0296 
0297     /* vlan continues to inherit address of lower device */
0298     if (vlan_dev_inherit_address(vlandev, dev))
0299         goto out;
0300 
0301     /* vlan address was different from the old address and is equal to
0302      * the new address */
0303     if (!ether_addr_equal(vlandev->dev_addr, vlan->real_dev_addr) &&
0304         ether_addr_equal(vlandev->dev_addr, dev->dev_addr))
0305         dev_uc_del(dev, vlandev->dev_addr);
0306 
0307     /* vlan address was equal to the old address and is different from
0308      * the new address */
0309     if (ether_addr_equal(vlandev->dev_addr, vlan->real_dev_addr) &&
0310         !ether_addr_equal(vlandev->dev_addr, dev->dev_addr))
0311         dev_uc_add(dev, vlandev->dev_addr);
0312 
0313 out:
0314     ether_addr_copy(vlan->real_dev_addr, dev->dev_addr);
0315 }
0316 
0317 static void vlan_transfer_features(struct net_device *dev,
0318                    struct net_device *vlandev)
0319 {
0320     struct vlan_dev_priv *vlan = vlan_dev_priv(vlandev);
0321 
0322     netif_inherit_tso_max(vlandev, dev);
0323 
0324     if (vlan_hw_offload_capable(dev->features, vlan->vlan_proto))
0325         vlandev->hard_header_len = dev->hard_header_len;
0326     else
0327         vlandev->hard_header_len = dev->hard_header_len + VLAN_HLEN;
0328 
0329 #if IS_ENABLED(CONFIG_FCOE)
0330     vlandev->fcoe_ddp_xid = dev->fcoe_ddp_xid;
0331 #endif
0332 
0333     vlandev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
0334     vlandev->priv_flags |= (vlan->real_dev->priv_flags & IFF_XMIT_DST_RELEASE);
0335     vlandev->hw_enc_features = vlan_tnl_features(vlan->real_dev);
0336 
0337     netdev_update_features(vlandev);
0338 }
0339 
0340 static int __vlan_device_event(struct net_device *dev, unsigned long event)
0341 {
0342     int err = 0;
0343 
0344     switch (event) {
0345     case NETDEV_CHANGENAME:
0346         vlan_proc_rem_dev(dev);
0347         err = vlan_proc_add_dev(dev);
0348         break;
0349     case NETDEV_REGISTER:
0350         err = vlan_proc_add_dev(dev);
0351         break;
0352     case NETDEV_UNREGISTER:
0353         vlan_proc_rem_dev(dev);
0354         break;
0355     }
0356 
0357     return err;
0358 }
0359 
0360 static int vlan_device_event(struct notifier_block *unused, unsigned long event,
0361                  void *ptr)
0362 {
0363     struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(ptr);
0364     struct net_device *dev = netdev_notifier_info_to_dev(ptr);
0365     struct vlan_group *grp;
0366     struct vlan_info *vlan_info;
0367     int i, flgs;
0368     struct net_device *vlandev;
0369     struct vlan_dev_priv *vlan;
0370     bool last = false;
0371     LIST_HEAD(list);
0372     int err;
0373 
0374     if (is_vlan_dev(dev)) {
0375         int err = __vlan_device_event(dev, event);
0376 
0377         if (err)
0378             return notifier_from_errno(err);
0379     }
0380 
0381     if ((event == NETDEV_UP) &&
0382         (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER)) {
0383         pr_info("adding VLAN 0 to HW filter on device %s\n",
0384             dev->name);
0385         vlan_vid_add(dev, htons(ETH_P_8021Q), 0);
0386     }
0387     if (event == NETDEV_DOWN &&
0388         (dev->features & NETIF_F_HW_VLAN_CTAG_FILTER))
0389         vlan_vid_del(dev, htons(ETH_P_8021Q), 0);
0390 
0391     vlan_info = rtnl_dereference(dev->vlan_info);
0392     if (!vlan_info)
0393         goto out;
0394     grp = &vlan_info->grp;
0395 
0396     /* It is OK that we do not hold the group lock right now,
0397      * as we run under the RTNL lock.
0398      */
0399 
0400     switch (event) {
0401     case NETDEV_CHANGE:
0402         /* Propagate real device state to vlan devices */
0403         vlan_group_for_each_dev(grp, i, vlandev)
0404             vlan_stacked_transfer_operstate(dev, vlandev,
0405                             vlan_dev_priv(vlandev));
0406         break;
0407 
0408     case NETDEV_CHANGEADDR:
0409         /* Adjust unicast filters on underlying device */
0410         vlan_group_for_each_dev(grp, i, vlandev) {
0411             flgs = vlandev->flags;
0412             if (!(flgs & IFF_UP))
0413                 continue;
0414 
0415             vlan_sync_address(dev, vlandev);
0416         }
0417         break;
0418 
0419     case NETDEV_CHANGEMTU:
0420         vlan_group_for_each_dev(grp, i, vlandev) {
0421             if (vlandev->mtu <= dev->mtu)
0422                 continue;
0423 
0424             dev_set_mtu(vlandev, dev->mtu);
0425         }
0426         break;
0427 
0428     case NETDEV_FEAT_CHANGE:
0429         /* Propagate device features to underlying device */
0430         vlan_group_for_each_dev(grp, i, vlandev)
0431             vlan_transfer_features(dev, vlandev);
0432         break;
0433 
0434     case NETDEV_DOWN: {
0435         struct net_device *tmp;
0436         LIST_HEAD(close_list);
0437 
0438         /* Put all VLANs for this dev in the down state too.  */
0439         vlan_group_for_each_dev(grp, i, vlandev) {
0440             flgs = vlandev->flags;
0441             if (!(flgs & IFF_UP))
0442                 continue;
0443 
0444             vlan = vlan_dev_priv(vlandev);
0445             if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
0446                 list_add(&vlandev->close_list, &close_list);
0447         }
0448 
0449         dev_close_many(&close_list, false);
0450 
0451         list_for_each_entry_safe(vlandev, tmp, &close_list, close_list) {
0452             vlan_stacked_transfer_operstate(dev, vlandev,
0453                             vlan_dev_priv(vlandev));
0454             list_del_init(&vlandev->close_list);
0455         }
0456         list_del(&close_list);
0457         break;
0458     }
0459     case NETDEV_UP:
0460         /* Put all VLANs for this dev in the up state too.  */
0461         vlan_group_for_each_dev(grp, i, vlandev) {
0462             flgs = dev_get_flags(vlandev);
0463             if (flgs & IFF_UP)
0464                 continue;
0465 
0466             vlan = vlan_dev_priv(vlandev);
0467             if (!(vlan->flags & VLAN_FLAG_LOOSE_BINDING))
0468                 dev_change_flags(vlandev, flgs | IFF_UP,
0469                          extack);
0470             vlan_stacked_transfer_operstate(dev, vlandev, vlan);
0471         }
0472         break;
0473 
0474     case NETDEV_UNREGISTER:
0475         /* twiddle thumbs on netns device moves */
0476         if (dev->reg_state != NETREG_UNREGISTERING)
0477             break;
0478 
0479         vlan_group_for_each_dev(grp, i, vlandev) {
0480             /* removal of last vid destroys vlan_info, abort
0481              * afterwards */
0482             if (vlan_info->nr_vids == 1)
0483                 last = true;
0484 
0485             unregister_vlan_dev(vlandev, &list);
0486             if (last)
0487                 break;
0488         }
0489         unregister_netdevice_many(&list);
0490         break;
0491 
0492     case NETDEV_PRE_TYPE_CHANGE:
0493         /* Forbid underlaying device to change its type. */
0494         if (vlan_uses_dev(dev))
0495             return NOTIFY_BAD;
0496         break;
0497 
0498     case NETDEV_NOTIFY_PEERS:
0499     case NETDEV_BONDING_FAILOVER:
0500     case NETDEV_RESEND_IGMP:
0501         /* Propagate to vlan devices */
0502         vlan_group_for_each_dev(grp, i, vlandev)
0503             call_netdevice_notifiers(event, vlandev);
0504         break;
0505 
0506     case NETDEV_CVLAN_FILTER_PUSH_INFO:
0507         err = vlan_filter_push_vids(vlan_info, htons(ETH_P_8021Q));
0508         if (err)
0509             return notifier_from_errno(err);
0510         break;
0511 
0512     case NETDEV_CVLAN_FILTER_DROP_INFO:
0513         vlan_filter_drop_vids(vlan_info, htons(ETH_P_8021Q));
0514         break;
0515 
0516     case NETDEV_SVLAN_FILTER_PUSH_INFO:
0517         err = vlan_filter_push_vids(vlan_info, htons(ETH_P_8021AD));
0518         if (err)
0519             return notifier_from_errno(err);
0520         break;
0521 
0522     case NETDEV_SVLAN_FILTER_DROP_INFO:
0523         vlan_filter_drop_vids(vlan_info, htons(ETH_P_8021AD));
0524         break;
0525     }
0526 
0527 out:
0528     return NOTIFY_DONE;
0529 }
0530 
0531 static struct notifier_block vlan_notifier_block __read_mostly = {
0532     .notifier_call = vlan_device_event,
0533 };
0534 
0535 /*
0536  *  VLAN IOCTL handler.
0537  *  o execute requested action or pass command to the device driver
0538  *   arg is really a struct vlan_ioctl_args __user *.
0539  */
0540 static int vlan_ioctl_handler(struct net *net, void __user *arg)
0541 {
0542     int err;
0543     struct vlan_ioctl_args args;
0544     struct net_device *dev = NULL;
0545 
0546     if (copy_from_user(&args, arg, sizeof(struct vlan_ioctl_args)))
0547         return -EFAULT;
0548 
0549     /* Null terminate this sucker, just in case. */
0550     args.device1[sizeof(args.device1) - 1] = 0;
0551     args.u.device2[sizeof(args.u.device2) - 1] = 0;
0552 
0553     rtnl_lock();
0554 
0555     switch (args.cmd) {
0556     case SET_VLAN_INGRESS_PRIORITY_CMD:
0557     case SET_VLAN_EGRESS_PRIORITY_CMD:
0558     case SET_VLAN_FLAG_CMD:
0559     case ADD_VLAN_CMD:
0560     case DEL_VLAN_CMD:
0561     case GET_VLAN_REALDEV_NAME_CMD:
0562     case GET_VLAN_VID_CMD:
0563         err = -ENODEV;
0564         dev = __dev_get_by_name(net, args.device1);
0565         if (!dev)
0566             goto out;
0567 
0568         err = -EINVAL;
0569         if (args.cmd != ADD_VLAN_CMD && !is_vlan_dev(dev))
0570             goto out;
0571     }
0572 
0573     switch (args.cmd) {
0574     case SET_VLAN_INGRESS_PRIORITY_CMD:
0575         err = -EPERM;
0576         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0577             break;
0578         vlan_dev_set_ingress_priority(dev,
0579                           args.u.skb_priority,
0580                           args.vlan_qos);
0581         err = 0;
0582         break;
0583 
0584     case SET_VLAN_EGRESS_PRIORITY_CMD:
0585         err = -EPERM;
0586         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0587             break;
0588         err = vlan_dev_set_egress_priority(dev,
0589                            args.u.skb_priority,
0590                            args.vlan_qos);
0591         break;
0592 
0593     case SET_VLAN_FLAG_CMD:
0594         err = -EPERM;
0595         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0596             break;
0597         err = vlan_dev_change_flags(dev,
0598                         args.vlan_qos ? args.u.flag : 0,
0599                         args.u.flag);
0600         break;
0601 
0602     case SET_VLAN_NAME_TYPE_CMD:
0603         err = -EPERM;
0604         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0605             break;
0606         if (args.u.name_type < VLAN_NAME_TYPE_HIGHEST) {
0607             struct vlan_net *vn;
0608 
0609             vn = net_generic(net, vlan_net_id);
0610             vn->name_type = args.u.name_type;
0611             err = 0;
0612         } else {
0613             err = -EINVAL;
0614         }
0615         break;
0616 
0617     case ADD_VLAN_CMD:
0618         err = -EPERM;
0619         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0620             break;
0621         err = register_vlan_device(dev, args.u.VID);
0622         break;
0623 
0624     case DEL_VLAN_CMD:
0625         err = -EPERM;
0626         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0627             break;
0628         unregister_vlan_dev(dev, NULL);
0629         err = 0;
0630         break;
0631 
0632     case GET_VLAN_REALDEV_NAME_CMD:
0633         err = 0;
0634         vlan_dev_get_realdev_name(dev, args.u.device2,
0635                       sizeof(args.u.device2));
0636         if (copy_to_user(arg, &args,
0637                  sizeof(struct vlan_ioctl_args)))
0638             err = -EFAULT;
0639         break;
0640 
0641     case GET_VLAN_VID_CMD:
0642         err = 0;
0643         args.u.VID = vlan_dev_vlan_id(dev);
0644         if (copy_to_user(arg, &args,
0645                  sizeof(struct vlan_ioctl_args)))
0646               err = -EFAULT;
0647         break;
0648 
0649     default:
0650         err = -EOPNOTSUPP;
0651         break;
0652     }
0653 out:
0654     rtnl_unlock();
0655     return err;
0656 }
0657 
0658 static int __net_init vlan_init_net(struct net *net)
0659 {
0660     struct vlan_net *vn = net_generic(net, vlan_net_id);
0661     int err;
0662 
0663     vn->name_type = VLAN_NAME_TYPE_RAW_PLUS_VID_NO_PAD;
0664 
0665     err = vlan_proc_init(net);
0666 
0667     return err;
0668 }
0669 
0670 static void __net_exit vlan_exit_net(struct net *net)
0671 {
0672     vlan_proc_cleanup(net);
0673 }
0674 
0675 static struct pernet_operations vlan_net_ops = {
0676     .init = vlan_init_net,
0677     .exit = vlan_exit_net,
0678     .id   = &vlan_net_id,
0679     .size = sizeof(struct vlan_net),
0680 };
0681 
0682 static int __init vlan_proto_init(void)
0683 {
0684     int err;
0685 
0686     pr_info("%s v%s\n", vlan_fullname, vlan_version);
0687 
0688     err = register_pernet_subsys(&vlan_net_ops);
0689     if (err < 0)
0690         goto err0;
0691 
0692     err = register_netdevice_notifier(&vlan_notifier_block);
0693     if (err < 0)
0694         goto err2;
0695 
0696     err = vlan_gvrp_init();
0697     if (err < 0)
0698         goto err3;
0699 
0700     err = vlan_mvrp_init();
0701     if (err < 0)
0702         goto err4;
0703 
0704     err = vlan_netlink_init();
0705     if (err < 0)
0706         goto err5;
0707 
0708     vlan_ioctl_set(vlan_ioctl_handler);
0709     return 0;
0710 
0711 err5:
0712     vlan_mvrp_uninit();
0713 err4:
0714     vlan_gvrp_uninit();
0715 err3:
0716     unregister_netdevice_notifier(&vlan_notifier_block);
0717 err2:
0718     unregister_pernet_subsys(&vlan_net_ops);
0719 err0:
0720     return err;
0721 }
0722 
0723 static void __exit vlan_cleanup_module(void)
0724 {
0725     vlan_ioctl_set(NULL);
0726 
0727     vlan_netlink_fini();
0728 
0729     unregister_netdevice_notifier(&vlan_notifier_block);
0730 
0731     unregister_pernet_subsys(&vlan_net_ops);
0732     rcu_barrier(); /* Wait for completion of call_rcu()'s */
0733 
0734     vlan_mvrp_uninit();
0735     vlan_gvrp_uninit();
0736 }
0737 
0738 module_init(vlan_proto_init);
0739 module_exit(vlan_cleanup_module);
0740 
0741 MODULE_LICENSE("GPL");
0742 MODULE_VERSION(DRV_VERSION);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!