Struct ether accesses netif anonymously
authorBarret Rhoden <brho@cs.berkeley.edu>
Thu, 5 Feb 2015 20:06:20 +0000 (15:06 -0500)
committerBarret Rhoden <brho@cs.berkeley.edu>
Sun, 1 Mar 2015 14:36:16 +0000 (09:36 -0500)
To fix any out-of-tree drivers, apply the spatch remove_netif.cocci.

After spatching, I modified ip.h manually.

kern/drivers/dev/ether.c
kern/drivers/net/ether8139.c
kern/drivers/net/ether8169.c
kern/drivers/net/ether82563.c
kern/drivers/net/etherigbe.c
kern/include/ip.h
kern/src/net/netif.c
scripts/spatch/remove_netif.cocci [new file with mode: 0644]

index b7641c1..9da3f38 100644 (file)
@@ -97,7 +97,7 @@ static struct walkqid *etherwalk(struct chan *chan, struct chan *nchan,
                runlock(&ether->rwlock);
                nexterror();
        }
-       wq = netifwalk(&ether->netif, chan, nchan, name, nname);
+       wq = netifwalk(ether, chan, nchan, name, nname);
        if (wq && wq->clone != NULL && wq->clone != chan)
                wq->clone->aux = ether;
        poperror();
@@ -117,7 +117,7 @@ static int etherstat(struct chan *chan, uint8_t * dp, int n)
                runlock(&ether->rwlock);
                nexterror();
        }
-       s = netifstat(&ether->netif, chan, dp, n);
+       s = netifstat(ether, chan, dp, n);
        poperror();
        runlock(&ether->rwlock);
        return s;
@@ -135,7 +135,7 @@ static struct chan *etheropen(struct chan *chan, int omode)
                runlock(&ether->rwlock);
                nexterror();
        }
-       c = netifopen(&ether->netif, chan, omode);
+       c = netifopen(ether, chan, omode);
        poperror();
        runlock(&ether->rwlock);
        return c;
@@ -152,7 +152,7 @@ static void etherclose(struct chan *chan)
                runlock(&ether->rwlock);
                nexterror();
        }
-       netifclose(&ether->netif, chan);
+       netifclose(ether, chan);
        poperror();
        runlock(&ether->rwlock);
 }
@@ -182,7 +182,7 @@ static long etherread(struct chan *chan, void *buf, long n, int64_t off)
                if (NETTYPE(chan->qid.path) == Nstatqid)
                        ether->ifstat(ether, buf, 0, offset);
        }
-       r = netifread(&ether->netif, chan, buf, n, offset);
+       r = netifread(ether, chan, buf, n, offset);
 out:
        poperror();
        runlock(&ether->rwlock);
@@ -201,7 +201,7 @@ static struct block *etherbread(struct chan *chan, long n, uint32_t offset)
                runlock(&ether->rwlock);
                nexterror();
        }
-       b = netifbread(&ether->netif, chan, n, offset);
+       b = netifbread(ether, chan, n, offset);
        poperror();
        runlock(&ether->rwlock);
        return b;
@@ -219,7 +219,7 @@ static int etherwstat(struct chan *chan, uint8_t * dp, int n)
                runlock(&ether->rwlock);
                nexterror();
        }
-       r = netifwstat(&ether->netif, chan, dp, n);
+       r = netifwstat(ether, chan, dp, n);
        poperror();
        runlock(&ether->rwlock);
        return r;
@@ -277,7 +277,7 @@ struct block *etheriq(struct ether *ether, struct block *bp, int fromwire)
        struct block *xbp;
        struct ether *vlan;
 
-       ether->netif.inpackets++;
+       ether->inpackets++;
 
        pkt = (struct etherpkt *)bp->rp;
        len = BLEN(bp);
@@ -298,13 +298,13 @@ struct block *etheriq(struct ether *ether, struct block *bp, int fromwire)
        }
 
        fx = 0;
-       ep = &ether->netif.f[Ntypes];
+       ep = &ether->f[Ntypes];
 
        multi = pkt->d[0] & 1;
        /* check for valid multcast addresses */
