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 */
__mctp_dev_get(const struct net_device * dev)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 */
mctp_dev_get_rtnl(const struct net_device * dev)46 struct mctp_dev *mctp_dev_get_rtnl(const struct net_device *dev)
47 {
48 return rtnl_dereference(dev->mctp_ptr);
49 }
50
mctp_addrinfo_size(void)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 */
mctp_fill_addrinfo(struct sk_buff * skb,struct mctp_dev * mdev,mctp_eid_t eid,int msg_type,u32 portid,u32 seq,int flag)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
mctp_dump_dev_addrinfo(struct mctp_dev * mdev,struct sk_buff * skb,struct netlink_callback * cb)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
mctp_dump_addrinfo(struct sk_buff * skb,struct netlink_callback * cb)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
mctp_addr_notify(struct mctp_dev * mdev,mctp_eid_t eid,int msg_type,struct sk_buff * req_skb,struct nlmsghdr * req_nlh)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
mctp_rtm_newaddr(struct sk_buff * skb,struct nlmsghdr * nlh,struct netlink_ext_ack * extack)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
mctp_rtm_deladdr(struct sk_buff * skb,struct nlmsghdr * nlh,struct netlink_ext_ack * extack)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
mctp_dev_hold(struct mctp_dev * mdev)301 void mctp_dev_hold(struct mctp_dev *mdev)
302 {
303 refcount_inc(&mdev->refs);
304 }
305
mctp_dev_put(struct mctp_dev * mdev)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
mctp_dev_release_key(struct mctp_dev * dev,struct mctp_sk_key * key)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
mctp_dev_set_key(struct mctp_dev * dev,struct mctp_sk_key * key)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
mctp_add_dev(struct net_device * dev)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);
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
mctp_fill_link_af(struct sk_buff * skb,const struct net_device * dev,u32 ext_filter_mask)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
mctp_get_link_af_size(const struct net_device * dev,u32 ext_filter_mask)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
mctp_set_link_af(struct net_device * dev,const struct nlattr * attr,struct netlink_ext_ack * extack)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 */
mctp_known(struct net_device * dev)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
mctp_unregister(struct net_device * dev)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
mctp_register(struct net_device * dev)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
mctp_dev_notify(struct notifier_block * this,unsigned long event,void * ptr)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
mctp_register_netdevice(struct net_device * dev,const struct mctp_netdev_ops * ops,enum mctp_phys_binding binding)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
mctp_register_netdev(struct net_device * dev,const struct mctp_netdev_ops * ops,enum mctp_phys_binding binding)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
mctp_unregister_netdev(struct net_device * dev)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
mctp_device_init(void)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
mctp_device_exit(void)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