leaving function in locked state

|static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im);
|static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr);
|static void igmpv3_clear_delrec(struct in_device *in_dev);
|static int sf_setstate(struct ip_mc_list *pmc);
|static void sf_markstate(struct ip_mc_list *pmc);
|
|static void ip_mc_clear_src(struct ip_mc_list *pmc);
|static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
|    int sfcount, __be32 *psfsrc, int delta);
|
|
|static void ip_mc_list_reclaim(struct rcu_head *head)
|{
| kfree(({ const typeof( ((struct ip_mc_list *)0)->rcu ) *__mptr = (head); (struct ip_mc_list *)( (char *)__mptr - 1 );}));
|}
|
|static void ip_ma_put(struct ip_mc_list *im)
|{
| if (atomic_dec_and_test(&im->refcnt)) {
|  in_dev_put(im->interface);
|  call_rcu_sched(&im->rcu, ip_mc_list_reclaim);
| }
|}
|static void igmp_stop_timer(struct ip_mc_list *im)
|{
| __st_spin_lock_bh_st__(&im->lock);
| if (del_timer(&im->timer))
|  atomic_dec(&im->refcnt);
| im->tm_running = 0;
| im->reporter = 0;
| im->unsolicit_count = 0;
| __st_spin_unlock_bh_st__(&im->lock);
|}
|
|
|static void igmp_start_timer(struct ip_mc_list *im, int max_delay)
|{
| int tv = random32() % max_delay;
|
| im->tm_running = 1;
| if (!mod_timer(&im->timer, jiffies+tv+2))
|  atomic_inc(&im->refcnt);
|}
|
|static void igmp_gq_start_timer(struct in_device *in_dev)
|{
| int tv = random32() % in_dev->mr_maxdelay;
|
| in_dev->mr_gq_running = 1;
| if (!mod_timer(&in_dev->mr_gq_timer, jiffies+tv+2))
|  atomic_inc(&(in_dev)->refcnt);
|}
|
|static void igmp_ifc_start_timer(struct in_device *in_dev, int delay)
|{
| int tv = random32() % delay;
|
| if (!mod_timer(&in_dev->mr_ifc_timer, jiffies+tv+2))
|  atomic_inc(&(in_dev)->refcnt);
|}
|
|static void igmp_mod_timer(struct ip_mc_list *im, int max_delay)
|{
| __st_spin_lock_bh_st__(&im->lock);
| im->unsolicit_count = 0;
| if (del_timer(&im->timer)) {
|  if ((long)(im->timer.expires-jiffies) < max_delay) {
|   add_timer(&im->timer);
|   im->tm_running = 1;
|   __st_spin_unlock_bh_st__(&im->lock);
|   return;
|  }
|  atomic_dec(&im->refcnt);
| }
| igmp_start_timer(im, max_delay);
| __st_spin_unlock_bh_st__(&im->lock);
|}
|static int is_in(struct ip_mc_list *pmc, struct ip_sf_list *psf, int type,
| int gdeleted, int sdeleted)
|{
| switch (type) {
| case 1:
| case 2:
|  if (gdeleted || sdeleted)
|   return 0;
|  if (!(pmc->gsquery && !psf->sf_gsresp)) {
|   if (pmc->sfmode == 1)
|    return 1;
|
|
|
|   if (psf->sf_count[1])
|    return type == 1;
|   return pmc->sfcount[0] ==
|    psf->sf_count[0];
|  }
|  return 0;
| case 3:
|  if (gdeleted || sdeleted)
|   return 0;
|  return psf->sf_count[1] != 0;
| case 4:
|  if (gdeleted || sdeleted)
|   return 0;
|  if (pmc->sfcount[0] == 0 ||
|      psf->sf_count[1])
|   return 0;
|  return pmc->sfcount[0] ==
|   psf->sf_count[0];
| case 5:
|  if (gdeleted || !psf->sf_crcount)
|   return 0;
|  return (pmc->sfmode == 1) ^ sdeleted;
| case 6:
|  if (pmc->sfmode == 1)
|   return gdeleted || (psf->sf_crcount && sdeleted);
|  return psf->sf_crcount && !gdeleted && !sdeleted;
| }
| return 0;
|}
|
|static int
|igmp_scount(struct ip_mc_list *pmc, int type, int gdeleted, int sdeleted)
|{
| struct ip_sf_list *psf;
| int scount = 0;
|
| for (psf=pmc->sources; psf; psf=psf->sf_next) {
|  if (!is_in(pmc, psf, type, gdeleted, sdeleted))
|   continue;
|  scount++;
| }
| return scount;
|}
|
|
|
|static struct sk_buff *igmpv3_newpack(struct net_device *dev, int size)
|{
| struct sk_buff *skb;
| struct rtable *rt;
| struct iphdr *pip;
| struct igmpv3_report *pig;
| struct net *net = dev_net(dev);
|
| while (1) {
|  skb = alloc_skb(size + ((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(16 - 1)) + 16),
|    ((( gfp_t)0x20u)) | (( gfp_t)0x200u));
|  if (skb)
|   break;
|  size >>= 1;
|  if (size < 256)
|   return ((void *)0);
| }
| (*(unsigned int *)((skb)->cb)) = size;
|
| {
|  struct flowi fl = { .oif = dev->ifindex,
|        .nl_u.ip4_u.daddr = (( __be32)(__builtin_constant_p((__u32)((0xE0000016L))) ? ((__u32)( (((__u32)((0xE0000016L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000016L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000016L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000016L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000016L)))),
|        .proto = IPPROTO_IGMP };
|  if (ip_route_output_key(net, &rt, &fl)) {
|   kfree_skb(skb);
|   return ((void *)0);
|  }
| }
| if (rt->rt_src == 0) {
|  kfree_skb(skb);
|  ip_rt_put(rt);
|  return ((void *)0);
| }
|
| skb_dst_set(skb, &rt->dst);
| skb->dev = dev;
|
| skb_reserve(skb, ((((dev)->hard_header_len+(dev)->needed_headroom)&~(16 - 1)) + 16));
|
| skb_reset_network_header(skb);
| pip = ip_hdr(skb);
| skb_put(skb, sizeof(struct iphdr) + 4);
|
| pip->version = 4;
| pip->ihl = (sizeof(struct iphdr)+4)>>2;
| pip->tos = 0xc0;
| pip->frag_off = (( __be16)(__builtin_constant_p((__u16)((0x4000))) ? ((__u16)( (((__u16)((0x4000)) & (__u16)0x00ffU) << 8) | (((__u16)((0x4000)) & (__u16)0xff00U) >> 8))) : __fswab16((0x4000))));
| pip->ttl = 1;
| pip->daddr = rt->rt_dst;
| pip->saddr = rt->rt_src;
| pip->protocol = IPPROTO_IGMP;
| pip->tot_len = 0;
| ip_select_ident(pip, &rt->dst, ((void *)0));
| ((u8*)&pip[1])[0] = (20|0x00|0x80);
| ((u8*)&pip[1])[1] = 4;
| ((u8*)&pip[1])[2] = 0;
| ((u8*)&pip[1])[3] = 0;
|
| skb->transport_header = skb->network_header + sizeof(struct iphdr) + 4;
| skb_put(skb, sizeof(*pig));
| pig = igmpv3_report_hdr(skb);
| pig->type = 0x22;
| pig->resv1 = 0;
| pig->csum = 0;
| pig->resv2 = 0;
| pig->ngrec = 0;
| return skb;
|}
|
|static int igmpv3_sendpack(struct sk_buff *skb)
|{
| struct igmphdr *pig = igmp_hdr(skb);
| const int igmplen = skb->tail - skb->transport_header;
|
| pig->csum = ip_compute_csum(igmp_hdr(skb), igmplen);
|
| return ip_local_out(skb);
|}
|
|static int grec_size(struct ip_mc_list *pmc, int type, int gdel, int sdel)
|{
| return sizeof(struct igmpv3_grec) + 4*igmp_scount(pmc, type, gdel, sdel);
|}
|
|static struct sk_buff *add_grhead(struct sk_buff *skb, struct ip_mc_list *pmc,
| int type, struct igmpv3_grec **ppgr)
|{
| struct net_device *dev = pmc->interface->dev;
| struct igmpv3_report *pih;
| struct igmpv3_grec *pgr;
|
| if (!skb)
|  skb = igmpv3_newpack(dev, dev->mtu);
| if (!skb)
|  return ((void *)0);
| pgr = (struct igmpv3_grec *)skb_put(skb, sizeof(struct igmpv3_grec));
| pgr->grec_type = type;
| pgr->grec_auxwords = 0;
| pgr->grec_nsrcs = 0;
| pgr->grec_mca = pmc->multiaddr;
| pih = igmpv3_report_hdr(skb);
| pih->ngrec = (( __be16)(__builtin_constant_p((__u16)(((__builtin_constant_p((__u16)(( __u16)(__be16)(pih->ngrec))) ? ((__u16)( (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(pih->ngrec)))+1))) ? ((__u16)( (((__u16)(((__builtin_constant_p((__u16)(( __u16)(__be16)(pih->ngrec))) ? ((__u16)( (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(pih->ngrec)))+1)) & (__u16)0x00ffU) << 8) | (((__u16)(((__builtin_constant_p((__u16)(( __u16)(__be16)(pih->ngrec))) ? ((__u16)( (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(pih->ngrec)))+1)) & (__u16)0xff00U) >> 8))) : __fswab16(((__builtin_constant_p((__u16)(( __u16)(__be16)(pih->ngrec))) ? ((__u16)( (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(pih->ngrec)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(pih->ngrec)))+1))));
| *ppgr = pgr;
| return skb;
|}
|
|
|
|
|static struct sk_buff *add_grec(struct sk_buff *skb, struct ip_mc_list *pmc,
| int type, int gdeleted, int sdeleted)
|{
| struct net_device *dev = pmc->interface->dev;
| struct igmpv3_report *pih;
| struct igmpv3_grec *pgr = ((void *)0);
| struct ip_sf_list *psf, *psf_next, *psf_prev, **psf_list;
| int scount, stotal, first, isquery, truncate;
|
| if (pmc->multiaddr == (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))))
|  return skb;
|
| isquery = type == 1 ||
|    type == 2;
| truncate = type == 2 ||
|      type == 4;
|
| stotal = scount = 0;
|
| psf_list = sdeleted ? &pmc->tomb : &pmc->sources;
|
| if (!*psf_list)
|  goto empty_source;
|
| pih = skb ? igmpv3_report_hdr(skb) : ((void *)0);
|
|
| if (truncate) {
|  if (pih && pih->ngrec &&
|      ((skb) ? ((skb)->dev ? (*(unsigned int *)((skb)->cb)) - (skb)->len : skb_tailroom(skb)) : 0) < grec_size(pmc, type, gdeleted, sdeleted)) {
|   if (skb)
|    igmpv3_sendpack(skb);
|   skb = igmpv3_newpack(dev, dev->mtu);
|  }
| }
| first = 1;
| psf_prev = ((void *)0);
| for (psf=*psf_list; psf; psf=psf_next) {
|  __be32 *psrc;
|
|  psf_next = psf->sf_next;
|
|  if (!is_in(pmc, psf, type, gdeleted, sdeleted)) {
|   psf_prev = psf;
|   continue;
|  }
|
|
|  if (isquery)
|   psf->sf_gsresp = 0;
|
|  if (((skb) ? ((skb)->dev ? (*(unsigned int *)((skb)->cb)) - (skb)->len : skb_tailroom(skb)) : 0) < sizeof(__be32) +
|      first*sizeof(struct igmpv3_grec)) {
|   if (truncate && !first)
|    break;
|   if (pgr)
|    pgr->grec_nsrcs = (( __be16)(__builtin_constant_p((__u16)((scount))) ? ((__u16)( (((__u16)((scount)) & (__u16)0x00ffU) << 8) | (((__u16)((scount)) & (__u16)0xff00U) >> 8))) : __fswab16((scount))));
|   if (skb)
|    igmpv3_sendpack(skb);
|   skb = igmpv3_newpack(dev, dev->mtu);
|   first = 1;
|   scount = 0;
|  }
|  if (first) {
|   skb = add_grhead(skb, pmc, type, &pgr);
|   first = 0;
|  }
|  if (!skb)
|   return ((void *)0);
|  psrc = (__be32 *)skb_put(skb, sizeof(__be32));
|  *psrc = psf->sf_inaddr;
|  scount++; stotal++;
|  if ((type == 5 ||
|       type == 6) && psf->sf_crcount) {
|   psf->sf_crcount--;
|   if ((sdeleted || gdeleted) && psf->sf_crcount == 0) {
|    if (psf_prev)
|     psf_prev->sf_next = psf->sf_next;
|    else
|     *psf_list = psf->sf_next;
|    kfree(psf);
|    continue;
|   }
|  }
|  psf_prev = psf;
| }
|
|empty_source:
| if (!stotal) {
|  if (type == 5 ||
|      type == 6)
|   return skb;
|  if (pmc->crcount || isquery) {
|
|   if (skb && ((skb) ? ((skb)->dev ? (*(unsigned int *)((skb)->cb)) - (skb)->len : skb_tailroom(skb)) : 0)  342|    igmpv3_sendpack(skb);
|    skb = ((void *)0);
|   }
|   skb = add_grhead(skb, pmc, type, &pgr);
|  }
| }
| if (pgr)
|  pgr->grec_nsrcs = (( __be16)(__builtin_constant_p((__u16)((scount))) ? ((__u16)( (((__u16)((scount)) & (__u16)0x00ffU) << 8) | (((__u16)((scount)) & (__u16)0xff00U) >> 8))) : __fswab16((scount))));
|
| if (isquery)
|  pmc->gsquery = 0;
| return skb;
|}
|
|static int igmpv3_send_report(struct in_device *in_dev, struct ip_mc_list *pmc)
|{
| struct sk_buff *skb = ((void *)0);
| int type;
|
| if (!pmc) {
|  __st_rcu_read_lock_st__();
|  for (pmc = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 530); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); pmc != ((void *)0); pmc = ({ typeof(*(pmc->next_rcu)) *_________p1 = (typeof(*(pmc->next_rcu))* )(*(volatile typeof((pmc->next_rcu)) *)&((pmc->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 530); } } while (0); ; do { } while (0); ((typeof(*(pmc->next_rcu)) *)(_________p1)); })) {
|   if (pmc->multiaddr == (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))))
|    continue;
|   __st_spin_lock_bh_st__(&pmc->lock);
|   if (pmc->sfcount[0])
|    type = 2;
|   else
|    type = 1;
|   skb = add_grec(skb, pmc, type, 0, 0);
|   __st_spin_unlock_bh_st__(&pmc->lock);
|  }
|  __st_rcu_read_unlock_st__();
| } else {
|  __st_spin_lock_bh_st__(&pmc->lock);
|  if (pmc->sfcount[0])
|   type = 2;
|  else
|   type = 1;
|  skb = add_grec(skb, pmc, type, 0, 0);
|  __st_spin_unlock_bh_st__(&pmc->lock);
| }
| if (!skb)
|  return 0;
| return igmpv3_sendpack(skb);
|}
|
|
|
|
|static void igmpv3_clear_zeros(struct ip_sf_list **ppsf)
|{
| struct ip_sf_list *psf_prev, *psf_next, *psf;
|
| psf_prev = ((void *)0);
| for (psf=*ppsf; psf; psf = psf_next) {
|  psf_next = psf->sf_next;
|  if (psf->sf_crcount == 0) {
|   if (psf_prev)
|    psf_prev->sf_next = psf->sf_next;
|   else
|    *ppsf = psf->sf_next;
|   kfree(psf);
|  } else
|   psf_prev = psf;
| }
|}
|
|static void igmpv3_send_cr(struct in_device *in_dev)
|{
| struct ip_mc_list *pmc, *pmc_prev, *pmc_next;
| struct sk_buff *skb = ((void *)0);
| int type, dtype;
|
| __st_rcu_read_lock_st__();
| __st_spin_lock_bh_st__(&in_dev->mc_tomb_lock);
|
|
| pmc_prev = ((void *)0);
| for (pmc=in_dev->mc_tomb; pmc; pmc=pmc_next) {
|  pmc_next = pmc->next;
|  if (pmc->sfmode == 1) {
|   type = 6;
|   dtype = 6;
|   skb = add_grec(skb, pmc, type, 1, 0);
|   skb = add_grec(skb, pmc, dtype, 1, 1);
|  }
|  if (pmc->crcount) {
|   if (pmc->sfmode == 0) {
|    type = 3;
|    skb = add_grec(skb, pmc, type, 1, 0);
|   }
|   pmc->crcount--;
|   if (pmc->crcount == 0) {
|    igmpv3_clear_zeros(&pmc->tomb);
|    igmpv3_clear_zeros(&pmc->sources);
|   }
|  }
|  if (pmc->crcount == 0 && !pmc->tomb && !pmc->sources) {
|   if (pmc_prev)
|    pmc_prev->next = pmc_next;
|   else
|    in_dev->mc_tomb = pmc_next;
|   in_dev_put(pmc->interface);
|   kfree(pmc);
|  } else
|   pmc_prev = pmc;
| }
| __st_spin_unlock_bh_st__(&in_dev->mc_tomb_lock);
|
|
| for (pmc = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 620); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); pmc != ((void *)0); pmc = ({ typeof(*(pmc->next_rcu)) *_________p1 = (typeof(*(pmc->next_rcu))* )(*(volatile typeof((pmc->next_rcu)) *)&((pmc->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 620); } } while (0); ; do { } while (0); ((typeof(*(pmc->next_rcu)) *)(_________p1)); })) {
|  __st_spin_lock_bh_st__(&pmc->lock);
|  if (pmc->sfcount[0]) {
|   type = 6;
|   dtype = 5;
|  } else {
|   type = 5;
|   dtype = 6;
|  }
|  skb = add_grec(skb, pmc, type, 0, 0);
|  skb = add_grec(skb, pmc, dtype, 0, 1);
|
|
|  if (pmc->crcount) {
|   if (pmc->sfmode == 0)
|    type = 4;
|   else
|    type = 3;
|   skb = add_grec(skb, pmc, type, 0, 0);
|   pmc->crcount--;
|  }
|  __st_spin_unlock_bh_st__(&pmc->lock);
| }
| __st_rcu_read_unlock_st__();
|
| if (!skb)
|  return;
| (void) igmpv3_sendpack(skb);
|}
|
|static int igmp_send_report(struct in_device *in_dev, struct ip_mc_list *pmc,
| int type)
|{
| struct sk_buff *skb;
| struct iphdr *iph;
| struct igmphdr *ih;
| struct rtable *rt;
| struct net_device *dev = in_dev->dev;
| struct net *net = dev_net(dev);
| __be32 group = pmc ? pmc->multiaddr : 0;
| __be32 dst;
|
| if (type == 0x22)
|  return igmpv3_send_report(in_dev, pmc);
| else if (type == 0x17)
|  dst = (( __be32)(__builtin_constant_p((__u32)((0xE0000002L))) ? ((__u32)( (((__u32)((0xE0000002L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000002L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000002L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000002L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000002L))));
| else
|  dst = group;
|
| {
|  struct flowi fl = { .oif = dev->ifindex,
|        .nl_u.ip4_u.daddr = dst,
|        .proto = IPPROTO_IGMP };
|  if (ip_route_output_key(net, &rt, &fl))
|   return -1;
| }
| if (rt->rt_src == 0) {
|  ip_rt_put(rt);
|  return -1;
| }
|
| skb = alloc_skb((sizeof(struct igmphdr)+sizeof(struct iphdr)+4)+((((dev)->hard_header_len+(dev)->needed_headroom+(dev)->needed_tailroom)&~(16 - 1)) + 16), ((( gfp_t)0x20u)));
| if (skb == ((void *)0)) {
|  ip_rt_put(rt);
|  return -1;
| }
|
| skb_dst_set(skb, &rt->dst);
|
| skb_reserve(skb, ((((dev)->hard_header_len+(dev)->needed_headroom)&~(16 - 1)) + 16));
|
| skb_reset_network_header(skb);
| iph = ip_hdr(skb);
| skb_put(skb, sizeof(struct iphdr) + 4);
|
| iph->version = 4;
| iph->ihl = (sizeof(struct iphdr)+4)>>2;
| iph->tos = 0xc0;
| iph->frag_off = (( __be16)(__builtin_constant_p((__u16)((0x4000))) ? ((__u16)( (((__u16)((0x4000)) & (__u16)0x00ffU) << 8) | (((__u16)((0x4000)) & (__u16)0xff00U) >> 8))) : __fswab16((0x4000))));
| iph->ttl = 1;
| iph->daddr = dst;
| iph->saddr = rt->rt_src;
| iph->protocol = IPPROTO_IGMP;
| ip_select_ident(iph, &rt->dst, ((void *)0));
| ((u8*)&iph[1])[0] = (20|0x00|0x80);
| ((u8*)&iph[1])[1] = 4;
| ((u8*)&iph[1])[2] = 0;
| ((u8*)&iph[1])[3] = 0;
|
| ih = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
| ih->type = type;
| ih->code = 0;
| ih->csum = 0;
| ih->group = group;
| ih->csum = ip_compute_csum((void *)ih, sizeof(struct igmphdr));
|
| return ip_local_out(skb);
|}
|
|static void igmp_gq_timer_expire(unsigned long data)
|{
| struct in_device *in_dev = (struct in_device *)data;
|
| in_dev->mr_gq_running = 0;
| igmpv3_send_report(in_dev, ((void *)0));
| atomic_dec(&(in_dev)->refcnt);
|}
|
|static void igmp_ifc_timer_expire(unsigned long data)
|{
| struct in_device *in_dev = (struct in_device *)data;
|
| igmpv3_send_cr(in_dev);
| if (in_dev->mr_ifc_count) {
|  in_dev->mr_ifc_count--;
|  igmp_ifc_start_timer(in_dev, (10*250));
| }
| atomic_dec(&(in_dev)->refcnt);
|}
|
|static void igmp_ifc_event(struct in_device *in_dev)
|{
| if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v1_seen) < 0)))) || ((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v2_seen) < 0)))))
|  return;
| in_dev->mr_ifc_count = in_dev->mr_qrv ? in_dev->mr_qrv :
|  2;
| igmp_ifc_start_timer(in_dev, 1);
|}
|
|
|static void igmp_timer_expire(unsigned long data)
|{
| struct ip_mc_list *im=(struct ip_mc_list *)data;
| struct in_device *in_dev = im->interface;
|
| __st_spin_lock_st__(&im->lock);
| im->tm_running = 0;
|
| if (im->unsolicit_count) {
|  im->unsolicit_count--;
|  igmp_start_timer(im, (10*250));
| }
| im->reporter = 1;
| __st_spin_unlock_st__(&im->lock);
|
| if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v1_seen) < 0)))))
|  igmp_send_report(in_dev, im, 0x12);
| else if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v2_seen) < 0)))))
|  igmp_send_report(in_dev, im, 0x16);
| else
|  igmp_send_report(in_dev, im, 0x22);
|
| ip_ma_put(im);
|}
|
|
|static int igmp_xmarksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
|{
| struct ip_sf_list *psf;
| int i, scount;
|
| scount = 0;
| for (psf=pmc->sources; psf; psf=psf->sf_next) {
|  if (scount == nsrcs)
|   break;
|  for (i=0; i  619|
|   if (pmc->sfcount[1] ||
|       pmc->sfcount[0] !=
|       psf->sf_count[0])
|    continue;
|   if (srcs[i] == psf->sf_inaddr) {
|    scount++;
|    break;
|   }
|  }
| }
| pmc->gsquery = 0;
| if (scount == nsrcs)
|  return 0;
| return 1;
|}
|
|static int igmp_marksources(struct ip_mc_list *pmc, int nsrcs, __be32 *srcs)
|{
| struct ip_sf_list *psf;
| int i, scount;
|
| if (pmc->sfmode == 0)
|  return igmp_xmarksources(pmc, nsrcs, srcs);
|
|
| scount = 0;
| for (psf=pmc->sources; psf; psf=psf->sf_next) {
|  if (scount == nsrcs)
|   break;
|  for (i=0; i  650|   if (srcs[i] == psf->sf_inaddr) {
|    psf->sf_gsresp = 1;
|    scount++;
|    break;
|   }
| }
| if (!scount) {
|  pmc->gsquery = 0;
|  return 0;
| }
| pmc->gsquery = 1;
| return 1;
|}
|
|static void igmp_heard_report(struct in_device *in_dev, __be32 group)
|{
| struct ip_mc_list *im;
|
|
|
| if (group == (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))))
|  return;
|
| __st_rcu_read_lock_st__();
| for (im = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 841); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); im != ((void *)0); im = ({ typeof(*(im->next_rcu)) *_________p1 = (typeof(*(im->next_rcu))* )(*(volatile typeof((im->next_rcu)) *)&((im->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 841); } } while (0); ; do { } while (0); ((typeof(*(im->next_rcu)) *)(_________p1)); })) {
|  if (im->multiaddr == group) {
|   igmp_stop_timer(im);
|   break;
|  }
| }
| __st_rcu_read_unlock_st__();
|}
|
|static void igmp_heard_query(struct in_device *in_dev, struct sk_buff *skb,
| int len)
|{
| struct igmphdr *ih = igmp_hdr(skb);
| struct igmpv3_query *ih3 = igmpv3_query_hdr(skb);
| struct ip_mc_list *im;
| __be32 group = ih->group;
| int max_delay;
| int mark = 0;
|
|
| if (len == 8) {
|  if (ih->code == 0) {
|
|
|   max_delay = (10*250);
|   in_dev->mr_v1_seen = jiffies +
|    (400*250);
|   group = 0;
|  } else {
|
|   max_delay = ih->code*(250/10);
|   in_dev->mr_v2_seen = jiffies +
|    (400*250);
|  }
|
|  in_dev->mr_ifc_count = 0;
|  if (del_timer(&in_dev->mr_ifc_timer))
|   atomic_dec(&(in_dev)->refcnt);
|
|  igmpv3_clear_delrec(in_dev);
| } else if (len < 12) {
|  return;
| } else if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v1_seen) < 0))))) {
|
|  max_delay = (10*250);
|  group = 0;
| } else if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v2_seen) < 0))))) {
|
|
|
|
|
|
|  max_delay = ((ih3->code) < (0x80) ? (ih3->code) : ((((4)>=32 ? (ih3->code) : ((1<<(4))-1) & (ih3->code)) | (1<<(4))) << (((3)>=32 ? ((ih3->code) >> (4)) : ((1<<(3))-1) & ((ih3->code) >> (4))) + (3))))*(250/10);
| } else {
|  if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)))
|   return;
|
|  ih3 = igmpv3_query_hdr(skb);
|  if (ih3->nsrcs) {
|   if (!pskb_may_pull(skb, sizeof(struct igmpv3_query)
|        + (__builtin_constant_p((__u16)(( __u16)(__be16)(ih3->nsrcs))) ? ((__u16)( (((__u16)(( __u16)(__be16)(ih3->nsrcs)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(ih3->nsrcs)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(ih3->nsrcs)))*sizeof(__be32)))
|    return;
|   ih3 = igmpv3_query_hdr(skb);
|  }
|
|  max_delay = ((ih3->code) < (0x80) ? (ih3->code) : ((((4)>=32 ? (ih3->code) : ((1<<(4))-1) & (ih3->code)) | (1<<(4))) << (((3)>=32 ? ((ih3->code) >> (4)) : ((1<<(3))-1) & ((ih3->code) >> (4))) + (3))))*(250/10);
|  if (!max_delay)
|   max_delay = 1;
|  in_dev->mr_maxdelay = max_delay;
|  if (ih3->qrv)
|   in_dev->mr_qrv = ih3->qrv;
|  if (!group) {
|   if (ih3->nsrcs)
|    return;
|   igmp_gq_start_timer(in_dev);
|   return;
|  }
|
|  mark = ih3->nsrcs != 0;
| }
| __st_rcu_read_lock_st__();
| for (im = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 934); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); im != ((void *)0); im = ({ typeof(*(im->next_rcu)) *_________p1 = (typeof(*(im->next_rcu))* )(*(volatile typeof((im->next_rcu)) *)&((im->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 934); } } while (0); ; do { } while (0); ((typeof(*(im->next_rcu)) *)(_________p1)); })) {
|  int changed;
|
|  if (group && group != im->multiaddr)
|   continue;
|  if (im->multiaddr == (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))))
|   continue;
|  __st_spin_lock_bh_st__(&im->lock);
|  if (im->tm_running)
|   im->gsquery = im->gsquery && mark;
|  else
|   im->gsquery = mark;
|  changed = !im->gsquery ||
|   igmp_marksources(im, (__builtin_constant_p((__u16)(( __u16)(__be16)(ih3->nsrcs))) ? ((__u16)( (((__u16)(( __u16)(__be16)(ih3->nsrcs)) & (__u16)0x00ffU) << 8) | (((__u16)(( __u16)(__be16)(ih3->nsrcs)) & (__u16)0xff00U) >> 8))) : __fswab16(( __u16)(__be16)(ih3->nsrcs))), ih3->srcs);
|  __st_spin_unlock_bh_st__(&im->lock);
|  if (changed)
|   igmp_mod_timer(im, max_delay);
| }
| __st_rcu_read_unlock_st__();
|}
|
|
|int igmp_rcv(struct sk_buff *skb)
|{
|
| struct igmphdr *ih;
| struct in_device *in_dev = __in_dev_get_rcu(skb->dev);
| int len = skb->len;
|
| if (in_dev == ((void *)0))
|  goto drop;
|
| if (!pskb_may_pull(skb, sizeof(struct igmphdr)))
|  goto drop;
|
| switch (skb->ip_summed) {
| case 2:
|  if (!csum_fold(skb->csum))
|   break;
|
| case 0:
|  skb->csum = 0;
|  if (__skb_checksum_complete(skb))
|   goto drop;
| }
|
| ih = igmp_hdr(skb);
| switch (ih->type) {
| case 0x11:
|  igmp_heard_query(in_dev, skb, len);
|  break;
| case 0x12:
| case 0x16:
|
|  if (rt_is_output_route(skb_rtable(skb)))
|   break;
|
|  if (skb->pkt_type == 2 ||
|      skb->pkt_type == 1)
|   igmp_heard_report(in_dev, ih->group);
|  break;
| case 0x14:
|
|  return pim_rcv_v1(skb);
|
| case 0x22:
| case 0x13:
| case 0x15:
| case 0x17:
| case 0x1f:
| case 0x1e:
|  break;
| default:
|  break;
| }
|
|drop:
| kfree_skb(skb);
| return 0;
|}
|static void ip_mc_filter_add(struct in_device *in_dev, __be32 addr)
|{
| char buf[32];
| struct net_device *dev = in_dev->dev;
| if (arp_mc_map(addr, buf, dev, 0) == 0)
|  dev_mc_add(dev, buf);
|}
|
|
|
|
|
|static void ip_mc_filter_del(struct in_device *in_dev, __be32 addr)
|{
| char buf[32];
| struct net_device *dev = in_dev->dev;
|
| if (arp_mc_map(addr, buf, dev, 0) == 0)
|  dev_mc_del(dev, buf);
|}
|
|
|
|
|
|static void igmpv3_add_delrec(struct in_device *in_dev, struct ip_mc_list *im)
|{
| struct ip_mc_list *pmc;
|
|
|
|
|
|
|
| pmc = kzalloc(sizeof(*pmc), __st_GFP_KERNEL_st__);
| if (!pmc)
|  return;
| __st_spin_lock_bh_st__(&im->lock);
| pmc->interface = im->interface;
| atomic_inc(&(in_dev)->refcnt);
| pmc->multiaddr = im->multiaddr;
| pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|  2;
| pmc->sfmode = im->sfmode;
| if (pmc->sfmode == 1) {
|  struct ip_sf_list *psf;
|
|  pmc->tomb = im->tomb;
|  pmc->sources = im->sources;
|  im->tomb = im->sources = ((void *)0);
|  for (psf=pmc->sources; psf; psf=psf->sf_next)
|   psf->sf_crcount = pmc->crcount;
| }
| __st_spin_unlock_bh_st__(&im->lock);
|
| __st_spin_lock_bh_st__(&in_dev->mc_tomb_lock);
| pmc->next = in_dev->mc_tomb;
| in_dev->mc_tomb = pmc;
| __st_spin_unlock_bh_st__(&in_dev->mc_tomb_lock);
|}
|
|static void igmpv3_del_delrec(struct in_device *in_dev, __be32 multiaddr)
|{
| struct ip_mc_list *pmc, *pmc_prev;
| struct ip_sf_list *psf, *psf_next;
|
| __st_spin_lock_bh_st__(&in_dev->mc_tomb_lock);
| pmc_prev = ((void *)0);
| for (pmc=in_dev->mc_tomb; pmc; pmc=pmc->next) {
|  if (pmc->multiaddr == multiaddr)
|   break;
|  pmc_prev = pmc;
| }
| if (pmc) {
|  if (pmc_prev)
|   pmc_prev->next = pmc->next;
|  else
|   in_dev->mc_tomb = pmc->next;
| }
| __st_spin_unlock_bh_st__(&in_dev->mc_tomb_lock);
| if (pmc) {
|  for (psf=pmc->tomb; psf; psf=psf_next) {
|   psf_next = psf->sf_next;
|   kfree(psf);
|  }
|  in_dev_put(pmc->interface);
|  kfree(pmc);
| }
|}
|
|static void igmpv3_clear_delrec(struct in_device *in_dev)
|{
| struct ip_mc_list *pmc, *nextpmc;
|
| __st_spin_lock_bh_st__(&in_dev->mc_tomb_lock);
| pmc = in_dev->mc_tomb;
| in_dev->mc_tomb = ((void *)0);
| __st_spin_unlock_bh_st__(&in_dev->mc_tomb_lock);
|
| for (; pmc; pmc = nextpmc) {
|  nextpmc = pmc->next;
|  ip_mc_clear_src(pmc);
|  in_dev_put(pmc->interface);
|  kfree(pmc);
| }
|
| __st_rcu_read_lock_st__();
| for (pmc = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1138); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); pmc != ((void *)0); pmc = ({ typeof(*(pmc->next_rcu)) *_________p1 = (typeof(*(pmc->next_rcu))* )(*(volatile typeof((pmc->next_rcu)) *)&((pmc->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1138); } } while (0); ; do { } while (0); ((typeof(*(pmc->next_rcu)) *)(_________p1)); })) {
|  struct ip_sf_list *psf, *psf_next;
|
|  __st_spin_lock_bh_st__(&pmc->lock);
|  psf = pmc->tomb;
|  pmc->tomb = ((void *)0);
|  __st_spin_unlock_bh_st__(&pmc->lock);
|  for (; psf; psf=psf_next) {
|   psf_next = psf->sf_next;
|   kfree(psf);
|  }
| }
| __st_rcu_read_unlock_st__();
|}
|
|
|static void igmp_group_dropped(struct ip_mc_list *im)
|{
| struct in_device *in_dev = im->interface;
|
| int reporter;
|
|
| if (im->loaded) {
|  im->loaded = 0;
|  ip_mc_filter_del(in_dev, im->multiaddr);
| }
|
|
| if (im->multiaddr == (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))))
|  return;
|
| reporter = im->reporter;
| igmp_stop_timer(im);
|
| if (!in_dev->dead) {
|  if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v1_seen) < 0)))))
|   goto done;
|  if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v2_seen) < 0))))) {
|   if (reporter)
|    igmp_send_report(in_dev, im, 0x17);
|   goto done;
|  }
|
|  igmpv3_add_delrec(in_dev, im);
|
|  igmp_ifc_event(in_dev);
| }
|done:
|
| ip_mc_clear_src(im);
|}
|
|static void igmp_group_added(struct ip_mc_list *im)
|{
| struct in_device *in_dev = im->interface;
|
| if (im->loaded == 0) {
|  im->loaded = 1;
|  ip_mc_filter_add(in_dev, im->multiaddr);
| }
|
|
| if (im->multiaddr == (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))))
|  return;
|
| if (in_dev->dead)
|  return;
| if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v1_seen) < 0)))) || ((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v2_seen) < 0))))) {
|  __st_spin_lock_bh_st__(&im->lock);
|  igmp_start_timer(im, (1));
|  __st_spin_unlock_bh_st__(&im->lock);
|  return;
| }
|
|
| im->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|  2;
| igmp_ifc_event(in_dev);
|
|}
|void ip_mc_inc_group(struct in_device *in_dev, __be32 addr)
|{
| struct ip_mc_list *im;
|
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1234); dump_stack(); } } while(0);
|
| for (im = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1236); } } while (0); ; ((typeof(*(in_dev->mc_list)) *)((in_dev->mc_list))); }); im != ((void *)0); im = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1236); } } while (0); ; ((typeof(*(im->next_rcu)) *)((im->next_rcu))); })) {
|  if (im->multiaddr == addr) {
|   im->users++;
|   ip_mc_add_src(in_dev, &addr, 0, 0, ((void *)0), 0);
|   goto out;
|  }
| }
|
| im = kzalloc(sizeof(*im), __st_GFP_KERNEL_st__);
| if (!im)
|  goto out;
|
| im->users = 1;
| im->interface = in_dev;
| atomic_inc(&(in_dev)->refcnt);
| im->multiaddr = addr;
|
| im->sfmode = 0;
| im->sfcount[0] = 1;
| atomic_set(&im->refcnt, 1);
| do { spinlock_check(&im->lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&im->lock)->rlock), "&(&im->lock)->rlock", &__key); } while (0); } while (0);
|
| do { static struct lock_class_key __key; setup_timer_key((&im->timer), "&im->timer", &__key, (&igmp_timer_expire), ((unsigned long)im)); } while (0);
| im->unsolicit_count = 2;
|
|
| im->next_rcu = in_dev->mc_list;
| in_dev->mc_count++;
| __st_rcu_assign_pointer_st__(in_dev->mc_list, im);
|
|
| igmpv3_del_delrec(in_dev, im->multiaddr);
|
| igmp_group_added(im);
| if (!in_dev->dead)
|  ip_rt_multicast_event(in_dev);
|out:
| return;
|}
|extern typeof(ip_mc_inc_group) ip_mc_inc_group; extern void *__crc_ip_mc_inc_group ; static const unsigned long __kcrctab_ip_mc_inc_group = (unsigned long) &__crc_ip_mc_inc_group; static const char __kstrtab_ip_mc_inc_group[] = "" "ip_mc_inc_group"; static const struct kernel_symbol __ksymtab_ip_mc_inc_group = { (unsigned long)&ip_mc_inc_group, __kstrtab_ip_mc_inc_group };
|
|
|
|
|
|void ip_mc_rejoin_groups(struct in_device *in_dev)
|{
|
| struct ip_mc_list *im;
| int type;
|
| for (im = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1287); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); im != ((void *)0); im = ({ typeof(*(im->next_rcu)) *_________p1 = (typeof(*(im->next_rcu))* )(*(volatile typeof((im->next_rcu)) *)&((im->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1287); } } while (0); ; do { } while (0); ((typeof(*(im->next_rcu)) *)(_________p1)); })) {
|  if (im->multiaddr == (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))))
|   continue;
|
|
|
|
|  if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v1_seen) < 0)))))
|   type = 0x12;
|  else if (((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v2_seen) < 0)))))
|   type = 0x16;
|  else
|   type = 0x22;
|  igmp_send_report(in_dev, im, type);
| }
|
|}
|extern typeof(ip_mc_rejoin_groups) ip_mc_rejoin_groups; extern void *__crc_ip_mc_rejoin_groups ; static const unsigned long __kcrctab_ip_mc_rejoin_groups = (unsigned long) &__crc_ip_mc_rejoin_groups; static const char __kstrtab_ip_mc_rejoin_groups[] = "" "ip_mc_rejoin_groups"; static const struct kernel_symbol __ksymtab_ip_mc_rejoin_groups = { (unsigned long)&ip_mc_rejoin_groups, __kstrtab_ip_mc_rejoin_groups };
|
|
|
|
|
|void ip_mc_dec_group(struct in_device *in_dev, __be32 addr)
|{
| struct ip_mc_list *i;
| struct ip_mc_list **ip;
|
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1315); dump_stack(); } } while(0);
|
| for (ip = &in_dev->mc_list;
|      (i = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1318); } } while (0); ; ((typeof(*(*ip)) *)((*ip))); })) != ((void *)0);
|      ip = &i->next_rcu) {
|  if (i->multiaddr == addr) {
|   if (--i->users == 0) {
|    *ip = i->next_rcu;
|    in_dev->mc_count--;
|    igmp_group_dropped(i);
|
|    if (!in_dev->dead)
|     ip_rt_multicast_event(in_dev);
|
|    ip_ma_put(i);
|    return;
|   }
|   break;
|  }
| }
|}
|extern typeof(ip_mc_dec_group) ip_mc_dec_group; extern void *__crc_ip_mc_dec_group ; static const unsigned long __kcrctab_ip_mc_dec_group = (unsigned long) &__crc_ip_mc_dec_group; static const char __kstrtab_ip_mc_dec_group[] = "" "ip_mc_dec_group"; static const struct kernel_symbol __ksymtab_ip_mc_dec_group = { (unsigned long)&ip_mc_dec_group, __kstrtab_ip_mc_dec_group };
|
|
|
|void ip_mc_unmap(struct in_device *in_dev)
|{
| struct ip_mc_list *pmc;
|
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1344); dump_stack(); } } while(0);
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1346); } } while (0); ; ((typeof(*(in_dev->mc_list)) *)((in_dev->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1346); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); }))
|  igmp_group_dropped(pmc);
|}
|
|void ip_mc_remap(struct in_device *in_dev)
|{
| struct ip_mc_list *pmc;
|
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1354); dump_stack(); } } while(0);
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1356); } } while (0); ; ((typeof(*(in_dev->mc_list)) *)((in_dev->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1356); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); }))
|  igmp_group_added(pmc);
|}
|
|
|
|void ip_mc_down(struct in_device *in_dev)
|{
| struct ip_mc_list *pmc;
|
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1366); dump_stack(); } } while(0);
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1368); } } while (0); ; ((typeof(*(in_dev->mc_list)) *)((in_dev->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1368); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); }))
|  igmp_group_dropped(pmc);
|
|
| in_dev->mr_ifc_count = 0;
| if (del_timer(&in_dev->mr_ifc_timer))
|  atomic_dec(&(in_dev)->refcnt);
| in_dev->mr_gq_running = 0;
| if (del_timer(&in_dev->mr_gq_timer))
|  atomic_dec(&(in_dev)->refcnt);
| igmpv3_clear_delrec(in_dev);
|
|
| ip_mc_dec_group(in_dev, (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))));
|}
|
|void ip_mc_init_dev(struct in_device *in_dev)
|{
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1386); dump_stack(); } } while(0);
|
| in_dev->mc_tomb = ((void *)0);
|
| in_dev->mr_gq_running = 0;
| do { static struct lock_class_key __key; setup_timer_key((&in_dev->mr_gq_timer), "&in_dev->mr_gq_timer", &__key, (igmp_gq_timer_expire), ((unsigned long)in_dev)); } while (0)
|                         ;
| in_dev->mr_ifc_count = 0;
| in_dev->mc_count = 0;
| do { static struct lock_class_key __key; setup_timer_key((&in_dev->mr_ifc_timer), "&in_dev->mr_ifc_timer", &__key, (igmp_ifc_timer_expire), ((unsigned long)in_dev)); } while (0)
|                         ;
| in_dev->mr_qrv = 2;
|
|
| do { spinlock_check(&in_dev->mc_tomb_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&in_dev->mc_tomb_lock)->rlock), "&(&in_dev->mc_tomb_lock)->rlock", &__key); } while (0); } while (0);
|}
|
|
|
|void ip_mc_up(struct in_device *in_dev)
|{
| struct ip_mc_list *pmc;
|
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1409); dump_stack(); } } while(0);
|
| ip_mc_inc_group(in_dev, (( __be32)(__builtin_constant_p((__u32)((0xE0000001L))) ? ((__u32)( (((__u32)((0xE0000001L)) & (__u32)0x000000ffUL) << 24) | (((__u32)((0xE0000001L)) & (__u32)0x0000ff00UL) << 8) | (((__u32)((0xE0000001L)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)((0xE0000001L)) & (__u32)0xff000000UL) >> 24))) : __fswab32((0xE0000001L)))));
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1413); } } while (0); ; ((typeof(*(in_dev->mc_list)) *)((in_dev->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1413); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); }))
|  igmp_group_added(pmc);
|}
|
|
|
|
|
|void ip_mc_destroy_dev(struct in_device *in_dev)
|{
| struct ip_mc_list *i;
|
| do { if (__builtin_expect(!!(!rtnl_is_locked()), 0)) { printk("<3>" "RTNL: assertion failed at %s (%d)\n", "net/ipv4/.tmp_igmp.o.armored.c", 1425); dump_stack(); } } while(0);
|
|
| ip_mc_down(in_dev);
|
| while ((i = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1430); } } while (0); ; ((typeof(*(in_dev->mc_list)) *)((in_dev->mc_list))); })) != ((void *)0)) {
|  in_dev->mc_list = i->next_rcu;
|  in_dev->mc_count--;
|
|  igmp_group_dropped(i);
|  ip_ma_put(i);
| }
|}
|
|
|static struct in_device *ip_mc_find_dev(struct net *net, struct ip_mreqn *imr)
|{
| struct flowi fl = { .nl_u.ip4_u.daddr = imr->imr_multiaddr.s_addr };
| struct rtable *rt;
| struct net_device *dev = ((void *)0);
| struct in_device *idev = ((void *)0);
|
| if (imr->imr_ifindex) {
|  idev = inetdev_by_index(net, imr->imr_ifindex);
|  return idev;
| }
| if (imr->imr_address.s_addr) {
|  dev = __ip_dev_find(net, imr->imr_address.s_addr, false);
|  if (!dev)
|   return ((void *)0);
| }
|
| if (!dev && !ip_route_output_key(net, &rt, &fl)) {
|  dev = rt->dst.dev;
|  ip_rt_put(rt);
| }
| if (dev) {
|  imr->imr_ifindex = dev->ifindex;
|  idev = __in_dev_get_rtnl(dev);
| }
| return idev;
|}
|
|
|
|
|int sysctl_igmp_max_memberships = 20;
|int sysctl_igmp_max_msf = 10;
|
|
|static int ip_mc_del1_src(struct ip_mc_list *pmc, int sfmode,
| __be32 *psfsrc)
|{
| struct ip_sf_list *psf, *psf_prev;
| int rv = 0;
|
| psf_prev = ((void *)0);
| for (psf=pmc->sources; psf; psf=psf->sf_next) {
|  if (psf->sf_inaddr == *psfsrc)
|   break;
|  psf_prev = psf;
| }
| if (!psf || psf->sf_count[sfmode] == 0) {
|
|  return -3;
| }
| psf->sf_count[sfmode]--;
| if (psf->sf_count[sfmode] == 0) {
|  ip_rt_multicast_event(pmc->interface);
| }
| if (!psf->sf_count[1] && !psf->sf_count[0]) {
|
|  struct in_device *in_dev = pmc->interface;
|
|
|
|  if (psf_prev)
|   psf_prev->sf_next = psf->sf_next;
|  else
|   pmc->sources = psf->sf_next;
|
|  if (psf->sf_oldin &&
|      !((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v1_seen) < 0)))) && !((((*(dev_net(in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((in_dev)->mr_v2_seen) < 0))))) {
|   psf->sf_crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|    2;
|   psf->sf_next = pmc->tomb;
|   pmc->tomb = psf;
|   rv = 1;
|  } else
|
|   kfree(psf);
| }
| return rv;
|}
|
|
|
|
|
|static int ip_mc_del_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
|    int sfcount, __be32 *psfsrc, int delta)
|{
| struct ip_mc_list *pmc;
| int changerec = 0;
| int i, err;
|
| if (!in_dev)
|  return -19;
| __st_rcu_read_lock_st__();
| for (pmc = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1534); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); pmc != ((void *)0); pmc = ({ typeof(*(pmc->next_rcu)) *_________p1 = (typeof(*(pmc->next_rcu))* )(*(volatile typeof((pmc->next_rcu)) *)&((pmc->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1534); } } while (0); ; do { } while (0); ((typeof(*(pmc->next_rcu)) *)(_________p1)); })) {
|  if (*pmca == pmc->multiaddr)
|   break;
| }
| if (!pmc) {
|
|  __st_rcu_read_unlock_st__();
|  return -3;
| }
| __st_spin_lock_bh_st__(&pmc->lock);
| __st_rcu_read_unlock_st__();
|
| sf_markstate(pmc);
|
| if (!delta) {
|  err = -22;
|  if (!pmc->sfcount[sfmode])
|   goto out_unlock;
|  pmc->sfcount[sfmode]--;
| }
| err = 0;
| for (i=0; i 1351|  int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
|
|  changerec |= rv > 0;
|  if (!err && rv < 0)
|   err = rv;
| }
| if (pmc->sfmode == 0 &&
|     pmc->sfcount[0] == 0 &&
|     pmc->sfcount[1]) {
|
|  struct ip_sf_list *psf;
|
|
|
|  pmc->sfmode = 1;
|
|  pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|   2;
|  in_dev->mr_ifc_count = pmc->crcount;
|  for (psf=pmc->sources; psf; psf = psf->sf_next)
|   psf->sf_crcount = 0;
|  igmp_ifc_event(pmc->interface);
| } else if (sf_setstate(pmc) || changerec) {
|  igmp_ifc_event(pmc->interface);
|
| }
|out_unlock:
| __st_spin_unlock_bh_st__(&pmc->lock);
| return err;
|}
|
|
|
|
|static int ip_mc_add1_src(struct ip_mc_list *pmc, int sfmode,
| __be32 *psfsrc, int delta)
|{
| struct ip_sf_list *psf, *psf_prev;
|
| psf_prev = ((void *)0);
| for (psf=pmc->sources; psf; psf=psf->sf_next) {
|  if (psf->sf_inaddr == *psfsrc)
|   break;
|  psf_prev = psf;
| }
| if (!psf) {
|  psf = kzalloc(sizeof(*psf), ((( gfp_t)0x20u)));
|  if (!psf)
|   return -105;
|  psf->sf_inaddr = *psfsrc;
|  if (psf_prev) {
|   psf_prev->sf_next = psf;
|  } else
|   pmc->sources = psf;
| }
| psf->sf_count[sfmode]++;
| if (psf->sf_count[sfmode] == 1) {
|  ip_rt_multicast_event(pmc->interface);
| }
| return 0;
|}
|
|
|static void sf_markstate(struct ip_mc_list *pmc)
|{
| struct ip_sf_list *psf;
| int mca_xcount = pmc->sfcount[0];
|
| for (psf=pmc->sources; psf; psf=psf->sf_next)
|  if (pmc->sfcount[0]) {
|   psf->sf_oldin = mca_xcount ==
|    psf->sf_count[0] &&
|    !psf->sf_count[1];
|  } else
|   psf->sf_oldin = psf->sf_count[1] != 0;
|}
|
|static int sf_setstate(struct ip_mc_list *pmc)
|{
| struct ip_sf_list *psf, *dpsf;
| int mca_xcount = pmc->sfcount[0];
| int qrv = pmc->interface->mr_qrv;
| int new_in, rv;
|
| rv = 0;
| for (psf=pmc->sources; psf; psf=psf->sf_next) {
|  if (pmc->sfcount[0]) {
|   new_in = mca_xcount == psf->sf_count[0] &&
|    !psf->sf_count[1];
|  } else
|   new_in = psf->sf_count[1] != 0;
|  if (new_in) {
|   if (!psf->sf_oldin) {
|    struct ip_sf_list *prev = ((void *)0);
|
|    for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next) {
|     if (dpsf->sf_inaddr == psf->sf_inaddr)
|      break;
|     prev = dpsf;
|    }
|    if (dpsf) {
|     if (prev)
|      prev->sf_next = dpsf->sf_next;
|     else
|      pmc->tomb = dpsf->sf_next;
|     kfree(dpsf);
|    }
|    psf->sf_crcount = qrv;
|    rv++;
|   }
|  } else if (psf->sf_oldin) {
|
|   psf->sf_crcount = 0;
|
|
|
|
|   for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next)
|    if (dpsf->sf_inaddr == psf->sf_inaddr)
|     break;
|   if (!dpsf) {
|    dpsf = kmalloc(sizeof(*dpsf), ((( gfp_t)0x20u)));
|    if (!dpsf)
|     continue;
|    *dpsf = *psf;
|
|    dpsf->sf_next = pmc->tomb;
|    pmc->tomb = dpsf;
|   }
|   dpsf->sf_crcount = qrv;
|   rv++;
|  }
| }
| return rv;
|}
|
|
|
|
|
|static int ip_mc_add_src(struct in_device *in_dev, __be32 *pmca, int sfmode,
|    int sfcount, __be32 *psfsrc, int delta)
|{
| struct ip_mc_list *pmc;
| int isexclude;
| int i, err;
|
| if (!in_dev)
|  return -19;
| __st_rcu_read_lock_st__();
| for (pmc = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1706); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); pmc != ((void *)0); pmc = ({ typeof(*(pmc->next_rcu)) *_________p1 = (typeof(*(pmc->next_rcu))* )(*(volatile typeof((pmc->next_rcu)) *)&((pmc->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1706); } } while (0); ; do { } while (0); ((typeof(*(pmc->next_rcu)) *)(_________p1)); })) {
|  if (*pmca == pmc->multiaddr)
|   break;
| }
| if (!pmc) {
|
|  __st_rcu_read_unlock_st__();
|  return -3;
| }
| __st_spin_lock_bh_st__(&pmc->lock);
| __st_rcu_read_unlock_st__();
|
|
| sf_markstate(pmc);
|
| isexclude = pmc->sfmode == 0;
| if (!delta)
|  pmc->sfcount[sfmode]++;
| err = 0;
| for (i=0; i 1521|  err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i], delta);
|  if (err)
|   break;
| }
| if (err) {
|  int j;
|
|  pmc->sfcount[sfmode]--;
|  for (j=0; j 1530|   (void) ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
| } else if (isexclude != (pmc->sfcount[0] != 0)) {
|
|  struct ip_sf_list *psf;
|  in_dev = pmc->interface;
|
|
|
|  if (pmc->sfcount[0])
|   pmc->sfmode = 0;
|  else if (pmc->sfcount[1])
|   pmc->sfmode = 1;
|
|
|
|  pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
|   2;
|  in_dev->mr_ifc_count = pmc->crcount;
|  for (psf=pmc->sources; psf; psf = psf->sf_next)
|   psf->sf_crcount = 0;
|  igmp_ifc_event(in_dev);
| } else if (sf_setstate(pmc)) {
|  igmp_ifc_event(in_dev);
|
| }
| __st_spin_unlock_bh_st__(&pmc->lock);
| return err;
|}
|
|static void ip_mc_clear_src(struct ip_mc_list *pmc)
|{
| struct ip_sf_list *psf, *nextpsf;
|
| for (psf=pmc->tomb; psf; psf=nextpsf) {
|  nextpsf = psf->sf_next;
|  kfree(psf);
| }
| pmc->tomb = ((void *)0);
| for (psf=pmc->sources; psf; psf=nextpsf) {
|  nextpsf = psf->sf_next;
|  kfree(psf);
| }
| pmc->sources = ((void *)0);
| pmc->sfmode = 0;
| pmc->sfcount[1] = 0;
| pmc->sfcount[0] = 1;
|}
|
|
|
|
|
|int ip_mc_join_group(struct sock *sk , struct ip_mreqn *imr)
|{
| int err;
| __be32 addr = imr->imr_multiaddr.s_addr;
| struct ip_mc_socklist *iml = ((void *)0), *i;
| struct in_device *in_dev;
| struct inet_sock *inet = inet_sk(sk);
| struct net *net = sock_net(sk);
| int ifindex;
| int count = 0;
|
| if (!ipv4_is_multicast(addr))
|  return -22;
|
| rtnl_lock();
|
| in_dev = ip_mc_find_dev(net, imr);
|
| if (!in_dev) {
|  iml = ((void *)0);
|  err = -19;
|  goto done;
| }
|
| err = -98;
| ifindex = imr->imr_ifindex;
| for (i = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1813); } } while (0); ; ((typeof(*(inet->mc_list)) *)((inet->mc_list))); }); i != ((void *)0); i = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1813); } } while (0); ; ((typeof(*(i->next_rcu)) *)((i->next_rcu))); })) {
|  if (i->multi.imr_multiaddr.s_addr == addr &&
|      i->multi.imr_ifindex == ifindex)
|   goto done;
|  count++;
| }
| err = -105;
| if (count >= sysctl_igmp_max_memberships)
|  goto done;
| iml = sock_kmalloc(sk, sizeof(*iml), __st_GFP_KERNEL_st__);
| if (iml == ((void *)0))
|  goto done;
|
| __st_memcpy_st__(&iml->multi, imr, sizeof(*imr));
| iml->next_rcu = inet->mc_list;
| iml->sflist = ((void *)0);
| iml->sfmode = 0;
| __st_rcu_assign_pointer_st__(inet->mc_list, iml);
| ip_mc_inc_group(in_dev, addr);
| err = 0;
|done:
| rtnl_unlock();
| return err;
|}
|extern typeof(ip_mc_join_group) ip_mc_join_group; extern void *__crc_ip_mc_join_group ; static const unsigned long __kcrctab_ip_mc_join_group = (unsigned long) &__crc_ip_mc_join_group; static const char __kstrtab_ip_mc_join_group[] = "" "ip_mc_join_group"; static const struct kernel_symbol __ksymtab_ip_mc_join_group = { (unsigned long)&ip_mc_join_group, __kstrtab_ip_mc_join_group };
|
|static void ip_sf_socklist_reclaim(struct rcu_head *rp)
|{
| kfree(({ const typeof( ((struct ip_sf_socklist *)0)->rcu ) *__mptr = (rp); (struct ip_sf_socklist *)( (char *)__mptr - 1 );}));
|
|}
|
|static int ip_mc_leave_src(struct sock *sk, struct ip_mc_socklist *iml,
|      struct in_device *in_dev)
|{
| struct ip_sf_socklist *psf = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1848); } } while (0); ; ((typeof(*(iml->sflist)) *)((iml->sflist))); });
| int err;
|
| if (psf == ((void *)0)) {
|
|  return ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
|   iml->sfmode, 0, ((void *)0), 0);
| }
| err = ip_mc_del_src(in_dev, &iml->multi.imr_multiaddr.s_addr,
|   iml->sfmode, psf->sl_count, psf->sl_addr, 0);
| __st_rcu_assign_pointer_st__(iml->sflist, ((void *)0));
|
| atomic_sub((sizeof(struct ip_sf_socklist) + (psf->sl_max) * sizeof(__be32)), &sk->sk_omem_alloc);
| call_rcu_sched(&psf->rcu, ip_sf_socklist_reclaim);
| return err;
|}
|
|
|static void ip_mc_socklist_reclaim(struct rcu_head *rp)
|{
| kfree(({ const typeof( ((struct ip_mc_socklist *)0)->rcu ) *__mptr = (rp); (struct ip_mc_socklist *)( (char *)__mptr - 1 );}));
|
|}
|
|
|
|
|
|
|int ip_mc_leave_group(struct sock *sk, struct ip_mreqn *imr)
|{
| struct inet_sock *inet = inet_sk(sk);
| struct ip_mc_socklist *iml;
| struct ip_mc_socklist **imlp;
| struct in_device *in_dev;
| struct net *net = sock_net(sk);
| __be32 group = imr->imr_multiaddr.s_addr;
| u32 ifindex;
| int ret = -99;
|
| rtnl_lock();
| in_dev = ip_mc_find_dev(net, imr);
| ifindex = imr->imr_ifindex;
| for (imlp = &inet->mc_list;
|      (iml = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1892); } } while (0); ; ((typeof(*(*imlp)) *)((*imlp))); })) != ((void *)0);
|      imlp = &iml->next_rcu) {
|  if (iml->multi.imr_multiaddr.s_addr != group)
|   continue;
|  if (ifindex) {
|   if (iml->multi.imr_ifindex != ifindex)
|    continue;
|  } else if (imr->imr_address.s_addr && imr->imr_address.s_addr !=
|    iml->multi.imr_address.s_addr)
|   continue;
|
|  (void) ip_mc_leave_src(sk, iml, in_dev);
|
|  *imlp = iml->next_rcu;
|
|  if (in_dev)
|   ip_mc_dec_group(in_dev, group);
|  rtnl_unlock();
|
|  atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
|  call_rcu_sched(&iml->rcu, ip_mc_socklist_reclaim);
|  return 0;
| }
| if (!in_dev)
|  ret = -19;
| rtnl_unlock();
| return ret;
|}
|
|int ip_mc_source(int add, int omode, struct sock *sk, struct
| ip_mreq_source *mreqs, int ifindex)
|{
| int err;
| struct ip_mreqn imr;
| __be32 addr = mreqs->imr_multiaddr;
| struct ip_mc_socklist *pmc;
| struct in_device *in_dev = ((void *)0);
| struct inet_sock *inet = inet_sk(sk);
| struct ip_sf_socklist *psl;
| struct net *net = sock_net(sk);
| int leavegroup = 0;
| int i, j, rv;
|
| if (!ipv4_is_multicast(addr))
|  return -22;
|
| rtnl_lock();
|
| imr.imr_multiaddr.s_addr = mreqs->imr_multiaddr;
| imr.imr_address.s_addr = mreqs->imr_interface;
| imr.imr_ifindex = ifindex;
| in_dev = ip_mc_find_dev(net, &imr);
|
| if (!in_dev) {
|  err = -19;
|  goto done;
| }
| err = -99;
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1951); } } while (0); ; ((typeof(*(inet->mc_list)) *)((inet->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1951); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); })) {
|  if ((pmc->multi.imr_multiaddr.s_addr ==
|       imr.imr_multiaddr.s_addr) &&
|      (pmc->multi.imr_ifindex == imr.imr_ifindex))
|   break;
| }
| if (!pmc) {
|  err = -22;
|  goto done;
| }
|
| if (pmc->sflist) {
|  if (pmc->sfmode != omode) {
|   err = -22;
|   goto done;
|  }
| } else if (pmc->sfmode != omode) {
|
|  ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 0, ((void *)0), 0);
|  ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, pmc->sfmode, 0,
|   ((void *)0), 0);
|  pmc->sfmode = omode;
| }
|
| psl = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 1975); } } while (0); ; ((typeof(*(pmc->sflist)) *)((pmc->sflist))); });
| if (!add) {
|  if (!psl)
|   goto done;
|  rv = !0;
|  for (i=0; isl_count; i++) {
|   rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
|    sizeof(__be32));
|   if (rv == 0)
|    break;
|  }
|  if (rv)
|   goto done;
|
|
|  if (psl->sl_count == 1 && omode == 1) {
|   leavegroup = 1;
|   goto done;
|  }
|
|
|  ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
|   &mreqs->imr_sourceaddr, 1);
|
|  for (j=i+1; jsl_count; j++)
|   psl->sl_addr[j-1] = psl->sl_addr[j];
|  psl->sl_count--;
|  err = 0;
|  goto done;
| }
|
|
| if (psl && psl->sl_count >= sysctl_igmp_max_msf) {
|  err = -105;
|  goto done;
| }
| if (!psl || psl->sl_count == psl->sl_max) {
|  struct ip_sf_socklist *newpsl;
|  int count = 10;
|
|  if (psl)
|   count += psl->sl_max;
|  newpsl = sock_kmalloc(sk, (sizeof(struct ip_sf_socklist) + (count) * sizeof(__be32)), __st_GFP_KERNEL_st__);
|  if (!newpsl) {
|   err = -105;
|   goto done;
|  }
|  newpsl->sl_max = count;
|  newpsl->sl_count = count - 10;
|  if (psl) {
|   for (i=0; isl_count; i++)
|    newpsl->sl_addr[i] = psl->sl_addr[i];
|
|   atomic_sub((sizeof(struct ip_sf_socklist) + (psl->sl_max) * sizeof(__be32)), &sk->sk_omem_alloc);
|   call_rcu_sched(&psl->rcu, ip_sf_socklist_reclaim);
|  }
|  __st_rcu_assign_pointer_st__(pmc->sflist, newpsl);
|  psl = newpsl;
| }
| rv = 1;
| for (i=0; isl_count; i++) {
|  rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
|   sizeof(__be32));
|  if (rv == 0)
|   break;
| }
| if (rv == 0)
|  goto done;
| for (j=psl->sl_count-1; j>=i; j--)
|  psl->sl_addr[j+1] = psl->sl_addr[j];
| psl->sl_addr[i] = mreqs->imr_sourceaddr;
| psl->sl_count++;
| err = 0;
|
| ip_mc_add_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
|  &mreqs->imr_sourceaddr, 1);
|done:
| rtnl_unlock();
| if (leavegroup)
|  return ip_mc_leave_group(sk, &imr);
| return err;
|}
|
|int ip_mc_msfilter(struct sock *sk, struct ip_msfilter *msf, int ifindex)
|{
| int err = 0;
| struct ip_mreqn imr;
| __be32 addr = msf->imsf_multiaddr;
| struct ip_mc_socklist *pmc;
| struct in_device *in_dev;
| struct inet_sock *inet = inet_sk(sk);
| struct ip_sf_socklist *newpsl, *psl;
| struct net *net = sock_net(sk);
| int leavegroup = 0;
|
| if (!ipv4_is_multicast(addr))
|  return -22;
| if (msf->imsf_fmode != 1 &&
|     msf->imsf_fmode != 0)
|  return -22;
|
| rtnl_lock();
|
| imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
| imr.imr_address.s_addr = msf->imsf_interface;
| imr.imr_ifindex = ifindex;
| in_dev = ip_mc_find_dev(net, &imr);
|
| if (!in_dev) {
|  err = -19;
|  goto done;
| }
|
|
| if (msf->imsf_fmode == 1 && msf->imsf_numsrc == 0) {
|  leavegroup = 1;
|  goto done;
| }
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2094); } } while (0); ; ((typeof(*(inet->mc_list)) *)((inet->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2094); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); })) {
|  if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
|      pmc->multi.imr_ifindex == imr.imr_ifindex)
|   break;
| }
| if (!pmc) {
|  err = -22;
|  goto done;
| }
| if (msf->imsf_numsrc) {
|  newpsl = sock_kmalloc(sk, (sizeof(struct ip_sf_socklist) + (msf->imsf_numsrc) * sizeof(__be32)),
|          __st_GFP_KERNEL_st__);
|  if (!newpsl) {
|   err = -105;
|   goto done;
|  }
|  newpsl->sl_max = newpsl->sl_count = msf->imsf_numsrc;
|  __st_memcpy_st__(newpsl->sl_addr, msf->imsf_slist,
|   msf->imsf_numsrc * sizeof(msf->imsf_slist[0]));
|  err = ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
|   msf->imsf_fmode, newpsl->sl_count, newpsl->sl_addr, 0);
|  if (err) {
|   sock_kfree_s(sk, newpsl, (sizeof(struct ip_sf_socklist) + (newpsl->sl_max) * sizeof(__be32)));
|   goto done;
|  }
| } else {
|  newpsl = ((void *)0);
|  (void) ip_mc_add_src(in_dev, &msf->imsf_multiaddr,
|         msf->imsf_fmode, 0, ((void *)0), 0);
| }
| psl = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2124); } } while (0); ; ((typeof(*(pmc->sflist)) *)((pmc->sflist))); });
| if (psl) {
|  (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
|   psl->sl_count, psl->sl_addr, 0);
|
|  atomic_sub((sizeof(struct ip_sf_socklist) + (psl->sl_max) * sizeof(__be32)), &sk->sk_omem_alloc);
|  call_rcu_sched(&psl->rcu, ip_sf_socklist_reclaim);
| } else
|  (void) ip_mc_del_src(in_dev, &msf->imsf_multiaddr, pmc->sfmode,
|   0, ((void *)0), 0);
| __st_rcu_assign_pointer_st__(pmc->sflist, newpsl);
| pmc->sfmode = msf->imsf_fmode;
| err = 0;
|done:
| rtnl_unlock();
| if (leavegroup)
|  err = ip_mc_leave_group(sk, &imr);
| return err;
|}
|
|int ip_mc_msfget(struct sock *sk, struct ip_msfilter *msf,
| struct ip_msfilter *optval, int *optlen)
|{
| int err, len, count, copycount;
| struct ip_mreqn imr;
| __be32 addr = msf->imsf_multiaddr;
| struct ip_mc_socklist *pmc;
| struct in_device *in_dev;
| struct inet_sock *inet = inet_sk(sk);
| struct ip_sf_socklist *psl;
| struct net *net = sock_net(sk);
|
| if (!ipv4_is_multicast(addr))
|  return -22;
|
| rtnl_lock();
|
| imr.imr_multiaddr.s_addr = msf->imsf_multiaddr;
| imr.imr_address.s_addr = msf->imsf_interface;
| imr.imr_ifindex = 0;
| in_dev = ip_mc_find_dev(net, &imr);
|
| if (!in_dev) {
|  err = -19;
|  goto done;
| }
| err = -99;
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2172); } } while (0); ; ((typeof(*(inet->mc_list)) *)((inet->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2172); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); })) {
|  if (pmc->multi.imr_multiaddr.s_addr == msf->imsf_multiaddr &&
|      pmc->multi.imr_ifindex == imr.imr_ifindex)
|   break;
| }
| if (!pmc)
|  goto done;
| msf->imsf_fmode = pmc->sfmode;
| psl = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2180); } } while (0); ; ((typeof(*(pmc->sflist)) *)((pmc->sflist))); });
| rtnl_unlock();
| if (!psl) {
|  len = 0;
|  count = 0;
| } else {
|  count = psl->sl_count;
| }
| copycount = count < msf->imsf_numsrc ? count : msf->imsf_numsrc;
| len = copycount * sizeof(psl->sl_addr[0]);
| msf->imsf_numsrc = count;
| if (__st_put_user_st__((sizeof(struct ip_msfilter) - sizeof(__u32) + (copycount) * sizeof(__u32)), optlen) ||
|     copy_to_user(optval, msf, (sizeof(struct ip_msfilter) - sizeof(__u32) + (0) * sizeof(__u32)))) {
|  return -14;
| }
| if (len &&
|     copy_to_user(&optval->imsf_slist[0], psl->sl_addr, len))
|  return -14;
| return 0;
|done:
| rtnl_unlock();
| return err;
|}
|
|int ip_mc_gsfget(struct sock *sk, struct group_filter *gsf,
| struct group_filter *optval, int *optlen)
|{
| int err, i, count, copycount;
| struct sockaddr_in *psin;
| __be32 addr;
| struct ip_mc_socklist *pmc;
| struct inet_sock *inet = inet_sk(sk);
| struct ip_sf_socklist *psl;
|
| psin = (struct sockaddr_in *)&gsf->gf_group;
| if (psin->sin_family != 2)
|  return -22;
| addr = psin->sin_addr.s_addr;
| if (!ipv4_is_multicast(addr))
|  return -22;
|
| rtnl_lock();
|
| err = -99;
|
| for (pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2225); } } while (0); ; ((typeof(*(inet->mc_list)) *)((inet->mc_list))); }); pmc != ((void *)0); pmc = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2225); } } while (0); ; ((typeof(*(pmc->next_rcu)) *)((pmc->next_rcu))); })) {
|  if (pmc->multi.imr_multiaddr.s_addr == addr &&
|      pmc->multi.imr_ifindex == gsf->gf_interface)
|   break;
| }
| if (!pmc)
|  goto done;
| gsf->gf_fmode = pmc->sfmode;
| psl = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2233); } } while (0); ; ((typeof(*(pmc->sflist)) *)((pmc->sflist))); });
| rtnl_unlock();
| count = psl ? psl->sl_count : 0;
| copycount = count < gsf->gf_numsrc ? count : gsf->gf_numsrc;
| gsf->gf_numsrc = count;
| if (__st_put_user_st__((sizeof(struct group_filter) - sizeof(struct __kernel_sockaddr_storage) + (copycount) * sizeof(struct __kernel_sockaddr_storage)), optlen) ||
|     copy_to_user(optval, gsf, (sizeof(struct group_filter) - sizeof(struct __kernel_sockaddr_storage) + (0) * sizeof(struct __kernel_sockaddr_storage)))) {
|  return -14;
| }
| for (i=0; i 2038|  struct __kernel_sockaddr_storage ss;
|
|  psin = (struct sockaddr_in *)&ss;
|  __st_memset_st__(&ss, 0, sizeof(ss));
|  psin->sin_family = 2;
|  psin->sin_addr.s_addr = psl->sl_addr[i];
|  if (copy_to_user(&optval->gf_slist[i], &ss, sizeof(ss)))
|   return -14;
| }
| return 0;
|done:
| rtnl_unlock();
| return err;
|}
|
|
|
|
|int ip_mc_sf_allow(struct sock *sk, __be32 loc_addr, __be32 rmt_addr, int dif)
|{
| struct inet_sock *inet = inet_sk(sk);
| struct ip_mc_socklist *pmc;
| struct ip_sf_socklist *psl;
| int i;
| int ret;
|
| ret = 1;
| if (!ipv4_is_multicast(loc_addr))
|  goto out;
|
| __st_rcu_read_lock_st__();
| for (pmc = ({ typeof(*(inet->mc_list)) *_________p1 = (typeof(*(inet->mc_list))* )(*(volatile typeof((inet->mc_list)) *)&((inet->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2274); } } while (0); ; do { } while (0); ((typeof(*(inet->mc_list)) *)(_________p1)); }); pmc != ((void *)0); pmc = ({ typeof(*(pmc->next_rcu)) *_________p1 = (typeof(*(pmc->next_rcu))* )(*(volatile typeof((pmc->next_rcu)) *)&((pmc->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2274); } } while (0); ; do { } while (0); ((typeof(*(pmc->next_rcu)) *)(_________p1)); })) {
|  if (pmc->multi.imr_multiaddr.s_addr == loc_addr &&
|      pmc->multi.imr_ifindex == dif)
|   break;
| }
| ret = inet->mc_all;
| if (!pmc)
|  goto unlock;
| psl = ({ typeof(*(pmc->sflist)) *_________p1 = (typeof(*(pmc->sflist))* )(*(volatile typeof((pmc->sflist)) *)&((pmc->sflist))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2282); } } while (0); ; do { } while (0); ((typeof(*(pmc->sflist)) *)(_________p1)); });
| ret = (pmc->sfmode == 0);
| if (!psl)
|  goto unlock;
|
| for (i=0; isl_count; i++) {
|  if (psl->sl_addr[i] == rmt_addr)
|   break;
| }
| ret = 0;
| if (pmc->sfmode == 1 && i >= psl->sl_count)
|  goto unlock;
| if (pmc->sfmode == 0 && i < psl->sl_count)
|  goto unlock;
| ret = 1;
|unlock:
| __st_rcu_read_unlock_st__();
|out:
| return ret;
|}
|
|
|
|
|
|void ip_mc_drop_socket(struct sock *sk)
|{
| struct inet_sock *inet = inet_sk(sk);
| struct ip_mc_socklist *iml;
| struct net *net = sock_net(sk);
|
| if (inet->mc_list == ((void *)0))
|  return;
|
| rtnl_lock();
| while ((iml = ({ do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !((lockdep_rtnl_is_held()))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2317); } } while (0); ; ((typeof(*(inet->mc_list)) *)((inet->mc_list))); })) != ((void *)0)) {
|  struct in_device *in_dev;
|
|  inet->mc_list = iml->next_rcu;
|  in_dev = inetdev_by_index(net, iml->multi.imr_ifindex);
|  (void) ip_mc_leave_src(sk, iml, in_dev);
|  if (in_dev != ((void *)0))
|   ip_mc_dec_group(in_dev, iml->multi.imr_multiaddr.s_addr);
|
|  atomic_sub(sizeof(*iml), &sk->sk_omem_alloc);
|  call_rcu_sched(&iml->rcu, ip_mc_socklist_reclaim);
| }
| rtnl_unlock();
|}
|
|int ip_check_mc(struct in_device *in_dev, __be32 mc_addr, __be32 src_addr, u16 proto)
|{
| struct ip_mc_list *im;
| struct ip_sf_list *psf;
| int rv = 0;
|
| __st_rcu_read_lock_st__();
| for (im = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2339); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); }); im != ((void *)0); im = ({ typeof(*(im->next_rcu)) *_________p1 = (typeof(*(im->next_rcu))* )(*(volatile typeof((im->next_rcu)) *)&((im->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2339); } } while (0); ; do { } while (0); ((typeof(*(im->next_rcu)) *)(_________p1)); })) {
|  if (im->multiaddr == mc_addr)
|   break;
| }
| if (im && proto == IPPROTO_IGMP) {
|  rv = 1;
| } else if (im) {
|  if (src_addr) {
|   for (psf=im->sources; psf; psf=psf->sf_next) {
|    if (psf->sf_inaddr == src_addr)
|     break;
|   }
|   if (psf)
|    rv = psf->sf_count[1] ||
|     psf->sf_count[0] !=
|     im->sfcount[0];
|   else
|    rv = im->sfcount[0] != 0;
|  } else
|   rv = 1;
| }
| __st_rcu_read_unlock_st__();
| return rv;
|}
|
|
|struct igmp_mc_iter_state {
| struct seq_net_private p;
| struct net_device *dev;
| struct in_device *in_dev;
|};
|
|
|
|static inline struct ip_mc_list *igmp_mc_get_first(struct seq_file *seq)
|{
| struct net *net = seq_file_net(seq);
| struct ip_mc_list *im = ((void *)0);
| struct igmp_mc_iter_state *state = ((struct igmp_mc_iter_state *)(seq)->private);
|
| state->in_dev = ((void *)0);
| for (state->dev = ({typeof (*(&(net)->dev_base_head)->next) *__ptr = (typeof (*(&(net)->dev_base_head)->next) *)(&(net)->dev_base_head)->next; ({ const typeof( ((typeof(*state->dev) *)0)->dev_list ) *__mptr = ((typeof((&(net)->dev_base_head)->next))({ typeof(*(__ptr)) *_________p1 = (typeof(*(__ptr))* )(*(volatile typeof((__ptr)) *)&((__ptr))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (1))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2380); } } while (0); ; do { } while (0); ((typeof(*(__ptr)) *)(_________p1)); })); (typeof(*state->dev) *)( (char *)__mptr - 1 );}); }); __builtin_prefetch(state->dev->dev_list.next), &state->dev->dev_list != (&(net)->dev_base_head); state->dev = ({typeof (*state->dev->dev_list.next) *__ptr = (typeof (*state->dev->dev_list.next) *)state->dev->dev_list.next; ({ const typeof( ((typeof(*state->dev) *)0)->dev_list ) *__mptr = ((typeof(state->dev->dev_list.next))({ typeof(*(__ptr)) *_________p1 = (typeof(*(__ptr))* )(*(volatile typeof((__ptr)) *)&((__ptr))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (1))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2380); } } while (0); ; do { } while (0); ((typeof(*(__ptr)) *)(_________p1)); })); (typeof(*state->dev) *)( (char *)__mptr - 1 );}); })) {
|  struct in_device *in_dev;
|
|  in_dev = __in_dev_get_rcu(state->dev);
|  if (!in_dev)
|   continue;
|  im = ({ typeof(*(in_dev->mc_list)) *_________p1 = (typeof(*(in_dev->mc_list))* )(*(volatile typeof((in_dev->mc_list)) *)&((in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2386); } } while (0); ; do { } while (0); ((typeof(*(in_dev->mc_list)) *)(_________p1)); });
|  if (im) {
|   state->in_dev = in_dev;
|   break;
|  }
| }
| return im;
|}
|
|static struct ip_mc_list *igmp_mc_get_next(struct seq_file *seq, struct ip_mc_list *im)
|{
| struct igmp_mc_iter_state *state = ((struct igmp_mc_iter_state *)(seq)->private);
|
| im = ({ typeof(*(im->next_rcu)) *_________p1 = (typeof(*(im->next_rcu))* )(*(volatile typeof((im->next_rcu)) *)&((im->next_rcu))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2399); } } while (0); ; do { } while (0); ((typeof(*(im->next_rcu)) *)(_________p1)); });
| while (!im) {
|  state->dev = next_net_device_rcu(state->dev);
|  if (!state->dev) {
|   state->in_dev = ((void *)0);
|   break;
|  }
|  state->in_dev = __in_dev_get_rcu(state->dev);
|  if (!state->in_dev)
|   continue;
|  im = ({ typeof(*(state->in_dev->mc_list)) *_________p1 = (typeof(*(state->in_dev->mc_list))* )(*(volatile typeof((state->in_dev->mc_list)) *)&((state->in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2409); } } while (0); ; do { } while (0); ((typeof(*(state->in_dev->mc_list)) *)(_________p1)); });
| }
| return im;
|}
|
|static struct ip_mc_list *igmp_mc_get_idx(struct seq_file *seq, loff_t pos)
|{
| struct ip_mc_list *im = igmp_mc_get_first(seq);
| if (im)
|  while (pos && (im = igmp_mc_get_next(seq, im)) != ((void *)0))
|   --pos;
| return pos ? ((void *)0) : im;
|}
|
|static void *igmp_mc_seq_start(struct seq_file *seq, loff_t *pos)
|
|{
| __st_rcu_read_lock_st__();
| return *pos ? igmp_mc_get_idx(seq, *pos - 1) : ((void *)1);
|}
|
|static void *igmp_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|{
| struct ip_mc_list *im;
| if (v == ((void *)1))
|  im = igmp_mc_get_first(seq);
| else
|  im = igmp_mc_get_next(seq, v);
| ++*pos;
| return im;
|}
|
|static void igmp_mc_seq_stop(struct seq_file *seq, void *v)
|
|{
| struct igmp_mc_iter_state *state = ((struct igmp_mc_iter_state *)(seq)->private);
|
| state->in_dev = ((void *)0);
| state->dev = ((void *)0);
| __st_rcu_read_unlock_st__();
|}
|
|static int igmp_mc_seq_show(struct seq_file *seq, void *v)
|{
| if (v == ((void *)1))
|  seq_puts(seq,
|    "Idx\tDevice    : Count Querier\tGroup    Users Timer\tReporter\n");
| else {
|  struct ip_mc_list *im = (struct ip_mc_list *)v;
|  struct igmp_mc_iter_state *state = ((struct igmp_mc_iter_state *)(seq)->private);
|  char *querier;
|
|  querier = ((((*(dev_net(state->in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 1 || ipv4_devconf_get(((state->in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 1 || ((state->in_dev)->mr_v1_seen && (({ unsigned long __dummy; typeof((state->in_dev)->mr_v1_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((state->in_dev)->mr_v1_seen) < 0)))) ? "V1" :
|     ((((*(dev_net(state->in_dev->dev))->ipv4.devconf_all)).data[IPV4_DEVCONF_FORCE_IGMP_VERSION - 1]) == 2 || ipv4_devconf_get(((state->in_dev)), IPV4_DEVCONF_FORCE_IGMP_VERSION) == 2 || ((state->in_dev)->mr_v2_seen && (({ unsigned long __dummy; typeof((state->in_dev)->mr_v2_seen) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)(jiffies) - (long)((state->in_dev)->mr_v2_seen) < 0)))) ? "V2" :
|     "V3";
|
|
|
|
|  if (({ typeof(*(state->in_dev->mc_list)) *_________p1 = (typeof(*(state->in_dev->mc_list))* )(*(volatile typeof((state->in_dev->mc_list)) *)&((state->in_dev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2468); } } while (0); ; do { } while (0); ((typeof(*(state->in_dev->mc_list)) *)(_________p1)); }) == im) {
|   seq_printf(seq, "%d\t%-10s: %5d %7s\n",
|       state->dev->ifindex, state->dev->name, state->in_dev->mc_count, querier);
|  }
|
|  seq_printf(seq,
|      "\t\t\t\t%08X %5d %d:%08lX\t\t%d\n",
|      im->multiaddr, im->users,
|      im->tm_running, im->tm_running ?
|      jiffies_to_clock_t(im->timer.expires-jiffies) : 0,
|      im->reporter);
| }
| return 0;
|}
|
|static const struct seq_operations igmp_mc_seq_ops = {
| .start = igmp_mc_seq_start,
| .next = igmp_mc_seq_next,
| .stop = igmp_mc_seq_stop,
| .show = igmp_mc_seq_show,
|};
|
|static int igmp_mc_seq_open(struct inode *inode, struct file *file)
|{
| return seq_open_net(inode, file, &igmp_mc_seq_ops,
|   sizeof(struct igmp_mc_iter_state));
|}
|
|static const struct file_operations igmp_mc_seq_fops = {
| .owner = ((struct module *)0),
| .open = igmp_mc_seq_open,
| .read = seq_read,
| .llseek = seq_lseek,
| .release = seq_release_net,
|};
|
|struct igmp_mcf_iter_state {
| struct seq_net_private p;
| struct net_device *dev;
| struct in_device *idev;
| struct ip_mc_list *im;
|};
|
|
|
|static inline struct ip_sf_list *igmp_mcf_get_first(struct seq_file *seq)
|{
| struct net *net = seq_file_net(seq);
| struct ip_sf_list *psf = ((void *)0);
| struct ip_mc_list *im = ((void *)0);
| struct igmp_mcf_iter_state *state = ((struct igmp_mcf_iter_state *)(seq)->private);
|
| state->idev = ((void *)0);
| state->im = ((void *)0);
| for (state->dev = ({typeof (*(&(net)->dev_base_head)->next) *__ptr = (typeof (*(&(net)->dev_base_head)->next) *)(&(net)->dev_base_head)->next; ({ const typeof( ((typeof(*state->dev) *)0)->dev_list ) *__mptr = ((typeof((&(net)->dev_base_head)->next))({ typeof(*(__ptr)) *_________p1 = (typeof(*(__ptr))* )(*(volatile typeof((__ptr)) *)&((__ptr))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (1))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2522); } } while (0); ; do { } while (0); ((typeof(*(__ptr)) *)(_________p1)); })); (typeof(*state->dev) *)( (char *)__mptr - 1 );}); }); __builtin_prefetch(state->dev->dev_list.next), &state->dev->dev_list != (&(net)->dev_base_head); state->dev = ({typeof (*state->dev->dev_list.next) *__ptr = (typeof (*state->dev->dev_list.next) *)state->dev->dev_list.next; ({ const typeof( ((typeof(*state->dev) *)0)->dev_list ) *__mptr = ((typeof(state->dev->dev_list.next))({ typeof(*(__ptr)) *_________p1 = (typeof(*(__ptr))* )(*(volatile typeof((__ptr)) *)&((__ptr))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (1))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2522); } } while (0); ; do { } while (0); ((typeof(*(__ptr)) *)(_________p1)); })); (typeof(*state->dev) *)( (char *)__mptr - 1 );}); })) {
|  struct in_device *idev;
|  idev = __in_dev_get_rcu(state->dev);
|  if (idev == ((void *)0))
|   continue;
|  im = ({ typeof(*(idev->mc_list)) *_________p1 = (typeof(*(idev->mc_list))* )(*(volatile typeof((idev->mc_list)) *)&((idev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2527); } } while (0); ; do { } while (0); ((typeof(*(idev->mc_list)) *)(_________p1)); });
|  if (im != ((void *)0)) {
|   __st_spin_lock_bh_st__(&im->lock);
     |The lock is locked here. prev next
|   psf = im->sources;
     |not affected ==> the lock is still locked. prev next
|   if (psf != ((void *)0)) {
     |not affected ==> the lock is still locked. prev next
|    state->im = im;
     |not affected ==> the lock is still locked. prev next
|    state->idev = idev;
     |not affected ==> the lock is still locked. prev next
|    break;
     |not affected ==> the lock is still locked. prev next
|   }
|   __st_spin_unlock_bh_st__(&im->lock);
|  }
| }
| return psf;
     |not affected ==> the lock is still locked. prev next
|}
     |not affected ==> the lock is still locked. prev next
|
|static struct ip_sf_list *igmp_mcf_get_next(struct seq_file *seq, struct ip_sf_list *psf)
|{
| struct igmp_mcf_iter_state *state = ((struct igmp_mcf_iter_state *)(seq)->private);
|
| psf = psf->sf_next;
| while (!psf) {
|  __st_spin_unlock_bh_st__(&state->im->lock);
|  state->im = state->im->next;
|  while (!state->im) {
|   state->dev = next_net_device_rcu(state->dev);
|   if (!state->dev) {
|    state->idev = ((void *)0);
|    goto out;
|   }
|   state->idev = __in_dev_get_rcu(state->dev);
|   if (!state->idev)
|    continue;
|   state->im = ({ typeof(*(state->idev->mc_list)) *_________p1 = (typeof(*(state->idev->mc_list))* )(*(volatile typeof((state->idev->mc_list)) *)&((state->idev->mc_list))); do { static bool __warned; if (debug_lockdep_rcu_enabled() && !__warned && !(rcu_read_lock_held() || (0))) { __warned = true; lockdep_rcu_dereference("net/ipv4/.tmp_igmp.o.armored.c", 2559); } } while (0); ; do { } while (0); ((typeof(*(state->idev->mc_list)) *)(_________p1)); });
|  }
|  if (!state->im)
|   break;
|  __st_spin_lock_bh_st__(&state->im->lock);
|  psf = state->im->sources;
| }
|out:
| return psf;
|}
|
|static struct ip_sf_list *igmp_mcf_get_idx(struct seq_file *seq, loff_t pos)
|{
| struct ip_sf_list *psf = igmp_mcf_get_first(seq);
| if (psf)
|  while (pos && (psf = igmp_mcf_get_next(seq, psf)) != ((void *)0))
|   --pos;
| return pos ? ((void *)0) : psf;
|}
|
|static void *igmp_mcf_seq_start(struct seq_file *seq, loff_t *pos)
|
|{
| __st_rcu_read_lock_st__();
| return *pos ? igmp_mcf_get_idx(seq, *pos - 1) : ((void *)1);
|}
|
|static void *igmp_mcf_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|{
| struct ip_sf_list *psf;
| if (v == ((void *)1))
|  psf = igmp_mcf_get_first(seq);
     |not affected ==> the lock is still locked. prev next
| else
|  psf = igmp_mcf_get_next(seq, v);
| ++*pos;
     |not affected ==> the lock is still locked. prev next
| return psf;
     |not affected ==> the lock is still locked. prev next
|}
     |Leaving function in locked state.[& . * im_1 lock] prev
|
|static void igmp_mcf_seq_stop(struct seq_file *seq, void *v)
|
|{
| struct igmp_mcf_iter_state *state = ((struct igmp_mcf_iter_state *)(seq)->private);
| if (state->im != ((void *)0)) {
|  __st_spin_unlock_bh_st__(&state->im->lock);
|  state->im = ((void *)0);
| }
| state->idev = ((void *)0);
| state->dev = ((void *)0);
| __st_rcu_read_unlock_st__();
|}
|
|static int igmp_mcf_seq_show(struct seq_file *seq, void *v)
|{
| struct ip_sf_list *psf = (struct ip_sf_list *)v;
| struct igmp_mcf_iter_state *state = ((struct igmp_mcf_iter_state *)(seq)->private);
|
| if (v == ((void *)1)) {
|  seq_printf(seq,
|      "%3s %6s "
|      "%10s %10s %6s %6s\n", "Idx",
|      "Device", "MCA",
|      "SRC", "INC", "EXC");
| } else {
|  seq_printf(seq,
|      "%3d %6.6s 0x%08x "
|      "0x%08x %6lu %6lu\n",
|      state->dev->ifindex, state->dev->name,
|      (__builtin_constant_p((__u32)(( __u32)(__be32)(state->im->multiaddr))) ? ((__u32)( (((__u32)(( __u32)(__be32)(state->im->multiaddr)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(state->im->multiaddr)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(state->im->multiaddr)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(state->im->multiaddr)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(state->im->multiaddr))),
|      (__builtin_constant_p((__u32)(( __u32)(__be32)(psf->sf_inaddr))) ? ((__u32)( (((__u32)(( __u32)(__be32)(psf->sf_inaddr)) & (__u32)0x000000ffUL) << 24) | (((__u32)(( __u32)(__be32)(psf->sf_inaddr)) & (__u32)0x0000ff00UL) << 8) | (((__u32)(( __u32)(__be32)(psf->sf_inaddr)) & (__u32)0x00ff0000UL) >> 8) | (((__u32)(( __u32)(__be32)(psf->sf_inaddr)) & (__u32)0xff000000UL) >> 24))) : __fswab32(( __u32)(__be32)(psf->sf_inaddr))),
|      psf->sf_count[1],
|      psf->sf_count[0]);
| }
| return 0;
|}
|
|static const struct seq_operations igmp_mcf_seq_ops = {
| .start = igmp_mcf_seq_start,
| .next = igmp_mcf_seq_next,
| .stop = igmp_mcf_seq_stop,
| .show = igmp_mcf_seq_show,
|};
|
|static int igmp_mcf_seq_open(struct inode *inode, struct file *file)
|{
| return seq_open_net(inode, file, &igmp_mcf_seq_ops,
|   sizeof(struct igmp_mcf_iter_state));
|}
|
|static const struct file_operations igmp_mcf_seq_fops = {
| .owner = ((struct module *)0),
| .open = igmp_mcf_seq_open,
| .read = seq_read,
| .llseek = seq_lseek,
| .release = seq_release_net,
|};
|
|static int igmp_net_init(struct net *net)
|{
| struct proc_dir_entry *pde;
|
| pde = proc_net_fops_create(net, "igmp", (00400|00040|00004), &igmp_mc_seq_fops);
| if (!pde)
|  goto out_igmp;
| pde = proc_net_fops_create(net, "mcfilter", (00400|00040|00004), &igmp_mcf_seq_fops);
| if (!pde)
|  goto out_mcfilter;
| return 0;
|
|out_mcfilter:
| proc_net_remove(net, "igmp");
|out_igmp:
| return -12;
|}
|
|static void igmp_net_exit(struct net *net)
|{
| proc_net_remove(net, "mcfilter");
| proc_net_remove(net, "igmp");
|}
|
|static struct pernet_operations igmp_net_ops = {
| .init = igmp_net_init,
| .exit = igmp_net_exit,
|};
|
|int igmp_mc_proc_init(void)
|{
| return register_pernet_subsys(&igmp_net_ops);
|}