cirno/plan9front
1
0
Fork 0
mirror of git://git.9front.org/plan9front/plan9front synced 2025-01-12 11:10:06 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

allocb: implement buffer pools for ethernet drivers

Browse source 
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.
This commit is contained in:
cinap_lenrek 2025-01-10 14:32:50 +00:00
parent 8b7a03c5e9
commit 3459c8cb8e
23 changed files with 334 additions and 1831 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
sys/src/9/bcm64/ethergenet.c
View file

@ -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++){

24
sys/src/9/imx8/etherimx.c
View file

@ -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);
ctlr->rx->b[i] = b;
d = &ctlr->rx->d[i];
Block *b = ctlr->rx->b[i];
if(b == nil){
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;
}

67
sys/src/9/kw/ether1116.c
View file

@ -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();
if(b == nil) {
iprint("#l%d: rxreplenish out of buffers\n",
ctlr->ether->ctlrno);
b = iallocbp(&ctlr->pool);
if(b == nil)
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 */

13
sys/src/9/pc/ether8169.c
View file

@ -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);
if(bp == nil){
iprint("rtl8169: no available buffers\n");
bp = iallocbp(&ctlr->pool);
if(bp == nil)
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);

1377
sys/src/9/pc/ether82543gc.c
View file

File diff suppressed because it is too large Load diff

27
sys/src/9/pc/ether82563.c
View file

@ -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){
iprint("#l%d: %s: tx overrun\n", ctlr->edev->ctlrno, cname(ctlr));
if(ctlr->rb[rdt] != nil)
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);
rd->addr[1] = 0;
pa = PCIWADDR(bp->rp);
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);

55
sys/src/9/pc/etherdp83820.c
View file

@ -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){
ilock(&dp83820rblock);
if((bp = dp83820rbpool) == nil){
iunlock(&dp83820rblock);
desc->bp = nil;
bp = desc->bp;
if(bp == nil){
desc->bp = iallocbp(&ctlr->pool);
if(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];

35
sys/src/9/pc/etherigbe.c
View file

@ -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));
csr32w(ctlr, Tdbah, 0);
pa = PCIWADDR(ctlr->tdba);
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->rp = bp->lim - Rbsz;
bp->wp = bp->rp;
bp = iallocbp(&ctlr->pool);
if(bp == nil)
break;
ctlr->rb[rdt] = bp;
rd->addr[0] = PCIWADDR(bp->rp);
rd->addr[1] = 0;
pa = PCIWADDR(bp->rp);
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));
csr32w(ctlr, Rdbah, 0);
pa = PCIWADDR(ctlr->rdba);
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){

186
sys/src/9/pc/etherm10g.c
View file

@ -26,8 +26,8 @@
#define pcicapdbg(...)
#define malign(n) mallocalign((n), 4*KiB, 0, 0)
#include "etherm10g2k.i"
#include "etherm10g4k.i"
#include "../pc/etherm10g2k.i"
#include "../pc/etherm10g4k.i"
static int debug = 0;
static char Etimeout[] = "timeout";
@ -137,18 +137,8 @@ typedef struct {
} Tx;
typedef struct {
Lock;
Block *head;
uint size; /* buffer size of each block */
uint n; /* n free buffers */
uint cnt;
} Bpool;
Bpool pool;
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);
buf[i*2] = pbit32((uvlong)PCIWADDR(b->wp) >> 32);
buf[i*2+1] = pbit32(PCIWADDR(b->wp));
while((b = iallocbp(&rx->pool)) == nil)
resrcwait("out of m10g rx buffers");
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 i, sz, entries;
int 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;
cmd(c, CSsmallsz, c->sm.pool->size);
c->sm.pool.size = 128;
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 */
cmd(c, CSbigsz, c->bg.pool->size);
c->bg.pool.size = nextpow(2 + e->maxmtu); /* 2-byte alignment pad */
c->bg.pool.align = BY2PG;
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;
for(i = 0; i < c->sm.n; i++){
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);
}
growbp(&c->sm.pool, c->sm.n);
growbp(&c->bg.pool, c->bg.n);
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->bg.cnt, c->bg.i, c->bg.pool->n, lstcount(c->bg.pool->head),
c->sm.cnt, c->sm.i, c->sm.n,
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;
}

7
sys/src/9/pc/ethervirtio.c
View file

