allocb: implement buffer pools for ethernet drivers

Some ethernet drivers implemented their own buffer pools
using Block.free() callbacks.

Usually, these implementations have the defect that the
driver only allocates a fixed number of buffers total.

This upper bound is impossible to predict (depends
on protocol queue limits).

Also, allocation is not space efficient when large
alignments are needed.

This change removes the Block.free() callback and
replaces it with a common buffer pool implementation:

A Bpool struct, containing the block size and
alignment needed for the blocks. Block.pool
is non-nil when the block is from a pool.

growbp(Bpool*,int) supplies new blocks to a pool.

Allocation is done such that the data area and
Block headers are in separate allocations.

All the blocks share the same allocation for
data avoiding waste as not every block needs
to add alignment slack individually.

Block *iallocbp(Bpool*) allocates a block,
growing the pool if neccessary.

freeb(): returns the block back to the pool.

We also tweak the input queue sizes for devether,
making it twice as large as the transmit queue.

sys/src/9/bcm64/ethergenet.c

@@ -242,6 +242,8 @@ struct Ctlr
 	Lock;
 	u32int	*regs;
 
+	Bpool	pool[1];
+
 	Desc	rd[256];
 	Desc	td[256];
 
@@ -315,9 +317,10 @@ setdma(Desc *d, void *v)
 }
 
 static void
-replenish(Desc *d)
+replenish(Ctlr *c, Desc *d)
 {
-	d->b = allocb(Rbsz);
+	while((d->b = iallocbp(c->pool)) == nil)
+		resrcwait("out of genet rx buffers");
 	dmaflush(1, d->b->rp, Rbsz);
 	setdma(d, d->b->rp);
 }
@@ -355,7 +358,7 @@ recvproc(void *arg)
 		b = d->b;
 		dmaflush(0, b->rp, Rbsz);
 		s = REG(d->d[0]);
-		replenish(d);
+		replenish(ctlr, d);
 		coherence();
 		ctlr->rx->rp = (ctlr->rx->rp + 1) & 0xFFFF;
 		REG(ctlr->rx->regs[RxRP]) = ctlr->rx->rp;