-       if (multi && eaddrcmp(pkt->d, ether->netif.bcast) != 0
-               && ether->netif.prom == 0) {
-               if (!activemulti(&ether->netif, pkt->d, sizeof(pkt->d))) {
+       if (multi && eaddrcmp(pkt->d, ether->bcast) != 0
+               && ether->prom == 0) {
+               if (!activemulti(ether, pkt->d, sizeof(pkt->d))) {
                        if (fromwire) {
                                freeb(bp);
                                bp = 0;
@@ -323,7 +323,7 @@ struct block *etheriq(struct ether *ether, struct block *bp, int fromwire)
         * attempt to simply pass it into one of the connections, thereby
         * saving a copy of the data (usual case hopefully).
         */
-       for (fp = ether->netif.f; fp < ep; fp++) {
+       for (fp = ether->f; fp < ep; fp++) {
                if ((f = *fp) && (f->type == type || f->type < 0))
                        if (tome || multi || f->prom) {
                                /* Don't want to hear bridged packets */
@@ -336,9 +336,9 @@ struct block *etheriq(struct ether *ether, struct block *bp, int fromwire)
                                                memmove(xbp->wp, pkt, len);
                                                xbp->wp += len;
                                                if (qpass(f->in, xbp) < 0)
-                                                       ether->netif.soverflows++;
+                                                       ether->soverflows++;
                                        } else
-                                               ether->netif.soverflows++;
+                                               ether->soverflows++;
                                } else
                                        etherrtrace(f, pkt, len);
                        }
@@ -346,7 +346,7 @@ struct block *etheriq(struct ether *ether, struct block *bp, int fromwire)
 
        if (fx) {
                if (qpass(fx->in, bp) < 0)
-                       ether->netif.soverflows++;
+                       ether->soverflows++;
                return 0;
        }
        if (fromwire) {
@@ -363,11 +363,11 @@ static int etheroq(struct ether *ether, struct block *bp)
        struct etherpkt *pkt;
        int8_t irq_state = 0;
 
-       ether->netif.outpackets++;
+       ether->outpackets++;
 
-       if (!(ether->netif.feat & NETF_SG))
+       if (!(ether->feat & NETF_SG))
                bp = linearizeblock(bp);
-       ptclcsum_finalize(bp, ether->netif.feat);
+       ptclcsum_finalize(bp, ether->feat);
        /*
         * Check if the packet has to be placed back onto the input queue,
         * i.e. if it's a loopback or broadcast packet or the interface is
@@ -380,8 +380,8 @@ static int etheroq(struct ether *ether, struct block *bp)
        pkt = (struct etherpkt *)bp->rp;
        len = BLEN(bp);
        loopback = eaddrcmp(pkt->d, ether->ea) == 0;
-       if (loopback || eaddrcmp(pkt->d, ether->netif.bcast) == 0
-               || ether->netif.prom) {
+       if (loopback || eaddrcmp(pkt->d, ether->bcast) == 0
+               || ether->prom) {
                disable_irqsave(&irq_state);
                etheriq(ether, bp, 0);
                enable_irqsave(&irq_state);
@@ -397,7 +397,7 @@ static int etheroq(struct ether *ether, struct block *bp)
                        ether = ether->ctlr;
                }
 
-               if ((ether->netif.feat & NETF_PADMIN) == 0 && BLEN(bp) < ether->minmtu)
+               if ((ether->feat & NETF_PADMIN) == 0 && BLEN(bp) < ether->minmtu)
                        bp = adjustblock(bp, ether->minmtu);
 
                qbwrite(ether->oq, bp);
@@ -425,7 +425,7 @@ static long etherwrite(struct chan *chan, void *buf, long n, int64_t unused)
                nexterror();
        }
        if (NETTYPE(chan->qid.path) != Ndataqid) {
-               l = netifwrite(&ether->netif, chan, buf, n);
+               l = netifwrite(ether, chan, buf, n);
                if (l >= 0)
                        goto out;
                cb = parsecmd(buf, n);
@@ -515,7 +515,7 @@ static long vlanctl(struct ether *ether, void *buf, long n)
                && strcmp(cb->f[0], "ea") == 0 && parseether(ea, cb->f[1]) == 0) {
                kfree(cb);
                memmove(ether->ea, ea, Eaddrlen);
-               memmove(ether->netif.addr, ether->ea, Eaddrlen);
+               memmove(ether->addr, ether->ea, Eaddrlen);
                return 0;
        }
        if (cb->nf == 1 && strcmp(cb->f[0], "disable") == 0) {
@@ -569,28 +569,28 @@ static struct ether *vlanalloc(struct ether *ether, int id)
                        error(Enovmem);
                rwinit(&vlan->rwlock);
                qlock_init(&vlan->vlq);
-               netifinit(&vlan->netif, name, Ntypes, ether->netif.limit);
+               netifinit(vlan, name, Ntypes, ether->limit);
                ether->vlans[fid] = vlan;       /* id is still zero, can't be matched */
                ether->nvlan++;
        } else
-               memmove(vlan->netif.name, name, KNAMELEN - 1);
+               memmove(vlan->name, name, KNAMELEN - 1);
        vlan->attach = nop;
        vlan->transmit = NULL;
        vlan->ctl = vlanctl;
        vlan->irq = -1;
-       vlan->netif.promiscuous = ether->netif.promiscuous;
-       vlan->netif.multicast = ether->netif.multicast;
-       vlan->netif.arg = vlan;
-       vlan->netif.mbps = ether->netif.mbps;
+       vlan->promiscuous = ether->promiscuous;
+       vlan->multicast = ether->multicast;
+       vlan->arg = vlan;
+       vlan->mbps = ether->mbps;
        vlan->fullduplex = ether->fullduplex;
        vlan->encry = ether->encry;
        vlan->minmtu = ether->minmtu;
        vlan->maxmtu = ether->maxmtu;
        vlan->ctlrno = ether->ctlrno;
        vlan->vlanid = id;
-       vlan->netif.alen = Eaddrlen;
-       memmove(vlan->netif.addr, ether->netif.addr, sizeof(vlan->netif.addr));
-       memmove(vlan->netif.bcast, ether->netif.bcast, sizeof(ether->netif.bcast));
+       vlan->alen = Eaddrlen;
+       memmove(vlan->addr, ether->addr, sizeof(vlan->addr));
+       memmove(vlan->bcast, ether->bcast, sizeof(ether->bcast));
        vlan->oq = NULL;
        vlan->ctlr = ether;
        vlan->vlanid = id;
@@ -650,7 +650,7 @@ static void etherreset(void)
                rwinit(&ether->rwlock);
                qlock_init(&ether->vlq);
                ether->ctlrno = ctlrno;
-               ether->netif.mbps = 10;
+               ether->mbps = 10;
                ether->minmtu = ETHERMINTU;
                ether->maxmtu = ETHERMAXTU;
                /* looked like irq type, we don't have these yet */
@@ -687,7 +687,8 @@ static void etherreset(void)
 
                        i = snprintf(buf, sizeof(buf),
                                                 "#l%d: %s: %dMbps port 0x%x irq %u", ctlrno,
-                                                ether->type, ether->netif.mbps, ether->port,
+                                                ether->type, ether->mbps,
+                                    ether->port,
                                                 ether->irq);
                        /* Looks like this is for printing MMIO addrs */
 #if 0
@@ -705,7 +706,7 @@ static void etherreset(void)
                        snprintf(buf + i, sizeof(buf) - i, "\n");
                        printk(buf);
 
-                       switch (ether->netif.mbps) {
+                       switch (ether->mbps) {
 
                        case 1 ... 99:
                                qsize = 64 * 1024;
@@ -719,14 +720,14 @@ static void etherreset(void)
                        default:
                                qsize = 8 * 1024 * 1024;
                        }
-                       netifinit(&ether->netif, name, Ntypes, qsize);
+                       netifinit(ether, name, Ntypes, qsize);
                        if (ether->oq == 0)
                                ether->oq = qopen(qsize, Qmsg, 0, 0);
                        if (ether->oq == 0)
                                panic("etherreset %s", name);
-                       ether->netif.alen = Eaddrlen;
-                       memmove(ether->netif.addr, ether->ea, Eaddrlen);
-                       memset(ether->netif.bcast, 0xFF, Eaddrlen);
+                       ether->alen = Eaddrlen;
+                       memmove(ether->addr, ether->ea, Eaddrlen);
+                       memset(ether->bcast, 0xFF, Eaddrlen);
 
                        etherxx[ctlrno] = ether;
                        ether = 0;
index 47cab68..a8ec807 100644 (file)
@@ -480,11 +480,11 @@ static void rtl8139receive(struct ether *edev)
                status = (*(p + 1) << 8) | *p;
                if (!(status & Rcok)) {
                        if (status & (Ise | Fae))
-                               edev->netif.frames++;
+                               edev->frames++;
                        if (status & Crc)
-                               edev->netif.crcs++;
+                               edev->crcs++;
                        if (status & (Runt | Long))
-                               edev->netif.buffs++;
+                               edev->buffs++;
 
                        /*
                         * Reset the receiver.
@@ -565,7 +565,7 @@ static void rtl8139interrupt(struct hw_trapframe *tf, void *arg)
                                                if (ctlr->etxth < ETHERMAXTU / 32)
                                                        ctlr->etxth++;
                                        }
-                                       edev->netif.oerrs++;
+                                       edev->oerrs++;
                                }
 
                                if (td->bp != NULL) {
@@ -587,11 +587,11 @@ static void rtl8139interrupt(struct hw_trapframe *tf, void *arg)
                         */
                        msr = csr8r(ctlr, Msr);
                        if (!(msr & Linkb)) {
-                               if (!(msr & Speed10) && edev->netif.mbps != 100) {
-                                       edev->netif.mbps = 100;
+                               if (!(msr & Speed10) && edev->mbps != 100) {
+                                       edev->mbps = 100;
                                        qsetlimit(edev->oq, 256 * 1024);
-                               } else if ((msr & Speed10) && edev->netif.mbps != 10) {
-                                       edev->netif.mbps = 10;
+                               } else if ((msr & Speed10) && edev->mbps != 10) {
+                                       edev->mbps = 10;
                                        qsetlimit(edev->oq, 65 * 1024);
                                }
                        }
@@ -755,14 +755,14 @@ static int rtl8139pnp(struct ether *edev)
        edev->transmit = rtl8139transmit;
        edev->ifstat = rtl8139ifstat;
 
-       edev->netif.arg = edev;
-       edev->netif.promiscuous = rtl8139promiscuous;
+       edev->arg = edev;
+       edev->promiscuous = rtl8139promiscuous;
 
        /*
         * This should be much more dynamic but will do for now.
         */
        if ((csr8r(ctlr, Msr) & (Speed10 | Linkb)) == 0)
-               edev->netif.mbps = 100;
+               edev->mbps = 100;
 
        register_irq(edev->irq, rtl8139interrupt, edev, edev->tbdf);
        return 0;
index bfc790e..3942a17 100644 (file)
@@ -516,11 +516,11 @@ rtl8169ifstat(struct ether* edev, void* a, long n, uint32_t offset)
                error(Eio);
        dtcc = ctlr->dtcc;
 
-       edev->netif.oerrs = dtcc->txer;
-       edev->netif.crcs = dtcc->rxer;
-       edev->netif.frames = dtcc->fae;
-       edev->netif.buffs = dtcc->misspkt;
-       edev->netif.overflows = ctlr->txdu+ctlr->rdu;
+       edev->oerrs = dtcc->txer;
+       edev->crcs = dtcc->rxer;
+       edev->frames = dtcc->fae;
+       edev->buffs = dtcc->misspkt;
+       edev->overflows = ctlr->txdu+ctlr->rdu;
 
        if(n == 0){
                qunlock(&ctlr->slock);
@@ -857,7 +857,8 @@ rtl8169attach(struct ether* edev)
        }
        phy = ctlr->mii->curphy;
        printd("%s: speed %d fd %d link %d rfc %d tfc %d\n",
-               edev->netif.name, phy->speed, phy->fd, phy->link, phy->rfc, phy->tfc);
+               edev->name, phy->speed, phy->fd, phy->link, phy->rfc,
+              phy->tfc);
 }
 
 static void
@@ -880,24 +881,24 @@ rtl8169link(struct ether* edev)
        if(miistatus(ctlr->mii) < 0){
                // TODO : no name here
                printk("%slink n: speed %d fd %d link %d rfc %d tfc %d\n",
-                       edev->netif.name, phy->speed, phy->fd, phy->link,
+                       edev->name, phy->speed, phy->fd, phy->link,
                        phy->rfc, phy->tfc);
-               edev->netif.link = 0;
+               edev->link = 0;
                return;
        }
-       edev->netif.link = 1;
+       edev->link = 1;
 
        limit = 256*1024;
        if(phy->speed == 10){
-               edev->netif.mbps = 10;
+               edev->mbps = 10;
                limit = 65*1024;
        }
        else if(phy->speed == 100)
-               edev->netif.mbps = 100;
+               edev->mbps = 100;
        else if(phy->speed == 1000)
-               edev->netif.mbps = 1000;
+               edev->mbps = 1000;
        printk("%slink y: speed %d fd %d link %d rfc %d tfc %d\n",
-               edev->netif.name, phy->speed, phy->fd, phy->link,
+               edev->name, phy->speed, phy->fd, phy->link,
                phy->rfc, phy->tfc);
 
        if(edev->oq != NULL)
@@ -1198,7 +1199,7 @@ rtl8169pnp(struct ether* edev)
        edev->ctlr = ctlr;
        edev->port = ctlr->port;
        edev->irq = ctlr->pci->irqline;
-       edev->netif.mbps = 100;
+       edev->mbps = 100;
 
        /*
         * Check if the adapter's station address is to be overridden.
@@ -1221,9 +1222,9 @@ rtl8169pnp(struct ether* edev)
        edev->transmit = rtl8169transmit;
        edev->ifstat = rtl8169ifstat;
 
-       edev->netif.arg = edev;
-       edev->netif.promiscuous = rtl8169promiscuous;
-       edev->netif.multicast = rtl8169multicast;
+       edev->arg = edev;
+       edev->promiscuous = rtl8169promiscuous;
+       edev->multicast = rtl8169multicast;
 //     edev->netif.shutdown = rtl8169shutdown;
 
        rtl8169link(edev);
index 47283ea..93a65e2 100644 (file)
@@ -1184,7 +1184,7 @@ phywrite(struct ctlr *c, unsigned int phyno, unsigned int reg, uint16_t v)
 
 static void phyerrata(struct ether *e, struct ctlr *c, unsigned int phyno)
 {
-       if (e->netif.mbps == 0) {
+       if (e->mbps == 0) {
                if (c->phyerrata == 0) {
                        c->phyerrata++;
                        phywrite(c, phyno, Phyprst, Prst);      /* try a port reset */
@@ -1219,11 +1219,11 @@ static void phyl79proc(void *v)
                        phywrite(c, phyno, Phyctl, r | Ran | Ean);
                }
 next:
-               e->netif.link = i != 3 && (phy & Link) != 0;
-               if (e->netif.link == 0)
+               e->link = i != 3 && (phy & Link) != 0;
+               if (e->link == 0)
                        i = 3;
                c->speeds[i]++;
-               e->netif.mbps = speedtab[i];
+               e->mbps = speedtab[i];
                c->lim = 0;
                i82563im(c, Lsc);
                c->lsleep++;
@@ -1273,11 +1273,11 @@ static void phylproc(void *v)
                if (a)
                        phywrite(c, phyno, Phyctl, phyread(c, phyno, Phyctl) | Ran | Ean);
 next:
-               e->netif.link = (phy & Rtlink) != 0;
-               if (e->netif.link == 0)
+               e->link = (phy & Rtlink) != 0;
+               if (e->link == 0)
                        i = 3;
                c->speeds[i]++;
-               e->netif.mbps = speedtab[i];
+               e->mbps = speedtab[i];
                if (c->type == i82563)
                        phyerrata(e, c, phyno);
                c->lim = 0;
@@ -1300,14 +1300,14 @@ static void pcslproc(void *v)
                csr32w(c, Connsw, Enrgirq);
        for (;;) {
                phy = csr32r(c, Pcsstat);
-               e->netif.link = phy & Linkok;
+               e->link = phy & Linkok;
                i = 3;
-               if (e->netif.link)
+               if (e->link)
                        i = (phy & 6) >> 1;
                else if (phy & Anbad)
                        csr32w(c, Pcsctl, csr32r(c, Pcsctl) | Pan | Prestart);
                c->speeds[i]++;
-               e->netif.mbps = speedtab[i];
+               e->mbps = speedtab[i];
                c->lim = 0;
                i82563im(c, Lsc | Omed);
                c->lsleep++;
@@ -1327,13 +1327,13 @@ static void serdeslproc(void *v)
        for (;;) {
                rx = csr32r(c, Rxcw);
                tx = csr32r(c, Txcw);
-               e->netif.link = (rx & 1 << 31) != 0;
+               e->link = (rx & 1 << 31) != 0;
 //      e->netif.link = (csr32r(c, Status) & Lu) != 0;
                i = 3;
-               if (e->netif.link)
+               if (e->link)
                        i = 2;
                c->speeds[i]++;
-               e->netif.mbps = speedtab[i];
+               e->mbps = speedtab[i];
                c->lim = 0;
                i82563im(c, Lsc);
                c->lsleep++;
@@ -1923,7 +1923,7 @@ static int pnp(struct ether *edev, int type)
        edev->port = ctlr->mmio_paddr;
        edev->irq = ctlr->pcidev->irqline;
        edev->tbdf = pci_to_tbdf(ctlr->pcidev);
-       edev->netif.mbps = 1000;
+       edev->mbps = 1000;
        edev->maxmtu = ctlr->rbsz;
        memmove(edev->ea, ctlr->ra, Eaddrlen);
 
@@ -1934,10 +1934,10 @@ static int pnp(struct ether *edev, int type)
        edev->ifstat = i82563ifstat;
        edev->ctl = i82563ctl;
 
-       edev->netif.arg = edev;
-       edev->netif.promiscuous = i82563promiscuous;
+       edev->arg = edev;
+       edev->promiscuous = i82563promiscuous;
        edev->shutdown = i82563shutdown;
-       edev->netif.multicast = i82563multicast;
+       edev->multicast = i82563multicast;
 
        register_irq(edev->irq, i82563interrupt, edev, edev->tbdf);
        return 0;
index 4841321..ef111aa 100644 (file)
@@ -2054,7 +2054,7 @@ igbepnp(struct ether* edev)
        edev->port = ctlr->port;
        edev->irq = ctlr->pci->irqline;
        edev->tbdf = pci_to_tbdf(ctlr->pci);
-       edev->netif.mbps = 1000;
+       edev->mbps = 1000;
        memmove(edev->ea, ctlr->ra, Eaddrlen);
 
        /*
@@ -2066,9 +2066,9 @@ igbepnp(struct ether* edev)
        edev->ctl = igbectl;
        edev->shutdown = igbeshutdown;
 
-       edev->netif.arg = edev;
-       edev->netif.promiscuous = igbepromiscuous;
-       edev->netif.multicast = igbemulticast;
+       edev->arg = edev;
+       edev->promiscuous = igbepromiscuous;
+       edev->multicast = igbemulticast;
 
        register_irq(edev->irq, igbeinterrupt, edev, edev->tbdf);
        return 0;
index 178097c..ea40e01 100644 (file)
@@ -945,6 +945,7 @@ enum {
 /*
  *  a network interface
  */
+struct ether;
 struct netif {
        qlock_t qlock;
 
@@ -986,17 +987,18 @@ struct netif {
        void (*scanbs) (void *, unsigned nt);   /* scan for base stations */
 };
 
-void netifinit(struct netif *, char *, int, uint32_t);
-struct walkqid *netifwalk(struct netif *, struct chan *, struct chan *, char **,
+void netifinit(struct ether *, char *, int, uint32_t);
+struct walkqid *netifwalk(struct ether *, struct chan *, struct chan *,
+                         char **,
                                                  int);
-struct chan *netifopen(struct netif *, struct chan *, int);
-void netifclose(struct netif *, struct chan *);
-long netifread(struct netif *, struct chan *, void *, long, uint32_t);
-struct block *netifbread(struct netif *, struct chan *, long, uint32_t);
-long netifwrite(struct netif *, struct chan *, void *, long);
-int netifwstat(struct netif *, struct chan *, uint8_t *, int);
-int netifstat(struct netif *, struct chan *, uint8_t *, int);
-int activemulti(struct netif *, uint8_t *, int);
+struct chan *netifopen(struct ether *, struct chan *, int);
+void netifclose(struct ether *, struct chan *);
+long netifread(struct ether *, struct chan *, void *, long, uint32_t);
+struct block *netifbread(struct ether *, struct chan *, long, uint32_t);
+long netifwrite(struct ether *, struct chan *, void *, long);
+int netifwstat(struct ether *, struct chan *, uint8_t *, int);
+int netifstat(struct ether *, struct chan *, uint8_t *, int);
+int activemulti(struct ether *, uint8_t *, int);
 
 /*
  *  Ethernet specific
@@ -1052,8 +1054,7 @@ struct ether {
        int nvlan;
        struct ether *vlans[MaxFID];
 
-       /* another case where we wish we had anon struct members. */
-       struct netif netif;
+       struct netif;
 };
 
 extern struct block *etheriq(struct ether *, struct block *, int);
index 90f7ce0..ac753bd 100644 (file)
 #include <ip.h>
 
 static int netown(struct netfile *, char *unused_char_p_t, int);
-static int openfile(struct netif *, int);
+static int openfile(struct ether *, int);
 static char *matchtoken(char *unused_char_p_t, char *);
-static char *netmulti(struct netif *, struct netfile *,
+static char *netmulti(struct ether *, struct netfile *,
                                          uint8_t * unused_uint8_p_t, int);
 static int parseaddr(uint8_t * unused_uint8_p_t, char *unused_char_p_t, int);
 
 /*
  *  set up a new network interface
  */
-void netifinit(struct netif *nif, char *name, int nfile, uint32_t limit)
+void netifinit(struct ether *nif, char *name, int nfile, uint32_t limit)
 {
        qlock_init(&nif->qlock);
        strncpy(nif->name, name, KNAMELEN - 1);
@@ -45,7 +45,7 @@ netifgen(struct chan *c, char *unused_char_p_t, struct dirtab *vp,
                 int unused_int, int i, struct dir *dp)
 {
        struct qid q;
-       struct netif *nif = (struct netif *)vp;
+       struct ether *nif = (struct ether *)vp;
        struct netfile *f;
        int perm;
        char *o;
@@ -190,13 +190,13 @@ netifgen(struct chan *c, char *unused_char_p_t, struct dirtab *vp,
        return 1;
 }
 
-struct walkqid *netifwalk(struct netif *nif, struct chan *c, struct chan *nc,
+struct walkqid *netifwalk(struct ether *nif, struct chan *c, struct chan *nc,
                                                  char **name, int nname)
 {
        return devwalk(c, nc, name, nname, (struct dirtab *)nif, 0, netifgen);
 }
 
-struct chan *netifopen(struct netif *nif, struct chan *c, int omode)
+struct chan *netifopen(struct ether *nif, struct chan *c, int omode)
 {
        int id;
        struct netfile *f;
@@ -237,7 +237,8 @@ struct chan *netifopen(struct netif *nif, struct chan *c, int omode)
 }
 
 long
-netifread(struct netif *nif, struct chan *c, void *a, long n, uint32_t offset)
+netifread(struct ether *nif, struct chan *c, void *a, long n,
+         uint32_t offset)
 {
        int i, j;
        struct netfile *f;
@@ -313,7 +314,7 @@ netifread(struct netif *nif, struct chan *c, void *a, long n, uint32_t offset)
        return -1;      /* not reached */
 }
 
-struct block *netifbread(struct netif *nif, struct chan *c, long n,
+struct block *netifbread(struct ether *nif, struct chan *c, long n,
                                                 uint32_t offset)
 {
        if ((c->qid.type & QTDIR) || NETTYPE(c->qid.path) != Ndataqid)
@@ -325,7 +326,7 @@ struct block *netifbread(struct netif *nif, struct chan *c, long n,
 /*
  *  make sure this type isn't already in use on this device
  */
-static int typeinuse(struct netif *nif, int type)
+static int typeinuse(struct ether *nif, int type)
 {
        struct netfile *f, **fp, **efp;
 
@@ -346,7 +347,7 @@ static int typeinuse(struct netif *nif, int type)
 /*
  *  the devxxx.c that calls us handles writing data, it knows best
  */
-long netifwrite(struct netif *nif, struct chan *c, void *a, long n)
+long netifwrite(struct ether *nif, struct chan *c, void *a, long n)
 {
        ERRSTACK(1);
        struct netfile *f;
@@ -417,7 +418,7 @@ long netifwrite(struct netif *nif, struct chan *c, void *a, long n)
        return n;
 }
 
-int netifwstat(struct netif *nif, struct chan *c, uint8_t * db, int n)
+int netifwstat(struct ether *nif, struct chan *c, uint8_t * db, int n)
 {
        struct dir *dir;
        struct netfile *f;
@@ -446,12 +447,12 @@ int netifwstat(struct netif *nif, struct chan *c, uint8_t * db, int n)
        return m;
 }
 
-int netifstat(struct netif *nif, struct chan *c, uint8_t * db, int n)
+int netifstat(struct ether *nif, struct chan *c, uint8_t * db, int n)
 {
        return devstat(c, db, n, (struct dirtab *)nif, 0, netifgen);
 }
 
-void netifclose(struct netif *nif, struct chan *c)
+void netifclose(struct ether *nif, struct chan *c)
 {
        struct netfile *f;
        int t;
@@ -542,7 +543,7 @@ static int netown(struct netfile *p, char *o, int omode)
  *  Increment the reference count of a network device.
  *  If id < 0, return an unused ether device.
  */
-static int openfile(struct netif *nif, int id)
+static int openfile(struct ether *nif, int id)
 {
        ERRSTACK(1);
        struct netfile *f, **fp, **efp;
@@ -628,7 +629,7 @@ static uint32_t hash(uint8_t * a, int len)
        return sum % Nmhash;
 }
 
-int activemulti(struct netif *nif, uint8_t * addr, int alen)
+int activemulti(struct ether *nif, uint8_t * addr, int alen)
 {
        struct netaddr *hp;
 
@@ -667,7 +668,7 @@ static int parseaddr(uint8_t * to, char *from, int alen)
 /*
  *  keep track of multicast addresses
  */
-static char *netmulti(struct netif *nif, struct netfile *f, uint8_t * addr,
+static char *netmulti(struct ether *nif, struct netfile *f, uint8_t * addr,
                                          int add)
 {
        struct netaddr **l, *ap;
diff --git a/scripts/spatch/remove_netif.cocci b/scripts/spatch/remove_netif.cocci
new file mode 100644 (file)
index 0000000..c1960b7
--- /dev/null
@@ -0,0 +1,26 @@
+// struct ether->netif.whatever -> ether->whatever
+@@
+identifier E;
+identifier A;
+@@
+-E->netif.A
++E->A
+
+@@
+identifier E;
+identifier A;
+@@
+-E.netif.A
++E.A
+
+@@
+identifier E;
+@@
+-&E->netif
++E
+
+@@
+@@
+struct
+-netif
++ether