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(mdev->dev); 29 struct mctp_neigh *neigh; 30 int rc; 31 32 mutex_lock(&net->mctp.neigh_lock); 33 if (mctp_neigh_lookup(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_obj(*neigh); 44 if (!neigh) { 45 rc = -ENOMEM; 46 goto out; 47 } 48 INIT_LIST_HEAD(&neigh->list); 49 neigh->dev = mdev; 50 mctp_dev_hold(neigh->dev); 51 neigh->eid = eid; 52 neigh->source = source; 53 memcpy(neigh->ha, lladdr, lladdr_len); 54 55 list_add_rcu(&neigh->list, &net->mctp.neighbours); 56 rc = 0; 57 out: 58 mutex_unlock(&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(neigh->dev); 67 kfree(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(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(&neigh->list); 80 /* TODO: immediate RTM_DELNEIGH */ 81 call_rcu(&neigh->rcu, __mctp_neigh_free); 82 } 83 } 84 85 mutex_unlock(&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(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(&neigh->list); 100 /* TODO: immediate RTM_DELNEIGH */ 101 call_rcu(&neigh->rcu, __mctp_neigh_free); 102 dropped = true; 103 } 104 } 105 106 mutex_unlock(&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(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, sizeof(*ndm), tb, NDA_MAX, 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(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(tb[NDA_LLADDR]); 152 lladdr_len = nla_len(tb[NDA_LLADDR]); 153 154 ndm = nlmsg_data(nlh); 155 156 dev = __dev_get_by_index(net, 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, 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(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, sizeof(*ndm), tb, NDA_MAX, 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(tb[NDA_DST]); 196 197 ndm = nlmsg_data(nlh); 198 dev = __dev_get_by_index(net, 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, 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, event, sizeof(*hdr), flags); 217 if (!nlh) 218 return -EMSGSIZE; 219 220 hdr = nlmsg_data(nlh); 221 memset(hdr, 0, sizeof(*hdr)); 222 hdr->ndm_family = AF_MCTP; 223 hdr->ndm_ifindex = dev->ifindex; 224 hdr->ndm_state = 0; // TODO other state bits? 225 if (neigh->source == MCTP_NEIGH_STATIC) 226 hdr->ndm_state |= NUD_PERMANENT; 227 hdr->ndm_flags = 0; 228 hdr->ndm_type = RTN_UNICAST; // TODO: is loopback RTN_LOCAL? 229 230 if (nla_put_u8(skb, NDA_DST, neigh->eid)) 231 goto cancel; 232 233 if (nla_put(skb, NDA_LLADDR, dev->addr_len, neigh->ha)) 234 goto cancel; 235 236 nlmsg_end(skb, nlh); 237 238 return 0; 239 cancel: 240 nlmsg_cancel(skb, nlh); 241 return -EMSGSIZE; 242 } 243 244 static int mctp_rtm_getneigh(struct sk_buff *skb, struct netlink_callback *cb) 245 { 246 struct net *net = sock_net(skb->sk); 247 int rc, idx, req_ifindex; 248 struct mctp_neigh *neigh; 249 struct ndmsg *ndmsg; 250 struct { 251 int idx; 252 } *cbctx = (void *)cb->ctx; 253 254 ndmsg = nlmsg_payload(cb->nlh, sizeof(*ndmsg)); 255 if (!ndmsg) 256 return -EINVAL; 257 258 req_ifindex = ndmsg->ndm_ifindex; 259 260 idx = 0; 261 rcu_read_lock(); 262 list_for_each_entry_rcu(neigh, &net->mctp.neighbours, list) { 263 if (idx < cbctx->idx) 264 goto cont; 265 266 rc = 0; 267 if (req_ifindex == 0 || req_ifindex == neigh->dev->dev->ifindex) 268 rc = mctp_fill_neigh(skb, NETLINK_CB(cb->skb).portid, 269 cb->nlh->nlmsg_seq, 270 RTM_NEWNEIGH, NLM_F_MULTI, neigh); 271 272 if (rc) 273 break; 274 cont: 275 idx++; 276 } 277 rcu_read_unlock(); 278 279 cbctx->idx = idx; 280 return skb->len; 281 } 282 283 int mctp_neigh_lookup(struct mctp_dev *mdev, mctp_eid_t eid, void *ret_hwaddr) 284 { 285 struct net *net = dev_net(mdev->dev); 286 struct mctp_neigh *neigh; 287 int rc = -EHOSTUNREACH; // TODO: or ENOENT? 288 289 rcu_read_lock(); 290 list_for_each_entry_rcu(neigh, &net->mctp.neighbours, list) { 291 if (mdev == neigh->dev && eid == neigh->eid) { 292 if (ret_hwaddr) 293 memcpy(ret_hwaddr, neigh->ha, 294 sizeof(neigh->ha)); 295 rc = 0; 296 break; 297 } 298 } 299 rcu_read_unlock(); 300 return rc; 301 } 302 303 /* namespace registration */ 304 static int __net_init mctp_neigh_net_init(struct net *net) 305 { 306 struct netns_mctp *ns = &net->mctp; 307 308 INIT_LIST_HEAD(&ns->neighbours); 309 mutex_init(&ns->neigh_lock); 310 return 0; 311 } 312 313 static void __net_exit mctp_neigh_net_exit(struct net *net) 314 { 315 struct netns_mctp *ns = &net->mctp; 316 struct mctp_neigh *neigh; 317 318 list_for_each_entry(neigh, &ns->neighbours, list) 319 call_rcu(&neigh->rcu, __mctp_neigh_free); 320 } 321 322 /* net namespace implementation */ 323 324 static struct pernet_operations mctp_net_ops = { 325 .init = mctp_neigh_net_init, 326 .exit = mctp_neigh_net_exit, 327 }; 328 329 static const struct rtnl_msg_handler mctp_neigh_rtnl_msg_handlers[] = { 330 {THIS_MODULE, PF_MCTP, RTM_NEWNEIGH, mctp_rtm_newneigh, NULL, 0}, 331 {THIS_MODULE, PF_MCTP, RTM_DELNEIGH, mctp_rtm_delneigh, NULL, 0}, 332 {THIS_MODULE, PF_MCTP, RTM_GETNEIGH, NULL, mctp_rtm_getneigh, 0}, 333 }; 334 335 int __init mctp_neigh_init(void) 336 { 337 int err; 338 339 err = register_pernet_subsys(&mctp_net_ops); 340 if (err) 341 return err; 342 343 err = rtnl_register_many(mctp_neigh_rtnl_msg_handlers); 344 if (err) 345 unregister_pernet_subsys(&mctp_net_ops); 346 347 return err; 348 } 349 350 void mctp_neigh_exit(void) 351 { 352 rtnl_unregister_many(mctp_neigh_rtnl_msg_handlers); 353 unregister_pernet_subsys(&mctp_net_ops); 354 } 355