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