ref: 99db038e2825266e84ddb381718f3d047dc6d733
dir: /sys/src/9/port/segment.c/
#include "u.h" #include "../port/lib.h" #include "mem.h" #include "dat.h" #include "fns.h" #include "../port/error.h" /* * Attachable segment types */ static Physseg physseg[10] = { { SG_SHARED, "shared", 0, SEGMAXSIZE }, { SG_BSS, "memory", 0, SEGMAXSIZE }, { 0, 0, 0, 0 }, }; static Lock physseglock; #define IHASHSIZE 64 #define ihash(s) imagealloc.hash[s%IHASHSIZE] static struct Imagealloc { Lock; Image *list; Image *free; Image *hash[IHASHSIZE]; QLock ireclaim; /* mutex on reclaiming free images */ }imagealloc; Segment* (*_globalsegattach)(char*); void initseg(void) { Image *i, *ie; imagealloc.list = xalloc(conf.nimage*sizeof(Image)); if(imagealloc.list == nil) panic("initseg: no memory for Image"); ie = &imagealloc.list[conf.nimage-1]; for(i = imagealloc.list; i < ie; i++) i->next = i+1; i->next = nil; imagealloc.free = imagealloc.list; } Segment * newseg(int type, uintptr base, ulong size) { Segment *s; int mapsize; if(size > (SEGMAPSIZE*PTEPERTAB)) error(Enovmem); s = malloc(sizeof(Segment)); if(s == nil) error(Enomem); s->ref = 1; s->type = type; s->base = base; s->top = base+(size*BY2PG); s->size = size; s->sema.prev = &s->sema; s->sema.next = &s->sema; if((type & SG_TYPE) == SG_PHYSICAL){ s->map = nil; s->mapsize = 0; return s; } mapsize = ROUND(size, PTEPERTAB)/PTEPERTAB; if(mapsize > nelem(s->ssegmap)){ s->map = malloc(mapsize*sizeof(Pte*)); if(s->map == nil){ free(s); error(Enomem); } s->mapsize = mapsize; } else{ s->map = s->ssegmap; s->mapsize = nelem(s->ssegmap); } return s; } void putseg(Segment *s) { Pte **pte, **emap; Image *i; if(s == nil) return; i = s->image; if(i != nil) { lock(i); if(decref(s) != 0){ unlock(i); return; } if(i->s == s) i->s = nil; putimage(i); } else if(decref(s) != 0) return; if(s->mapsize > 0){ emap = &s->map[s->mapsize]; for(pte = s->map; pte < emap; pte++) if(*pte != nil) freepte(s, *pte); if(s->map != s->ssegmap) free(s->map); } if(s->profile != nil) free(s->profile); free(s); } void relocateseg(Segment *s, uintptr offset) { Pte **pte, **emap; Page **pg, **pe; emap = &s->map[s->mapsize]; for(pte = s->map; pte < emap; pte++) { if(*pte == nil) continue; pe = (*pte)->last; for(pg = (*pte)->first; pg <= pe; pg++) { if(!pagedout(*pg)) (*pg)->va += offset; } } } Segment* dupseg(Segment **seg, int segno, int share) { int i, size; Pte *pte; Segment *n, *s; SET(n); s = seg[segno]; qlock(s); if(waserror()){ qunlock(s); nexterror(); } switch(s->type&SG_TYPE) { case SG_TEXT: /* New segment shares pte set */ case SG_SHARED: case SG_PHYSICAL: case SG_FIXED: case SG_STICKY: goto sameseg; case SG_STACK: n = newseg(s->type, s->base, s->size); break; case SG_BSS: /* Just copy on write */ if(share) goto sameseg; n = newseg(s->type, s->base, s->size); break; case SG_DATA: /* Copy on write plus demand load info */ if(segno == TSEG){ n = data2txt(s); qunlock(s); poperror(); return n; } if(share) goto sameseg; n = newseg(s->type, s->base, s->size); incref(s->image); n->image = s->image; n->fstart = s->fstart; n->flen = s->flen; break; } size = s->mapsize; for(i = 0; i < size; i++) if((pte = s->map[i]) != nil) n->map[i] = ptecpy(pte); n->flushme = s->flushme; if(s->ref > 1) procflushseg(s); qunlock(s); poperror(); return n; sameseg: incref(s); qunlock(s); poperror(); return s; } void segpage(Segment *s, Page *p) { Pte **pte, *etp; uintptr soff; Page **pg; if(p->va < s->base || p->va >= s->top || s->mapsize == 0) panic("segpage"); soff = p->va - s->base; pte = &s->map[soff/PTEMAPMEM]; if((etp = *pte) == nil) *pte = etp = ptealloc(); pg = &etp->pages[(soff&(PTEMAPMEM-1))/BY2PG]; *pg = p; if(pg < etp->first) etp->first = pg; if(pg > etp->last) etp->last = pg; } Image* attachimage(int type, Chan *c, uintptr base, ulong len) { Image *i, **l; c->flag &= ~CCACHE; cclunk(c); lock(&imagealloc); /* * Search the image cache for remains of the text from a previous * or currently running incarnation */ for(i = ihash(c->qid.path); i; i = i->hash) { if(c->qid.path == i->qid.path) { lock(i); if(eqchantdqid(c, i->type, i->dev, i->qid, 0) && c->qid.type == i->qid.type) goto found; unlock(i); } } /* dump pages of inactive images to free image structures */ while((i = imagealloc.free) == nil) { unlock(&imagealloc); if(imagereclaim(0) == 0 && imagealloc.free == nil){ freebroken(); /* can use the memory */ resrcwait("no image after reclaim"); } lock(&imagealloc); } imagealloc.free = i->next; lock(i); i->type = c->type; i->dev = c->dev; i->qid = c->qid; l = &ihash(c->qid.path); i->hash = *l; *l = i; found: unlock(&imagealloc); if(i->c == nil){ i->c = c; incref(c); } if(i->s == nil) { incref(i); if(waserror()) { putimage(i); nexterror(); } i->s = newseg(type, base, len); i->s->image = i; poperror(); } else incref(i->s); return i; } ulong imagecached(void) { Image *i, *ie; ulong np; np = 0; ie = &imagealloc.list[conf.nimage]; for(i = imagealloc.list; i < ie; i++) np += i->pgref; return np; } ulong imagereclaim(int active) { static Image *i, *ie; int j; ulong np; eqlock(&imagealloc.ireclaim); if(i == nil){ i = imagealloc.list; ie = &imagealloc.list[conf.nimage]; } np = 0; for(j = 0; j < conf.nimage; j++, i++){ if(i >= ie) i = imagealloc.list; if(i->ref == 0 || (i->ref != i->pgref) == !active) continue; np += pagereclaim(i); if(np >= 1000) goto Done; } Done: qunlock(&imagealloc.ireclaim); return np; } /* putimage(): called with image locked and unlocks */ void putimage(Image *i) { Image *f, **l; Chan *c; long r; r = decref(i); if(i->notext){ unlock(i); return; } c = nil; if(r == i->pgref){ /* * all remaining references to this image are from the * page cache, so close the chan. */ c = i->c; i->c = nil; } if(r == 0){ l = &ihash(i->qid.path); mkqid(&i->qid, ~0, ~0, QTFILE); unlock(i); lock(&imagealloc); for(f = *l; f != nil; f = f->hash) { if(f == i) { *l = i->hash; break; } l = &f->hash; } i->next = imagealloc.free; imagealloc.free = i; unlock(&imagealloc); } else unlock(i); if(c != nil) ccloseq(c); /* does not block */ } uintptr ibrk(uintptr addr, int seg) { Segment *s, *ns; uintptr newtop; ulong newsize; int i, mapsize; Pte **map; s = up->seg[seg]; if(s == nil) error(Ebadarg); if(addr == 0) return s->base; qlock(s); /* We may start with the bss overlapping the data */ if(addr < s->base) { if(seg != BSEG || up->seg[DSEG] == nil || addr < up->seg[DSEG]->base) { qunlock(s); error(Enovmem); } addr = s->base; } newtop = PGROUND(addr); newsize = (newtop-s->base)/BY2PG; if(newtop < s->top) { /* * do not shrink a segment shared with other procs, as the * to-be-freed address space may have been passed to the kernel * already by another proc and is past the validaddr stage. */ if(s->ref > 1){ qunlock(s); error(Einuse); } mfreeseg(s, newtop, (s->top-newtop)/BY2PG); s->top = newtop; s->size = newsize; qunlock(s); flushmmu(); return 0; } for(i = 0; i < NSEG; i++) { ns = up->seg[i]; if(ns == nil || ns == s) continue; if(newtop > ns->base && s->base < ns->top) { qunlock(s); error(Esoverlap); } } if(newsize > (SEGMAPSIZE*PTEPERTAB)) { qunlock(s); error(Enovmem); } mapsize = ROUND(newsize, PTEPERTAB)/PTEPERTAB; if(mapsize > s->mapsize){ map = malloc(mapsize*sizeof(Pte*)); if(map == nil){ qunlock(s); error(Enomem); } memmove(map, s->map, s->mapsize*sizeof(Pte*)); if(s->map != s->ssegmap) free(s->map); s->map = map; s->mapsize = mapsize; } s->top = newtop; s->size = newsize; qunlock(s); return 0; } /* * called with s locked */ ulong mcountseg(Segment *s) { Pte **pte, **emap; Page **pg, **pe; ulong pages; pages = 0; emap = &s->map[s->mapsize]; for(pte = s->map; pte < emap; pte++){ if(*pte == nil) continue; pe = (*pte)->last; for(pg = (*pte)->first; pg <= pe; pg++) if(!pagedout(*pg)) pages++; } return pages; } /* * called with s locked */ void mfreeseg(Segment *s, uintptr start, ulong pages) { uintptr off; Pte **pte, **emap; Page **pg, **pe; if(pages == 0) return; switch(s->type&SG_TYPE){ case SG_PHYSICAL: case SG_FIXED: case SG_STICKY: return; } /* * we have to make sure other processors flush the * entry from their TLBs before the page is freed. */ if(s->ref > 1) procflushseg(s); off = start-s->base; pte = &s->map[off/PTEMAPMEM]; off = (off&(PTEMAPMEM-1))/BY2PG; for(emap = &s->map[s->mapsize]; pte < emap; pte++, off = 0) { if(*pte == nil) { off = PTEPERTAB - off; if(off >= pages) return; pages -= off; continue; } pg = &(*pte)->pages[off]; for(pe = &(*pte)->pages[PTEPERTAB]; pg < pe; pg++) { if(*pg != nil){ putpage(*pg); *pg = nil; } if(--pages == 0) return; } } } Segment* isoverlap(uintptr va, uintptr len) { int i; Segment *ns; uintptr newtop; newtop = va+len; for(i = 0; i < NSEG; i++) { ns = up->seg[i]; if(ns == nil) continue; if(newtop > ns->base && va < ns->top) return ns; } return nil; } Physseg* addphysseg(Physseg* new) { Physseg *ps; /* * Check not already entered and there is room * for a new entry and the terminating null entry. */ lock(&physseglock); for(ps = physseg; ps->name; ps++){ if(strcmp(ps->name, new->name) == 0){ unlock(&physseglock); return nil; } } if(ps-physseg >= nelem(physseg)-2){ unlock(&physseglock); return nil; } *ps = *new; unlock(&physseglock); return ps; } Physseg* findphysseg(char *name) { Physseg *ps; for(ps = physseg; ps->name; ps++) if(strcmp(ps->name, name) == 0) return ps; return nil; } uintptr segattach(int attr, char *name, uintptr va, uintptr len) { int sno; Segment *s, *os; Physseg *ps; if(va != 0 && va >= USTKTOP) error(Ebadarg); for(sno = 0; sno < NSEG; sno++) if(up->seg[sno] == nil && sno != ESEG) break; if(sno == NSEG) error(Enovmem); /* * first look for a global segment with the * same name */ if(_globalsegattach != nil){ s = (*_globalsegattach)(name); if(s != nil){ if(isoverlap(s->base, s->top - s->base) != nil){ putseg(s); error(Esoverlap); } up->seg[sno] = s; return s->base; } } /* round up va+len */ len += va & (BY2PG-1); len = PGROUND(len); if(len == 0) error(Ebadarg); /* * Find a hole in the address space. * Starting at the lowest possible stack address - len, * check for an overlapping segment, and repeat at the * base of that segment - len until either a hole is found * or the address space is exhausted. Ensure that we don't * map the zero page. */ if(va == 0) { for (os = up->seg[SSEG]; os != nil; os = isoverlap(va, len)) { va = os->base; if(len >= va) error(Enovmem); va -= len; } } va &= ~(BY2PG-1); if(va == 0 || (va+len) > USTKTOP || (va+len) < va) error(Ebadarg); if(isoverlap(va, len) != nil) error(Esoverlap); ps = findphysseg(name); if(ps == nil) error(Ebadarg); if(len > ps->size) error(Enovmem); /* Turn off what is not allowed */ attr &= ~(SG_TYPE | SG_CACHED | SG_DEVICE); /* Copy in defaults */ attr |= ps->attr; s = newseg(attr, va, len/BY2PG); s->pseg = ps; up->seg[sno] = s; return va; } static void segflush(void *va, uintptr len) { uintptr from, to, off; Segment *s; Pte *pte; Page **pg, **pe; from = (uintptr)va; to = from + len; to = PGROUND(to); from &= ~(BY2PG-1); if(to < from) error(Ebadarg); while(from < to) { s = seg(up, from, 1); if(s == nil) error(Ebadarg); s->flushme = 1; if(s->ref > 1) procflushseg(s); more: len = (s->top < to ? s->top : to) - from; if(s->mapsize > 0){ off = from-s->base; pte = s->map[off/PTEMAPMEM]; off &= PTEMAPMEM-1; if(off+len > PTEMAPMEM) len = PTEMAPMEM-off; if(pte != nil) { pg = &pte->pages[off/BY2PG]; pe = pg + len/BY2PG; while(pg < pe) { settxtflush(*pg, !pagedout(*pg)); pg++; } } } from += len; if(from < to && from < s->top) goto more; qunlock(s); } } uintptr syssegflush(va_list list) { void *va; ulong len; va = va_arg(list, void*); len = va_arg(list, ulong); segflush(va, len); flushmmu(); return 0; } void segclock(uintptr pc) { Segment *s; s = up->seg[TSEG]; if(s == nil || s->profile == nil) return; s->profile[0] += TK2MS(1); if(pc >= s->base && pc < s->top) { pc -= s->base; s->profile[pc>>LRESPROF] += TK2MS(1); } } Segment* txt2data(Segment *s) { Segment *ps; ps = newseg(SG_DATA, s->base, s->size); ps->image = s->image; incref(ps->image); ps->fstart = s->fstart; ps->flen = s->flen; ps->flushme = 1; qunlock(s); putseg(s); qlock(ps); return ps; } Segment* data2txt(Segment *s) { Segment *ps; ps = newseg(SG_TEXT | SG_RONLY, s->base, s->size); ps->image = s->image; incref(ps->image); ps->fstart = s->fstart; ps->flen = s->flen; ps->flushme = 1; return ps; } enum { /* commands to segmentioproc */ Cnone=0, Cread, Cwrite, Cdie, }; static int cmddone(void *arg) { Segio *sio = arg; return sio->cmd == Cnone; } static void docmd(Segio *sio, int cmd) { sio->err = nil; sio->cmd = cmd; while(waserror()) ; wakeup(&sio->cmdwait); sleep(&sio->replywait, cmddone, sio); poperror(); if(sio->err != nil) error(sio->err); } static int cmdready(void *arg) { Segio *sio = arg; return sio->cmd != Cnone; } static void segmentioproc(void *arg) { Segio *sio = arg; int done; int sno; for(sno = 0; sno < NSEG; sno++) if(up->seg[sno] == nil && sno != ESEG) break; if(sno == NSEG) panic("segmentkproc"); sio->p = up; incref(sio->s); up->seg[sno] = sio->s; while(waserror()) ; for(done = 0; !done;){ sleep(&sio->cmdwait, cmdready, sio); if(waserror()) sio->err = up->errstr; else { if(sio->s != nil && up->seg[sno] != sio->s){ putseg(up->seg[sno]); incref(sio->s); up->seg[sno] = sio->s; flushmmu(); } switch(sio->cmd){ case Cread: memmove(sio->data, sio->addr, sio->dlen); break; case Cwrite: memmove(sio->addr, sio->data, sio->dlen); if(sio->s->flushme) segflush(sio->addr, sio->dlen); break; case Cdie: done = 1; break; } poperror(); } sio->cmd = Cnone; wakeup(&sio->replywait); } pexit("done", 1); } long segio(Segio *sio, Segment *s, void *a, long n, vlong off, int read) { uintptr m; void *b; b = a; if(s != nil){ m = s->top - s->base; if(off < 0 || off >= m){ if(!read) error(Ebadarg); return 0; } if(off+n > m){ if(!read) error(Ebadarg); n = m - off; } if((uintptr)a < KZERO) { b = smalloc(n); if(waserror()){ free(b); nexterror(); } if(!read) memmove(b, a, n); } } eqlock(sio); if(waserror()){ qunlock(sio); nexterror(); } sio->s = s; if(s == nil){ if(sio->p != nil){ docmd(sio, Cdie); sio->p = nil; } qunlock(sio); poperror(); return 0; } if(sio->p == nil){ sio->cmd = Cnone; kproc("segmentio", segmentioproc, sio); } sio->addr = (char*)s->base + off; sio->data = b; sio->dlen = n; docmd(sio, read ? Cread : Cwrite); qunlock(sio); poperror(); if(a != b){ if(read) memmove(a, b, n); free(b); poperror(); } return n; }