Make all block allocations use the same func [2/2]
authorBarret Rhoden <brho@cs.berkeley.edu>
Fri, 25 Mar 2016 16:45:25 +0000 (12:45 -0400)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 31 Mar 2016 20:53:42 +0000 (16:53 -0400)
Other than ns.h and allocb.c, this was done with
scripts/spatch/malloc.cocci.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
20 files changed:
kern/drivers/dev/ether.c
kern/drivers/dev/mnt.c
kern/drivers/net/bnx2x/bnx2x_cmn.c
kern/drivers/net/bnx2x/bnx2x_dev.c
kern/drivers/net/ether8139.c
kern/drivers/net/ether8169.c
kern/drivers/net/ether82563.c
kern/drivers/net/etherigbe.c
kern/drivers/net/mlx4/en_rx.c
kern/include/ns.h
kern/src/net/ethermedium.c
kern/src/net/icmp.c
kern/src/net/icmp6.c
kern/src/net/ipv6.c
kern/src/net/tcp.c
kern/src/ns/allocb.c
kern/src/ns/dev.c
kern/src/ns/qio.c
kern/src/profiler.c
scripts/spatch/malloc.cocci

index 2bd885c..4f8e7b7 100644 (file)
@@ -270,7 +270,7 @@ static void etherrtrace(struct netfile *f, struct etherpkt *pkt, int len)
                n = 58;
        else
                n = len;
-       bp = iallocb(68);
+       bp = block_alloc(68, MEM_ATOMIC);
        if (bp == NULL)
                return;
        memmove(bp->wp, pkt->d, n);
@@ -371,7 +371,7 @@ struct block *etheriq(struct ether *ether, struct block *bp, int fromwire)
                                        fx = f;
                                        continue;
                                }
