sys/src/cmd/venti/srv/arenas.c

   1 #include "stdinc.h"
   2 #include "dat.h"
   3 #include "fns.h"
   4
   5 typedef struct AHash    AHash;
   6
   7 /*
   8  * hash table for finding arena's based on their names.
   9  */
  10 struct AHash
  11 {
  12         AHash   *next;
  13         Arena   *arena;
  14 };
  15
  16 enum
  17 {
  18         AHashSize       = 512
  19 };
  20
  21 static AHash    *ahash[AHashSize];
  22
  23 static u32int
  24 hashstr(char *s)
  25 {
  26         u32int h;
  27         int c;
  28
  29         h = 0;
  30         for(; c = *s; s++){
  31                 c ^= c << 6;
  32                 h += (c << 11) ^ (c >> 1);
  33                 c = *s;
  34                 h ^= (c << 14) + (c << 7) + (c << 4) + c;
  35         }
  36         return h;
  37 }
  38
  39 int
  40 addarena(Arena *arena)
  41 {
  42         AHash *a;
  43         u32int h;
  44
  45         h = hashstr(arena->name) & (AHashSize - 1);
  46         a = MK(AHash);
  47         if(a == nil)
  48                 return -1;
  49         a->arena = arena;
  50         a->next = ahash[h];
  51         ahash[h] = a;
  52         return 0;
  53 }
  54
  55 Arena*
  56 findarena(char *name)
  57 {
  58         AHash *a;
  59         u32int h;
  60
  61         h = hashstr(name) & (AHashSize - 1);
  62         for(a = ahash[h]; a != nil; a = a->next)
  63                 if(strcmp(a->arena->name, name) == 0)
  64                         return a->arena;
  65         return nil;
  66 }
  67
  68 int
  69 delarena(Arena *arena)
  70 {
  71         AHash *a, *last;
  72         u32int h;
  73
  74         h = hashstr(arena->name) & (AHashSize - 1);
  75         last = nil;
  76         for(a = ahash[h]; a != nil; a = a->next){
  77                 if(a->arena == arena){
  78                         if(last != nil)
  79                                 last->next = a->next;
  80                         else
  81                                 ahash[h] = a->next;
  82                         free(a);
  83                         return 0;
  84                 }
  85                 last = a;
  86         }
  87         return -1;
  88 }
  89
  90 ArenaPart*
  91 initarenapart(Part *part)
  92 {
  93         AMapN amn;
  94         ArenaPart *ap;
  95         ZBlock *b;
  96         u32int i;
  97         int ok;
  98
  99         b = alloczblock(HeadSize, 0, 0);
 100         if(b == nil || readpart(part, PartBlank, b->data, HeadSize) < 0){
 101                 seterr(EAdmin, "can't read arena partition header: %r");
 102                 return nil;
 103         }
 104
 105         ap = MKZ(ArenaPart);
 106         if(ap == nil){
 107                 freezblock(b);
 108                 return nil;
 109         }
 110         ap->part = part;
 111         ok = unpackarenapart(ap, b->data);
 112         freezblock(b);
 113         if(ok < 0){
 114                 freearenapart(ap, 0);
 115                 return nil;
 116         }
 117
 118         ap->tabbase = (PartBlank + HeadSize + ap->blocksize - 1) & ~(ap->blocksize - 1);
 119         if(ap->version != ArenaPartVersion){
 120                 seterr(ECorrupt, "unknown arena partition version %d", ap->version);
 121                 freearenapart(ap, 0);
 122                 return nil;
 123         }
 124         if(ap->blocksize & (ap->blocksize - 1)){
 125                 seterr(ECorrupt, "illegal non-power-of-2 block size %d\n", ap->blocksize);
 126                 freearenapart(ap, 0);
 127                 return nil;
 128         }
 129         if(ap->tabbase >= ap->arenabase){
 130                 seterr(ECorrupt, "arena partition table overlaps with arena storage");
 131                 freearenapart(ap, 0);
 132                 return nil;
 133         }
 134         ap->tabsize = ap->arenabase - ap->tabbase;
 135         partblocksize(part, ap->blocksize);
 136         ap->size = ap->part->size & ~(u64int)(ap->blocksize - 1);
 137
 138         if(readarenamap(&amn, part, ap->tabbase, ap->tabsize) < 0){
 139                 freearenapart(ap, 0);
 140                 return nil;
 141         }
 142         ap->narenas = amn.n;
 143         ap->map = amn.map;
 144         if(okamap(ap->map, ap->narenas, ap->arenabase, ap->size, "arena table") < 0){
 145                 freearenapart(ap, 0);
 146                 return nil;
 147         }
 148
 149         ap->arenas = MKNZ(Arena*, ap->narenas);
 150         for(i = 0; i < ap->narenas; i++){
 151                 debugarena = i;
 152                 ap->arenas[i] = initarena(part, ap->map[i].start, ap->map[i].stop - ap->map[i].start, ap->blocksize);
 153                 if(ap->arenas[i] == nil){
 154                         seterr(ECorrupt, "%s: %r", ap->map[i].name);
 155                         freearenapart(ap, 1);
 156                         return nil;
 157                 }
 158                 if(namecmp(ap->map[i].name, ap->arenas[i]->name) != 0){
 159                         seterr(ECorrupt, "arena name mismatches with expected name: %s vs. %s",
 160                                 ap->map[i].name, ap->arenas[i]->name);
 161                         freearenapart(ap, 1);
 162                         return nil;
 163                 }
 164                 if(findarena(ap->arenas[i]->name)){
 165                         seterr(ECorrupt, "duplicate arena name %s in %s",
 166                                 ap->map[i].name, ap->part->name);
 167                         freearenapart(ap, 1);
 168                         return nil;
 169                 }
 170         }
 171
 172         for(i = 0; i < ap->narenas; i++) {
 173                 debugarena = i;
 174                 addarena(ap->arenas[i]);
 175         }
 176         debugarena = -1;
 177
 178         return ap;
 179 }
 180
 181 ArenaPart*
 182 newarenapart(Part *part, u32int blocksize, u32int tabsize)
 183 {
 184         ArenaPart *ap;
 185
 186         if(blocksize & (blocksize - 1)){
 187                 seterr(ECorrupt, "illegal non-power-of-2 block size %d\n", blocksize);
 188                 return nil;
 189         }
 190         ap = MKZ(ArenaPart);
 191         if(ap == nil)
 192                 return nil;
 193
 194         ap->version = ArenaPartVersion;
 195         ap->part = part;
 196         ap->blocksize = blocksize;
 197         partblocksize(part, blocksize);
 198         ap->size = part->size & ~(u64int)(blocksize - 1);
 199         ap->tabbase = (PartBlank + HeadSize + blocksize - 1) & ~(blocksize - 1);
 200         ap->arenabase = (ap->tabbase + tabsize + blocksize - 1) & ~(blocksize - 1);
 201         ap->tabsize = ap->arenabase - ap->tabbase;
 202         ap->narenas = 0;
 203
 204         if(wbarenapart(ap) < 0){
 205                 freearenapart(ap, 0);
 206                 return nil;
 207         }
 208
 209         return ap;
 210 }
 211
 212 int
 213 wbarenapart(ArenaPart *ap)
 214 {
 215         ZBlock *b;
 216
 217         if(okamap(ap->map, ap->narenas, ap->arenabase, ap->size, "arena table") < 0)
 218                 return -1;
 219         b = alloczblock(HeadSize, 1, 0);
 220         if(b == nil)
 221 /* ZZZ set error message? */
 222                 return -1;
 223
 224         if(packarenapart(ap, b->data) < 0){
 225                 seterr(ECorrupt, "can't make arena partition header: %r");
 226                 freezblock(b);
 227                 return -1;
 228         }
 229         if(writepart(ap->part, PartBlank, b->data, HeadSize) < 0 ||
 230            flushpart(ap->part) < 0){
 231                 seterr(EAdmin, "can't write arena partition header: %r");
 232                 freezblock(b);
 233                 return -1;
 234         }
 235         freezblock(b);
 236
 237         return wbarenamap(ap->map, ap->narenas, ap->part, ap->tabbase, ap->tabsize);
 238 }
 239
 240 void
 241 freearenapart(ArenaPart *ap, int freearenas)
 242 {
 243         int i;
 244
 245         if(ap == nil)
 246                 return;
 247         if(freearenas){
 248                 for(i = 0; i < ap->narenas; i++){
 249                         if(ap->arenas[i] == nil)
 250                                 continue;
 251                         delarena(ap->arenas[i]);
 252                         freearena(ap->arenas[i]);
 253                 }
 254         }
 255         free(ap->map);
 256         free(ap->arenas);
 257         free(ap);
 258 }
 259
 260 int
 261 okamap(AMap *am, int n, u64int start, u64int stop, char *what)
 262 {
 263         u64int last;
 264         u32int i;
 265
 266         last = start;
 267         for(i = 0; i < n; i++){
 268                 if(am[i].start < last){
 269                         if(i == 0)
 270                                 seterr(ECorrupt, "invalid start address in %s", what);
 271                         else
 272                                 seterr(ECorrupt, "overlapping ranges in %s", what);
 273                         return -1;
 274                 }
 275                 if(am[i].stop < am[i].start){
 276                         seterr(ECorrupt, "invalid range in %s", what);
 277                         return -1;
 278                 }
 279                 last = am[i].stop;
 280         }
 281         if(last > stop){
 282                 seterr(ECorrupt, "invalid ending address in %s", what);
 283                 return -1;
 284         }
 285         return 0;
 286 }
 287
 288 int
 289 maparenas(AMap *am, Arena **arenas, int n, char *what)
 290 {
 291         u32int i;
 292
 293         for(i = 0; i < n; i++){
 294                 arenas[i] = findarena(am[i].name);
 295                 if(arenas[i] == nil){
 296                         seterr(EAdmin, "can't find arena '%s' for '%s'\n", am[i].name, what);
 297                         return -1;
 298                 }
 299         }
 300         return 0;
 301 }
 302
 303 int
 304 readarenamap(AMapN *amn, Part *part, u64int base, u32int size)
 305 {
 306         IFile f;
 307         u32int ok;
 308
 309         if(partifile(&f, part, base, size) < 0)
 310                 return -1;
 311         ok = parseamap(&f, amn);
 312         freeifile(&f);
 313         return ok;
 314 }
 315
 316 int
 317 wbarenamap(AMap *am, int n, Part *part, u64int base, u64int size)
 318 {
 319         Fmt f;
 320         ZBlock *b;
 321
 322         b = alloczblock(size, 1, part->blocksize);
 323         if(b == nil)
 324                 return -1;
 325
 326         fmtzbinit(&f, b);
 327
 328         if(outputamap(&f, am, n) < 0){
 329                 seterr(ECorrupt, "arena set size too small");
 330                 freezblock(b);
 331                 return -1;
 332         }
 333         if(writepart(part, base, b->data, size) < 0 || flushpart(part) < 0){
 334                 seterr(EAdmin, "can't write arena set: %r");
 335                 freezblock(b);
 336                 return -1;
 337         }
 338         freezblock(b);
 339         return 0;
 340 }
 341
 342 /*
 343  * amap: n '\n' amapelem * n
 344  * n: u32int
 345  * amapelem: name '\t' astart '\t' astop '\n'
 346  * astart, astop: u64int
 347  */
 348 int
 349 parseamap(IFile *f, AMapN *amn)
 350 {
 351         AMap *am;
 352         u64int v64;
 353         u32int v;
 354         char *s, *t, *flds[4];
 355         int i, n;
 356
 357         /*
 358          * arenas
 359          */
 360         if(ifileu32int(f, &v) < 0){
 361                 seterr(ECorrupt, "syntax error: bad number of elements in %s", f->name);
 362                 return -1;
 363         }
 364         n = v;
 365         if(n > MaxAMap){
 366                 seterr(ECorrupt, "illegal number of elements %d in %s",
 367                         n, f->name);
 368                 return -1;
 369         }
 370         am = MKNZ(AMap, n);
 371         if(am == nil){
 372                 fprint(2, "out of memory\n");
 373                 return -1;
 374         }
 375         for(i = 0; i < n; i++){
 376                 s = ifileline(f);
 377                 if(s)
 378                         t = estrdup(s);
 379                 else
 380                         t = nil;
 381                 if(s == nil || getfields(s, flds, 4, 0, "\t") != 3){
 382                         fprint(2, "early eof after %d of %d, %s:#%d: %s\n", i, n, f->name, f->pos, t);
 383                         free(t);
 384                         return -1;
 385                 }
 386                 free(t);
 387                 if(nameok(flds[0]) < 0)
 388                         return -1;
 389                 namecp(am[i].name, flds[0]);
 390                 if(stru64int(flds[1], &v64) < 0){
 391                         seterr(ECorrupt, "syntax error: bad arena base address in %s", f->name);
 392                         free(am);
 393                         return -1;
 394                 }
 395                 am[i].start = v64;
 396                 if(stru64int(flds[2], &v64) < 0){
 397                         seterr(ECorrupt, "syntax error: bad arena size in %s", f->name);
 398                         free(am);
 399                         return -1;
 400                 }
 401                 am[i].stop = v64;
 402         }
 403
 404         amn->map = am;
 405         amn->n = n;
 406         return 0;
 407 }
 408
 409 int
 410 outputamap(Fmt *f, AMap *am, int n)
 411 {
 412         int i;
 413
 414         if(fmtprint(f, "%ud\n", n) < 0)
 415                 return -1;
 416         for(i = 0; i < n; i++)
 417                 if(fmtprint(f, "%s\t%llud\t%llud\n", am[i].name, am[i].start, am[i].stop) < 0)
 418                         return -1;
 419         return 0;
 420 }