sys/src/cmd/cwfs/malloc.c

   1 #include "all.h"
   2 #include "io.h"
   3
   4 static ulong
   5 memsize(void)
   6 {
   7         int nf, pgsize = 0;
   8         ulong userpgs = 0, userused = 0;
   9         char *ln, *sl;
  10         char *fields[2];
  11         Biobuf *bp;
  12
  13         bp = Bopen("#c/swap", OREAD);
  14         if (bp != nil) {
  15                 while ((ln = Brdline(bp, '\n')) != nil) {
  16                         ln[Blinelen(bp)-1] = '\0';
  17                         nf = tokenize(ln, fields, nelem(fields));
  18                         if (nf != 2)
  19                                 continue;
  20                         if (strcmp(fields[1], "pagesize") == 0)
  21                                 pgsize = atoi(fields[0]);
  22                         else if (strcmp(fields[1], "user") == 0) {
  23                                 sl = strchr(fields[0], '/');
  24                                 if (sl == nil)
  25                                         continue;
  26                                 userpgs = atol(sl+1);
  27                                 userused = atol(fields[0]);
  28                         }
  29                 }
  30                 Bterm(bp);
  31                 if (pgsize > 0 && userused < userpgs)
  32                         return (userpgs - userused)*pgsize;
  33         }
  34         return 64*MB;
  35 }
  36
  37
  38 long    niob;
  39 long    nhiob;
  40 Hiob    *hiob;
  41
  42 /*
  43  * Called to allocate permanent data structures
  44  * Alignment is in number of bytes. It pertains both to the start and
  45  * end of the allocated memory.
  46  */
  47 void*
  48 ialloc(ulong n, int align)
  49 {
  50         void *p = mallocalign(n, align, 0, 0);
  51
  52         if (p == nil)
  53                 panic("ialloc: out of memory");
  54         setmalloctag(p, getcallerpc(&n));
  55         memset(p, 0, n);
  56         return p;
  57 }
  58
  59 enum { HWIDTH = 8 };            /* buffers per hash */
  60
  61 /*
  62  * allocate rest of mem
  63  * for io buffers.
  64  */
  65 void
  66 iobufinit(void)
  67 {
  68         long m;
  69         int i;
  70         char *xiop;
  71         Iobuf *p, *q;
  72         Hiob *hp;
  73
  74         wlock(&mainlock);       /* init */
  75         wunlock(&mainlock);
  76
  77         m = memsize() / 4;
  78         niob = m / (sizeof(Iobuf) + RBUFSIZE + sizeof(Hiob)/HWIDTH);
  79         nhiob = niob / HWIDTH;
  80         while(!prime(nhiob))
  81                 nhiob++;
  82         if(chatty)
  83                 print("\t%ld buffers; %ld hashes\n", niob, nhiob);
  84         hiob = ialloc(nhiob * sizeof(Hiob), 0);
  85         hp = hiob;
  86         for(i=0; i<nhiob; i++) {
  87                 lock(hp);
  88                 unlock(hp);
  89                 hp++;
  90         }
  91         p = ialloc(niob * sizeof(Iobuf), 0);
  92         xiop = ialloc(niob * RBUFSIZE, 0);
  93         hp = hiob;
  94         for(i=0; i < niob; i++) {
  95                 qlock(p);
  96                 qunlock(p);
  97                 if(hp == hiob)
  98                         hp = hiob + nhiob;
  99                 hp--;
 100                 q = hp->link;
 101                 if(q) {
 102                         p->fore = q;
 103                         p->back = q->back;
 104                         q->back = p;
 105                         p->back->fore = p;
 106                 } else {
 107                         hp->link = p;
 108                         p->fore = p;
 109                         p->back = p;
 110                 }
 111                 p->dev = devnone;
 112                 p->addr = -1;
 113                 p->xiobuf = xiop;
 114                 p->iobuf = (char*)-1;
 115                 p++;
 116                 xiop += RBUFSIZE;
 117         }
 118 }
 119
 120 void*
 121 iobufmap(Iobuf *p)
 122 {
 123         return p->iobuf = p->xiobuf;
 124 }
 125
 126 void
 127 iobufunmap(Iobuf *p)
 128 {
 129         p->iobuf = (char*)-1;
 130 }