1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Management Component Transport Protocol (MCTP) - routing |
4 | * implementation. |
5 | * |
6 | * This is currently based on a simple routing table, with no dst cache. The |
7 | * number of routes should stay fairly small, so the lookup cost is small. |
8 | * |
9 | * Copyright (c) 2021 Code Construct |
10 | * Copyright (c) 2021 Google |
11 | */ |
12 | |
13 | #include <linux/idr.h> |
14 | #include <linux/mctp.h> |
15 | #include <linux/netdevice.h> |
16 | #include <linux/rtnetlink.h> |
17 | #include <linux/skbuff.h> |
18 | |
19 | #include <net/mctp.h> |
20 | #include <net/mctpdevice.h> |
21 | #include <net/netlink.h> |
22 | #include <net/sock.h> |
23 | |
24 | static int mctp_neigh_add(struct mctp_dev *mdev, mctp_eid_t eid, |
25 | enum mctp_neigh_source source, |
26 | size_t lladdr_len, const void *lladdr) |
27 | { |
28 | struct net *net = dev_net(dev: mdev->dev); |
29 | struct mctp_neigh *neigh; |
30 | int rc; |
31 | |
32 | mutex_lock(&net->mctp.neigh_lock); |
33 | if (mctp_neigh_lookup(dev: mdev, eid, NULL) == 0) { |
34 | rc = -EEXIST; |
35 | goto out; |
36 | } |
37 | |
38 | if (lladdr_len > sizeof(neigh->ha)) { |
39 | rc = -EINVAL; |
40 | goto out; |
41 | } |
42 | |
43 | neigh = kzalloc(size: sizeof(*neigh), GFP_KERNEL); |
44 | if (!neigh) { |
45 | rc = -ENOMEM; |
46 | goto out; |
47 | } |
48 | INIT_LIST_HEAD(list: &neigh->list); |
49 | neigh->dev = mdev; |
50 | mctp_dev_hold(mdev: neigh->dev); |
51 | neigh->eid = eid; |
52 | neigh->source = source; |
53 | memcpy(neigh->ha, lladdr, lladdr_len); |
54 | |
55 | list_add_rcu(new: &neigh->list, head: &net->mctp.neighbours); |
56 | rc = 0; |
57 | out: |
58 | mutex_unlock(lock: &net->mctp.neigh_lock); |
59 | return rc; |
60 | } |
61 | |
62 | static void __mctp_neigh_free(struct rcu_head *rcu) |
63 | { |
64 | struct mctp_neigh *neigh = container_of(rcu, struct mctp_neigh, rcu); |
65 | |
66 | mctp_dev_put(mdev: neigh->dev); |
67 | kfree(objp: neigh); |
68 | } |
69 | |
70 | /* Removes all neighbour entries referring to a device */ |
71 | void mctp_neigh_remove_dev(struct mctp_dev *mdev) |
72 | { |
73 | struct net *net = dev_net(dev: mdev->dev); |
74 | struct mctp_neigh *neigh, *tmp; |
75 | |
76 | mutex_lock(&net->mctp.neigh_lock); |
77 | list_for_each_entry_safe(neigh, tmp, &net->mctp.neighbours, list) { |
78 | if (neigh->dev == mdev) { |
79 | list_del_rcu(entry: &neigh->list); |
80 | /* TODO: immediate RTM_DELNEIGH */ |
81 | call_rcu(head: &neigh->rcu, func: __mctp_neigh_free); |
82 | } |
83 | } |
84 | |
85 | mutex_unlock(lock: &net->mctp.neigh_lock); |
86 | } |
87 | |
88 | static int mctp_neigh_remove(struct mctp_dev *mdev, mctp_eid_t eid, |
89 | enum mctp_neigh_source source) |
90 | { |
91 | struct net *net = dev_net(dev: mdev->dev); |
92 | struct mctp_neigh *neigh, *tmp; |
93 | bool dropped = false; |
94 | |
95 | mutex_lock(&net->mctp.neigh_lock); |
96 | list_for_each_entry_safe(neigh, tmp, &net->mctp.neighbours, list) { |
97 | if (neigh->dev == mdev && neigh->eid == eid && |
98 | neigh->source == source) { |
99 | list_del_rcu(entry: &neigh->list); |
100 | /* TODO: immediate RTM_DELNEIGH */ |
101 | call_rcu(head: &neigh->rcu, func: __mctp_neigh_free); |
102 | dropped = true; |
103 | } |
104 | } |
105 | |
106 | mutex_unlock(lock: &net->mctp.neigh_lock); |
107 | return dropped ? 0 : -ENOENT; |
108 | } |
109 | |
110 | static const struct nla_policy nd_mctp_policy[NDA_MAX + 1] = { |
111 | [NDA_DST] = { .type = NLA_U8 }, |
112 | [NDA_LLADDR] = { .type = NLA_BINARY, .len = MAX_ADDR_LEN }, |
113 | }; |
114 | |
115 | static int mctp_rtm_newneigh(struct sk_buff *skb, struct nlmsghdr *nlh, |
116 | struct netlink_ext_ack *extack) |
117 | { |
118 | struct net *net = sock_net(sk: skb->sk); |
119 | struct net_device *dev; |
120 | struct mctp_dev *mdev; |
121 | struct ndmsg *ndm; |
122 | struct nlattr *tb[NDA_MAX + 1]; |
123 | int rc; |
124 | mctp_eid_t eid; |
125 | void *lladdr; |
126 | int lladdr_len; |
127 | |
128 | rc = nlmsg_parse(nlh, hdrlen: sizeof(*ndm), tb, NDA_MAX, policy: nd_mctp_policy, |
129 | extack); |
130 | if (rc < 0) { |
131 | NL_SET_ERR_MSG(extack, "lladdr too large?" ); |
132 | return rc; |
133 | } |
134 | |
135 | if (!tb[NDA_DST]) { |
136 | NL_SET_ERR_MSG(extack, "Neighbour EID must be specified" ); |
137 | return -EINVAL; |
138 | } |
139 | |
140 | if (!tb[NDA_LLADDR]) { |
141 | NL_SET_ERR_MSG(extack, "Neighbour lladdr must be specified" ); |
142 | return -EINVAL; |
143 | } |
144 | |
145 | eid = nla_get_u8(nla: tb[NDA_DST]); |
146 | if (!mctp_address_unicast(eid)) { |
147 | NL_SET_ERR_MSG(extack, "Invalid neighbour EID" ); |
148 | return -EINVAL; |
149 | } |
150 | |
151 | lladdr = nla_data(nla: tb[NDA_LLADDR]); |
152 | lladdr_len = nla_len(nla: tb[NDA_LLADDR]); |
153 | |
154 | ndm = nlmsg_data(nlh); |
155 | |
156 | dev = __dev_get_by_index(net, ifindex: ndm->ndm_ifindex); |
157 | if (!dev) |
158 | return -ENODEV; |
159 | |
160 | mdev = mctp_dev_get_rtnl(dev); |
161 | if (!mdev) |
162 | return -ENODEV; |
163 | |
164 | if (lladdr_len != dev->addr_len) { |
165 | NL_SET_ERR_MSG(extack, "Wrong lladdr length" ); |
166 | return -EINVAL; |
167 | } |
168 | |
169 | return mctp_neigh_add(mdev, eid, source: MCTP_NEIGH_STATIC, |
170 | lladdr_len, lladdr); |
171 | } |
172 | |
173 | static int mctp_rtm_delneigh(struct sk_buff *skb, struct nlmsghdr *nlh, |
174 | struct netlink_ext_ack *extack) |
175 | { |
176 | struct net *net = sock_net(sk: skb->sk); |
177 | struct nlattr *tb[NDA_MAX + 1]; |
178 | struct net_device *dev; |
179 | struct mctp_dev *mdev; |
180 | struct ndmsg *ndm; |
181 | int rc; |
182 | mctp_eid_t eid; |
183 | |
184 | rc = nlmsg_parse(nlh, hdrlen: sizeof(*ndm), tb, NDA_MAX, policy: nd_mctp_policy, |
185 | extack); |
186 | if (rc < 0) { |
187 | NL_SET_ERR_MSG(extack, "incorrect format" ); |
188 | return rc; |
189 | } |
190 | |
191 | if (!tb[NDA_DST]) { |
192 | NL_SET_ERR_MSG(extack, "Neighbour EID must be specified" ); |
193 | return -EINVAL; |
194 | } |
195 | eid = nla_get_u8(nla: tb[NDA_DST]); |
196 | |
197 | ndm = nlmsg_data(nlh); |
198 | dev = __dev_get_by_index(net, ifindex: ndm->ndm_ifindex); |
199 | if (!dev) |
200 | return -ENODEV; |
201 | |
202 | mdev = mctp_dev_get_rtnl(dev); |
203 | if (!mdev) |
204 | return -ENODEV; |
205 | |
206 | return mctp_neigh_remove(mdev, eid, source: MCTP_NEIGH_STATIC); |
207 | } |
208 | |
209 | static int mctp_fill_neigh(struct sk_buff *skb, u32 portid, u32 seq, int event, |
210 | unsigned int flags, struct mctp_neigh *neigh) |
211 | { |
212 | struct net_device *dev = neigh->dev->dev; |
213 | struct nlmsghdr *nlh; |
214 | struct ndmsg *hdr; |
215 | |
216 | nlh = nlmsg_put(skb, portid, seq, type: event, payload: sizeof(*hdr), flags); |
217 | if (!nlh) |
218 | return -EMSGSIZE; |
219 | |
220 | hdr = nlmsg_data(nlh); |
221 | hdr->ndm_family = AF_MCTP; |
222 | hdr->ndm_ifindex = dev->ifindex; |
223 | hdr->ndm_state = 0; // TODO other state bits? |
224 | if (neigh->source == MCTP_NEIGH_STATIC) |
225 | hdr->ndm_state |= NUD_PERMANENT; |
226 | hdr->ndm_flags = 0; |
227 | hdr->ndm_type = RTN_UNICAST; // TODO: is loopback RTN_LOCAL? |
228 | |
229 | if (nla_put_u8(skb, attrtype: NDA_DST, value: neigh->eid)) |
230 | goto cancel; |
231 | |
232 | if (nla_put(skb, attrtype: NDA_LLADDR, attrlen: dev->addr_len, data: neigh->ha)) |
233 | goto cancel; |
234 | |
235 | nlmsg_end(skb, nlh); |
236 | |
237 | return 0; |
238 | cancel: |
239 | nlmsg_cancel(skb, nlh); |
240 | return -EMSGSIZE; |
241 | } |
242 | |
243 | static int mctp_rtm_getneigh(struct sk_buff *skb, struct netlink_callback *cb) |
244 | { |
245 | struct net *net = sock_net(sk: skb->sk); |
246 | int rc, idx, req_ifindex; |
247 | struct mctp_neigh *neigh; |
248 | struct ndmsg *ndmsg; |
249 | struct { |
250 | int idx; |
251 | } *cbctx = (void *)cb->ctx; |
252 | |
253 | ndmsg = nlmsg_data(nlh: cb->nlh); |
254 | req_ifindex = ndmsg->ndm_ifindex; |
255 | |
256 | idx = 0; |
257 | rcu_read_lock(); |
258 | list_for_each_entry_rcu(neigh, &net->mctp.neighbours, list) { |
259 | if (idx < cbctx->idx) |
260 | goto cont; |
261 | |
262 | rc = 0; |
263 | if (req_ifindex == 0 || req_ifindex == neigh->dev->dev->ifindex) |
264 | rc = mctp_fill_neigh(skb, NETLINK_CB(cb->skb).portid, |
265 | seq: cb->nlh->nlmsg_seq, |
266 | RTM_NEWNEIGH, NLM_F_MULTI, neigh); |
267 | |
268 | if (rc) |
269 | break; |
270 | cont: |
271 | idx++; |
272 | } |
273 | rcu_read_unlock(); |
274 | |
275 | cbctx->idx = idx; |
276 | return skb->len; |
277 | } |
278 | |
279 | int mctp_neigh_lookup(struct mctp_dev *mdev, mctp_eid_t eid, void *ret_hwaddr) |
280 | { |
281 | struct net *net = dev_net(dev: mdev->dev); |
282 | struct mctp_neigh *neigh; |
283 | int rc = -EHOSTUNREACH; // TODO: or ENOENT? |
284 | |
285 | rcu_read_lock(); |
286 | list_for_each_entry_rcu(neigh, &net->mctp.neighbours, list) { |
287 | if (mdev == neigh->dev && eid == neigh->eid) { |
288 | if (ret_hwaddr) |
289 | memcpy(ret_hwaddr, neigh->ha, |
290 | sizeof(neigh->ha)); |
291 | rc = 0; |
292 | break; |
293 | } |
294 | } |
295 | rcu_read_unlock(); |
296 | return rc; |
297 | } |
298 | |
299 | /* namespace registration */ |
300 | static int __net_init mctp_neigh_net_init(struct net *net) |
301 | { |
302 | struct netns_mctp *ns = &net->mctp; |
303 | |
304 | INIT_LIST_HEAD(list: &ns->neighbours); |
305 | mutex_init(&ns->neigh_lock); |
306 | return 0; |
307 | } |
308 | |
309 | static void __net_exit mctp_neigh_net_exit(struct net *net) |
310 | { |
311 | struct netns_mctp *ns = &net->mctp; |
312 | struct mctp_neigh *neigh; |
313 | |
314 | list_for_each_entry(neigh, &ns->neighbours, list) |
315 | call_rcu(head: &neigh->rcu, func: __mctp_neigh_free); |
316 | } |
317 | |
318 | /* net namespace implementation */ |
319 | |
320 | static struct pernet_operations mctp_net_ops = { |
321 | .init = mctp_neigh_net_init, |
322 | .exit = mctp_neigh_net_exit, |
323 | }; |
324 | |
325 | int __init mctp_neigh_init(void) |
326 | { |
327 | rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_NEWNEIGH, |
328 | mctp_rtm_newneigh, NULL, flags: 0); |
329 | rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_DELNEIGH, |
330 | mctp_rtm_delneigh, NULL, flags: 0); |
331 | rtnl_register_module(THIS_MODULE, PF_MCTP, RTM_GETNEIGH, |
332 | NULL, mctp_rtm_getneigh, flags: 0); |
333 | |
334 | return register_pernet_subsys(&mctp_net_ops); |
335 | } |
336 | |
337 | void __exit mctp_neigh_exit(void) |
338 | { |
339 | unregister_pernet_subsys(&mctp_net_ops); |
340 | rtnl_unregister(PF_MCTP, RTM_GETNEIGH); |
341 | rtnl_unregister(PF_MCTP, RTM_DELNEIGH); |
342 | rtnl_unregister(PF_MCTP, RTM_NEWNEIGH); |
343 | } |
344 | |