Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Management Component Transport Protocol (MCTP) - device implementation.
0004  *
0005  * Copyright (c) 2021 Code Construct
0006  * Copyright (c) 2021 Google
0007  */
0008 
0009 #include <linux/if_arp.h>
0010 #include <linux/if_link.h>
0011 #include <linux/mctp.h>
0012 #include <linux/netdevice.h>
0013 #include <linux/rcupdate.h>
0014 #include <linux/rtnetlink.h>
0015 
0016 #include <net/addrconf.h>
0017 #include <net/netlink.h>
0018 #include <net/mctp.h>
0019 #include <net/mctpdevice.h>
0020 #include <net/sock.h>
0021 
0022 struct mctp_dump_cb {
0023     int h;
0024     int idx;
0025     size_t a_idx;
0026 };
0027 
0028 /* unlocked: caller must hold rcu_read_lock.
0029  * Returned mctp_dev has its refcount incremented, or NULL if unset.
0030  */
0031 struct mctp_dev *__mctp_dev_get(const struct net_device *dev)
0032 {
0033     struct mctp_dev *mdev = rcu_dereference(dev->mctp_ptr);
0034 
0035     /* RCU guarantees that any mdev is still live.
0036      * Zero refcount implies a pending free, return NULL.
0037      */
0038     if (mdev)
0039         if (!refcount_inc_not_zero(&mdev->refs))
0040             return NULL;
0041     return mdev;
0042 }
0043 
0044 /* Returned mctp_dev does not have refcount incremented. The returned pointer
0045  * remains live while rtnl_lock is held, as that prevents mctp_unregister()
0046  */
0047 struct mctp_dev *mctp_dev_get_rtnl(const struct net_device *dev)
0048 {
0049     return rtnl_dereference(dev->mctp_ptr);
0050 }
0051 
0052 static int mctp_addrinfo_size(void)
0053 {
0054     return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
0055         + nla_total_size(1) // IFA_LOCAL
0056         + nla_total_size(1) // IFA_ADDRESS
0057         ;
0058 }
0059 
0060 /* flag should be NLM_F_MULTI for dump calls */
0061 static int mctp_fill_addrinfo(struct sk_buff *skb,
0062                   struct mctp_dev *mdev, mctp_eid_t eid,
0063                   int msg_type, u32 portid, u32 seq, int flag)
0064 {
0065     struct ifaddrmsg *hdr;
0066     struct nlmsghdr *nlh;
0067 
0068     nlh = nlmsg_put(skb, portid, seq,
0069             msg_type, sizeof(*hdr), flag);
0070     if (!nlh)
0071         return -EMSGSIZE;
0072 
0073     hdr = nlmsg_data(nlh);
0074     hdr->ifa_family = AF_MCTP;
0075     hdr->ifa_prefixlen = 0;
0076     hdr->ifa_flags = 0;
0077     hdr->ifa_scope = 0;
0078     hdr->ifa_index = mdev->dev->ifindex;
0079 
0080     if (nla_put_u8(skb, IFA_LOCAL, eid))
0081         goto cancel;
0082 
0083     if (nla_put_u8(skb, IFA_ADDRESS, eid))
0084         goto cancel;
0085 
0086     nlmsg_end(skb, nlh);
0087 
0088     return 0;
0089 
0090 cancel:
0091     nlmsg_cancel(skb, nlh);
0092     return -EMSGSIZE;
0093 }
0094 
0095 static int mctp_dump_dev_addrinfo(struct mctp_dev *mdev, struct sk_buff *skb,
0096                   struct netlink_callback *cb)
0097 {
0098     struct mctp_dump_cb *mcb = (void *)cb->ctx;
0099     u32 portid, seq;
0100     int rc = 0;
0101 
0102     portid = NETLINK_CB(cb->skb).portid;
0103     seq = cb->nlh->nlmsg_seq;
0104     for (; mcb->a_idx < mdev->num_addrs; mcb->a_idx++) {
0105         rc = mctp_fill_addrinfo(skb, mdev, mdev->addrs[mcb->a_idx],
0106                     RTM_NEWADDR, portid, seq, NLM_F_MULTI);
0107         if (rc < 0)
0108             break;
0109     }
0110 
0111     return rc;
0112 }
0113 
0114 static int mctp_dump_addrinfo(struct sk_buff *skb, struct netlink_callback *cb)
0115 {
0116     struct mctp_dump_cb *mcb = (void *)cb->ctx;
0117     struct net *net = sock_net(skb->sk);
0118     struct hlist_head *head;
0119     struct net_device *dev;
0120     struct ifaddrmsg *hdr;
0121     struct mctp_dev *mdev;
0122     int ifindex;
0123     int idx = 0, rc;
0124 
0125     hdr = nlmsg_data(cb->nlh);
0126     // filter by ifindex if requested
0127     ifindex = hdr->ifa_index;
0128 
0129     rcu_read_lock();
0130     for (; mcb->h < NETDEV_HASHENTRIES; mcb->h++, mcb->idx = 0) {
0131         idx = 0;
0132         head = &net->dev_index_head[mcb->h];
0133         hlist_for_each_entry_rcu(dev, head, index_hlist) {
0134             if (idx >= mcb->idx &&
0135                 (ifindex == 0 || ifindex == dev->ifindex)) {
0136                 mdev = __mctp_dev_get(dev);
0137                 if (mdev) {
0138                     rc = mctp_dump_dev_addrinfo(mdev,
0139                                     skb, cb);
0140                     mctp_dev_put(mdev);
0141                     // Error indicates full buffer, this
0142                     // callback will get retried.
0143                     if (rc < 0)
0144                         goto out;
0145                 }
0146             }
0147             idx++;
0148             // reset for next iteration
0149             mcb->a_idx = 0;
0150         }
0151     }
0152 out:
0153     rcu_read_unlock();
0154     mcb->idx = idx;
0155 
0156     return skb->len;
0157 }
0158 
0159 static void mctp_addr_notify(struct mctp_dev *mdev, mctp_eid_t eid, int msg_type,
0160                  struct sk_buff *req_skb, struct nlmsghdr *req_nlh)
0161 {
0162     u32 portid = NETLINK_CB(req_skb).portid;
0163     struct net *net = dev_net(mdev->dev);
0164     struct sk_buff *skb;
0165     int rc = -ENOBUFS;
0166 
0167     skb = nlmsg_new(mctp_addrinfo_size(), GFP_KERNEL);
0168     if (!skb)
0169         goto out;
0170 
0171     rc = mctp_fill_addrinfo(skb, mdev, eid, msg_type,
0172                 portid, req_nlh->nlmsg_seq, 0);
0173     if (rc < 0) {
0174         WARN_ON_ONCE(rc == -EMSGSIZE);
0175         goto out;
0176     }
0177 
0178     rtnl_notify(skb, net, portid, RTNLGRP_MCTP_IFADDR, req_nlh, GFP_KERNEL);
0179     return;
0180 out:
0181     kfree_skb(skb);
0182     rtnl_set_sk_err(net, RTNLGRP_MCTP_IFADDR, rc);
0183 }
0184 
0185 static const struct nla_policy ifa_mctp_policy[IFA_MAX + 1] = {
0186     [IFA_ADDRESS]       = { .type = NLA_U8 },
0187     [IFA_LOCAL]     = { .type = NLA_U8 },
0188 };
0189 
0190 static int mctp_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh,
0191                 struct netlink_ext_ack *extack)
0192 {
0193     struct net *net = sock_net(skb->sk);
0194     struct nlattr *tb[IFA_MAX + 1];
0195     struct net_device *dev;
0196     struct mctp_addr *addr;
0197     struct mctp_dev *mdev;
0198     struct ifaddrmsg *ifm;
0199     unsigned long flags;
0200     u8 *tmp_addrs;
0201     int rc;
0202 
0203     rc = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_mctp_policy,
0204              extack);
0205     if (rc < 0)
0206         return rc;
0207 
0208     ifm = nlmsg_data(nlh);
0209 
0210     if (tb[IFA_LOCAL])
0211         addr = nla_data(tb[IFA_LOCAL]);
0212     else if (tb[IFA_ADDRESS])
0213         addr = nla_data(tb[IFA_ADDRESS]);
0214     else
0215         return -EINVAL;
0216 
0217     /* find device */
0218     dev = __dev_get_by_index(net, ifm->ifa_index);
0219     if (!dev)
0220         return -ENODEV;
0221 
0222     mdev = mctp_dev_get_rtnl(dev);
0223     if (!mdev)
0224         return -ENODEV;
0225 
0226     if (!mctp_address_unicast(addr->s_addr))
0227         return -EINVAL;
0228 
0229     /* Prevent duplicates. Under RTNL so don't need to lock for reading */
0230     if (memchr(mdev->addrs, addr->s_addr, mdev->num_addrs))
0231         return -EEXIST;
0232 
0233     tmp_addrs = kmalloc(mdev->num_addrs + 1, GFP_KERNEL);
0234     if (!tmp_addrs)
0235         return -ENOMEM;
0236     memcpy(tmp_addrs, mdev->addrs, mdev->num_addrs);
0237     tmp_addrs[mdev->num_addrs] = addr->s_addr;
0238 
0239     /* Lock to write */
0240     spin_lock_irqsave(&mdev->addrs_lock, flags);
0241     mdev->num_addrs++;
0242     swap(mdev->addrs, tmp_addrs);
0243     spin_unlock_irqrestore(&mdev->addrs_lock, flags);
0244 
0245     kfree(tmp_addrs);
0246 
0247     mctp_addr_notify(mdev, addr->s_addr, RTM_NEWADDR, skb, nlh);
0248     mctp_route_add_local(mdev, addr->s_addr);
0249 
0250     return 0;
0251 }
0252 
0253 static int mctp_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh,
0254                 struct netlink_ext_ack *extack)
0255 {
0256     struct net *net = sock_net(skb->sk);
0257     struct nlattr *tb[IFA_MAX + 1];
0258     struct net_device *dev;
0259     struct mctp_addr *addr;
0260     struct mctp_dev *mdev;
0261     struct ifaddrmsg *ifm;
0262     unsigned long flags;
0263     u8 *pos;
0264     int rc;
0265 
0266     rc = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_mctp_policy,
0267              extack);
0268     if (rc < 0)
0269         return rc;
0270 
0271     ifm = nlmsg_data(nlh);
0272 
0273     if (tb[IFA_LOCAL])
0274         addr = nla_data(tb[IFA_LOCAL]);
0275     else if (tb[IFA_ADDRESS])
0276         addr = nla_data(tb[IFA_ADDRESS]);
0277     else
0278         return -EINVAL;
0279 
0280     /* find device */
0281     dev = __dev_get_by_index(net, ifm->ifa_index);
0282     if (!dev)
0283         return -ENODEV;
0284 
0285     mdev = mctp_dev_get_rtnl(dev);
0286     if (!mdev)
0287         return -ENODEV;
0288 
0289     pos = memchr(mdev->addrs, addr->s_addr, mdev->num_addrs);
0290     if (!pos)
0291         return -ENOENT;
0292 
0293     rc = mctp_route_remove_local(mdev, addr->s_addr);
0294     // we can ignore -ENOENT in the case a route was already removed
0295     if (rc < 0 && rc != -ENOENT)
0296         return rc;
0297 
0298     spin_lock_irqsave(&mdev->addrs_lock, flags);
0299     memmove(pos, pos + 1, mdev->num_addrs - 1 - (pos - mdev->addrs));
0300     mdev->num_addrs--;
0301     spin_unlock_irqrestore(&mdev->addrs_lock, flags);
0302 
0303     mctp_addr_notify(mdev, addr->s_addr, RTM_DELADDR, skb, nlh);
0304 
0305     return 0;
0306 }
0307 
0308 void mctp_dev_hold(struct mctp_dev *mdev)
0309 {
0310     refcount_inc(&mdev->refs);
0311 }
0312 
0313 void mctp_dev_put(struct mctp_dev *mdev)
0314 {
0315     if (mdev && refcount_dec_and_test(&mdev->refs)) {
0316         kfree(mdev->addrs);
0317         dev_put(mdev->dev);
0318         kfree_rcu(mdev, rcu);
0319     }
0320 }
0321 
0322 void mctp_dev_release_key(struct mctp_dev *dev, struct mctp_sk_key *key)
0323     __must_hold(&key->lock)
0324 {
0325     if (!dev)
0326         return;
0327     if (dev->ops && dev->ops->release_flow)
0328         dev->ops->release_flow(dev, key);
0329     key->dev = NULL;
0330     mctp_dev_put(dev);
0331 }
0332 
0333 void mctp_dev_set_key(struct mctp_dev *dev, struct mctp_sk_key *key)
0334     __must_hold(&key->lock)
0335 {
0336     mctp_dev_hold(dev);
0337     key->dev = dev;
0338 }
0339 
0340 static struct mctp_dev *mctp_add_dev(struct net_device *dev)
0341 {
0342     struct mctp_dev *mdev;
0343 
0344     ASSERT_RTNL();
0345 
0346     mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
0347     if (!mdev)
0348         return ERR_PTR(-ENOMEM);
0349 
0350     spin_lock_init(&mdev->addrs_lock);
0351 
0352     mdev->net = mctp_default_net(dev_net(dev));
0353 
0354     /* associate to net_device */
0355     refcount_set(&mdev->refs, 1);
0356     rcu_assign_pointer(dev->mctp_ptr, mdev);
0357 
0358     dev_hold(dev);
0359     mdev->dev = dev;
0360 
0361     return mdev;
0362 }
0363 
0364 static int mctp_fill_link_af(struct sk_buff *skb,
0365                  const struct net_device *dev, u32 ext_filter_mask)
0366 {
0367     struct mctp_dev *mdev;
0368 
0369     mdev = mctp_dev_get_rtnl(dev);
0370     if (!mdev)
0371         return -ENODATA;
0372     if (nla_put_u32(skb, IFLA_MCTP_NET, mdev->net))
0373         return -EMSGSIZE;
0374     return 0;
0375 }
0376 
0377 static size_t mctp_get_link_af_size(const struct net_device *dev,
0378                     u32 ext_filter_mask)
0379 {
0380     struct mctp_dev *mdev;
0381     unsigned int ret;
0382 
0383     /* caller holds RCU */
0384     mdev = __mctp_dev_get(dev);
0385     if (!mdev)
0386         return 0;
0387     ret = nla_total_size(4); /* IFLA_MCTP_NET */
0388     mctp_dev_put(mdev);
0389     return ret;
0390 }
0391 
0392 static const struct nla_policy ifla_af_mctp_policy[IFLA_MCTP_MAX + 1] = {
0393     [IFLA_MCTP_NET]     = { .type = NLA_U32 },
0394 };
0395 
0396 static int mctp_set_link_af(struct net_device *dev, const struct nlattr *attr,
0397                 struct netlink_ext_ack *extack)
0398 {
0399     struct nlattr *tb[IFLA_MCTP_MAX + 1];
0400     struct mctp_dev *mdev;
0401     int rc;
0402 
0403     rc = nla_parse_nested(tb, IFLA_MCTP_MAX, attr, ifla_af_mctp_policy,
0404                   NULL);
0405     if (rc)
0406         return rc;
0407 
0408     mdev = mctp_dev_get_rtnl(dev);
0409     if (!mdev)
0410         return 0;
0411 
0412     if (tb[IFLA_MCTP_NET])
0413         WRITE_ONCE(mdev->net, nla_get_u32(tb[IFLA_MCTP_NET]));
0414 
0415     return 0;
0416 }
0417 
0418 /* Matches netdev types that should have MCTP handling */
0419 static bool mctp_known(struct net_device *dev)
0420 {
0421     /* only register specific types (inc. NONE for TUN devices) */
0422     return dev->type == ARPHRD_MCTP ||
0423            dev->type == ARPHRD_LOOPBACK ||
0424            dev->type == ARPHRD_NONE;
0425 }
0426 
0427 static void mctp_unregister(struct net_device *dev)
0428 {
0429     struct mctp_dev *mdev;
0430 
0431     mdev = mctp_dev_get_rtnl(dev);
0432     if (mdev && !mctp_known(dev)) {
0433         // Sanity check, should match what was set in mctp_register
0434         netdev_warn(dev, "%s: BUG mctp_ptr set for unknown type %d",
0435                 __func__, dev->type);
0436         return;
0437     }
0438     if (!mdev)
0439         return;
0440 
0441     RCU_INIT_POINTER(mdev->dev->mctp_ptr, NULL);
0442 
0443     mctp_route_remove_dev(mdev);
0444     mctp_neigh_remove_dev(mdev);
0445 
0446     mctp_dev_put(mdev);
0447 }
0448 
0449 static int mctp_register(struct net_device *dev)
0450 {
0451     struct mctp_dev *mdev;
0452 
0453     /* Already registered? */
0454     mdev = rtnl_dereference(dev->mctp_ptr);
0455 
0456     if (mdev) {
0457         if (!mctp_known(dev))
0458             netdev_warn(dev, "%s: BUG mctp_ptr set for unknown type %d",
0459                     __func__, dev->type);
0460         return 0;
0461     }
0462 
0463     /* only register specific types */
0464     if (!mctp_known(dev))
0465         return 0;
0466 
0467     mdev = mctp_add_dev(dev);
0468     if (IS_ERR(mdev))
0469         return PTR_ERR(mdev);
0470 
0471     return 0;
0472 }
0473 
0474 static int mctp_dev_notify(struct notifier_block *this, unsigned long event,
0475                void *ptr)
0476 {
0477     struct net_device *dev = netdev_notifier_info_to_dev(ptr);
0478     int rc;
0479 
0480     switch (event) {
0481     case NETDEV_REGISTER:
0482         rc = mctp_register(dev);
0483         if (rc)
0484             return notifier_from_errno(rc);
0485         break;
0486     case NETDEV_UNREGISTER:
0487         mctp_unregister(dev);
0488         break;
0489     }
0490 
0491     return NOTIFY_OK;
0492 }
0493 
0494 static int mctp_register_netdevice(struct net_device *dev,
0495                    const struct mctp_netdev_ops *ops)
0496 {
0497     struct mctp_dev *mdev;
0498 
0499     mdev = mctp_add_dev(dev);
0500     if (IS_ERR(mdev))
0501         return PTR_ERR(mdev);
0502 
0503     mdev->ops = ops;
0504 
0505     return register_netdevice(dev);
0506 }
0507 
0508 int mctp_register_netdev(struct net_device *dev,
0509              const struct mctp_netdev_ops *ops)
0510 {
0511     int rc;
0512 
0513     rtnl_lock();
0514     rc = mctp_register_netdevice(dev, ops);
0515     rtnl_unlock();
0516 
0517     return rc;
0518 }
0519 EXPORT_SYMBOL_GPL(mctp_register_netdev);
0520 
0521 void mctp_unregister_netdev(struct net_device *dev)
0522 {
0523     unregister_netdev(dev);
0524 }
0525 EXPORT_SYMBOL_GPL(mctp_unregister_netdev);
0526 
0527 static struct rtnl_af_ops mctp_af_ops = {
0528     .family = AF_MCTP,
0529     .fill_link_af = mctp_fill_link_af,
0530     .get_link_af_size = mctp_get_link_af_size,
0531     .set_link_af = mctp_set_link_af,
0532 };
0533 
0534 static struct notifier_block mctp_dev_nb = {
0535     .notifier_call = mctp_dev_notify,
0536     .priority = ADDRCONF_NOTIFY_PRIORITY,
0537 };
0538 
0539 void __init mctp_device_init(void)
0540 {
0541     register_netdevice_notifier(&mctp_dev_nb);
0542 
0543     rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_GETADDR,
0544                  NULL, mctp_dump_addrinfo, 0);
0545     rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_NEWADDR,
0546                  mctp_rtm_newaddr, NULL, 0);
0547     rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_DELADDR,
0548                  mctp_rtm_deladdr, NULL, 0);
0549     rtnl_af_register(&mctp_af_ops);
0550 }
0551 
0552 void __exit mctp_device_exit(void)
0553 {
0554     rtnl_af_unregister(&mctp_af_ops);
0555     rtnl_unregister(PF_MCTP, RTM_DELADDR);
0556     rtnl_unregister(PF_MCTP, RTM_NEWADDR);
0557     rtnl_unregister(PF_MCTP, RTM_GETADDR);
0558 
0559     unregister_netdevice_notifier(&mctp_dev_nb);
0560 }
[ 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!