1 // SPDX-License-Identifier: GPL-2.0 2 /* Linux multicast routing support 3 * Common logic shared by IPv4 [ipmr] and IPv6 [ip6mr] implementation 4 */ 5 6 #include <linux/rhashtable.h> 7 #include <linux/mroute_base.h> 8 9 /* Sets everything common except 'dev', since that is done under locking */ 10 void vif_device_init(struct vif_device *v, 11 struct net_device *dev, 12 unsigned long rate_limit, 13 unsigned char threshold, 14 unsigned short flags, 15 unsigned short get_iflink_mask) 16 { 17 RCU_INIT_POINTER(v->dev, NULL); 18 v->bytes_in = 0; 19 v->bytes_out = 0; 20 v->pkt_in = 0; 21 v->pkt_out = 0; 22 v->rate_limit = rate_limit; 23 v->flags = flags; 24 v->threshold = threshold; 25 if (v->flags & get_iflink_mask) 26 v->link = dev_get_iflink(dev); 27 else 28 v->link = dev->ifindex; 29 } 30 31 static void __mr_free_table(struct work_struct *work) 32 { 33 struct mr_table *mrt = container_of(to_rcu_work(work), 34 struct mr_table, work); 35 36 rhltable_destroy(&mrt->mfc_hash); 37 kfree(mrt); 38 } 39 40 void mr_table_free(struct mr_table *mrt) 41 { 42 queue_rcu_work(system_unbound_wq, &mrt->work); 43 } 44 45 struct mr_table * 46 mr_table_alloc(struct net *net, u32 id, 47 struct mr_table_ops *ops, 48 void (*expire_func)(struct timer_list *t), 49 void (*table_set)(struct mr_table *mrt, 50 struct net *net)) 51 { 52 struct mr_table *mrt; 53 int err; 54 55 mrt = kzalloc_obj(*mrt); 56 if (!mrt) 57 return ERR_PTR(-ENOMEM); 58 mrt->id = id; 59 write_pnet(&mrt->net, net); 60 61 mrt->ops = *ops; 62 err = rhltable_init(&mrt->mfc_hash, mrt->ops.rht_params); 63 if (err) { 64 kfree(mrt); 65 return ERR_PTR(err); 66 } 67 68 INIT_RCU_WORK(&mrt->work, __mr_free_table); 69 INIT_LIST_HEAD(&mrt->mfc_cache_list); 70 INIT_LIST_HEAD(&mrt->mfc_unres_queue); 71 72 timer_setup(&mrt->ipmr_expire_timer, expire_func, 0); 73 74 mrt->mroute_reg_vif_num = -1; 75 table_set(mrt, net); 76 return mrt; 77 } 78 79 void *mr_mfc_find_parent(struct mr_table *mrt, void *hasharg, int parent) 80 { 81 struct rhlist_head *tmp, *list; 82 struct mr_mfc *c; 83 84 list = rhltable_lookup(&mrt->mfc_hash, hasharg, *mrt->ops.rht_params); 85 rhl_for_each_entry_rcu(c, tmp, list, mnode) 86 if (parent == -1 || parent == c->mfc_parent) 87 return c; 88 89 return NULL; 90 } 91 92 void *mr_mfc_find_any_parent(struct mr_table *mrt, int vifi) 93 { 94 struct rhlist_head *tmp, *list; 95 struct mr_mfc *c; 96 97 list = rhltable_lookup(&mrt->mfc_hash, mrt->ops.cmparg_any, 98 *mrt->ops.rht_params); 99 rhl_for_each_entry_rcu(c, tmp, list, mnode) 100 if (c->mfc_un.res.ttls[vifi] < 255) 101 return c; 102 103 return NULL; 104 } 105 106 void *mr_mfc_find_any(struct mr_table *mrt, int vifi, void *hasharg) 107 { 108 struct rhlist_head *tmp, *list; 109 struct mr_mfc *c, *proxy; 110 111 list = rhltable_lookup(&mrt->mfc_hash, hasharg, *mrt->ops.rht_params); 112 rhl_for_each_entry_rcu(c, tmp, list, mnode) { 113 if (c->mfc_un.res.ttls[vifi] < 255) 114 return c; 115 116 /* It's ok if the vifi is part of the static tree */ 117 proxy = mr_mfc_find_any_parent(mrt, c->mfc_parent); 118 if (proxy && proxy->mfc_un.res.ttls[vifi] < 255) 119 return c; 120 } 121 122 return mr_mfc_find_any_parent(mrt, vifi); 123 } 124 125 #ifdef CONFIG_PROC_FS 126 void *mr_vif_seq_idx(struct net *net, struct mr_vif_iter *iter, loff_t pos) 127 { 128 struct mr_table *mrt = iter->mrt; 129 130 for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) { 131 if (!VIF_EXISTS(mrt, iter->ct)) 132 continue; 133 if (pos-- == 0) 134 return &mrt->vif_table[iter->ct]; 135 } 136 return NULL; 137 } 138 139 void *mr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos) 140 { 141 struct mr_vif_iter *iter = seq->private; 142 struct net *net = seq_file_net(seq); 143 struct mr_table *mrt = iter->mrt; 144 145 ++*pos; 146 if (v == SEQ_START_TOKEN) 147 return mr_vif_seq_idx(net, iter, 0); 148 149 while (++iter->ct < mrt->maxvif) { 150 if (!VIF_EXISTS(mrt, iter->ct)) 151 continue; 152 return &mrt->vif_table[iter->ct]; 153 } 154 return NULL; 155 } 156 157 void *mr_mfc_seq_idx(struct net *net, 158 struct mr_mfc_iter *it, loff_t pos) 159 { 160 struct mr_table *mrt = it->mrt; 161 struct mr_mfc *mfc; 162 163 rcu_read_lock(); 164 it->cache = &mrt->mfc_cache_list; 165 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) 166 if (pos-- == 0) 167 return mfc; 168 rcu_read_unlock(); 169 170 spin_lock_bh(it->lock); 171 it->cache = &mrt->mfc_unres_queue; 172 list_for_each_entry(mfc, it->cache, list) 173 if (pos-- == 0) 174 return mfc; 175 spin_unlock_bh(it->lock); 176 177 it->cache = NULL; 178 return NULL; 179 } 180 181 void *mr_mfc_seq_next(struct seq_file *seq, void *v, 182 loff_t *pos) 183 { 184 struct mr_mfc_iter *it = seq->private; 185 struct net *net = seq_file_net(seq); 186 struct mr_table *mrt = it->mrt; 187 struct mr_mfc *c = v; 188 189 ++*pos; 190 191 if (v == SEQ_START_TOKEN) 192 return mr_mfc_seq_idx(net, seq->private, 0); 193 194 if (c->list.next != it->cache) 195 return list_entry(c->list.next, struct mr_mfc, list); 196 197 if (it->cache == &mrt->mfc_unres_queue) 198 goto end_of_list; 199 200 /* exhausted cache_array, show unresolved */ 201 rcu_read_unlock(); 202 it->cache = &mrt->mfc_unres_queue; 203 204 spin_lock_bh(it->lock); 205 if (!list_empty(it->cache)) 206 return list_first_entry(it->cache, struct mr_mfc, list); 207 208 end_of_list: 209 spin_unlock_bh(it->lock); 210 it->cache = NULL; 211 212 return NULL; 213 } 214 #endif 215 216 int mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb, 217 struct mr_mfc *c, struct rtmsg *rtm) 218 { 219 struct net_device *vif_dev; 220 struct rta_mfc_stats mfcs; 221 struct nlattr *mp_attr; 222 struct rtnexthop *nhp; 223 unsigned long lastuse; 224 int ct; 225 226 /* If cache is unresolved, don't try to parse IIF and OIF */ 227 if (c->mfc_parent >= MAXVIFS) { 228 rtm->rtm_flags |= RTNH_F_UNRESOLVED; 229 return -ENOENT; 230 } 231 232 rcu_read_lock(); 233 vif_dev = rcu_dereference(mrt->vif_table[c->mfc_parent].dev); 234 if (vif_dev && nla_put_u32(skb, RTA_IIF, READ_ONCE(vif_dev->ifindex)) < 0) { 235 rcu_read_unlock(); 236 return -EMSGSIZE; 237 } 238 rcu_read_unlock(); 239 240 if (c->mfc_flags & MFC_OFFLOAD) 241 rtm->rtm_flags |= RTNH_F_OFFLOAD; 242 243 mp_attr = nla_nest_start_noflag(skb, RTA_MULTIPATH); 244 if (!mp_attr) 245 return -EMSGSIZE; 246 247 rcu_read_lock(); 248 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) { 249 struct vif_device *vif = &mrt->vif_table[ct]; 250 251 vif_dev = rcu_dereference(vif->dev); 252 if (vif_dev && c->mfc_un.res.ttls[ct] < 255) { 253 254 nhp = nla_reserve_nohdr(skb, sizeof(*nhp)); 255 if (!nhp) { 256 rcu_read_unlock(); 257 nla_nest_cancel(skb, mp_attr); 258 return -EMSGSIZE; 259 } 260 261 nhp->rtnh_flags = 0; 262 nhp->rtnh_hops = c->mfc_un.res.ttls[ct]; 263 nhp->rtnh_ifindex = READ_ONCE(vif_dev->ifindex); 264 nhp->rtnh_len = sizeof(*nhp); 265 } 266 } 267 rcu_read_unlock(); 268 269 nla_nest_end(skb, mp_attr); 270 271 lastuse = READ_ONCE(c->mfc_un.res.lastuse); 272 lastuse = time_after_eq(jiffies, lastuse) ? jiffies - lastuse : 0; 273 274 mfcs.mfcs_packets = atomic_long_read(&c->mfc_un.res.pkt); 275 mfcs.mfcs_bytes = atomic_long_read(&c->mfc_un.res.bytes); 276 mfcs.mfcs_wrong_if = atomic_long_read(&c->mfc_un.res.wrong_if); 277 if (nla_put_64bit(skb, RTA_MFC_STATS, sizeof(mfcs), &mfcs, RTA_PAD) || 278 nla_put_u64_64bit(skb, RTA_EXPIRES, jiffies_to_clock_t(lastuse), 279 RTA_PAD)) 280 return -EMSGSIZE; 281 282 rtm->rtm_type = RTN_MULTICAST; 283 return 1; 284 } 285 286 static bool mr_mfc_uses_dev(const struct mr_table *mrt, 287 const struct mr_mfc *c, 288 const struct net_device *dev) 289 { 290 int ct; 291 292 for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) { 293 const struct net_device *vif_dev; 294 const struct vif_device *vif; 295 296 vif = &mrt->vif_table[ct]; 297 vif_dev = rcu_access_pointer(vif->dev); 298 if (vif_dev && c->mfc_un.res.ttls[ct] < 255 && 299 vif_dev == dev) 300 return true; 301 } 302 return false; 303 } 304 305 int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb, 306 struct netlink_callback *cb, 307 int (*fill)(struct mr_table *mrt, struct sk_buff *skb, 308 u32 portid, u32 seq, struct mr_mfc *c, 309 int cmd, int flags), 310 spinlock_t *lock, struct fib_dump_filter *filter) 311 { 312 unsigned int e = 0, s_e = cb->args[1]; 313 unsigned int flags = NLM_F_MULTI; 314 struct mr_mfc *mfc; 315 int err; 316 317 if (filter->filter_set) 318 flags |= NLM_F_DUMP_FILTERED; 319 320 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list, 321 lockdep_rtnl_is_held()) { 322 if (e < s_e) 323 goto next_entry; 324 if (filter->dev && 325 !mr_mfc_uses_dev(mrt, mfc, filter->dev)) 326 goto next_entry; 327 328 err = fill(mrt, skb, NETLINK_CB(cb->skb).portid, 329 cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags); 330 if (err < 0) 331 goto out; 332 next_entry: 333 e++; 334 } 335 336 spin_lock_bh(lock); 337 list_for_each_entry(mfc, &mrt->mfc_unres_queue, list) { 338 if (e < s_e) 339 goto next_entry2; 340 341 err = fill(mrt, skb, NETLINK_CB(cb->skb).portid, 342 cb->nlh->nlmsg_seq, mfc, RTM_NEWROUTE, flags); 343 if (err < 0) { 344 spin_unlock_bh(lock); 345 goto out; 346 } 347 next_entry2: 348 e++; 349 } 350 spin_unlock_bh(lock); 351 err = 0; 352 out: 353 cb->args[1] = e; 354 return err; 355 } 356 357 int mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb, 358 struct mr_table *(*iter)(struct net *net, 359 struct mr_table *mrt), 360 int (*fill)(struct mr_table *mrt, 361 struct sk_buff *skb, 362 u32 portid, u32 seq, struct mr_mfc *c, 363 int cmd, int flags), 364 spinlock_t *lock, struct fib_dump_filter *filter) 365 { 366 unsigned int t = 0, s_t = cb->args[0]; 367 struct net *net = sock_net(skb->sk); 368 struct mr_table *mrt; 369 int err; 370 371 /* multicast does not track protocol or have route type other 372 * than RTN_MULTICAST 373 */ 374 if (filter->filter_set) { 375 if (filter->protocol || filter->flags || 376 (filter->rt_type && filter->rt_type != RTN_MULTICAST)) 377 return skb->len; 378 } 379 380 rcu_read_lock(); 381 for (mrt = iter(net, NULL); mrt; mrt = iter(net, mrt)) { 382 if (t < s_t) 383 goto next_table; 384 385 err = mr_table_dump(mrt, skb, cb, fill, lock, filter); 386 if (err < 0) 387 break; 388 cb->args[1] = 0; 389 next_table: 390 t++; 391 } 392 rcu_read_unlock(); 393 394 cb->args[0] = t; 395 396 return skb->len; 397 } 398 399 int mr_dump(struct net *net, struct notifier_block *nb, unsigned short family, 400 int (*rules_dump)(struct net *net, 401 struct notifier_block *nb, 402 struct netlink_ext_ack *extack), 403 struct mr_table *(*mr_iter)(struct net *net, 404 struct mr_table *mrt), 405 struct netlink_ext_ack *extack) 406 { 407 struct mr_table *mrt; 408 int err; 409 410 err = rules_dump(net, nb, extack); 411 if (err) 412 return err; 413 414 for (mrt = mr_iter(net, NULL); mrt; mrt = mr_iter(net, mrt)) { 415 struct vif_device *v = &mrt->vif_table[0]; 416 struct net_device *vif_dev; 417 struct mr_mfc *mfc; 418 int vifi; 419 420 /* Notifiy on table VIF entries */ 421 rcu_read_lock(); 422 for (vifi = 0; vifi < mrt->maxvif; vifi++, v++) { 423 vif_dev = rcu_dereference(v->dev); 424 if (!vif_dev) 425 continue; 426 427 err = mr_call_vif_notifier(nb, family, 428 FIB_EVENT_VIF_ADD, v, 429 vif_dev, vifi, 430 mrt->id, extack); 431 if (err) 432 break; 433 } 434 rcu_read_unlock(); 435 436 if (err) 437 return err; 438 439 /* Notify on table MFC entries */ 440 list_for_each_entry_rcu(mfc, &mrt->mfc_cache_list, list) { 441 err = mr_call_mfc_notifier(nb, family, 442 FIB_EVENT_ENTRY_ADD, 443 mfc, mrt->id, extack); 444 if (err) 445 return err; 446 } 447 } 448 449 return 0; 450 } 451