struct ip_sf_list *psf;
        int scount = 0;
 
-       for (psf=pmc->sources; psf; psf=psf->sf_next) {
+       for (psf = pmc->sources; psf; psf = psf->sf_next) {
                if (!is_in(pmc, psf, type, gdeleted, sdeleted))
                        continue;
                scount++;
        }
        first = 1;
        psf_prev = NULL;
-       for (psf=*psf_list; psf; psf=psf_next) {
+       for (psf = *psf_list; psf; psf = psf_next) {
                __be32 *psrc;
 
                psf_next = psf->sf_next;
                        return skb;
                if (pmc->crcount || isquery) {
                        /* make sure we have room for group header */
-                       if (skb && AVAILABLE(skb)<sizeof(struct igmpv3_grec)) {
+                       if (skb && AVAILABLE(skb) < sizeof(struct igmpv3_grec)) {
                                igmpv3_sendpack(skb);
                                skb = NULL; /* add_grhead will get a new one */
                        }
        struct ip_sf_list *psf_prev, *psf_next, *psf;
 
        psf_prev = NULL;
-       for (psf=*ppsf; psf; psf = psf_next) {
+       for (psf = *ppsf; psf; psf = psf_next) {
                psf_next = psf->sf_next;
                if (psf->sf_crcount == 0) {
                        if (psf_prev)
 
        /* deleted MCA's */
        pmc_prev = NULL;
-       for (pmc=in_dev->mc_tomb; pmc; pmc=pmc_next) {
+       for (pmc = in_dev->mc_tomb; pmc; pmc = pmc_next) {
                pmc_next = pmc->next;
                if (pmc->sfmode == MCAST_INCLUDE) {
                        type = IGMPV3_BLOCK_OLD_SOURCES;
 
 static void igmp_timer_expire(unsigned long data)
 {
-       struct ip_mc_list *im=(struct ip_mc_list *)data;
+       struct ip_mc_list *im = (struct ip_mc_list *)data;
        struct in_device *in_dev = im->interface;
 
        spin_lock(&im->lock);
        int i, scount;
 
        scount = 0;
-       for (psf=pmc->sources; psf; psf=psf->sf_next) {
+       for (psf = pmc->sources; psf; psf = psf->sf_next) {
                if (scount == nsrcs)
                        break;
-               for (i=0; i<nsrcs; i++) {
+               for (i = 0; i < nsrcs; i++) {
                        /* skip inactive filters */
                        if (psf->sf_count[MCAST_INCLUDE] ||
                            pmc->sfcount[MCAST_EXCLUDE] !=
 
        /* mark INCLUDE-mode sources */
        scount = 0;
-       for (psf=pmc->sources; psf; psf=psf->sf_next) {
+       for (psf = pmc->sources; psf; psf = psf->sf_next) {
                if (scount == nsrcs)
                        break;
-               for (i=0; i<nsrcs; i++)
+               for (i = 0; i < nsrcs; i++)
                        if (srcs[i] == psf->sf_inaddr) {
                                psf->sf_gsresp = 1;
                                scount++;
                pmc->tomb = im->tomb;
                pmc->sources = im->sources;
                im->tomb = im->sources = NULL;
-               for (psf=pmc->sources; psf; psf=psf->sf_next)
+               for (psf = pmc->sources; psf; psf = psf->sf_next)
                        psf->sf_crcount = pmc->crcount;
        }
        spin_unlock_bh(&im->lock);
 
        spin_lock_bh(&in_dev->mc_tomb_lock);
        pmc_prev = NULL;
-       for (pmc=in_dev->mc_tomb; pmc; pmc=pmc->next) {
+       for (pmc = in_dev->mc_tomb; pmc; pmc = pmc->next) {
                if (pmc->multiaddr == multiaddr)
                        break;
                pmc_prev = pmc;
        }
        spin_unlock_bh(&in_dev->mc_tomb_lock);
        if (pmc) {
-               for (psf=pmc->tomb; psf; psf=psf_next) {
+               for (psf = pmc->tomb; psf; psf = psf_next) {
                        psf_next = psf->sf_next;
                        kfree(psf);
                }
                psf = pmc->tomb;
                pmc->tomb = NULL;
                spin_unlock_bh(&pmc->lock);
-               for (; psf; psf=psf_next) {
+               for (; psf; psf = psf_next) {
                        psf_next = psf->sf_next;
                        kfree(psf);
                }
        int rv = 0;
 
        psf_prev = NULL;
-       for (psf=pmc->sources; psf; psf=psf->sf_next) {
+       for (psf = pmc->sources; psf; psf = psf->sf_next) {
                if (psf->sf_inaddr == *psfsrc)
                        break;
                psf_prev = psf;
                pmc->sfcount[sfmode]--;
        }
        err = 0;
-       for (i=0; i<sfcount; i++) {
+       for (i = 0; i < sfcount; i++) {
                int rv = ip_mc_del1_src(pmc, sfmode, &psfsrc[i]);
 
                changerec |= rv > 0;
                pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
                        IGMP_Unsolicited_Report_Count;
                in_dev->mr_ifc_count = pmc->crcount;
-               for (psf=pmc->sources; psf; psf = psf->sf_next)
+               for (psf = pmc->sources; psf; psf = psf->sf_next)
                        psf->sf_crcount = 0;
                igmp_ifc_event(pmc->interface);
        } else if (sf_setstate(pmc) || changerec) {
        struct ip_sf_list *psf, *psf_prev;
 
        psf_prev = NULL;
-       for (psf=pmc->sources; psf; psf=psf->sf_next) {
+       for (psf = pmc->sources; psf; psf = psf->sf_next) {
                if (psf->sf_inaddr == *psfsrc)
                        break;
                psf_prev = psf;
        struct ip_sf_list *psf;
        int mca_xcount = pmc->sfcount[MCAST_EXCLUDE];
 
-       for (psf=pmc->sources; psf; psf=psf->sf_next)
+       for (psf = pmc->sources; psf; psf = psf->sf_next)
                if (pmc->sfcount[MCAST_EXCLUDE]) {
                        psf->sf_oldin = mca_xcount ==
                                psf->sf_count[MCAST_EXCLUDE] &&
        int new_in, rv;
 
        rv = 0;
-       for (psf=pmc->sources; psf; psf=psf->sf_next) {
+       for (psf = pmc->sources; psf; psf = psf->sf_next) {
                if (pmc->sfcount[MCAST_EXCLUDE]) {
                        new_in = mca_xcount == psf->sf_count[MCAST_EXCLUDE] &&
                                !psf->sf_count[MCAST_INCLUDE];
                        if (!psf->sf_oldin) {
                                struct ip_sf_list *prev = NULL;
 
-                               for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next) {
+                               for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next) {
                                        if (dpsf->sf_inaddr == psf->sf_inaddr)
                                                break;
                                        prev = dpsf;
                         * add or update "delete" records if an active filter
                         * is now inactive
                         */
-                       for (dpsf=pmc->tomb; dpsf; dpsf=dpsf->sf_next)
+                       for (dpsf = pmc->tomb; dpsf; dpsf = dpsf->sf_next)
                                if (dpsf->sf_inaddr == psf->sf_inaddr)
                                        break;
                        if (!dpsf) {
        if (!delta)
                pmc->sfcount[sfmode]++;
        err = 0;
-       for (i=0; i<sfcount; i++) {
+       for (i = 0; i < sfcount; i++) {
                err = ip_mc_add1_src(pmc, sfmode, &psfsrc[i]);
                if (err)
                        break;
 
                if (!delta)
                        pmc->sfcount[sfmode]--;
-               for (j=0; j<i; j++)
+               for (j = 0; j < i; j++)
                        (void) ip_mc_del1_src(pmc, sfmode, &psfsrc[j]);
        } else if (isexclude != (pmc->sfcount[MCAST_EXCLUDE] != 0)) {
 #ifdef CONFIG_IP_MULTICAST
                pmc->crcount = in_dev->mr_qrv ? in_dev->mr_qrv :
                        IGMP_Unsolicited_Report_Count;
                in_dev->mr_ifc_count = pmc->crcount;
-               for (psf=pmc->sources; psf; psf = psf->sf_next)
+               for (psf = pmc->sources; psf; psf = psf->sf_next)
                        psf->sf_crcount = 0;
                igmp_ifc_event(in_dev);
        } else if (sf_setstate(pmc)) {
 {
        struct ip_sf_list *psf, *nextpsf;
 
-       for (psf=pmc->tomb; psf; psf=nextpsf) {
+       for (psf = pmc->tomb; psf; psf = nextpsf) {
                nextpsf = psf->sf_next;
                kfree(psf);
        }
        pmc->tomb = NULL;
-       for (psf=pmc->sources; psf; psf=nextpsf) {
+       for (psf = pmc->sources; psf; psf = nextpsf) {
                nextpsf = psf->sf_next;
                kfree(psf);
        }
                if (!psl)
                        goto done;      /* err = -EADDRNOTAVAIL */
                rv = !0;
-               for (i=0; i<psl->sl_count; i++) {
+               for (i = 0; i < psl->sl_count; i++) {
                        rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
                                sizeof(__be32));
                        if (rv == 0)
                ip_mc_del_src(in_dev, &mreqs->imr_multiaddr, omode, 1,
                        &mreqs->imr_sourceaddr, 1);
 
-               for (j=i+1; j<psl->sl_count; j++)
+               for (j = i+1; j < psl->sl_count; j++)
                        psl->sl_addr[j-1] = psl->sl_addr[j];
                psl->sl_count--;
                err = 0;
                newpsl->sl_max = count;
                newpsl->sl_count = count - IP_SFBLOCK;
                if (psl) {
-                       for (i=0; i<psl->sl_count; i++)
+                       for (i = 0; i < psl->sl_count; i++)
                                newpsl->sl_addr[i] = psl->sl_addr[i];
                        /* decrease mem now to avoid the memleak warning */
                        atomic_sub(IP_SFLSIZE(psl->sl_max), &sk->sk_omem_alloc);
                psl = newpsl;
        }
        rv = 1; /* > 0 for insert logic below if sl_count is 0 */
-       for (i=0; i<psl->sl_count; i++) {
+       for (i = 0; i < psl->sl_count; i++) {
                rv = memcmp(&psl->sl_addr[i], &mreqs->imr_sourceaddr,
                        sizeof(__be32));
                if (rv == 0)
        }
        if (rv == 0)            /* address already there is an error */
                goto done;
-       for (j=psl->sl_count-1; j>=i; j--)
+       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++;
            copy_to_user(optval, gsf, GROUP_FILTER_SIZE(0))) {
                return -EFAULT;
        }
-       for (i=0; i<copycount; i++) {
+       for (i = 0; i < copycount; i++) {
                struct sockaddr_storage ss;
 
                psin = (struct sockaddr_in *)&ss;
        if (!psl)
                goto unlock;
 
-       for (i=0; i<psl->sl_count; i++) {
+       for (i = 0; i < psl->sl_count; i++) {
                if (psl->sl_addr[i] == rmt_addr)
                        break;
        }
                rv = 1;
        } else if (im) {
                if (src_addr) {
-                       for (psf=im->sources; psf; psf=psf->sf_next) {
+                       for (psf = im->sources; psf; psf = psf->sf_next) {
                                if (psf->sf_inaddr == src_addr)
                                        break;
                        }