-                               xbp = iallocb(len);
+                               xbp = block_alloc(len, MEM_ATOMIC);
                                if (xbp == 0) {
                                        ether->soverflows++;
                                        continue;
@@ -492,7 +492,7 @@ static long etherwrite(struct chan *chan, void *buf, long n, int64_t unused)
 
        if (n > ether->maxmtu + ETHERHDRSIZE)
                error(E2BIG, ERROR_FIXME);
-       bp = allocb(n);
+       bp = block_alloc(n, MEM_WAIT);
        if (waserror()) {
                freeb(bp);
                nexterror();
index c0628de..b9036cc 100644 (file)
@@ -984,7 +984,7 @@ int mntrpcread(struct mnt *m, struct mntrpc *r)
                        l = &(b->next);
                } else {
                        /* split block and put unused bit back */
-                       nb = allocb(i - len);
+                       nb = block_alloc(i - len, MEM_WAIT);
                        memmove(nb->wp, b->rp + len, i - len);
                        b->wp = b->rp + len;
                        nb->wp += i - len;
index 8fbd2cd..6b67b18 100644 (file)
@@ -1004,7 +1004,7 @@ static int bnx2x_rx_int(struct bnx2x_fastpath *fp, int budget)
                if (1) {
 //             if ((bp->dev->maxmtu > ETH_MAX_PACKET_SIZE) &&
 //                 (len <= RX_COPY_THRESH)) {
-                       block = iallocb(len);
+                       block = block_alloc(len, MEM_ATOMIC);
                        if (block == NULL) {
                                DP(NETIF_MSG_RX_ERR | NETIF_MSG_RX_STATUS,
                                   "ERROR  packet dropped because of alloc failure\n");
index f7c0be4..b86b582 100644 (file)
@@ -229,7 +229,8 @@ static void bnx2x_replenish(struct bnx2x *ctlr)
        //while (NEXT_RING(rdt, ctlr->nrd) != ctlr->rdh) {
                //if we want a new block
                {
-                       bp = iallocb(64); // TODO: use your block size, e.g. Rbsz
+                       // TODO: use your block size, e.g. Rbsz
+                       bp = block_alloc(64, MEM_ATOMIC);
                        if (bp == NULL) {
                                /* needs to be a safe print for interrupt level */
                                printk("#l%d bnx2x_replenish: no available buffers\n",
index 1d75d95..c6ddb26 100644 (file)
@@ -539,7 +539,7 @@ static void rtl8139receive(struct ether *edev)
                p = ctlr->rbstart + capr;
                capr = (capr + length) % ctlr->rblen;
 
-               if ((bp = iallocb(length)) != NULL) {
+               if ((bp = block_alloc(length, MEM_ATOMIC)) != NULL) {
                        if (p + length >= ctlr->rbstart + ctlr->rblen) {
                                l = ctlr->rbstart + ctlr->rblen - p;
                                memmove(bp->wp, p, l);
index 828e0ef..7efc181 100644 (file)
@@ -619,7 +619,7 @@ rtl8169replenish(struct ctlr* ctlr)
                         * Simple allocation for now.
                         * This better be aligned on 8.
                         */
-                       bp = iallocb(Mps);
+                       bp = block_alloc(Mps, MEM_ATOMIC);
                        if(bp == NULL){
                                printk("no available buffers\n");
                                break;
index 822151a..36de4d2 100644 (file)
@@ -1121,7 +1121,7 @@ static void i82563replenish(struct ctlr *ctlr)
                        printd("#l%d: 82563: rx overrun\n", ctlr->edev->ctlrno);
                        break;
                }
-               bp = iallocb(ctlr->rbsz + Slop + Rbalign);
+               bp = block_alloc(ctlr->rbsz + Slop + Rbalign, MEM_ATOMIC);
                if (bp == NULL) {
                        warn_once("OOM, trying to survive");
                        break;
index 039f228..7cad744 100644 (file)
@@ -1054,7 +1054,7 @@ igbereplenish(struct ctlr* ctlr)
        while(NEXT_RING(rdt, ctlr->nrd) != ctlr->rdh){
                rd = &ctlr->rdba[rdt];
                if(ctlr->rb[rdt] == NULL){
-                       bp = iallocb(Rbsz);
+                       bp = block_alloc(Rbsz, MEM_ATOMIC);
                        if(bp == NULL){
                                /* needs to be a safe print for interrupt level */
                                printk("#l%d: igbereplenish: no available buffers\n",
index c37901c..c26c0b1 100644 (file)
@@ -609,7 +609,7 @@ static void recv_packet(struct mlx4_en_priv *priv,
 
        assert(priv->num_frags == 1);
 
-       block = iallocb(length);
+       block = block_alloc(length, MEM_ATOMIC);
        if (!block) {
                en_dbg(RX_ERR, priv, "Failed allocating block\n");
                priv->stats.rx_dropped++;
index c5e341c..eba2c7a 100644 (file)
@@ -648,7 +648,7 @@ struct cname *addelem(struct cname *, char *unused_char_p_t);
 void addprog(struct proc *);
 void addrootfile(char *unused_char_p_t, uint8_t * unused_uint8_p_t, uint32_t);
 struct block *adjustblock(struct block *, int);
-struct block *allocb(int);
+struct block *block_alloc(size_t, int);
 int block_add_extd(struct block *b, unsigned int nr_bufs, int mem_flags);
 int block_append_extra(struct block *b, int len, int mem_flags);
 int anyhigher(void);
@@ -747,7 +747,6 @@ void freeskey(struct signerkey *);
 void getcolor(uint32_t, uint32_t *, uint32_t *, uint32_t *);
 uint32_t getmalloctag(void *);
 uint32_t getrealloctag(void *);
-struct block *iallocb(int);
 void printblock(struct block *b);
 void ilock(spinlock_t *);
 int iprint(char *unused_char_p_t, ...);
index f8749be..d1393f0 100644 (file)
@@ -582,7 +582,7 @@ static void sendarp(struct Ipifc *ifc, struct arpent *a)
        n = sizeof(Etherarp);
        if (n < a->type->mintu)
                n = a->type->mintu;
-       bp = allocb(n);
+       bp = block_alloc(n, MEM_WAIT);
        memset(bp->rp, 0, n);
        e = (Etherarp *) bp->rp;
        memmove(e->tpa, a->ip + IPv4off, sizeof(e->tpa));
@@ -657,7 +657,7 @@ static void sendgarp(struct Ipifc *ifc, uint8_t * ip)
        n = sizeof(Etherarp);
        if (n < ifc->m->mintu)
                n = ifc->m->mintu;
-       bp = allocb(n);
+       bp = block_alloc(n, MEM_WAIT);
        memset(bp->rp, 0, n);
        e = (Etherarp *) bp->rp;
        memmove(e->tpa, ip + IPv4off, sizeof(e->tpa));
@@ -758,7 +758,7 @@ static void recvarp(struct Ipifc *ifc)
                        n = sizeof(Etherarp);
                        if (n < ifc->mintu)
                                n = ifc->mintu;
-                       rbp = allocb(n);
+                       rbp = block_alloc(n, MEM_WAIT);
                        r = (Etherarp *) rbp->rp;
                        memset(r, 0, sizeof(Etherarp));
                        hnputs(r->type, ETARP);
index ee04d2f..6d4bd84 100644 (file)
@@ -218,7 +218,7 @@ extern void icmpttlexceeded(struct Fs *f, uint8_t * ia, struct block *bp)
        p = (Icmp *) bp->rp;
 
        netlog(f, Logicmp, "sending icmpttlexceeded -> %V\n", p->src);
-       nbp = allocb(ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8);
+       nbp = block_alloc(ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8, MEM_WAIT);
        nbp->wp += ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8;
        np = (Icmp *) nbp->rp;
        np->vihl = IP_VER4;
@@ -256,7 +256,7 @@ static void icmpunreachable(struct Fs *f, struct block *bp, int code, int seq)
                return;
 
        netlog(f, Logicmp, "sending icmpnoconv -> %V\n", p->src);
-       nbp = allocb(ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8);
+       nbp = block_alloc(ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8, MEM_WAIT);
        nbp->wp += ICMP_IPSIZE + ICMP_HDRSIZE + ICMP_IPSIZE + 8;
        np = (Icmp *) nbp->rp;
        np->vihl = IP_VER4;
index 9b3cdf3..fc60a7c 100644 (file)
@@ -254,7 +254,7 @@ static void set_cksum(struct block *bp)
 static struct block *newIPICMP(int packetlen)
 {
        struct block *nbp;
-       nbp = allocb(packetlen);
+       nbp = block_alloc(packetlen, MEM_WAIT);
        nbp->wp += packetlen;
        memset(nbp->rp, 0, packetlen);
        return nbp;
index 320b403..e2b9450 100644 (file)
@@ -29,6 +29,7 @@
 
 #include <error.h>
 #include <ip.h>
+#include <kmalloc.h>
 
 enum {
        IP4HDR = 20,                            /* sizeof(Ip4hdr) */
@@ -291,7 +292,7 @@ int ipoput6(struct Fs *f, struct block *bp,
        morefrags = 1;
 
        for (; fragoff < flen; fragoff += seglen) {
-               nb = allocb(uflen + IP6FHDR + seglen);
+               nb = block_alloc(uflen + IP6FHDR + seglen, MEM_WAIT);
 
                if (fragoff + seglen >= flen) {
                        seglen = flen - fragoff;
index fd15bce..cd6affd 100644 (file)
@@ -984,7 +984,8 @@ struct block *htontcp6(Tcp * tcph, struct block *data, Tcp6hdr * ph,
                        return NULL;
        } else {
                dlen = 0;
-               data = allocb(hdrlen + TCP6_PKT + 64);  /* the 64 pad is to meet mintu's */
+               /* the 64 pad is to meet mintu's */
+               data = block_alloc(hdrlen + TCP6_PKT + 64, MEM_WAIT);
                if (data == NULL)
                        return NULL;
                data->wp += hdrlen + TCP6_PKT;
@@ -1067,7 +1068,8 @@ struct block *htontcp4(Tcp * tcph, struct block *data, Tcp4hdr * ph,
                        return NULL;
        } else {
                dlen = 0;
-               data = allocb(hdrlen + TCP4_PKT + 64);  /* the 64 pad is to meet mintu's */
+               /* the 64 pad is to meet mintu's */
+               data = block_alloc(hdrlen + TCP4_PKT + 64, MEM_WAIT);
                if (data == NULL)
                        return NULL;
                data->wp += hdrlen + TCP4_PKT;
@@ -2692,7 +2694,7 @@ void tcpsendka(struct conv *s)
        if (tcb->state == Finwait2) {
                seg.flags |= FIN;
        } else {
-               dbp = allocb(1);
+               dbp = block_alloc(1, MEM_WAIT);
                dbp->wp++;
        }
 
index 30bfb7c..bc2057d 100644 (file)
@@ -53,7 +53,7 @@ enum {
  *  if mallocz gives us more than we asked for, leave room at the front
  *  for header.
  */
-static struct block *_allocb(int size, int mem_flags)
+struct block *block_alloc(size_t size, int mem_flags)
 {
        struct block *b;
        uintptr_t addr;
@@ -95,11 +95,6 @@ static struct block *_allocb(int size, int mem_flags)
        return b;
 }
 
-struct block *allocb(int size)
-{
-       return _allocb(size, MEM_WAIT);
-}
-
 /* Makes sure b has nr_bufs extra_data.  Will grow, but not shrink, an existing
  * extra_data array.  When growing, it'll copy over the old entries.  All new
  * entries will be zeroed.  mem_flags determines if we'll block on kmallocs.
@@ -168,14 +163,6 @@ int block_append_extra(struct block *b, int len, int mem_flags)
        return 0;
 }
 
-/*
- *  interrupt time allocation
- */
-struct block *iallocb(int size)
-{
-       return _allocb(size, 0);
-}
-
 void free_block_extra(struct block *b)
 {
        struct extra_bdata *ebd;
index 7b7717c..ffe3cfa 100644 (file)
@@ -437,7 +437,7 @@ struct block *devbread(struct chan *c, long n, uint32_t offset)
        ERRSTACK(1);
        struct block *bp;
 
-       bp = allocb(n);
+       bp = block_alloc(n, MEM_WAIT);
        if (bp == 0)
                error(ENOMEM, ERROR_FIXME);
        if (waserror()) {
index 8a94794..c61c4b8 100644 (file)
@@ -153,7 +153,7 @@ struct block *padblock(struct block *bp, int size)
                        panic("padblock %p", getcallerpc(&bp));
                n = BLEN(bp);
                padblockcnt++;
-               nbp = allocb(size + n);
+               nbp = block_alloc(size + n, MEM_WAIT);
                nbp->rp += size;
                nbp->wp = nbp->rp;
                memmove(nbp->wp, bp->rp, n);
@@ -173,7 +173,7 @@ struct block *padblock(struct block *bp, int size)
 
                n = BLEN(bp);
                padblockcnt++;
-               nbp = allocb(size + n);
+               nbp = block_alloc(size + n, MEM_WAIT);
                memmove(nbp->wp, bp->rp, n);
                nbp->wp += n;
                freeb(bp);
@@ -232,7 +232,7 @@ struct block *concatblock(struct block *bp)
 
        /* probably use parts of qclone */
        PANIC_EXTRA(bp);
-       nb = allocb(blocklen(bp));
+       nb = block_alloc(blocklen(bp), MEM_WAIT);
        for (f = bp; f; f = f->next) {
                len = BLEN(f);
                memmove(nb->wp, f->rp, len);
@@ -256,7 +256,7 @@ struct block *linearizeblock(struct block *b)
        if (!b->extra_len)
                return b;
 
-       newb = allocb(BLEN(b));
+       newb = block_alloc(BLEN(b), MEM_WAIT);
        len = BHLEN(b);
        memcpy(newb->wp, b->rp, len);
        newb->wp += len;
@@ -337,7 +337,7 @@ struct block *pullupblock(struct block *bp, int n)
         *  add another to the front of the list.
         */
        if (bp->lim - bp->rp < n) {
-               nbp = allocb(n);
+               nbp = block_alloc(n, MEM_WAIT);
                nbp->next = bp;
                bp = nbp;
        }
@@ -528,7 +528,7 @@ struct block *copyblock(struct block *bp, int count)
        struct block *nbp;
 
        QDEBUG checkb(bp, "copyblock 0");
-       nbp = allocb(count);
+       nbp = block_alloc(count, MEM_WAIT);
        if (bp->flag & BCKSUM_FLAGS) {
                nbp->flag |= (bp->flag & BCKSUM_FLAGS);
                nbp->checksum_start = bp->checksum_start;
@@ -936,7 +936,7 @@ struct block *packblock(struct block *bp)
                nbp = *l;
                n = BLEN(nbp);
                if ((n << 2) < BALLOC(nbp)) {
-                       *l = allocb(n);
+                       *l = block_alloc(n, MEM_WAIT);
                        memmove((*l)->wp, nbp->rp, n);
                        (*l)->wp += n;
                        (*l)->next = nbp->next;
@@ -974,7 +974,7 @@ int qproduce(struct queue *q, void *vp, int len)
        if ((q->state & Qcoalesce) == 0 || q->bfirst == NULL
                || b->lim - b->wp < len) {
                /* need a new block */
-               b = iallocb(len);
+               b = block_alloc(len, MEM_ATOMIC);
                if (b == 0) {
                        spin_unlock_irqsave(&q->lock);
                        return 0;
@@ -1137,7 +1137,7 @@ struct block *blist_clone(struct block *blist, int header_len, int len,
                           uint32_t offset)
 {
        int ret;
-       struct block *newb = allocb(header_len);
+       struct block *newb = block_alloc(header_len, MEM_WAIT);
        do {
                ret = __blist_clone_to(blist, newb, len, offset);
                if (ret)
@@ -1152,7 +1152,7 @@ struct block *blist_clone(struct block *blist, int header_len, int len,
 struct block *qclone(struct queue *q, int header_len, int len, uint32_t offset)
 {
        int ret;
-       struct block *newb = allocb(header_len);
+       struct block *newb = block_alloc(header_len, MEM_WAIT);
        /* the while loop should rarely be used: it would require someone
         * concurrently adding to the queue. */
        do {
@@ -1176,7 +1176,7 @@ struct block *qcopy_old(struct queue *q, int len, uint32_t offset)
        struct block *b, *nb;
        uint8_t *p;
 
-       nb = allocb(len);
+       nb = block_alloc(len, MEM_WAIT);
 
        spin_lock_irqsave(&q->lock);
 
@@ -1444,7 +1444,7 @@ struct block *mem2bl(uint8_t * p, int len)
                if (n > Maxatomic)
                        n = Maxatomic;
 
-               *l = b = allocb(n);
+               *l = b = block_alloc(n, MEM_WAIT);
                /* TODO consider extra_data */
                memmove(b->wp, p, n);
                b->wp += n;
@@ -1530,7 +1530,7 @@ struct block *qbread(struct queue *q, int len)
                PANIC_EXTRA(b);
                if ((q->state & Qmsg) == 0) {
                        n -= len;
-                       b = allocb(n);
+                       b = block_alloc(n, MEM_WAIT);
                        memmove(b->wp, nb->rp + len, n);
                        b->wp += n;
                        qputback(q, b);
@@ -1818,7 +1818,7 @@ int qwrite(struct queue *q, void *vp, int len)
                 * only available via padblock (to the left).  we also need some space
                 * for pullupblock for some basic headers (like icmp) that get written
                 * in directly */
-               b = allocb(64);
+               b = block_alloc(64, MEM_WAIT);
                ext_buf = kmalloc(n, 0);
                memcpy(ext_buf, p + sofar, n);
                block_add_extd(b, 1, MEM_WAIT); /* returns 0 on success */
@@ -1827,7 +1827,7 @@ int qwrite(struct queue *q, void *vp, int len)
                b->extra_data[0].len = n;
                b->extra_len += n;
 #else
-               b = allocb(n);
+               b = block_alloc(n, MEM_WAIT);
                memmove(b->wp, p + sofar, n);
                b->wp += n;
 #endif
@@ -1856,7 +1856,7 @@ int qiwrite(struct queue *q, void *vp, int len)
                if (n > Maxatomic)
                        n = Maxatomic;
 
-               b = iallocb(n);
+               b = block_alloc(n, MEM_ATOMIC);
                if (b == NULL)
                        break;
                /* TODO consider extra_data */
index d1abcc4..7b6698f 100644 (file)
@@ -76,7 +76,7 @@ static struct block *profiler_buffer_write(struct profiler_cpu_context *cpu_buf,
                }
        }
 
-       return iallocb(profiler_cpu_buffer_size);
+       return block_alloc(profiler_cpu_buffer_size, MEM_ATOMIC);
 }
 
 static char *profiler_cpu_buffer_write_reserve(
index 54a908a..55e0240 100644 (file)
@@ -53,3 +53,17 @@ expression E1;
 -mallocz(
 +kzmalloc(
 ...);
+
+@@
+expression E1;
+@@
+-allocb(E1
++block_alloc(E1, MEM_WAIT
+ )
+
+@@
+expression E1;
+@@
+-iallocb(E1
++block_alloc(E1, MEM_ATOMIC
+ )