1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Management Component Transport Protocol (MCTP) - device implementation. 4 * 5 * Copyright (c) 2021 Code Construct 6 * Copyright (c) 2021 Google 7 */ 8 9 #include <linux/if_arp.h> 10 #include <linux/if_link.h> 11 #include <linux/mctp.h> 12 #include <linux/netdevice.h> 13 #include <linux/rcupdate.h> 14 #include <linux/rtnetlink.h> 15 16 #include <net/addrconf.h> 17 #include <net/netlink.h> 18 #include <net/mctp.h> 19 #include <net/mctpdevice.h> 20 #include <net/sock.h> 21 22 struct mctp_dump_cb { 23 unsigned long ifindex; 24 size_t a_idx; 25 }; 26 27 /* unlocked: caller must hold rcu_read_lock. 28 * Returned mctp_dev has its refcount incremented, or NULL if unset. 29 */ 30 struct mctp_dev *__mctp_dev_get(const struct net_device *dev) 31 { 32 struct mctp_dev *mdev = rcu_dereference(dev->mctp_ptr); 33 34 /* RCU guarantees that any mdev is still live. 35 * Zero refcount implies a pending free, return NULL. 36 */ 37 if (mdev) 38 if (!refcount_inc_not_zero(&mdev->refs)) 39 return NULL; 40 return mdev; 41 } 42 43 /* Returned mctp_dev does not have refcount incremented. The returned pointer 44 * remains live while rtnl_lock is held, as that prevents mctp_unregister() 45 */ 46 struct mctp_dev *mctp_dev_get_rtnl(const struct net_device *dev) 47 { 48 return rtnl_dereference(dev->mctp_ptr); 49 } 50 51 static int mctp_addrinfo_size(void) 52 { 53 return NLMSG_ALIGN(sizeof(struct ifaddrmsg)) 54 + nla_total_size(1) // IFA_LOCAL 55 + nla_total_size(1) // IFA_ADDRESS 56 ; 57 } 58 59 /* flag should be NLM_F_MULTI for dump calls */ 60 static int mctp_fill_addrinfo(struct sk_buff *skb, 61 struct mctp_dev *mdev, mctp_eid_t eid, 62 int msg_type, u32 portid, u32 seq, int flag) 63 { 64 struct ifaddrmsg *hdr; 65 struct nlmsghdr *nlh; 66 67 nlh = nlmsg_put(skb, portid, seq, 68 msg_type, sizeof(*hdr), flag); 69 if (!nlh) 70 return -EMSGSIZE; 71 72 hdr = nlmsg_data(nlh); 73 hdr->ifa_family = AF_MCTP; 74 hdr->ifa_prefixlen = 0; 75 hdr->ifa_flags = 0; 76 hdr->ifa_scope = 0; 77 hdr->ifa_index = mdev->dev->ifindex; 78 79 if (nla_put_u8(skb, IFA_LOCAL, eid)) 80 goto cancel; 81 82 if (nla_put_u8(skb, IFA_ADDRESS, eid)) 83 goto cancel; 84 85 nlmsg_end(skb, nlh); 86 87 return 0; 88 89 cancel: 90 nlmsg_cancel(skb, nlh); 91 return -EMSGSIZE; 92 } 93 94 static int mctp_dump_dev_addrinfo(struct mctp_dev *mdev, struct sk_buff *skb, 95 struct netlink_callback *cb) 96 { 97 struct mctp_dump_cb *mcb = (void *)cb->ctx; 98 u32 portid, seq; 99 int rc = 0; 100 101 portid = NETLINK_CB(cb->skb).portid; 102 seq = cb->nlh->nlmsg_seq; 103 for (; mcb->a_idx < mdev->num_addrs; mcb->a_idx++) { 104 rc = mctp_fill_addrinfo(skb, mdev, mdev->addrs[mcb->a_idx], 105 RTM_NEWADDR, portid, seq, NLM_F_MULTI); 106 if (rc < 0) 107 break; 108 } 109 110 return rc; 111 } 112 113 static int mctp_dump_addrinfo(struct sk_buff *skb, struct netlink_callback *cb) 114 { 115 struct mctp_dump_cb *mcb = (void *)cb->ctx; 116 struct net *net = sock_net(skb->sk); 117 struct net_device *dev; 118 struct ifaddrmsg *hdr; 119 struct mctp_dev *mdev; 120 int ifindex, rc; 121 122 hdr = nlmsg_data(cb->nlh); 123 // filter by ifindex if requested 124 ifindex = hdr->ifa_index; 125 126 rcu_read_lock(); 127 for_each_netdev_dump(net, dev, mcb->ifindex) { 128 if (ifindex && ifindex != dev->ifindex) 129 continue; 130 mdev = __mctp_dev_get(dev); 131 if (!mdev) 132 continue; 133 rc = mctp_dump_dev_addrinfo(mdev, skb, cb); 134 mctp_dev_put(mdev); 135 if (rc < 0) 136 break; 137 mcb->a_idx = 0; 138 } 139 rcu_read_unlock(); 140 141 return skb->len; 142 } 143 144 static void mctp_addr_notify(struct mctp_dev *mdev, mctp_eid_t eid, int msg_type, 145 struct sk_buff *req_skb, struct nlmsghdr *req_nlh) 146 { 147 u32 portid = NETLINK_CB(req_skb).portid; 148 struct net *net = dev_net(mdev->dev); 149 struct sk_buff *skb; 150 int rc = -ENOBUFS; 151 152 skb = nlmsg_new(mctp_addrinfo_size(), GFP_KERNEL); 153 if (!skb) 154 goto out; 155 156 rc = mctp_fill_addrinfo(skb, mdev, eid, msg_type, 157 portid, req_nlh->nlmsg_seq, 0); 158 if (rc < 0) { 159 WARN_ON_ONCE(rc == -EMSGSIZE); 160 goto out; 161 } 162 163 rtnl_notify(skb, net, portid, RTNLGRP_MCTP_IFADDR, req_nlh, GFP_KERNEL); 164 return; 165 out: 166 kfree_skb(skb); 167 rtnl_set_sk_err(net, RTNLGRP_MCTP_IFADDR, rc); 168 } 169 170 static const struct nla_policy ifa_mctp_policy[IFA_MAX + 1] = { 171 [IFA_ADDRESS] = { .type = NLA_U8 }, 172 [IFA_LOCAL] = { .type = NLA_U8 }, 173 }; 174 175 static int mctp_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, 176 struct netlink_ext_ack *extack) 177 { 178 struct net *net = sock_net(skb->sk); 179 struct nlattr *tb[IFA_MAX + 1]; 180 struct net_device *dev; 181 struct mctp_addr *addr; 182 struct mctp_dev *mdev; 183 struct ifaddrmsg *ifm; 184 unsigned long flags; 185 u8 *tmp_addrs; 186 int rc; 187 188 rc = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_mctp_policy, 189 extack); 190 if (rc < 0) 191 return rc; 192 193 ifm = nlmsg_data(nlh); 194 195 if (tb[IFA_LOCAL]) 196 addr = nla_data(tb[IFA_LOCAL]); 197 else if (tb[IFA_ADDRESS]) 198 addr = nla_data(tb[IFA_ADDRESS]); 199 else 200 return -EINVAL; 201 202 /* find device */ 203 dev = __dev_get_by_index(net, ifm->ifa_index); 204 if (!dev) 205 return -ENODEV; 206 207 mdev = mctp_dev_get_rtnl(dev); 208 if (!mdev) 209 return -ENODEV; 210 211 if (!mctp_address_unicast(addr->s_addr)) 212 return -EINVAL; 213 214 /* Prevent duplicates. Under RTNL so don't need to lock for reading */ 215 if (memchr(mdev->addrs, addr->s_addr, mdev->num_addrs)) 216 return -EEXIST; 217 218 tmp_addrs = kmalloc(mdev->num_addrs + 1, GFP_KERNEL); 219 if (!tmp_addrs) 220 return -ENOMEM; 221 memcpy(tmp_addrs, mdev->addrs, mdev->num_addrs); 222 tmp_addrs[mdev->num_addrs] = addr->s_addr; 223 224 /* Lock to write */ 225 spin_lock_irqsave(&mdev->addrs_lock, flags); 226 mdev->num_addrs++; 227 swap(mdev->addrs, tmp_addrs); 228 spin_unlock_irqrestore(&mdev->addrs_lock, flags); 229 230 kfree(tmp_addrs); 231 232 mctp_addr_notify(mdev, addr->s_addr, RTM_NEWADDR, skb, nlh); 233 mctp_route_add_local(mdev, addr->s_addr); 234 235 return 0; 236 } 237 238 static int mctp_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, 239 struct netlink_ext_ack *extack) 240 { 241 struct net *net = sock_net(skb->sk); 242 struct nlattr *tb[IFA_MAX + 1]; 243 struct net_device *dev; 244 struct mctp_addr *addr; 245 struct mctp_dev *mdev; 246 struct ifaddrmsg *ifm; 247 unsigned long flags; 248 u8 *pos; 249 int rc; 250 251 rc = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_mctp_policy, 252 extack); 253 if (rc < 0) 254 return rc; 255 256 ifm = nlmsg_data(nlh); 257 258 if (tb[IFA_LOCAL]) 259 addr = nla_data(tb[IFA_LOCAL]); 260 else if (tb[IFA_ADDRESS]) 261 addr = nla_data(tb[IFA_ADDRESS]); 262 else 263 return -EINVAL; 264 265 /* find device */ 266 dev = __dev_get_by_index(net, ifm->ifa_index); 267 if (!dev) 268 return -ENODEV; 269 270 mdev = mctp_dev_get_rtnl(dev); 271 if (!mdev) 272 return -ENODEV; 273 274 pos = memchr(mdev->addrs, addr->s_addr, mdev->num_addrs); 275 if (!pos) 276 return -ENOENT; 277 278 rc = mctp_route_remove_local(mdev, addr->s_addr); 279 // we can ignore -ENOENT in the case a route was already removed 280 if (rc < 0 && rc != -ENOENT) 281 return rc; 282 283 spin_lock_irqsave(&mdev->addrs_lock, flags); 284 memmove(pos, pos + 1, mdev->num_addrs - 1 - (pos - mdev->addrs)); 285 mdev->num_addrs--; 286 spin_unlock_irqrestore(&mdev->addrs_lock, flags); 287 288 mctp_addr_notify(mdev, addr->s_addr, RTM_DELADDR, skb, nlh); 289 290 return 0; 291 } 292 293 void mctp_dev_hold(struct mctp_dev *mdev) 294 { 295 refcount_inc(&mdev->refs); 296 } 297 298 void mctp_dev_put(struct mctp_dev *mdev) 299 { 300 if (mdev && refcount_dec_and_test(&mdev->refs)) { 301 kfree(mdev->addrs); 302 dev_put(mdev->dev); 303 kfree_rcu(mdev, rcu); 304 } 305 } 306 307 void mctp_dev_release_key(struct mctp_dev *dev, struct mctp_sk_key *key) 308 __must_hold(&key->lock) 309 { 310 if (!dev) 311 return; 312 if (dev->ops && dev->ops->release_flow) 313 dev->ops->release_flow(dev, key); 314 key->dev = NULL; 315 mctp_dev_put(dev); 316 } 317 318 void mctp_dev_set_key(struct mctp_dev *dev, struct mctp_sk_key *key) 319 __must_hold(&key->lock) 320 { 321 mctp_dev_hold(dev); 322 key->dev = dev; 323 } 324 325 static struct mctp_dev *mctp_add_dev(struct net_device *dev) 326 { 327 struct mctp_dev *mdev; 328 329 ASSERT_RTNL(); 330 331 mdev = kzalloc(sizeof(*mdev), GFP_KERNEL); 332 if (!mdev) 333 return ERR_PTR(-ENOMEM); 334 335 spin_lock_init(&mdev->addrs_lock); 336 337 mdev->net = mctp_default_net(dev_net(dev)); 338 339 /* associate to net_device */ 340 refcount_set(&mdev->refs, 1); 341 rcu_assign_pointer(dev->mctp_ptr, mdev); 342 343 dev_hold(dev); 344 mdev->dev = dev; 345 346 return mdev; 347 } 348 349 static int mctp_fill_link_af(struct sk_buff *skb, 350 const struct net_device *dev, u32 ext_filter_mask) 351 { 352 struct mctp_dev *mdev; 353 354 mdev = mctp_dev_get_rtnl(dev); 355 if (!mdev) 356 return -ENODATA; 357 if (nla_put_u32(skb, IFLA_MCTP_NET, mdev->net)) 358 return -EMSGSIZE; 359 if (nla_put_u8(skb, IFLA_MCTP_PHYS_BINDING, mdev->binding)) 360 return -EMSGSIZE; 361 return 0; 362 } 363 364 static size_t mctp_get_link_af_size(const struct net_device *dev, 365 u32 ext_filter_mask) 366 { 367 struct mctp_dev *mdev; 368 unsigned int ret; 369 370 /* caller holds RCU */ 371 mdev = __mctp_dev_get(dev); 372 if (!mdev) 373 return 0; 374 ret = nla_total_size(4); /* IFLA_MCTP_NET */ 375 ret += nla_total_size(1); /* IFLA_MCTP_PHYS_BINDING */ 376 mctp_dev_put(mdev); 377 return ret; 378 } 379 380 static const struct nla_policy ifla_af_mctp_policy[IFLA_MCTP_MAX + 1] = { 381 [IFLA_MCTP_NET] = { .type = NLA_U32 }, 382 }; 383 384 static int mctp_set_link_af(struct net_device *dev, const struct nlattr *attr, 385 struct netlink_ext_ack *extack) 386 { 387 struct nlattr *tb[IFLA_MCTP_MAX + 1]; 388 struct mctp_dev *mdev; 389 int rc; 390 391 rc = nla_parse_nested(tb, IFLA_MCTP_MAX, attr, ifla_af_mctp_policy, 392 NULL); 393 if (rc) 394 return rc; 395 396 mdev = mctp_dev_get_rtnl(dev); 397 if (!mdev) 398 return 0; 399 400 if (tb[IFLA_MCTP_NET]) 401 WRITE_ONCE(mdev->net, nla_get_u32(tb[IFLA_MCTP_NET])); 402 403 return 0; 404 } 405 406 /* Matches netdev types that should have MCTP handling */ 407 static bool mctp_known(struct net_device *dev) 408 { 409 /* only register specific types (inc. NONE for TUN devices) */ 410 return dev->type == ARPHRD_MCTP || 411 dev->type == ARPHRD_LOOPBACK || 412 dev->type == ARPHRD_NONE; 413 } 414 415 static void mctp_unregister(struct net_device *dev) 416 { 417 struct mctp_dev *mdev; 418 419 mdev = mctp_dev_get_rtnl(dev); 420 if (!mdev) 421 return; 422 423 RCU_INIT_POINTER(mdev->dev->mctp_ptr, NULL); 424 425 mctp_route_remove_dev(mdev); 426 mctp_neigh_remove_dev(mdev); 427 428 mctp_dev_put(mdev); 429 } 430 431 static int mctp_register(struct net_device *dev) 432 { 433 struct mctp_dev *mdev; 434 435 /* Already registered? */ 436 if (rtnl_dereference(dev->mctp_ptr)) 437 return 0; 438 439 /* only register specific types */ 440 if (!mctp_known(dev)) 441 return 0; 442 443 mdev = mctp_add_dev(dev); 444 if (IS_ERR(mdev)) 445 return PTR_ERR(mdev); 446 447 return 0; 448 } 449 450 static int mctp_dev_notify(struct notifier_block *this, unsigned long event, 451 void *ptr) 452 { 453 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 454 int rc; 455 456 switch (event) { 457 case NETDEV_REGISTER: 458 rc = mctp_register(dev); 459 if (rc) 460 return notifier_from_errno(rc); 461 break; 462 case NETDEV_UNREGISTER: 463 mctp_unregister(dev); 464 break; 465 } 466 467 return NOTIFY_OK; 468 } 469 470 static int mctp_register_netdevice(struct net_device *dev, 471 const struct mctp_netdev_ops *ops, 472 enum mctp_phys_binding binding) 473 { 474 struct mctp_dev *mdev; 475 476 mdev = mctp_add_dev(dev); 477 if (IS_ERR(mdev)) 478 return PTR_ERR(mdev); 479 480 mdev->ops = ops; 481 mdev->binding = binding; 482 483 return register_netdevice(dev); 484 } 485 486 int mctp_register_netdev(struct net_device *dev, 487 const struct mctp_netdev_ops *ops, 488 enum mctp_phys_binding binding) 489 { 490 int rc; 491 492 rtnl_lock(); 493 rc = mctp_register_netdevice(dev, ops, binding); 494 rtnl_unlock(); 495 496 return rc; 497 } 498 EXPORT_SYMBOL_GPL(mctp_register_netdev); 499 500 void mctp_unregister_netdev(struct net_device *dev) 501 { 502 unregister_netdev(dev); 503 } 504 EXPORT_SYMBOL_GPL(mctp_unregister_netdev); 505 506 static struct rtnl_af_ops mctp_af_ops = { 507 .family = AF_MCTP, 508 .fill_link_af = mctp_fill_link_af, 509 .get_link_af_size = mctp_get_link_af_size, 510 .set_link_af = mctp_set_link_af, 511 }; 512 513 static struct notifier_block mctp_dev_nb = { 514 .notifier_call = mctp_dev_notify, 515 .priority = ADDRCONF_NOTIFY_PRIORITY, 516 }; 517 518 static const struct rtnl_msg_handler mctp_device_rtnl_msg_handlers[] = { 519 {.owner = THIS_MODULE, .protocol = PF_MCTP, .msgtype = RTM_NEWADDR, 520 .doit = mctp_rtm_newaddr}, 521 {.owner = THIS_MODULE, .protocol = PF_MCTP, .msgtype = RTM_DELADDR, 522 .doit = mctp_rtm_deladdr}, 523 {.owner = THIS_MODULE, .protocol = PF_MCTP, .msgtype = RTM_GETADDR, 524 .dumpit = mctp_dump_addrinfo}, 525 }; 526 527 int __init mctp_device_init(void) 528 { 529 int err; 530 531 register_netdevice_notifier(&mctp_dev_nb); 532 533 err = rtnl_af_register(&mctp_af_ops); 534 if (err) 535 goto err_notifier; 536 537 err = rtnl_register_many(mctp_device_rtnl_msg_handlers); 538 if (err) 539 goto err_af; 540 541 return 0; 542 err_af: 543 rtnl_af_unregister(&mctp_af_ops); 544 err_notifier: 545 unregister_netdevice_notifier(&mctp_dev_nb); 546 return err; 547 } 548 549 void __exit mctp_device_exit(void) 550 { 551 rtnl_unregister_many(mctp_device_rtnl_msg_handlers); 552 rtnl_af_unregister(&mctp_af_ops); 553 unregister_netdevice_notifier(&mctp_dev_nb); 554 } 555