@ -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;

54
sys/src/9/pc/ethervt6105m.c
View file

@ -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 == nil)
error("vt6105M: can't allocate receive ring\n");
ds->bp->rp = (uchar*)ROUNDUP((ulong)ds->bp->rp, 4);
if((ds->bp = iallocbp(&ctlr->pool)) == nil)
error(Enomem);
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;
}

13
sys/src/9/pc/etheryuk.c
View file

@ -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);
if(b == nil || getnslot(r, &wp, tab, 1 + is64()) == -1){
b = iallocbp(&c->pool);
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);

3
sys/src/9/pc/pc
View file

@ -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

4
sys/src/9/pc64/mkfile
View file

@ -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

1
sys/src/9/pc64/pc64
View file

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

121
sys/src/9/port/allocb.c
View file

@ -13,31 +13,24 @@ enum
};
static Block*
_allocb(int size)
_allocb(ulong size, ulong align)
{
Block *b;
uintptr addr;
size += Tlrspc;
size = ROUND(size, BLOCKALIGN);
if((b = mallocz(sizeof(Block)+BLOCKALIGN+Hdrspc+size, 0)) == nil)
size = ROUND(size+Tlrspc, align);
if((b = mallocz(sizeof(Block)+Hdrspc+size+align-1, 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;
addr = ROUND(addr + sizeof(Block), BLOCKALIGN);
b->base = (uchar*)addr;
b->base = (uchar*)ROUND((uintptr)&b[1], (uintptr)align);
/* align end of data portion by rounding down */
b->lim = (uchar*)b + msize(b);
addr = (uintptr)b->lim;
addr &= ~(BLOCKALIGN-1);
b->lim = (uchar*)addr;
b->lim = (uchar*)(((uintptr)b + msize(b)) & ~((uintptr)align-1));
/* 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;
/*
* 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) {
if((p = b->pool) != nil) {
b->next = nil;
b->list = nil;
b->free(b);
b->rp = b->wp = b->lim - ROUND(p->size+Tlrspc, p->align);
b->flag = BINTR;
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
|| b->rp == dead || b->wp == dead){
print("checkb: base %#p lim %#p next %#p\n",
b->base, b->lim, b->next);
if(b->base == dead || b->lim == dead
|| b->next == dead || b->list == dead || b->pool == dead
|| b->rp == dead || b->wp == dead){
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)

59
sys/src/9/port/devether.c
View file

@ -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;
if(qpass(f->in, xbp) < 0)
ether->soverflows++;
} else
ether->soverflows++;
xbp->flag |= bp->flag & ~(BINTR|BFREE);
if(qpass(f->in, xbp) >= 0)
continue;
}
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;
ulong bsz;
int b, q;
/* compute log10(mbps) into lg */
for(lg = 0, mb = ether->mbps; mb >= 10; lg++)
mb /= 10;
if (lg > 0)
lg--;
if (lg > 14) /* 2^(14+17) = 2³¹ */
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;
b = ether->mbps * 2*125; /* 2ms */
for(q = 128*1024; q < b; q <<= 1)
;
if(mainmem->maxsize / 8 < q)
q = mainmem->maxsize / 8;
return q;
}
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;
netifsetlimit(ether, etherqueuesize(ether));
qsetlimit(ether->oq, ether->limit);
q = etherqueuesize(ether);
qsetlimit(ether->oq, q);
netifsetlimit(ether, q*2);
}
void

7
sys/src/9/port/ethervirtio10.c
View file

@ -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;

12
sys/src/9/port/portdat.h
View file

@ -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;

2
sys/src/9/port/portfns.h
View file

@ -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);

7
sys/src/9/port/qio.c
View file

@ -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)

58
sys/src/9/teg2/ether8169.c
View file

@ -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();
if(bp == nil){
iprint("rtl8169: no available buffers\n");
bp = iallocbp(&ctlr->pool);
if(bp == nil)
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 */
ctlr->nrb = Nrb;
for(i = 0; i < Nrb; i++){
if((bp = allocb(Mps)) == nil)
error(Enomem);
bp->free = rbfree;
freeb(bp);
if(ctlr->pool.size == 0){
ctlr->pool.size = Mps;
growbp(&ctlr->pool, Nrb);
}
rtl8169init(edev);

13
sys/src/9/xen/etherxen.c
View file

@ -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;
}