LCOV - code coverage report
Current view: top level - net/ipv4 - ipmr_base.c (source / functions) Hit Total Coverage
Test: Real Lines: 13 171 7.6 %
Date: 2020-10-17 15:46:43 Functions: 0 13 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14