@@ -503,15 +506,22 @@ allocbufs(Ctlr *ctlr)
 {
 	int i;
 
+	if(ctlr->pool->size == 0){
+		ctlr->pool->size = Rbsz;
+		growbp(ctlr->pool, nelem(ctlr->rd)*4);
+	}
+
 	if(scratch == nil){
-		scratch = allocb(Rbsz);
+		scratch = iallocbp(ctlr->pool);
+		if(scratch == nil)
+			error("out of rx buffers");
 		memset(scratch->rp, 0xFF, Rbsz);
 		dmaflush(1, scratch->rp, Rbsz);
 	}
 
 	for(i = 0; i < nelem(ctlr->rd); i++){
 		ctlr->rd[i].d = &ctlr->regs[RdmaOffset + i*3];
-		replenish(&ctlr->rd[i]);
+		replenish(ctlr, &ctlr->rd[i]);
 	}
 
 	for(i = 0; i < nelem(ctlr->td); i++){

sys/src/9/imx8/etherimx.c

@@ -216,6 +216,8 @@ struct Ctlr
 	u32int	*regs;
 	u32int	intmask;
 
+	Bpool	pool;
+
 	struct {
 		Block	*b[256];
 		Descr	*d;
@@ -441,7 +443,9 @@ rxproc(void *arg)
 			etheriq(edev, b);
 
 			/* replenish */
-			b = allocb(R_BUF_SIZE);
+			while((b = iallocbp(&ctlr->pool)) == nil)
+				resrcwait("out of imx rx buffers");
+
 			ctlr->rx->b[i] = b;
 			dmaflush(1, b->rp, R_BUF_SIZE);
 			d->addr = PADDR(b->rp); 
@@ -569,11 +573,23 @@ attach(Ether *edev)
 
 	if(ctlr->rx->d == nil)
 		ctlr->rx->d = ucalloc(sizeof(Descr) * nelem(ctlr->rx->b));
+
+	if(ctlr->pool.size == 0){
+		ctlr->pool.size = R_BUF_SIZE;
+		ctlr->pool.align = BLOCKALIGN;
+		growbp(&ctlr->pool, 4*nelem(ctlr->rx->b));
+	}
+
 	for(i=0; i<nelem(ctlr->rx->b); i++){
-		Block *b = allocb(R_BUF_SIZE);
+		Block *b = ctlr->rx->b[i];
-		ctlr->rx->b[i] = b;
+		if(b == nil){
-		d = &ctlr->rx->d[i];
+			b = iallocbp(&ctlr->pool);
+			if(b == nil)
+				error("out of rx buffers");
+			ctlr->rx->b[i] = b;
+		}
 		dmaflush(1, b->rp, R_BUF_SIZE);
+		d = &ctlr->rx->d[i];
 		d->addr = PADDR(b->rp);
 		d->status = RD_E;
 	}

sys/src/9/kw/ether1116.c

@@ -49,11 +49,6 @@ typedef struct Mibstats Mibstats;
 typedef struct Rx Rx;
 typedef struct Tx Tx;
 
-static struct {
-	Lock;
-	Block	*head;
-} freeblocks;
-
 /* hardware receive buffer descriptor */
 struct Rx {
 	ulong	cs;
@@ -129,6 +124,8 @@ struct Ctlr {
 	Lock	initlock;
 	int	init;
 
+	Bpool	pool;
+
 	Rx	*rx;		/* receive descriptors */
 	Block	*rxb[Nrx];	/* blocks belonging to the descriptors */
 	int	rxhead;		/* descr ethernet will write to next */
@@ -514,36 +511,6 @@ static uchar zeroea[Eaddrlen];
 
 static void getmibstats(Ctlr *);
 
-static void
-rxfreeb(Block *b)
-{
-	b->wp = b->rp =
-		(uchar*)((uintptr)(b->lim - Rxblklen) & ~(Bufalign - 1));
-	assert(((uintptr)b->rp & (Bufalign - 1)) == 0);
-	b->free = rxfreeb;
-
-	ilock(&freeblocks);
-	b->next = freeblocks.head;
-	freeblocks.head = b;
-	iunlock(&freeblocks);
-}
-
-static Block *
-rxallocb(void)
-{
-	Block *b;
-
-	ilock(&freeblocks);
-	b = freeblocks.head;
-	if(b != nil) {
-		freeblocks.head = b->next;
-		b->next = nil;
-		b->free = rxfreeb;
-	}
-	iunlock(&freeblocks);
-	return b;
-}
-
 static void
 rxkick(Ctlr *ctlr)
 {
@@ -575,12 +542,9 @@ rxreplenish(Ctlr *ctlr)
 	Block *b;
 
 	while(ctlr->rxb[ctlr->rxtail] == nil) {
-		b = rxallocb();
+		b = iallocbp(&ctlr->pool);
-		if(b == nil) {
+		if(b == nil)
-			iprint("#l%d: rxreplenish out of buffers\n",
-				ctlr->ether->ctlrno);
 			break;
-		}
 
 		ctlr->rxb[ctlr->rxtail] = b;
 
@@ -1437,26 +1401,9 @@ static void
 ctlralloc(Ctlr *ctlr)
 {
 	int i;
-	Block *b;
 	Rx *r;
 	Tx *t;
 
-	ilock(&freeblocks);
-	for(i = 0; i < Nrxblks; i++) {
-		b = iallocb(Rxblklen+Bufalign-1);
-		if(b == nil) {
-			iprint("ether1116: no memory for rx buffers\n");
-			break;
-		}
-		b->wp = b->rp = (uchar*)
-			((uintptr)(b->lim - Rxblklen) & ~(Bufalign - 1));
-		assert(((uintptr)b->rp & (Bufalign - 1)) == 0);
-		b->free = rxfreeb;
-		b->next = freeblocks.head;
-		freeblocks.head = b;
-	}
-	iunlock(&freeblocks);
-
 	/*
 	 * allocate uncached rx ring descriptors because rings are shared
 	 * with the ethernet controller and more than one fits in a cache line.
@@ -1473,6 +1420,12 @@ ctlralloc(Ctlr *ctlr)
 		ctlr->rxb[i] = nil;
 	}
 	ctlr->rxtail = ctlr->rxhead = 0;
+
+	/* allocate private buffer pool */
+	ctlr->pool.size = Rxblklen;
+	ctlr->pool.align = Bufalign;
+	growbp(&ctlr->pool, Nrx*4);
+
 	rxreplenish(ctlr);
 
 	/* allocate uncached tx ring descriptors */

sys/src/9/pc/ether8169.c

@@ -306,6 +306,8 @@ typedef struct Ctlr {
 	int	rdt;			/* tail - consumer index (host) */
 	int	nrq;
 
+	Bpool	pool;
+
 	int	tcr;			/* transmit configuration register */
 	int	rcr;			/* receive configuration register */
 	int	imr;
@@ -646,11 +648,9 @@ rtl8169replenish(Ctlr* ctlr)
 
 	x = ctlr->rdt;
 	while(NEXT(x, ctlr->nrd) != ctlr->rdh){
-		bp = iallocb(Mps);
+		bp = iallocbp(&ctlr->pool);
-		if(bp == nil){
+		if(bp == nil)
-			iprint("rtl8169: no available buffers\n");
 			break;
-		}
 		ctlr->rb[x] = bp;
 		ctlr->nrq++;
 		pa = PCIWADDR(bp->rp);
@@ -698,7 +698,10 @@ rtl8169init(Ether* edev)
 			ctlr->rb[i] = nil;
 			freeb(bp);
 		}
-
+	if(ctlr->pool.size == 0){
+		ctlr->pool.size = Mps;
+		growbp(&ctlr->pool, ctlr->nrd*4);
+	}
 	rtl8169replenish(ctlr);
 
 	cplusc = csr16r(ctlr, Cplusc);

sys/src/9/pc/ether82563.c

@@ -518,6 +518,8 @@ struct Ctlr {
 	int	ntd;
 	int	rbsz;
 
+	Bpool	pool;
+
 	u32int	*nic;
 	Lock	imlock;
 	int	im;			/* interrupt mask */
@@ -907,24 +909,25 @@ static void
 i82563replenish(Ctlr *ctlr)
 {
 	uint rdt, i;
+	uvlong pa;
 	Block *bp;
 	Rd *rd;
 
 	i = 0;
 	for(rdt = ctlr->rdt; NEXT(rdt, ctlr->nrd) != ctlr->rdh; rdt = NEXT(rdt, ctlr->nrd)){
 		rd = &ctlr->rdba[rdt];
-		if(ctlr->rb[rdt] != nil){
+		if(ctlr->rb[rdt] != nil)
-			iprint("#l%d: %s: tx overrun\n", ctlr->edev->ctlrno, cname(ctlr));
+			break;
+		bp = iallocbp(&ctlr->pool);
+		if(bp == nil)
 			break;
-		}
-		i++;
-		bp = allocb(ctlr->rbsz + Rbalign);
-		bp->rp = bp->wp = (uchar*)ROUND((uintptr)bp->base, Rbalign);
 		ctlr->rb[rdt] = bp;
-		rd->addr[0] = PCIWADDR(bp->rp);
+		pa = PCIWADDR(bp->rp);
-		rd->addr[1] = 0;
+		rd->addr[0] = pa;
+		rd->addr[1] = pa>>32;
 		rd->status = 0;
 		ctlr->rdfree++;
+		i++;
 	}
 	if(i != 0){
 		coherence();
@@ -977,6 +980,13 @@ i82563rxinit(Ctlr *ctlr)
 			ctlr->rb[i] = nil;
 			freeb(bp);
 		}
+
+	if(ctlr->pool.size == 0){
+		ctlr->pool.size = ctlr->rbsz;
+		ctlr->pool.align = Rbalign;
+		growbp(&ctlr->pool, Nrb);
+	}
+
 	if(cttab[ctlr->type].flag & F75)
 		csr32w(ctlr, Rxdctl, 1<<WthreshSHIFT | 8<<PthreshSHIFT | 1<<HthreshSHIFT | Enable);
 	else
@@ -1007,6 +1017,7 @@ i82563rproc(void *arg)
 	ctlr = edev->ctlr;
 
 	i82563rxinit(ctlr);
+
 	csr32w(ctlr, Rctl, csr32r(ctlr, Rctl) | Ren);
 	if(cttab[ctlr->type].flag & F75){
 		csr32w(ctlr, Rxdctl, csr32r(ctlr, Rxdctl) | Enable);

sys/src/9/pc/etherdp83820.c

@@ -362,6 +362,8 @@ typedef struct Ctlr {
 
 	Mii*	mii;
 
+	Bpool	pool;
+
 	Lock	rdlock;			/* receive */
 	Desc*	rd;
 	int	nrd;
@@ -395,9 +397,6 @@ typedef struct Ctlr {
 static Ctlr* dp83820ctlrhead;
 static Ctlr* dp83820ctlrtail;
 
-static Lock dp83820rblock;		/* free receive Blocks */
-static Block* dp83820rbpool;
-
 static char* dp83820mibs[Nmibd] = {
 	"RXErroredPkts",
 	"RXFCSErrors",
@@ -497,30 +496,20 @@ dp83820miimiw(Mii* mii, int pa, int ra, int data)
 }
 
 static Block *
-dp83820rballoc(Desc* desc)
+dp83820rballoc(Ctlr *ctlr, Desc* desc)
 {
 	Block *bp;
 
-	if(desc->bp == nil){
+	bp = desc->bp;
-		ilock(&dp83820rblock);
+	if(bp == nil){
-		if((bp = dp83820rbpool) == nil){
+		desc->bp = iallocbp(&ctlr->pool);
-			iunlock(&dp83820rblock);
+		if(desc->bp == nil){
-			desc->bp = nil;
 			desc->cmdsts = Own;
 			return nil;
 		}
-		dp83820rbpool = bp->next;
-		bp->next = nil;
-		iunlock(&dp83820rblock);
-	
 		desc->bufptr = PCIWADDR(bp->rp);
 		desc->bp = bp;
 	}
-	else{
-		bp = desc->bp;
-		bp->rp = bp->lim - Rbsz;
-		bp->wp = bp->rp;
-	}
 
 	coherence();
 	desc->cmdsts = Intr|Rbsz;
@@ -528,18 +517,6 @@ dp83820rballoc(Desc* desc)
 	return bp;
 }
 
-static void
-dp83820rbfree(Block *bp)
-{
-	bp->rp = bp->lim - Rbsz;
-	bp->wp = bp->rp;
-
-	ilock(&dp83820rblock);
-	bp->next = dp83820rbpool;
-	dp83820rbpool = bp;
-	iunlock(&dp83820rblock);
-}
-
 static void
 dp83820halt(Ctlr* ctlr)
 {
@@ -635,6 +612,11 @@ dp83820init(Ether* edev)
 
 	dp83820halt(ctlr);
 
+	if(ctlr->pool.size == 0){
+		ctlr->pool.size = Rbsz;
+		growbp(&ctlr->pool, ctlr->nrb);
+	}
+
 	/*
 	 * Receiver
 	 */
@@ -646,7 +628,7 @@ dp83820init(Ether* edev)
 	for(i = 0; i < ctlr->nrd; i++){
 		desc = &ctlr->rd[i];
 		desc->link = PCIWADDR(&ctlr->rd[NEXT(i, ctlr->nrd)]);
-		if(dp83820rballoc(desc) == nil)
+		if(dp83820rballoc(ctlr, desc) == nil)
 			continue;
 	}
 	csr32w(ctlr, Rxdphi, 0);
@@ -698,7 +680,6 @@ dp83820init(Ether* edev)
 static void
 dp83820attach(Ether* edev)
 {
-	Block *bp;
 	Ctlr *ctlr;
 
 	ctlr = edev->ctlr;
@@ -739,14 +720,6 @@ dp83820attach(Ether* edev)
 	ctlr->alloc = mallocz((ctlr->nrd+ctlr->ntd)*sizeof(Desc) + 7, 0);
 	if(ctlr->alloc == nil)
 		error(Enomem);
-
-	for(ctlr->nrb = 0; ctlr->nrb < Nrb; ctlr->nrb++){
-		if((bp = allocb(Rbsz)) == nil)
-			break;
-		bp->free = dp83820rbfree;
-		dp83820rbfree(bp);
-	}
-
 	dp83820init(edev);
 
 	qunlock(&ctlr->alock);
@@ -848,7 +821,7 @@ dp83820interrupt(Ureg*, void* arg)
 						iprint(" %2.2uX", bp->rp[i]);
 					iprint("\n");
 				}
-				dp83820rballoc(desc);
+				dp83820rballoc(ctlr, desc);
 
 				x = NEXT(x, ctlr->nrd);
 				desc = &ctlr->rd[x];

sys/src/9/pc/etherigbe.c

@@ -492,6 +492,8 @@ typedef struct Ctlr {
 	uchar	ra[Eaddrlen];		/* receive address */
 	ulong	mta[128];		/* multicast table array */
 
+	Bpool	pool;
+
 	Rendez	rrendez;
 	int	rim;
 	int	rdfree;
@@ -858,6 +860,7 @@ igbetxinit(Ctlr* ctlr)
 {
 	int i, r;
 	Block *bp;
+	uvlong pa;
 
 	csr32w(ctlr, Tctl, (0x0F<<CtSHIFT)|Psp|(66<<ColdSHIFT));
 	switch(ctlr->id){
@@ -887,8 +890,9 @@ igbetxinit(Ctlr* ctlr)
 	csr32w(ctlr, Ait, 0);
 	csr32w(ctlr, Txdmac, 0);
 
-	csr32w(ctlr, Tdbal, PCIWADDR(ctlr->tdba));
+	pa = PCIWADDR(ctlr->tdba);
-	csr32w(ctlr, Tdbah, 0);
+	csr32w(ctlr, Tdbal, pa);
+	csr32w(ctlr, Tdbah, pa >> 32);
 	csr32w(ctlr, Tdlen, ctlr->ntd*sizeof(Td));
 	ctlr->tdh = PREV(0, ctlr->ntd);
 	csr32w(ctlr, Tdh, 0);
@@ -942,6 +946,7 @@ igbetransmit(Ether* edev)
 	Block *bp;
 	Ctlr *ctlr;
 	int tdh, tdt;
+	uvlong pa;
 
 	ctlr = edev->ctlr;
 
@@ -969,7 +974,9 @@ igbetransmit(Ether* edev)
 		if((bp = qget(edev->oq)) == nil)
 			break;
 		td = &ctlr->tdba[tdt];
-		td->addr[0] = PCIWADDR(bp->rp);
+		pa = PCIWADDR(bp->rp);
+		td->addr[0] = pa;
+		td->addr[1] = pa >> 32;
 		td->control = ((BLEN(bp) & LenMASK)<<LenSHIFT);
 		td->control |= Dext|Ifcs|Teop|DtypeDD;
 		ctlr->tb[tdt] = bp;
@@ -995,17 +1002,19 @@ igbereplenish(Ctlr* ctlr)
 	Rd *rd;
 	int rdt;
 	Block *bp;
+	uvlong pa;
 
 	rdt = ctlr->rdt;
 	while(NEXT(rdt, ctlr->nrd) != ctlr->rdh){
 		rd = &ctlr->rdba[rdt];
 		if(ctlr->rb[rdt] == nil){
-			bp = allocb(Rbsz);
+			bp = iallocbp(&ctlr->pool);
-			bp->rp = bp->lim - Rbsz;
+			if(bp == nil)
-			bp->wp = bp->rp;
+				break;
 			ctlr->rb[rdt] = bp;
-			rd->addr[0] = PCIWADDR(bp->rp);
+			pa = PCIWADDR(bp->rp);
-			rd->addr[1] = 0;
+			rd->addr[0] = pa;
+			rd->addr[1] = pa >> 32;
 		}
 		coherence();
 		rd->status = 0;
@@ -1021,12 +1030,14 @@ igberxinit(Ctlr* ctlr)
 {
 	int i;
 	Block *bp;
+	uvlong pa;
 
 	/* temporarily keep Mpe on */
 	csr32w(ctlr, Rctl, Dpf|Bsize2048|Bam|RdtmsHALF|Mpe);
 
-	csr32w(ctlr, Rdbal, PCIWADDR(ctlr->rdba));
+	pa = PCIWADDR(ctlr->rdba);
-	csr32w(ctlr, Rdbah, 0);
+	csr32w(ctlr, Rdbal, pa);
+	csr32w(ctlr, Rdbah, pa >> 32);
 	csr32w(ctlr, Rdlen, ctlr->nrd*sizeof(Rd));
 	ctlr->rdh = 0;
 	csr32w(ctlr, Rdh, 0);
@@ -1041,6 +1052,10 @@ igberxinit(Ctlr* ctlr)
 			freeb(bp);
 		}
 	}
+	if(ctlr->pool.size == 0){
+		ctlr->pool.size = Rbsz;
+		growbp(&ctlr->pool, Nrb);
+	}
 	igbereplenish(ctlr);
 
 	switch(ctlr->id){

sys/src/9/pc/etherm10g.c

@@ -26,8 +26,8 @@
 #define	pcicapdbg(...)
 #define malign(n)	mallocalign((n), 4*KiB, 0, 0)
 
-#include "etherm10g2k.i"
+#include "../pc/etherm10g2k.i"
-#include "etherm10g4k.i"
+#include "../pc/etherm10g4k.i"
 
 static int 	debug		= 0;
 static char	Etimeout[]	= "timeout";
@@ -137,18 +137,8 @@ typedef struct {
 } Tx;
 
 typedef struct {
-	Lock;
+	Bpool	pool;
-	Block	*head;
-	uint	size;		/* buffer size of each block */
-	uint	n;		/* n free buffers */
-	uint	cnt;
-} Bpool;
 
-static Bpool	smpool 	= { .size = 128, };
-static Bpool	bgpool	= { .size = Maxmtu, };
-
-typedef struct {
-	Bpool	*pool;		/* free buffers */
 	ulong	*lanai;		/* rx ring; we have no permanent host shadow */
 	Block	**host;		/* called "info" in myricom driver */
 //	uchar	*wcfifo;	/* cmd submission fifo */
@@ -253,51 +243,6 @@ enum {
 	PcieMRD	= 0x7000,	/* maximum read size */
 };
 
-static int
-pcicap(Pcidev *p, int cap)
-{
-	int i, c, off;
-
-	pcicapdbg("pcicap: %x:%d\n", p->vid, p->did);
-	off = 0x34;			/* 0x14 for cardbus */
-	for(i = 48; i--; ){
-		pcicapdbg("\t" "loop %x\n", off);
-		off = pcicfgr8(p, off);
-		pcicapdbg("\t" "pcicfgr8 %x\n", off);
-		if(off < 0x40)
-			break;
-		off &= ~3;
-		c = pcicfgr8(p, off);
-		pcicapdbg("\t" "pcicfgr8 %x\n", c);
-		if(c == 0xff)
-			break;
-		if(c == cap)
-			return off;
-		off++;
-	}
-	return 0;
-}
-
-/*
- * this function doesn't work because pcicgr32 doesn't have access
- * to the pcie extended configuration space.
- */
-static int
-pciecap(Pcidev *p, int cap)
-{
-	uint off, i;
-
-	off = 0x100;
-	while(((i = pcicfgr32(p, off)) & 0xffff) != cap){
-		off = i >> 20;
-		print("m10g: pciecap offset = %ud",  off);
-		if(off < 0x100 || off >= 4*KiB - 1)
-			return 0;
-	}
-	print("m10g: pciecap found = %ud",  off);
-	return off;
-}
-
 static int
 setpcie(Pcidev *p)
 {
@@ -328,7 +273,7 @@ whichfw(Pcidev *p)
 	lanes = (cap>>4) & 0x3f;
 
 	/* check AERC register.  we need it on.  */
-	off = pciecap(p, PcieAERC);
+	off = pcicap(p, PcieAERC);
 	print("; offset %d returned\n", off);
 	cap = 0;
 	if(off != 0){
@@ -486,7 +431,6 @@ cmd(Ctlr *c, int type, uvlong data)
 	iprint("m10g: cmd timeout [%ux %ux] cmd=%d\n",
 		cmd->i[0], cmd->i[1], type);
 	error(Etimeout);
-	return ~0;			/* silence! */
 }
 
 ulong
@@ -525,7 +469,6 @@ maccmd(Ctlr *c, int type, uchar *m)
 	iprint("m10g: maccmd timeout [%ux %ux] cmd=%d\n",
 		cmd->i[0], cmd->i[1], type);
 	error(Etimeout);
-	return ~0;			/* silence! */
 }
 
 /* remove this garbage after testing */
@@ -564,7 +507,6 @@ dmatestcmd(Ctlr *c, int type, uvlong addr, int len)
 		tsleep(&up->sleep, return0, 0, 5);
 	}
 	error(Etimeout);
-	return ~0;			/* silence! */
 }
 
 ulong
@@ -594,8 +536,6 @@ rdmacmd(Ctlr *c, int on)
 		tsleep(&up->sleep, return0, 0, 1);
 	}
 	error(Etimeout);
-	iprint("m10g: rdmacmd timeout\n");
-	return ~0;			/* silence! */
 }
 
 static int
@@ -741,7 +681,6 @@ reset(Ether *e, Ctlr *c)
 	if(waserror()){
 		print("m10g: reset error\n");
 		nexterror();
-		return -1;
 	}
 
 	chkfw(c);
@@ -811,7 +750,7 @@ setmem(Pcidev *p, Ctlr *c)
 		print("m10g: can't map %llux\n", raddr);
 		return -1;
 	}
-	dprint("%llux <- vmap(mem[0].size = %d)\n", raddr, p->mem[0].size);
+	dprint("%llux <- vmap(mem[0].size = %llud)\n", raddr, p->mem[0].size);
 	c->port = raddr;
 	c->ram = mem;
 	c->cmd = malign(sizeof *c->cmd);
@@ -836,81 +775,35 @@ setmem(Pcidev *p, Ctlr *c)
 static Rx*
 whichrx(Ctlr *c, int sz)
 {
-	if(sz <= smpool.size)
+	if(sz <= c->sm.pool.size)
 		return &c->sm;
 	return &c->bg;
 }
 
-static Block*
-balloc(Rx* rx)
-{
-	Block *bp;
-
-	ilock(rx->pool);
-	if((bp = rx->pool->head) != nil){
-		rx->pool->head = bp->next;
-		bp->next = nil;
-		rx->pool->n--;
-	}
-	iunlock(rx->pool);
-	return bp;
-}
-
-static void
-rbfree(Block *b, Bpool *p)
-{
-	b->rp = b->wp = (uchar*)PGROUND((uintptr)b->base);
- 	b->flag &= ~(Bipck | Budpck | Btcpck | Bpktck);
-
-	ilock(p);
-	b->next = p->head;
-	p->head = b;
-	p->n++;
-	p->cnt++;
-	iunlock(p);
-}
-
-static void
-smbfree(Block *b)
-{
-	rbfree(b, &smpool);
-}
-
-static void
-bgbfree(Block *b)
-{
-	rbfree(b, &bgpool);
-}
-
 static void
 replenish(Rx *rx)
 {
 	ulong buf[16], i, idx, e;
-	Bpool *p;
+	uvlong pa;
 	Block *b;
 
-	p = rx->pool;
-	if(p->n < 8)
-		return;
-	memset(buf, 0, sizeof buf);
 	e = (rx->i - rx->cnt) & ~7;
 	e += rx->n;
-	while(p->n >= 8 && e){
+	while(e){
 		idx = rx->cnt & rx->m;
 		for(i = 0; i < 8; i++){
-			b = balloc(rx);
+			while((b = iallocbp(&rx->pool)) == nil)
-			buf[i*2]   = pbit32((uvlong)PCIWADDR(b->wp) >> 32);
+				resrcwait("out of m10g rx buffers");
-			buf[i*2+1] = pbit32(PCIWADDR(b->wp));
+			pa = PCIWADDR(b->wp);
+			buf[i*2+0] = pbit32(pa >> 32);
+			buf[i*2+1] = pbit32(pa);
 			rx->host[idx+i] = b;
-			assert(b);
 		}
-		memmove(rx->lanai + 2*idx, buf, sizeof buf);
+		memmove(rx->lanai + 2*idx, buf, sizeof(buf));
 		coherence();
 		rx->cnt += 8;
 		e -= 8;
 	}
-	if(e && p->n > 7+1)
-		print("m10g: should panic? pool->n = %d", p->n);
 }
 
 /*
@@ -947,8 +840,7 @@ emalign(int sz)
 static void
 open0(Ether *e, Ctlr *c)
 {
-	Block *b;
+	int entries;
-	int i, sz, entries;
 
 	entries = cmd(c, CGsendrgsz, 0) / sizeof *c->tx.lanai;
 	c->tx.lanai = (Send*)(c->ram + cmd(c, CGsendoff, 0));
@@ -958,35 +850,24 @@ open0(Ether *e, Ctlr *c)
 	c->tx.m = entries-1;
 
 	entries = cmd(c, CGrxrgsz, 0)/8;
-	c->sm.pool = &smpool;
+	c->sm.pool.size = 128;
-	cmd(c, CSsmallsz, c->sm.pool->size);
+	c->sm.pool.align = BY2PG;
+	cmd(c, CSsmallsz, c->sm.pool.size);
 	c->sm.lanai = (ulong*)(c->ram + cmd(c, CGsmallrxoff, 0));
 	c->sm.n = entries;
 	c->sm.m = entries-1;
 	c->sm.host = emalign(entries * sizeof *c->sm.host);
 
-	c->bg.pool = &bgpool;
+	c->bg.pool.size = nextpow(2 + e->maxmtu);	/* 2-byte alignment pad */
-	c->bg.pool->size = nextpow(2 + e->maxmtu);  /* 2-byte alignment pad */
+	c->bg.pool.align = BY2PG;
-	cmd(c, CSbigsz, c->bg.pool->size);
+	cmd(c, CSbigsz, c->bg.pool.size);
 	c->bg.lanai = (ulong*)(c->ram + cmd(c, CGbigrxoff, 0));
 	c->bg.n = entries;
 	c->bg.m = entries-1;
 	c->bg.host = emalign(entries * sizeof *c->bg.host);
 
-	sz = c->sm.pool->size + BY2PG;
+	growbp(&c->sm.pool, c->sm.n);
-	for(i = 0; i < c->sm.n; i++){
+	growbp(&c->bg.pool, c->bg.n);
-		if((b = allocb(sz)) == 0)
-			break;
-		b->free = smbfree;
-		freeb(b);
-	}
-	sz = c->bg.pool->size + BY2PG;
-	for(i = 0; i < c->bg.n; i++){
-		if((b = allocb(sz)) == 0)
-			break;
-		b->free = bgbfree;
-		freeb(b);
-	}
 
 	cmd(c, CSstatsdma, c->statsprt);
 	c->linkstat = ~0;
@@ -1332,17 +1213,6 @@ m10gdetach(Ctlr *c)
 	return -1;
 }
 
-static int
-lstcount(Block *b)
-{
-	int i;
-
-	i = 0;
-	for(; b; b = b->next)
-		i++;
-	return i;
-}
-
 static char*
 m10gifstat(void *arg, char *p, char *e)
 {
@@ -1364,9 +1234,7 @@ m10gifstat(void *arg, char *p, char *e)
 		"tx pkt = %lud\n"  "tx bytes = %lld\n"
 		"tx cnt = %ud\n"  "tx n = %ud\n"	"tx i = %ud\n"
 		"sm cnt = %ud\n"  "sm i = %ud\n"	"sm n = %ud\n"
-		"sm lst = %ud\n"
 		"bg cnt = %ud\n"  "bg i = %ud\n"	"bg n = %ud\n"
-		"bg lst = %ud\n"
 		"segsz = %lud\n"   "coal = %lud\n",
 		gbit32(s.txcnt),  gbit32(s.linkstat),	gbit32(s.dlink),
 		gbit32(s.derror), gbit32(s.drunt),	gbit32(s.doverrun),
@@ -1374,8 +1242,8 @@ m10gifstat(void *arg, char *p, char *e)
 		s.txstopped,  s.down, s.updated, s.valid,
 		c->tx.npkt, c->tx.nbytes,
 		c->tx.cnt, c->tx.n, c->tx.i,
-		c->sm.cnt, c->sm.i, c->sm.pool->n, lstcount(c->sm.pool->head),
+		c->sm.cnt, c->sm.i, c->sm.n,
-		c->bg.cnt, c->bg.i, c->bg.pool->n, lstcount(c->bg.pool->head),
+		c->bg.cnt, c->bg.i, c->bg.n,
 		c->tx.segsz, gbit32((uchar*)c->coal));
 }
 
@@ -1595,9 +1463,7 @@ m10gpnp(Ether *e)
 
 	e->attach = m10gattach;
 	e->transmit = m10gtransmit;
-	e->interrupt = m10ginterrupt;
 	e->ctl = m10gctl;
-//	e->power = m10gpower;
 	e->shutdown = m10gshutdown;
 
 	e->arg = e;
@@ -1605,6 +1471,8 @@ m10gpnp(Ether *e)
 	e->promiscuous = m10gpromiscuous;
 	e->multicast = m10gmulticast;
 
+	intrenable(e->irq, m10ginterrupt, e, e->tbdf, e->name);
+
 	return 0;
 }
 

sys/src/9/pc/ethervirtio.c

@@ -156,6 +156,8 @@ struct Ctlr {
 	ulong	feat;
 	int	nqueue;
 
+	Bpool	pool;
+
 	/* virtioether has 3 queues: rx, tx and ctl */
 	Vqueue	queue[3];
 };
@@ -275,6 +277,9 @@ rxproc(void *v)
 	header = smalloc(VheaderSize);
 	blocks = smalloc(sizeof(Block*) * (q->qsize/2));
 
+	ctlr->pool.size = ETHERMAXTU;
+	growbp(&ctlr->pool, q->qsize*2);
+
 	for(i = 0; i < q->qsize/2; i++){
 		j = i << 1;
 		q->desc[j].addr = PADDR(header);
@@ -300,7 +305,7 @@ rxproc(void *v)
 			i = q->avail->idx & (q->qmask >> 1);
 			if(blocks[i] != nil)
 				break;
-			if((b = iallocb(ETHERMAXTU)) == nil)
+			if((b = iallocbp(&ctlr->pool)) == nil)
 				break;
 			blocks[i] = b;
 			j = (i << 1) | 1;

sys/src/9/pc/ethervt6105m.c

@@ -308,6 +308,8 @@ typedef struct Ctlr {
 	int	nrd;
 	int	ntd;
 
+	Bpool	pool;
+
 	Ds*	rd;
 	Ds*	rdh;
 
@@ -359,10 +361,6 @@ static Ctlr* vt6105Mctlrtail;
 #define csr16w(c, r, w)	(outs((c)->port+(r), (ushort)(w)))
 #define csr32w(c, r, w)	(outl((c)->port+(r), (ulong)(w)))
 
-static Lock vt6105Mrblock;			/* receive Block freelist */
-static Block* vt6105Mrbpool;
-static uint vt6105Mrbpoolsz;
-
 typedef struct Regs Regs;
 typedef struct Regs {
 	char*	name;
@@ -472,7 +470,6 @@ vt6105Mifstat(void *arg, char *p, char *e)
 	p = seprint(p, e, "tuok: %ud\n", ctlr->tuok);
 	p = seprint(p, e, "ipok: %ud\n", ctlr->ipok);
 
-	p = seprint(p, e, "rbpoolsz: %ud\n", vt6105Mrbpoolsz);
 	p = seprint(p, e, "totalt: %uld\n", ctlr->totalt);
 
 	for(i = 0; regs[i].name != nil; i++){
@@ -574,38 +571,6 @@ enable:
 	pexit("vt6105Mlproc: done", 1);
 }
 
-static void
-vt6105Mrbfree(Block* bp)
-{
-	bp->rp = bp->lim - (Rdbsz+3);
-	bp->wp = bp->rp;
- 	bp->flag &= ~(Bipck | Budpck | Btcpck | Bpktck);
-
-	ilock(&vt6105Mrblock);
-	bp->next = vt6105Mrbpool;
-	vt6105Mrbpool = bp;
-	iunlock(&vt6105Mrblock);
-}
-
-static Block*
-vt6105Mrballoc(void)
-{
-	Block *bp;
-
-	ilock(&vt6105Mrblock);
-	if((bp = vt6105Mrbpool) != nil){
-		vt6105Mrbpool = bp->next;
-		bp->next = nil;
-	}
-	iunlock(&vt6105Mrblock);
-
-	if(bp == nil && (bp = iallocb(Rdbsz+3)) != nil){
-		bp->free = vt6105Mrbfree;
-		vt6105Mrbpoolsz++;
-	}
-	return bp;
-}
-
 static void
 vt6105Mattach(Ether* edev)
 {
@@ -655,6 +620,12 @@ vt6105Mattach(Ether* edev)
 		nexterror();
 	}
 
+	if(ctlr->pool.size == 0){
+		ctlr->pool.size = Rdbsz;
+		ctlr->pool.align = 4;
+		growbp(&ctlr->pool, ctlr->nrd);
+	}
+
 	prev = (Ds*)(alloc + (ctlr->nrd-1)*dsz);
 	for(i = 0; i < ctlr->nrd; i++){
 		ds = (Ds*)alloc;
@@ -663,10 +634,8 @@ vt6105Mattach(Ether* edev)
 		ds->control = Ipkt|Tcpkt|Udpkt|Rdbsz;
 		ds->branch = PCIWADDR(alloc);
 
-		ds->bp = vt6105Mrballoc();
+		if((ds->bp = iallocbp(&ctlr->pool)) == nil)
-		if(ds->bp == nil)
+			error(Enomem);
-			error("vt6105M: can't allocate receive ring\n");
-		ds->bp->rp = (uchar*)ROUNDUP((ulong)ds->bp->rp, 4);
 		ds->addr = PCIWADDR(ds->bp->rp);
 
 		ds->next = (Ds*)alloc;
@@ -853,7 +822,7 @@ vt6105Mreceive(Ether* edev)
 					ctlr->rxstats[i]++;
 			}
 		}
-		else if(bp = vt6105Mrballoc()){
+		else if(bp = iallocbp(&ctlr->pool)){
 			if(ds->control & Tuok){
 				ds->bp->flag |= Btcpck|Budpck;
 				ctlr->tuok++;
@@ -865,7 +834,6 @@ vt6105Mreceive(Ether* edev)
 			len = ((ds->status & LengthMASK)>>LengthSHIFT)-4;
 			ds->bp->wp = ds->bp->rp+len;
 			etheriq(edev, ds->bp);
-			bp->rp = (uchar*)ROUNDUP((ulong)bp->rp, 4);
 			ds->addr = PCIWADDR(bp->rp);
 			ds->bp = bp;
 		}

sys/src/9/pc/etheryuk.c

@@ -696,6 +696,7 @@ struct Ctlr {
 	Block	*tbring[Tringcnt];
 	Sring	rx;
 	Block	*rbring[Rringcnt];
+	Bpool	pool;
 	Kproc	txmit;
 	Kproc	rxmit;
 	Kproc	iproc;
@@ -1197,6 +1198,10 @@ rxinit(Ether *e)
 		qrwrite(c, Qr + Qcsr, Qsumen);
 	}
 	macwrite32(c, Gfrxctl, Gftroff);
+
+	c->pool.size = c->rbsz;
+	c->pool.align = Rbalign;
+	growbp(&c->pool, Nrb);
 }
 
 /* debug; remove */
@@ -1235,13 +1240,13 @@ replenish(Ether *e, Ctlr *c)
 	if(lim > 128)
 		lim = 128;		/* hw limit? */
 	for(n = 0; n < lim; n++){
-		b = iallocb(c->rbsz + Rbalign);
+		b = iallocbp(&c->pool);
-		if(b == nil || getnslot(r, &wp, tab, 1 + is64()) == -1){
+		if(b == nil)
+			break;
+		if(getnslot(r, &wp, tab, 1 + is64()) == -1){
 			freeb(b);
 			break;
 		}
-		b->rp = b->wp = (uchar*)ROUND((uintptr)b->base, Rbalign);
-
 		t = tab[is64()];
 		if(rxscrew(e, r, t, wp) == -1){
 			freeb(b);

sys/src/9/pc/pc

@@ -55,8 +55,6 @@ link
 	ether8003	ether8390
 	ether8139	pci
 	ether8169	pci ethermii
-# should be obsoleted by igbe
-#	ether82543gc	pci
 	ether82557	pci
 	ether82563	pci
 	ether82598	pci
@@ -68,6 +66,7 @@ link
 	etherelnk3	pci
 	etherga620	pci
 	etherigbe	pci ethermii
+#	etherm10g	pci
 	ethervgbe	pci ethermii
 	ethervt6102	pci ethermii
 	ethervt6105m	pci ethermii

sys/src/9/pc64/mkfile

@@ -121,6 +121,10 @@ sd53c8xx.$O:			../pc/sd53c8xx.i
 ../pc/sd53c8xx.i:		../pc/sd53c8xx.n
 	cd ../pc && mk sd53c8xx.i
 
+etherm10g.$O:			../pc/etherm10g2k.i ../pc/etherm10g4k.i
+../pc/etherm10g%.i:		../pc/etherm10g%.fw
+	cd ../pc && mk etherm10g$stem.i
+
 $SDEV pmmc.$O:			../port/sd.h
 sdiahci.$O:			ahci.h
 devaoe.$O sdaoe.$O:		../port/aoe.h

sys/src/9/pc64/pc64

@@ -66,6 +66,7 @@ link
 #	etherelnk3	pci
 #	etherga620	pci
 	etherigbe	pci ethermii
+#	etherm10g	pci
 #	ethervgbe	pci ethermii
 #	ethervt6102	pci ethermii
 #	ethervt6105m	pci ethermii

sys/src/9/port/allocb.c

@@ -13,31 +13,24 @@ enum
 };
 
 static Block*
-_allocb(int size)
+_allocb(ulong size, ulong align)
 {
 	Block *b;
-	uintptr addr;
 
-	size += Tlrspc;
+	size = ROUND(size+Tlrspc, align);
-	size = ROUND(size, BLOCKALIGN);
+	if((b = mallocz(sizeof(Block)+Hdrspc+size+align-1, 0)) == nil)
-	if((b = mallocz(sizeof(Block)+BLOCKALIGN+Hdrspc+size, 0)) == nil)
 		return nil;
 
 	b->next = nil;
 	b->list = nil;
-	b->free = nil;
+	b->pool = nil;
 	b->flag = 0;
 
 	/* align start of data portion by rounding up */
-	addr = (uintptr)b;
+	b->base = (uchar*)ROUND((uintptr)&b[1], (uintptr)align);
-	addr = ROUND(addr + sizeof(Block), BLOCKALIGN);
-	b->base = (uchar*)addr;
 
 	/* align end of data portion by rounding down */
-	b->lim = (uchar*)b + msize(b);
+	b->lim = (uchar*)(((uintptr)b + msize(b)) & ~((uintptr)align-1));
-	addr = (uintptr)b->lim;
-	addr &= ~(BLOCKALIGN-1);
-	b->lim = (uchar*)addr;
 
 	/* leave room at beginning for added headers */
 	b->wp = b->rp = b->lim - size;
@@ -55,7 +48,7 @@ allocb(int size)
 	 */
 	if(up == nil)
 		panic("allocb without up: %#p", getcallerpc(&size));
-	while((b = _allocb(size)) == nil){
+	while((b = _allocb(size, BLOCKALIGN)) == nil){
 		if(up->nlocks || m->ilockdepth || !islo()){
 			xsummary();
 			mallocsummary();
@@ -76,7 +69,7 @@ iallocb(int size)
 {
 	Block *b;
 
-	if((b = _allocb(size)) == nil){
+	if((b = _allocb(size, BLOCKALIGN)) == nil){
 		static ulong nerr;
 		if((nerr++%10000)==0){
 			if(nerr > 10000000){
@@ -97,20 +90,20 @@ iallocb(int size)
 void
 freeb(Block *b)
 {
+	Bpool *p;
 	void *dead = (void*)Bdead;
 
 	if(b == nil)
 		return;
 
-	/*
+	if((p = b->pool) != nil) {
-	 * drivers which perform non cache coherent DMA manage their own buffer
-	 * pool of uncached buffers and provide their own free routine.
-	 */
-	if(b->free != nil) {
 		b->next = nil;
-		b->list = nil;
+		b->rp = b->wp = b->lim - ROUND(p->size+Tlrspc, p->align);
-
+		b->flag = BINTR;
-		b->free(b);
+		ilock(p);
+		b->list = p->head;
+		p->head = b;
+		iunlock(p);
 		return;
 	}
 
@@ -121,10 +114,82 @@ freeb(Block *b)
 	b->wp = dead;
 	b->lim = dead;
 	b->base = dead;
+	b->pool = dead;
 
 	free(b);
 }
 
+static ulong
+_alignment(ulong align)
+{
+	if(align <= BLOCKALIGN)
+		return BLOCKALIGN;
+
+	/* make it a power of two */
+	align--;
+	align |= align>>1;
+	align |= align>>2;
+	align |= align>>4;
+	align |= align>>8;
+	align |= align>>16;
+	align++;
+
+	return align;
+}
+
+Block*
+iallocbp(Bpool *p)
+{
+	Block *b;
+
+	ilock(p);
+	if((b = p->head) != nil){
+		p->head = b->list;
+		b->list = nil;
+		iunlock(p);
+	} else {
+		iunlock(p);
+		p->align = _alignment(p->align);
+		b = _allocb(p->size, p->align);
+		if(b == nil)
+			return nil;
+		setmalloctag(b, getcallerpc(&p));
+		b->pool = p;
+		b->flag = BINTR;
+	}
+
+	return b;
+}
+
+void
+growbp(Bpool *p, int n)
+{
+	ulong size;
+	Block *b;
+	uchar *a;
+
+	if(n < 1)
+		return;
+	if((b = malloc(sizeof(Block)*n)) == nil)
+		return;
+	p->align = _alignment(p->align);
+	size = ROUND(p->size+Hdrspc+Tlrspc, p->align);
+	if((a = mallocalign(size*n, p->align, 0, 0)) == nil){
+		free(b);
+		return;
+	}
+	setmalloctag(b, getcallerpc(&p));
+	while(n > 0){
+		b->base = a;
+		a += size;
+		b->lim = a;
+		b->pool = p;
+		freeb(b);
+		b++;
+		n--;
+	}
+}
+
 void
 checkb(Block *b, char *msg)
 {
@@ -132,14 +197,14 @@ checkb(Block *b, char *msg)
 
 	if(b == dead)
 		panic("checkb b %s %#p", msg, b);
-	if(b->base == dead || b->lim == dead || b->next == dead
+	if(b->base == dead || b->lim == dead
-	  || b->rp == dead || b->wp == dead){
+	|| b->next == dead || b->list == dead || b->pool == dead
-		print("checkb: base %#p lim %#p next %#p\n",
+	|| b->rp == dead || b->wp == dead){
-			b->base, b->lim, b->next);
+		print("checkb: base %#p lim %#p next %#p list %#p pool %#p\n",
+			b->base, b->lim, b->next, b->list, b->pool);
 		print("checkb: rp %#p wp %#p\n", b->rp, b->wp);
 		panic("checkb dead: %s", msg);
 	}
-
 	if(b->base > b->lim)
 		panic("checkb 0 %s %#p %#p", msg, b->base, b->lim);
 	if(b->rp < b->base)

sys/src/9/port/devether.c

@@ -212,16 +212,22 @@ ethermux(Ether *ether, Block *bp, Netfile **from)
 			etherrtrace(f, pkt, len);
 			continue;
 		}
-		if(dispose && x == nil)
+		if(dispose && x == nil){
 			x = f;
-		else if((xbp = iallocb(len)) != nil){
+			continue;
+		}
+		if(bp->pool != nil && len <= bp->pool->size)
+			xbp = iallocbp(bp->pool);
+		else
+			xbp = iallocb(len);
+		if(xbp != nil){
 			memmove(xbp->wp, pkt, len);
 			xbp->wp += len;
-			xbp->flag = bp->flag;
+			xbp->flag |= bp->flag & ~(BINTR|BFREE);
-			if(qpass(f->in, xbp) < 0)
+			if(qpass(f->in, xbp) >= 0)
-				ether->soverflows++;
+				continue;
-		} else
+		}
-			ether->soverflows++;
+		ether->soverflows++;
 	}
 	if(x != nil){
 		if(qpass(x->in, bp) < 0)
@@ -376,28 +382,20 @@ addethercard(char* t, int (*r)(Ether*))
 static int
 etherqueuesize(Ether *ether)
 {
-	int lg, mb;
+	int b, q;
-	ulong bsz;
 
-	/* compute log10(mbps) into lg */
+	b = ether->mbps * 2*125;	/* 2ms */
-	for(lg = 0, mb = ether->mbps; mb >= 10; lg++)
+	for(q = 128*1024; q < b; q <<= 1)
-		mb /= 10;
+		;
-	if (lg > 0)
+	if(mainmem->maxsize / 8 < q)
-		lg--;
+		q = mainmem->maxsize / 8;
-	if (lg > 14)			/* 2^(14+17) = 2³¹ */
+	return q;
-		lg = 14;
-	/* allocate larger output queues for higher-speed interfaces */
-	bsz = 1UL << (lg + 17);		/* 2¹⁷ = 128K, bsz = 2ⁿ × 128K */
-	while (bsz > mainmem->maxsize / 8 && bsz > 128*1024)
-		bsz /= 2;
-if(0) print("#l%d: %d Mbps -> queue size %lud\n", ether->ctlrno, ether->mbps, bsz);
-	return (int)bsz;
 }
 
 static Ether*
 etherprobe(int cardno, int ctlrno, char *conf)
 {
-	int i;
+	int i, q;
 	Ether *ether;
 
 	ether = malloc(sizeof(Ether));
@@ -447,14 +445,15 @@ Nope:
 	print("#l%d: %s: %dMbps port 0x%lluX irq %d ea %E\n",
 		ctlrno, ether->type, ether->mbps, (uvlong)ether->port, ether->irq, ether->ea);
 
-	netifinit(ether, ether->name, Ntypes, etherqueuesize(ether));
+	q = etherqueuesize(ether);
 	if(ether->oq == nil){
-		ether->oq = qopen(ether->limit, Qmsg, 0, 0);
+		ether->oq = qopen(q, Qmsg, 0, 0);
 		if(ether->oq == nil)
 			panic("etherreset %s: can't allocate output queue", ether->name);
 	} else {
-		qsetlimit(ether->oq, ether->limit);
+		qsetlimit(ether->oq, q);
 	}
+	netifinit(ether, ether->name, Ntypes, q*2);
 	ether->alen = Eaddrlen;
 	memmove(ether->addr, ether->ea, Eaddrlen);
 	memset(ether->bcast, 0xFF, Eaddrlen);
@@ -465,15 +464,17 @@ Nope:
 void
 ethersetspeed(Ether *ether, int mbps)
 {
+	int q;
+
 	if(ether->mbps == mbps)
 		return;
 	ether->mbps = mbps;
 
 	if(mbps <= 0 || ether->f == nil || ether->oq == nil)
 		return;
-
+	q = etherqueuesize(ether);
-	netifsetlimit(ether, etherqueuesize(ether));
+	qsetlimit(ether->oq, q);
-	qsetlimit(ether->oq, ether->limit);
+	netifsetlimit(ether, q*2);
 }
 
 void

sys/src/9/port/ethervirtio10.c

@@ -197,6 +197,8 @@ struct Ctlr {
 	ulong	feat[2];
 	int	nqueue;
 
+	Bpool	pool;
+
 	/* virtioether has 3 queues: rx, tx and ctl */
 	Vqueue	queue[3];
 };
@@ -316,6 +318,9 @@ rxproc(void *v)
 	header = smalloc(VheaderSize);
 	blocks = smalloc(sizeof(Block*) * (q->qsize/2));
 
+	ctlr->pool.size = ETHERMAXTU;
+	growbp(&ctlr->pool, q->qsize*2);
+
 	for(i = 0; i < q->qsize/2; i++){
 		j = i << 1;
 		q->desc[j].addr = PADDR(header);
@@ -341,7 +346,7 @@ rxproc(void *v)
 			i = q->avail->idx & (q->qmask >> 1);
 			if(blocks[i] != nil)
 				break;
-			if((b = iallocb(ETHERMAXTU)) == nil)
+			if((b = iallocbp(&ctlr->pool)) == nil)
 				break;
 			blocks[i] = b;
 			j = (i << 1) | 1;

sys/src/9/port/portdat.h

@@ -1,5 +1,6 @@
 typedef struct Alarms	Alarms;
 typedef struct Block	Block;
+typedef struct Bpool	Bpool;
 typedef struct Chan	Chan;
 typedef struct Cmdbuf	Cmdbuf;
 typedef struct Cmdtab	Cmdtab;
@@ -151,7 +152,7 @@ struct Block
 	uchar*	wp;			/* first empty byte */
 	uchar*	lim;			/* 1 past the end of the buffer */
 	uchar*	base;			/* start of the buffer */
-	void	(*free)(Block*);
+	Bpool*	pool;
 	ushort	flag;
 	ushort	checksum;		/* IP checksum of complete packet (minus media header) */
 };
@@ -159,6 +160,15 @@ struct Block
 #define BLEN(s)	((s)->wp - (s)->rp)
 #define BALLOC(s) ((s)->lim - (s)->base)
 
+struct Bpool
+{
+	ulong	size;			/* block size */
+	ulong	align;			/* block alignment */
+
+	Lock;
+	Block	*head;			/* freelist head */
+};
+
 struct Chan
 {
 	Ref;

sys/src/9/port/portfns.h

@@ -130,11 +130,13 @@ uintptr		getmalloctag(void*);
 uintptr		getrealloctag(void*);
 _Noreturn void	gotolabel(Label*);
 char*		getconfenv(void);
+void		growbp(Bpool*, int);
 long		hostdomainwrite(char*, int);
 long		hostownerwrite(char*, int);
 void 		(*hwrandbuf)(void*, ulong);
 void		hzsched(void);
 Block*		iallocb(int);
+Block*		iallocbp(Bpool*);
 uintptr		ibrk(uintptr, int);
 void		ilock(Lock*);
 _Noreturn void	interrupted(void);

sys/src/9/port/qio.c

@@ -300,7 +300,12 @@ copyblock(Block *bp, int count)
 	assert(count >= 0);
 
 	QDEBUG checkb(bp, "copyblock 0");
-	nbp = allocb(count);
+	if(bp->pool == nil
+	|| count > bp->pool->size
+	|| (nbp = iallocbp(bp->pool)) == nil)
+		nbp = allocb(count);
+	nbp->flag |= bp->flag & ~(BINTR|BFREE);
+
 	for(; count > 0 && bp != nil; bp = bp->next){
 		l = BLEN(bp);
 		if(l > count)

sys/src/9/teg2/ether8169.c

@@ -316,8 +316,6 @@ struct Ctlr {
 	int	ntdfree;
 	int	ntq;
 
-	int	nrb;
-
 //	Lock	rlock;			/* receive */
 	Rendez	rrendez;
 	D*	rd;			/* descriptor ring */
@@ -328,6 +326,8 @@ struct Ctlr {
 	int	rdt;			/* tail - consumer index (host) */
 	int	nrdfree;
 
+	Bpool	pool;
+
 	Lock	reglock;
 	int	tcr;			/* transmit configuration register */
 	int	rcr;			/* receive configuration register */
@@ -353,9 +353,6 @@ struct Ctlr {
 static Ctlr* rtl8169ctlrhead;
 static Ctlr* rtl8169ctlrtail;
 
-static Lock rblock;			/* free receive Blocks */
-static Block* rbpool;
-
 #define csr8r(c, r)	(*((uchar *) ((c)->nic)+(r)))
 #define csr16r(c, r)	(*((u16int *)((c)->nic)+((r)/2)))
 #define csr32p(c, r)	((u32int *)  ((c)->nic)+((r)/4))
@@ -453,32 +450,6 @@ rtl8169mii(Ctlr* ctlr)
 	return 0;
 }
 
-static Block*
-rballoc(void)
-{
-	Block *bp;
-
-	ilock(&rblock);
-	if((bp = rbpool) != nil){
-		rbpool = bp->next;
-		bp->next = nil;
-	}
-	iunlock(&rblock);
-	return bp;
-}
-
-static void
-rbfree(Block *bp)
-{
-	bp->wp = bp->rp = bp->lim - Mps;
- 	bp->flag &= ~(Bipck | Budpck | Btcpck | Bpktck);
-
-	ilock(&rblock);
-	bp->next = rbpool;
-	rbpool = bp;
-	iunlock(&rblock);
-}
-
 static void
 rtl8169promiscuous(void* arg, int on)
 {
@@ -700,6 +671,7 @@ rtl8169replenish(Ether *edev)
 	Block *bp;
 	Ctlr *ctlr;
 	D *d;
+	uvlong pa;
 
 	ctlr = edev->ctlr;
 	if (ctlr->nrd == 0) {
@@ -718,15 +690,14 @@ rtl8169replenish(Ether *edev)
 			break;
 		}
 		if(ctlr->rb[rdt] == nil){
-			bp = rballoc();
+			bp = iallocbp(&ctlr->pool);
-			if(bp == nil){
+			if(bp == nil)
-				iprint("rtl8169: no available buffers\n");
 				break;
-			}
 			ctlr->rb[rdt] = bp;
-			d->addrhi = 0;
+			pa = PCIWADDR(bp->rp);
+			d->addrhi = pa >> 32;
 			coherence();
-			d->addrlo = PCIWADDR(bp->rp);
+			d->addrlo = pa;
 			coherence();
 		} else
 			iprint("8169: replenish: rx overrun\n");
@@ -1199,9 +1170,8 @@ rtl8169init(Ether* edev)
 static void
 rtl8169attach(Ether* edev)
 {
-	int timeo, s, i;
+	int timeo, s;
 	char name[KNAMELEN];
-	Block *bp;
 	Ctlr *ctlr;
 
 	ctlr = edev->ctlr;
@@ -1233,13 +1203,9 @@ rtl8169attach(Ether* edev)
 	   ctlr->rb == nil || ctlr->dtcc == nil)
 		error(Enomem);
 
-	/* allocate private receive-buffer pool */
+	if(ctlr->pool.size == 0){
-	ctlr->nrb = Nrb;
+		ctlr->pool.size = Mps;
-	for(i = 0; i < Nrb; i++){
+		growbp(&ctlr->pool, Nrb);
-		if((bp = allocb(Mps)) == nil)
-			error(Enomem);
-		bp->free = rbfree;
-		freeb(bp);
 	}
 
 	rtl8169init(edev);

sys/src/9/xen/etherxen.c

@@ -236,18 +236,13 @@ vifrecvdone(Ether *ether, netif_rx_response_t *rr)
 		vifrecv(ctlr, rx);
 		return 1;
 	}
-
 	ctlr->receives++;
-	memmove(bp->base, rx->page + rr->offset, len);
-	vifrecv(ctlr, rx);
-
-	bp->rp = bp->base;
-	bp->wp = bp->rp + len;
-	bp->free = 0;
-	bp->next = 0;
-	bp->list = 0;
 	if (rr->flags & NETRXF_data_validated)
 		bp->flag |= Btcpck|Budpck;
+	bp->rp = bp->base;
+	bp->wp = bp->rp + len;
+	memmove(bp->rp, rx->page + rr->offset, len);
+	vifrecv(ctlr, rx);
 	etheriq(ether, bp);
 	return 0;
 }