device.c

  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
 22struct 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 */
 30struct 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 */
 46struct mctp_dev *mctp_dev_get_rtnl(const struct net_device *dev)
 47{
 48	return rtnl_dereference(dev->mctp_ptr);
 49}
 50
 51static 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 */
 60static 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
 90cancel:
 91	nlmsg_cancel(skb, nlh);
 92	return -EMSGSIZE;
 93}
 94
 95static 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
114static 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
152static 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;
173out:
174	kfree_skb(skb);
175	rtnl_set_sk_err(net, RTNLGRP_MCTP_IFADDR, rc);
176}
177
178static const struct nla_policy ifa_mctp_policy[IFA_MAX + 1] = {
179	[IFA_ADDRESS]		= { .type = NLA_U8 },
180	[IFA_LOCAL]		= { .type = NLA_U8 },
181};
182
183static 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
246static 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
301void mctp_dev_hold(struct mctp_dev *mdev)
302{
303	refcount_inc(&mdev->refs);
304}
305
306void 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
315void 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
326void 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
333static struct mctp_dev *mctp_add_dev(struct net_device *dev)
334{
335	struct mctp_dev *mdev;
336
337	ASSERT_RTNL();
338
339	mdev = kzalloc(sizeof(*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
357static 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
372static 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
388static const struct nla_policy ifla_af_mctp_policy[IFLA_MCTP_MAX + 1] = {
389	[IFLA_MCTP_NET]		= { .type = NLA_U32 },
390};
391
392static 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 */
415static 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
423static 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
439static 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
458static 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
478static 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
494int 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}
506EXPORT_SYMBOL_GPL(mctp_register_netdev);
507
508void mctp_unregister_netdev(struct net_device *dev)
509{
510	unregister_netdev(dev);
511}
512EXPORT_SYMBOL_GPL(mctp_unregister_netdev);
513
514static 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
521static struct notifier_block mctp_dev_nb = {
522	.notifier_call = mctp_dev_notify,
523	.priority = ADDRCONF_NOTIFY_PRIORITY,
524};
525
526static 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
535int __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;
550err_af:
551	rtnl_af_unregister(&mctp_af_ops);
552err_notifier:
553	unregister_netdevice_notifier(&mctp_dev_nb);
554	return err;
555}
556
557void __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}