1 /* 2 * cached-worm device 3 */ 4 #include "all.h" 5 6 #define CDEV(d) ((d)->cw.c) 7 #define WDEV(d) ((d)->cw.w) 8 #define RDEV(d) ((d)->cw.ro) 9 10 enum { 11 DEBUG = 0, 12 FIRST = SUPER_ADDR, 13 14 ADDFREE = 100, 15 CACHE_ADDR = SUPER_ADDR, 16 MAXAGE = 10000, 17 }; 18 19 /* cache state */ 20 enum 21 { 22 /* states -- beware these are recorded on the cache */ 23 /* cache worm */ 24 Cnone = 0, /* 0 ? */ 25 Cdirty, /* 1 0 */ 26 Cdump, /* 1 0->1 */ 27 Cread, /* 1 1 */ 28 Cwrite, /* 2 1 */ 29 Cdump1, /* inactive form of dump */ 30 Cerror, 31 32 /* opcodes -- these are not recorded */ 33 Onone, 34 Oread, 35 Owrite, 36 Ogrow, 37 Odump, 38 Orele, 39 Ofree, 40 }; 41 42 typedef struct Cw Cw; 43 struct Cw 44 { 45 Device* dev; 46 Device* cdev; 47 Device* wdev; 48 Device* rodev; 49 Cw* link; 50 51 int dbucket; /* last bucket dumped */ 52 Off daddr; /* last block dumped */ 53 Off ncopy; 54 int nodump; 55 /* 56 * following are cached variables for dumps 57 */ 58 Off fsize; 59 Off ndump; 60 int depth; 61 int all; /* local flag to recur on modified dirs */ 62 int allflag; /* global flag to recur on modified dirs */ 63 Off falsehits; /* times recur found modified blocks */ 64 struct { 65 char name[500]; 66 char namepad[NAMELEN+10]; 67 }; 68 }; 69 70 static char* cwnames[] = 71 { 72 [Cnone] "none", 73 [Cdirty] "dirty", 74 [Cdump] "dump", 75 [Cread] "read", 76 [Cwrite] "write", 77 [Cdump1] "dump1", 78 [Cerror] "error", 79 80 [Onone] "none", 81 [Oread] "read", 82 [Owrite] "write", 83 [Ogrow] "grow", 84 [Odump] "dump", 85 [Orele] "rele", 86 }; 87 88 int oldcachefmt = 1; 89 90 Centry* getcentry(Bucket*, Off); 91 int cwio(Device*, Off, void*, int); 92 void cmd_cwcmd(int, char*[]); 93 94 /* 95 * console command 96 * initiate a dump 97 */ 98 void 99 cmd_dump(int argc, char *argv[]) 100 { 101 Filsys *fs; 102 103 fs = cons.curfs; 104 if(argc > 1) 105 fs = fsstr(argv[1]); 106 if(fs == 0) { 107 print("%s: unknown file system\n", argv[1]); 108 return; 109 } 110 cfsdump(fs); 111 } 112 113 /* 114 * console command 115 * worm stats 116 */ 117 static void 118 cmd_statw(int, char*[]) 119 { 120 Filsys *fs; 121 Iobuf *p; 122 Superb *sb; 123 Cache *h; 124 Bucket *b; 125 Centry *c, *ce; 126 Off m, nw, bw, state[Onone]; 127 Off sbfsize, sbcwraddr, sbroraddr, sblast, sbnext; 128 Off hmsize, hmaddr, dsize, dsizepct; 129 Device *dev; 130 Cw *cw; 131 int s; 132 133 fs = cons.curfs; 134 dev = fs->dev; 135 if(dev->type != Devcw) { 136 print("curfs not type cw\n"); 137 return; 138 } 139 140 cw = dev->private; 141 if(cw == 0) { 142 print("curfs not inited\n"); 143 return; 144 } 145 146 print("cwstats %s\n", fs->name); 147 148 sbfsize = 0; 149 sbcwraddr = 0; 150 sbroraddr = 0; 151 sblast = 0; 152 sbnext = 0; 153 154 print("\tfilesys %s\n", fs->name); 155 // print("\tnio =%7W%7W%7W\n", cw->ncwio+0, cw->ncwio+1, cw->ncwio+2); 156 p = getbuf(dev, cwsaddr(dev), Brd); 157 if(!p || checktag(p, Tsuper, QPSUPER)) { 158 print("cwstats: checktag super\n"); 159 if(p) { 160 putbuf(p); 161 p = 0; 162 } 163 } 164 if(p) { 165 sb = (Superb*)p->iobuf; 166 sbfsize = sb->fsize; 167 sbcwraddr = sb->cwraddr; 168 sbroraddr = sb->roraddr; 169 sblast = sb->last; 170 sbnext = sb->next; 171 putbuf(p); 172 } 173 174 p = getbuf(cw->cdev, CACHE_ADDR, Brd|Bres); 175 if(!p || checktag(p, Tcache, QPSUPER)) { 176 print("cwstats: checktag c bucket\n"); 177 if(p) 178 putbuf(p); 179 return; 180 } 181 h = (Cache*)p->iobuf; 182 hmaddr = h->maddr; 183 hmsize = h->msize; 184 185 print("\t\tmaddr = %8lld\n", (Wideoff)hmaddr); 186 print("\t\tmsize = %8lld\n", (Wideoff)hmsize); 187 print("\t\tcaddr = %8lld\n", (Wideoff)h->caddr); 188 print("\t\tcsize = %8lld\n", (Wideoff)h->csize); 189 print("\t\tsbaddr = %8lld\n", (Wideoff)h->sbaddr); 190 print("\t\tcraddr = %8lld %8lld\n", 191 (Wideoff)h->cwraddr, (Wideoff)sbcwraddr); 192 print("\t\troaddr = %8lld %8lld\n", 193 (Wideoff)h->roraddr, (Wideoff)sbroraddr); 194 /* print stats in terms of (first-)disc sides */ 195 dsize = wormsizeside(dev, 0); 196 if (dsize < 1) { 197 if (DEBUG) 198 print("wormsizeside returned size %lld for %Z side 0\n", 199 (Wideoff)dsize, dev); 200 dsize = h->wsize; /* it's probably a fake worm */ 201 if (dsize < 1) 202 dsize = 1000; /* don't divide by zero */ 203 } 204 dsizepct = dsize/100; 205 print("\t\tfsize = %8lld %8lld %2lld+%2lld%%\n", (Wideoff)h->fsize, 206 (Wideoff)sbfsize, (Wideoff)h->fsize/dsize, 207 (Wideoff)(h->fsize%dsize)/dsizepct); 208 print("\t\tslast = %8lld\n", (Wideoff)sblast); 209 print("\t\tsnext = %8lld\n", (Wideoff)sbnext); 210 print("\t\twmax = %8lld %2lld+%2lld%%\n", 211 (Wideoff)h->wmax, (Wideoff)h->wmax/dsize, 212 (Wideoff)(h->wmax%dsize)/dsizepct); 213 print("\t\twsize = %8lld %2lld+%2lld%%\n", 214 (Wideoff)h->wsize, (Wideoff)h->wsize/dsize, 215 (Wideoff)(h->wsize%dsize)/dsizepct); 216 putbuf(p); 217 218 bw = 0; /* max filled bucket */ 219 memset(state, 0, sizeof(state)); 220 for(m = 0; m < hmsize; m++) { 221 p = getbuf(cw->cdev, hmaddr + m/BKPERBLK, Brd); 222 if(!p || checktag(p, Tbuck, hmaddr + m/BKPERBLK)) { 223 print("cwstats: checktag c bucket\n"); 224 if(p) 225 putbuf(p); 226 return; 227 } 228 b = (Bucket*)p->iobuf + m%BKPERBLK; 229 ce = b->entry + CEPERBK; 230 nw = 0; 231 for(c = b->entry; c < ce; c++) { 232 s = c->state; 233 state[s]++; 234 if(s != Cnone && s != Cread) 235 nw++; 236 } 237 putbuf(p); 238 if(nw > bw) 239 bw = nw; 240 } 241 for(s = Cnone; s < Cerror; s++) 242 print("\t\t%6lld %s\n", (Wideoff)state[s], cwnames[s]); 243 print("\t\tcache %2lld%% full\n", ((Wideoff)bw*100)/CEPERBK); 244 } 245 246 int 247 dumpblock(Device *dev) 248 { 249 Iobuf *p, *cb, *p1, *p2; 250 Cache *h; 251 Centry *c, *ce, *bc; 252 Bucket *b; 253 Off m, a, msize, maddr, wmax, caddr; 254 int s1, s2, count; 255 Cw *cw; 256 257 cw = dev->private; 258 if(cw == 0 || cw->nodump) 259 return 0; 260 261 cb = getbuf(cw->cdev, CACHE_ADDR, Brd|Bres); 262 h = (Cache*)cb->iobuf; 263 msize = h->msize; 264 maddr = h->maddr; 265 wmax = h->wmax; 266 caddr = h->caddr; 267 putbuf(cb); 268 269 for(m=msize; m>=0; m--) { 270 a = cw->dbucket + 1; 271 if(a < 0 || a >= msize) 272 a = 0; 273 cw->dbucket = a; 274 p = getbuf(cw->cdev, maddr + a/BKPERBLK, Brd); 275 b = (Bucket*)p->iobuf + a%BKPERBLK; 276 ce = b->entry + CEPERBK; 277 bc = 0; 278 for(c = b->entry; c < ce; c++) 279 if(c->state == Cdump) { 280 if(bc == 0) { 281 bc = c; 282 continue; 283 } 284 if(c->waddr < cw->daddr) { 285 if(bc->waddr < cw->daddr && 286 bc->waddr > c->waddr) 287 bc = c; 288 continue; 289 } 290 if(bc->waddr < cw->daddr || 291 bc->waddr > c->waddr) 292 bc = c; 293 } 294 if(bc) { 295 c = bc; 296 goto found; 297 } 298 putbuf(p); 299 } 300 if(cw->ncopy) { 301 print("%lld blocks copied to worm\n", (Wideoff)cw->ncopy); 302 cw->ncopy = 0; 303 } 304 cw->nodump = 1; 305 return 0; 306 307 found: 308 if (oldcachefmt) 309 a = a*CEPERBK + (c - b->entry) + caddr; 310 else 311 a += (c - b->entry)*msize + caddr; 312 p1 = getbuf(devnone, Cwdump1, 0); 313 count = 0; 314 315 retry: 316 count++; 317 if(count > 10 || devread(cw->cdev, a, p1->iobuf)) 318 goto stop; 319 m = c->waddr; 320 cw->daddr = m; 321 s1 = devwrite(cw->wdev, m, p1->iobuf); 322 if(s1) { 323 p2 = getbuf(devnone, Cwdump2, 0); 324 s2 = devread(cw->wdev, m, p2->iobuf); 325 if(s2) { 326 if(s1 == 0x61 && s2 == 0x60) { 327 putbuf(p2); 328 goto retry; 329 } 330 goto stop1; 331 } 332 if(memcmp(p1->iobuf, p2->iobuf, RBUFSIZE)) 333 goto stop1; 334 putbuf(p2); 335 } 336 /* 337 * reread and compare 338 */ 339 if(conf.dumpreread) { 340 p2 = getbuf(devnone, Cwdump2, 0); 341 s1 = devread(cw->wdev, m, p2->iobuf); 342 if(s1) 343 goto stop1; 344 if(memcmp(p1->iobuf, p2->iobuf, RBUFSIZE)) { 345 print("reread C%lld W%lld didnt compare\n", 346 (Wideoff)a, (Wideoff)m); 347 goto stop1; 348 } 349 putbuf(p2); 350 } 351 352 putbuf(p1); 353 c->state = Cread; 354 p->flags |= Bmod; 355 putbuf(p); 356 357 if(m > wmax) { 358 cb = getbuf(cw->cdev, CACHE_ADDR, Brd|Bmod|Bres); 359 h = (Cache*)cb->iobuf; 360 if(m > h->wmax) 361 h->wmax = m; 362 putbuf(cb); 363 } 364 cw->ncopy++; 365 return 1; 366 367 stop1: 368 putbuf(p2); 369 putbuf(p1); 370 c->state = Cdump1; 371 p->flags |= Bmod; 372 putbuf(p); 373 return 1; 374 375 stop: 376 putbuf(p1); 377 putbuf(p); 378 print("stopping dump!!\n"); 379 cw->nodump = 1; 380 return 0; 381 } 382 383 void 384 cwinit1(Device *dev) 385 { 386 Cw *cw; 387 static int first; 388 389 cw = dev->private; 390 if(cw) 391 return; 392 393 if(first == 0) { 394 cmd_install("dump", "-- make dump backup to worm", cmd_dump); 395 cmd_install("statw", "-- cache/worm stats", cmd_statw); 396 cmd_install("cwcmd", "subcommand -- cache/worm errata", cmd_cwcmd); 397 roflag = flag_install("ro", "-- ro reads and writes"); 398 first = 1; 399 } 400 cw = malloc(sizeof(Cw)); 401 dev->private = cw; 402 403 cw->allflag = 0; 404 405 cw->dev = dev; 406 cw->cdev = CDEV(dev); 407 cw->wdev = WDEV(dev); 408 cw->rodev = RDEV(dev); 409 410 devinit(cw->cdev); 411 devinit(cw->wdev); 412 } 413 414 void 415 cwinit(Device *dev) 416 { 417 Cw *cw; 418 Cache *h; 419 Iobuf *cb, *p; 420 Off l, m; 421 422 cwinit1(dev); 423 424 cw = dev->private; 425 l = devsize(cw->wdev); 426 cb = getbuf(cw->cdev, CACHE_ADDR, Brd|Bmod|Bres); 427 h = (Cache*)cb->iobuf; 428 h->toytime = toytime() + SECOND(30); 429 h->time = time(nil); 430 m = h->wsize; 431 if(l != m) { 432 print("wdev changed size %lld to %lld\n", 433 (Wideoff)m, (Wideoff)l); 434 h->wsize = l; 435 cb->flags |= Bmod; 436 } 437 438 for(m=0; m<h->msize; m++) { 439 p = getbuf(cw->cdev, h->maddr + m/BKPERBLK, Brd); 440 if(!p || checktag(p, Tbuck, h->maddr + m/BKPERBLK)) 441 panic("cwinit: checktag c bucket"); 442 putbuf(p); 443 } 444 putbuf(cb); 445 } 446 447 Off 448 cwsaddr(Device *dev) 449 { 450 Iobuf *cb; 451 Off sa; 452 453 cb = getbuf(CDEV(dev), CACHE_ADDR, Brd|Bres); 454 sa = ((Cache*)cb->iobuf)->sbaddr; 455 putbuf(cb); 456 return sa; 457 } 458 459 Off 460 cwraddr(Device *dev) 461 { 462 Iobuf *cb; 463 Off ra; 464 465 switch(dev->type) { 466 default: 467 print("unknown dev in cwraddr %Z\n", dev); 468 return 1; 469 470 case Devcw: 471 cb = getbuf(CDEV(dev), CACHE_ADDR, Brd|Bres); 472 ra = ((Cache*)cb->iobuf)->cwraddr; 473 break; 474 475 case Devro: 476 cb = getbuf(CDEV(dev->ro.parent), CACHE_ADDR, Brd|Bres); 477 ra = ((Cache*)cb->iobuf)->roraddr; 478 break; 479 } 480 putbuf(cb); 481 return ra; 482 } 483 484 Devsize 485 cwsize(Device *dev) 486 { 487 Iobuf *cb; 488 Devsize fs; 489 490 cb = getbuf(CDEV(dev), CACHE_ADDR, Brd|Bres); 491 fs = ((Cache*)cb->iobuf)->fsize; 492 putbuf(cb); 493 return fs; 494 } 495 496 int 497 cwread(Device *dev, Off b, void *c) 498 { 499 return cwio(dev, b, c, Oread) == Cerror; 500 } 501 502 int 503 cwwrite(Device *dev, Off b, void *c) 504 { 505 return cwio(dev, b, c, Owrite) == Cerror; 506 } 507 508 int 509 roread(Device *dev, Off b, void *c) 510 { 511 Device *d; 512 int s; 513 514 /* 515 * maybe better is to try buffer pool first 516 */ 517 d = dev->ro.parent; 518 if(d == 0 || d->type != Devcw || 519 d->private == 0 || RDEV(d) != dev) { 520 print("bad rodev %Z\n", dev); 521 return 1; 522 } 523 s = cwio(d, b, 0, Onone); 524 if(s == Cdump || s == Cdump1 || s == Cread) { 525 s = cwio(d, b, c, Oread); 526 if(s == Cdump || s == Cdump1 || s == Cread) { 527 if(cons.flags & roflag) 528 print("roread: %Z %lld -> %Z(hit)\n", 529 dev, (Wideoff)b, d); 530 return 0; 531 } 532 } 533 if(cons.flags & roflag) 534 print("roread: %Z %lld -> %Z(miss)\n", 535 dev, (Wideoff)b, WDEV(d)); 536 return devread(WDEV(d), b, c); 537 } 538 539 int 540 cwio(Device *dev, Off addr, void *buf, int opcode) 541 { 542 Iobuf *p, *p1, *p2, *cb; 543 Cache *h; 544 Bucket *b; 545 Centry *c; 546 Off bn, a1, a2, max, newmax; 547 int state; 548 Cw *cw; 549 550 cw = dev->private; 551 552 cb = getbuf(cw->cdev, CACHE_ADDR, Brd|Bres); 553 h = (Cache*)cb->iobuf; 554 if(toytime() >= h->toytime) { 555 cb->flags |= Bmod; 556 h->toytime = toytime() + SECOND(30); 557 h->time = time(nil); 558 } 559 560 if(addr < 0) { 561 putbuf(cb); 562 return Cerror; 563 } 564 565 bn = addr % h->msize; 566 a1 = h->maddr + bn/BKPERBLK; 567 if (oldcachefmt) 568 a2 = bn*CEPERBK + h->caddr; 569 else 570 a2 = bn + h->caddr; 571 max = h->wmax; 572 573 putbuf(cb); 574 newmax = 0; 575 576 p = getbuf(cw->cdev, a1, Brd|Bmod); 577 if(!p || checktag(p, Tbuck, a1)) 578 panic("cwio: checktag c bucket"); 579 b = (Bucket*)p->iobuf + bn%BKPERBLK; 580 581 c = getcentry(b, addr); 582 if(c == 0) { 583 putbuf(p); 584 print("%Z disk cache bucket %lld is full\n", 585 cw->cdev, (Wideoff)a1); 586 return Cerror; 587 } 588 a2 += c - b->entry; 589 590 state = c->state; 591 switch(opcode) { 592 default: 593 goto bad; 594 595 case Onone: 596 break; 597 598 case Oread: 599 switch(state) { 600 default: 601 goto bad; 602 603 case Cread: 604 if(!devread(cw->cdev, a2, buf)) 605 break; 606 c->state = Cnone; 607 608 case Cnone: 609 if(devread(cw->wdev, addr, buf)) { 610 state = Cerror; 611 break; 612 } 613 if(addr > max) 614 newmax = addr; 615 if(!devwrite(cw->cdev, a2, buf)) 616 c->state = Cread; 617 break; 618 619 case Cdirty: 620 case Cdump: 621 case Cdump1: 622 case Cwrite: 623 if(devread(cw->cdev, a2, buf)) 624 state = Cerror; 625 break; 626 } 627 break; 628 629 case Owrite: 630 switch(state) { 631 default: 632 goto bad; 633 634 case Cdump: 635 case Cdump1: 636 /* 637 * this is hard part -- a dump block must be 638 * sent to the worm if it is rewritten. 639 * if this causes an error, there is no 640 * place to save the dump1 data. the block 641 * is just reclassified as 'dump1' (botch) 642 */ 643 p1 = getbuf(devnone, Cwio1, 0); 644 if(devread(cw->cdev, a2, p1->iobuf)) { 645 putbuf(p1); 646 print("cwio: write induced dump error - r cache\n"); 647 648 casenone: 649 if(devwrite(cw->cdev, a2, buf)) { 650 state = Cerror; 651 break; 652 } 653 c->state = Cdump1; 654 break; 655 } 656 if(devwrite(cw->wdev, addr, p1->iobuf)) { 657 p2 = getbuf(devnone, Cwio2, 0); 658 if(devread(cw->wdev, addr, p2->iobuf)) { 659 putbuf(p1); 660 putbuf(p2); 661 print("cwio: write induced dump error - r+w worm\n"); 662 goto casenone; 663 } 664 if(memcmp(p1->iobuf, p2->iobuf, RBUFSIZE)) { 665 putbuf(p1); 666 putbuf(p2); 667 print("cwio: write induced dump error - w worm\n"); 668 goto casenone; 669 } 670 putbuf(p2); 671 } 672 putbuf(p1); 673 c->state = Cread; 674 if(addr > max) 675 newmax = addr; 676 cw->ncopy++; 677 678 case Cnone: 679 case Cread: 680 if(devwrite(cw->cdev, a2, buf)) { 681 state = Cerror; 682 break; 683 } 684 c->state = Cwrite; 685 break; 686 687 case Cdirty: 688 case Cwrite: 689 if(devwrite(cw->cdev, a2, buf)) 690 state = Cerror; 691 break; 692 } 693 break; 694 695 case Ogrow: 696 if(state != Cnone) { 697 print("%Z for block %lld cwgrow with state = %s\n", 698 cw->cdev, (Wideoff)addr, cwnames[state]); 699 break; 700 } 701 c->state = Cdirty; 702 break; 703 704 case Odump: 705 if(state != Cdirty) { /* BOTCH */ 706 print("%Z for block %lld cwdump with state = %s\n", 707 cw->cdev, (Wideoff)addr, cwnames[state]); 708 break; 709 } 710 c->state = Cdump; 711 cw->ndump++; /* only called from dump command */ 712 break; 713 714 case Orele: 715 if(state != Cwrite) { 716 if(state != Cdump1) 717 print("%Z for block %lld cwrele with state = %s\n", 718 cw->cdev, (Wideoff)addr, cwnames[state]); 719 break; 720 } 721 c->state = Cnone; 722 break; 723 724 case Ofree: 725 if(state == Cwrite || state == Cread) 726 c->state = Cnone; 727 break; 728 } 729 if(DEBUG) 730 print("cwio: %Z %lld s=%s o=%s ns=%s\n", 731 dev, (Wideoff)addr, cwnames[state], 732 cwnames[opcode], 733 cwnames[c->state]); 734 putbuf(p); 735 if(newmax) { 736 cb = getbuf(cw->cdev, CACHE_ADDR, Brd|Bmod|Bres); 737 h = (Cache*)cb->iobuf; 738 if(newmax > h->wmax) 739 h->wmax = newmax; 740 putbuf(cb); 741 } 742 return state; 743 744 bad: 745 print("%Z block %lld cw state = %s; cw opcode = %s", 746 dev, (Wideoff)addr, cwnames[state], cwnames[opcode]); 747 return Cerror; 748 } 749 750 751 int 752 cwgrow(Device *dev, Superb *sb, int uid) 753 { 754 char str[NAMELEN]; 755 Iobuf *cb; 756 Cache *h; 757 Filsys *filsys; 758 Off fs, nfs, ws; 759 760 cb = getbuf(CDEV(dev), CACHE_ADDR, Brd|Bmod|Bres); 761 h = (Cache*)cb->iobuf; 762 ws = h->wsize; 763 fs = h->fsize; 764 if(fs >= ws) 765 return 0; 766 nfs = fs + ADDFREE; 767 if(nfs >= ws) 768 nfs = ws; 769 h->fsize = nfs; 770 putbuf(cb); 771 772 sb->fsize = nfs; 773 filsys = dev2fs(dev); 774 if (filsys == nil) 775 print("%Z", dev); 776 else 777 print("%s", filsys->name); 778 uidtostr(str, uid, 1); 779 print(" grow from %lld to %lld limit %lld by %s uid=%d\n", 780 (Wideoff)fs, (Wideoff)nfs, (Wideoff)ws, str, uid); 781 for(nfs--; nfs>=fs; nfs--) 782 switch(cwio(dev, nfs, 0, Ogrow)) { 783 case Cerror: 784 return 0; 785 case Cnone: 786 addfree(dev, nfs, sb); 787 } 788 return 1; 789 } 790 791 int 792 cwfree(Device *dev, Off addr) 793 { 794 int state; 795 796 if(dev->type == Devcw) { 797 state = cwio(dev, addr, 0, Ofree); 798 if(state != Cdirty) 799 return 1; /* do not put in freelist */ 800 } 801 return 0; /* put in freelist */ 802 } 803 804 #ifdef unused 805 int 806 bktcheck(Bucket *b) 807 { 808 Centry *c, *c1, *c2, *ce; 809 int err; 810 811 err = 0; 812 if(b->agegen < CEPERBK || b->agegen > MAXAGE) { 813 print("agegen %ld\n", b->agegen); 814 err = 1; 815 } 816 817 ce = b->entry + CEPERBK; 818 c1 = 0; /* lowest age last pass */ 819 for(;;) { 820 c2 = 0; /* lowest age this pass */ 821 for(c = b->entry; c < ce; c++) { 822 if(c1 != 0 && c != c1) { 823 if(c->age == c1->age) { 824 print("same age %d\n", c->age); 825 err = 1; 826 } 827 if(c1->waddr == c->waddr) 828 if(c1->state != Cnone) 829 if(c->state != Cnone) { 830 print("same waddr %lld\n", 831 (Wideoff)c->waddr); 832 err = 1; 833 } 834 } 835 if(c1 != 0 && c->age <= c1->age) 836 continue; 837 if(c2 == 0 || c->age < c2->age) 838 c2 = c; 839 } 840 if(c2 == 0) 841 break; 842 c1 = c2; 843 if(c1->age >= b->agegen) { 844 print("age >= generator %d %ld\n", c1->age, b->agegen); 845 err = 1; 846 } 847 } 848 return err; 849 } 850 #endif 851 852 void 853 resequence(Bucket *b) 854 { 855 Centry *c, *ce, *cr; 856 int age, i; 857 858 ce = b->entry + CEPERBK; 859 for(c = b->entry; c < ce; c++) { 860 c->age += CEPERBK; 861 if(c->age < CEPERBK) 862 c->age = MAXAGE; 863 } 864 b->agegen += CEPERBK; 865 866 age = 0; 867 for(i=0;; i++) { 868 cr = 0; 869 for(c = b->entry; c < ce; c++) { 870 if(c->age < i) 871 continue; 872 if(cr == 0 || c->age < age) { 873 cr = c; 874 age = c->age; 875 } 876 } 877 if(cr == 0) 878 break; 879 cr->age = i; 880 } 881 b->agegen = i; 882 cons.nreseq++; 883 } 884 885 Centry* 886 getcentry(Bucket *b, Off addr) 887 { 888 Centry *c, *ce, *cr; 889 int s, age; 890 891 /* 892 * search for cache hit 893 * find oldest block as byproduct 894 */ 895 ce = b->entry + CEPERBK; 896 age = 0; 897 cr = 0; 898 for(c = b->entry; c < ce; c++) { 899 s = c->state; 900 if(s == Cnone) { 901 cr = c; 902 age = 0; 903 continue; 904 } 905 if(c->waddr == addr) 906 goto found; 907 if(s == Cread) 908 if(cr == 0 || c->age < age) { 909 cr = c; 910 age = c->age; 911 } 912 } 913 914 /* 915 * remap entry 916 */ 917 c = cr; 918 if(c == 0) 919 return 0; /* bucket is full */ 920 921 c->state = Cnone; 922 c->waddr = addr; 923 924 found: 925 /* 926 * update the age to get filo cache. 927 * small number in age means old 928 */ 929 if(!cons.noage || c->state == Cnone) { 930 age = b->agegen; 931 c->age = age; 932 age++; 933 b->agegen = age; 934 if(age < 0 || age >= MAXAGE) 935 resequence(b); 936 } 937 return c; 938 } 939 940 /* 941 * ream the cache 942 * calculate new buckets 943 */ 944 Iobuf* 945 cacheinit(Device *dev) 946 { 947 Iobuf *cb, *p; 948 Cache *h; 949 Device *cdev; 950 Off m; 951 952 print("cache init %Z\n", dev); 953 cdev = CDEV(dev); 954 devinit(cdev); 955 956 cb = getbuf(cdev, CACHE_ADDR, Bmod|Bres); 957 memset(cb->iobuf, 0, RBUFSIZE); 958 settag(cb, Tcache, QPSUPER); 959 h = (Cache*)cb->iobuf; 960 961 /* 962 * calculate csize such that 963 * tsize = msize/BKPERBLK + csize and 964 * msize = csize/CEPERBK 965 */ 966 h->maddr = CACHE_ADDR + 1; 967 m = devsize(cdev) - h->maddr; 968 h->csize = ((Devsize)(m-1) * CEPERBK*BKPERBLK) / (CEPERBK*BKPERBLK+1); 969 h->msize = h->csize/CEPERBK - 5; 970 while(!prime(h->msize)) 971 h->msize--; 972 h->csize = h->msize*CEPERBK; 973 h->caddr = h->maddr + (h->msize+BKPERBLK-1)/BKPERBLK; 974 h->wsize = devsize(WDEV(dev)); 975 976 if(h->msize <= 0) 977 panic("cache too small"); 978 if(h->caddr + h->csize > m) 979 panic("cache size error"); 980 981 /* 982 * setup cache map 983 */ 984 for(m=h->maddr; m<h->caddr; m++) { 985 p = getbuf(cdev, m, Bmod); 986 memset(p->iobuf, 0, RBUFSIZE); 987 settag(p, Tbuck, m); 988 putbuf(p); 989 } 990 print("done cacheinit\n"); 991 return cb; 992 } 993 994 Off 995 getstartsb(Device *dev) 996 { 997 Filsys *f; 998 Startsb *s; 999 1000 for(f=filsys; f->name; f++) 1001 if(devcmpr(f->dev, dev) == 0) { 1002 for(s=startsb; s->name; s++) 1003 if(strcmp(f->name, s->name) == 0) 1004 return s->startsb; 1005 print( 1006 "getstartsb: no special starting superblock for %Z %s\n", 1007 dev, f->name); 1008 return FIRST; 1009 } 1010 print("getstartsb: no filsys for device %Z\n", dev); 1011 return FIRST; 1012 } 1013 1014 /* 1015 * ream the cache 1016 * calculate new buckets 1017 * get superblock from 1018 * last worm dump block. 1019 */ 1020 void 1021 cwrecover(Device *dev) 1022 { 1023 Iobuf *p, *cb; 1024 Cache *h; 1025 Superb *s; 1026 Off m, baddr; 1027 Device *wdev; 1028 1029 // print("cwrecover %Z\n", dev); // DEBUG 1030 cwinit1(dev); 1031 wdev = WDEV(dev); 1032 1033 p = getbuf(devnone, Cwxx1, 0); 1034 s = (Superb*)p->iobuf; 1035 baddr = 0; 1036 m = getstartsb(dev); 1037 localconfinit(); 1038 if(conf.firstsb) 1039 m = conf.firstsb; 1040 for(;;) { 1041 memset(p->iobuf, 0, RBUFSIZE); 1042 if(devread(wdev, m, p->iobuf) || 1043 checktag(p, Tsuper, QPSUPER)) 1044 break; 1045 baddr = m; 1046 m = s->next; 1047 print("dump %lld is good; %lld next\n", (Wideoff)baddr, (Wideoff)m); 1048 if(baddr == conf.recovsb) 1049 break; 1050 } 1051 putbuf(p); 1052 if(!baddr) 1053 panic("recover: no superblock"); 1054 1055 p = getbuf(wdev, baddr, Brd); 1056 s = (Superb*)p->iobuf; 1057 1058 cb = cacheinit(dev); 1059 h = (Cache*)cb->iobuf; 1060 h->sbaddr = baddr; 1061 h->cwraddr = s->cwraddr; 1062 h->roraddr = s->roraddr; 1063 h->fsize = s->fsize + 100; /* this must be conservative */ 1064 if(conf.recovcw) 1065 h->cwraddr = conf.recovcw; 1066 if(conf.recovro) 1067 h->roraddr = conf.recovro; 1068 1069 putbuf(cb); 1070 putbuf(p); 1071 1072 p = getbuf(dev, baddr, Brd|Bmod); 1073 s = (Superb*)p->iobuf; 1074 1075 memset(&s->fbuf, 0, sizeof(s->fbuf)); 1076 s->fbuf.free[0] = 0; 1077 s->fbuf.nfree = 1; 1078 s->tfree = 0; 1079 if(conf.recovcw) 1080 s->cwraddr = conf.recovcw; 1081 if(conf.recovro) 1082 s->roraddr = conf.recovro; 1083 1084 putbuf(p); 1085 print("done recover\n"); 1086 } 1087 1088 /* 1089 * ream the cache 1090 * calculate new buckets 1091 * initialize superblock. 1092 */ 1093 void 1094 cwream(Device *dev) 1095 { 1096 Iobuf *p, *cb; 1097 Cache *h; 1098 Superb *s; 1099 Off m, baddr; 1100 Device *cdev; 1101 1102 print("cwream %Z\n", dev); 1103 cwinit1(dev); 1104 cdev = CDEV(dev); 1105 devinit(cdev); 1106 1107 baddr = FIRST; /* baddr = super addr 1108 baddr+1 = cw root 1109 baddr+2 = ro root 1110 baddr+3 = reserved next superblock */ 1111 1112 cb = cacheinit(dev); 1113 h = (Cache*)cb->iobuf; 1114 1115 h->sbaddr = baddr; 1116 h->cwraddr = baddr+1; 1117 h->roraddr = baddr+2; 1118 h->fsize = 0; /* prevents superream from freeing */ 1119 1120 putbuf(cb); 1121 1122 for(m=0; m<3; m++) 1123 cwio(dev, baddr+m, 0, Ogrow); 1124 superream(dev, baddr); 1125 rootream(dev, baddr+1); /* cw root */ 1126 rootream(dev, baddr+2); /* ro root */ 1127 1128 cb = getbuf(cdev, CACHE_ADDR, Brd|Bmod|Bres); 1129 h = (Cache*)cb->iobuf; 1130 h->fsize = baddr+4; 1131 putbuf(cb); 1132 1133 p = getbuf(dev, baddr, Brd|Bmod|Bimm); 1134 s = (Superb*)p->iobuf; 1135 s->last = baddr; 1136 s->cwraddr = baddr+1; 1137 s->roraddr = baddr+2; 1138 s->next = baddr+3; 1139 s->fsize = baddr+4; 1140 putbuf(p); 1141 1142 for(m=0; m<3; m++) 1143 cwio(dev, baddr+m, 0, Odump); 1144 } 1145 1146 Off 1147 rewalk1(Cw *cw, Off addr, int slot, Wpath *up) 1148 { 1149 Iobuf *p, *p1; 1150 Dentry *d; 1151 1152 if(up == 0) 1153 return cwraddr(cw->dev); 1154 up->addr = rewalk1(cw, up->addr, up->slot, up->up); 1155 p = getbuf(cw->dev, up->addr, Brd|Bmod); 1156 d = getdir(p, up->slot); 1157 if(!d || !(d->mode & DALLOC)) { 1158 print("rewalk1 1\n"); 1159 if(p) 1160 putbuf(p); 1161 return addr; 1162 } 1163 p1 = dnodebuf(p, d, slot/DIRPERBUF, 0, 0); 1164 if(!p1) { 1165 print("rewalk1 2\n"); 1166 if(p) 1167 putbuf(p); 1168 return addr; 1169 } 1170 if(DEBUG) 1171 print("rewalk1 %lld to %lld \"%s\"\n", 1172 (Wideoff)addr, (Wideoff)p1->addr, d->name); 1173 addr = p1->addr; 1174 p1->flags |= Bmod; 1175 putbuf(p1); 1176 putbuf(p); 1177 return addr; 1178 } 1179 1180 Off 1181 rewalk2(Cw *cw, Off addr, int slot, Wpath *up) 1182 { 1183 Iobuf *p, *p1; 1184 Dentry *d; 1185 1186 if(up == 0) 1187 return cwraddr(cw->rodev); 1188 up->addr = rewalk2(cw, up->addr, up->slot, up->up); 1189 p = getbuf(cw->rodev, up->addr, Brd); 1190 d = getdir(p, up->slot); 1191 if(!d || !(d->mode & DALLOC)) { 1192 print("rewalk2 1\n"); 1193 if(p) 1194 putbuf(p); 1195 return addr; 1196 } 1197 p1 = dnodebuf(p, d, slot/DIRPERBUF, 0, 0); 1198 if(!p1) { 1199 print("rewalk2 2\n"); 1200 if(p) 1201 putbuf(p); 1202 return addr; 1203 } 1204 if(DEBUG) 1205 print("rewalk2 %lld to %lld \"%s\"\n", 1206 (Wideoff)addr, (Wideoff)p1->addr, d->name); 1207 addr = p1->addr; 1208 putbuf(p1); 1209 putbuf(p); 1210 return addr; 1211 } 1212 1213 void 1214 rewalk(Cw *cw) 1215 { 1216 int h; 1217 File *f; 1218 1219 for(h=0; h<nelem(flist); h++) 1220 for(f=flist[h]; f; f=f->next) { 1221 if(!f->fs) 1222 continue; 1223 if(cw->dev == f->fs->dev) 1224 f->addr = rewalk1(cw, f->addr, f->slot, f->wpath); 1225 else 1226 if(cw->rodev == f->fs->dev) 1227 f->addr = rewalk2(cw, f->addr, f->slot, f->wpath); 1228 } 1229 } 1230 1231 Off 1232 split(Cw *cw, Iobuf *p, Off addr) 1233 { 1234 Off na; 1235 int state; 1236 1237 na = 0; 1238 if(p && (p->flags & Bmod)) { 1239 p->flags |= Bimm; 1240 putbuf(p); 1241 p = 0; 1242 } 1243 state = cwio(cw->dev, addr, 0, Onone); /* read the state (twice?) */ 1244 switch(state) { 1245 default: 1246 panic("split: unknown state %s", cwnames[state]); 1247 1248 case Cerror: 1249 case Cnone: 1250 case Cdump: 1251 case Cread: 1252 break; 1253 1254 case Cdump1: 1255 case Cwrite: 1256 /* 1257 * botch.. could be done by relabeling 1258 */ 1259 if(!p) { 1260 p = getbuf(cw->dev, addr, Brd); 1261 if(!p) { 1262 print("split: null getbuf\n"); 1263 break; 1264 } 1265 } 1266 na = cw->fsize; 1267 cw->fsize = na+1; 1268 cwio(cw->dev, na, 0, Ogrow); 1269 cwio(cw->dev, na, p->iobuf, Owrite); 1270 cwio(cw->dev, na, 0, Odump); 1271 cwio(cw->dev, addr, 0, Orele); 1272 break; 1273 1274 case Cdirty: 1275 cwio(cw->dev, addr, 0, Odump); 1276 break; 1277 } 1278 if(p) 1279 putbuf(p); 1280 return na; 1281 } 1282 1283 int 1284 isdirty(Cw *cw, Iobuf *p, Off addr, int tag) 1285 { 1286 int s; 1287 1288 if(p && (p->flags & Bmod)) 1289 return 1; 1290 s = cwio(cw->dev, addr, 0, Onone); 1291 if(s == Cdirty || s == Cwrite) 1292 return 1; 1293 if(tag >= Tind1 && tag <= Tmaxind) 1294 /* botch, get these modified */ 1295 if(s != Cnone) 1296 return 1; 1297 return 0; 1298 } 1299 1300 Off 1301 cwrecur(Cw *cw, Off addr, int tag, int tag1, long qp) 1302 { 1303 Iobuf *p; 1304 Dentry *d; 1305 int i, j, shouldstop; 1306 Off na; 1307 char *np; 1308 1309 shouldstop = 0; 1310 p = getbuf(cw->dev, addr, Bprobe); 1311 if(!isdirty(cw, p, addr, tag)) { 1312 if(!cw->all) { 1313 if(DEBUG) 1314 print("cwrecur: %lld t=%s not dirty %s\n", 1315 (Wideoff)addr, tagnames[tag], cw->name); 1316 if(p) 1317 putbuf(p); 1318 return 0; 1319 } 1320 shouldstop = 1; 1321 } 1322 if(DEBUG) 1323 print("cwrecur: %lld t=%s %s\n", 1324 (Wideoff)addr, tagnames[tag], cw->name); 1325 if(cw->depth >= 100) { 1326 print("dump depth too great %s\n", cw->name); 1327 if(p) 1328 putbuf(p); 1329 return 0; 1330 } 1331 cw->depth++; 1332 1333 switch(tag) { 1334 default: 1335 print("cwrecur: unknown tag %d %s\n", tag, cw->name); 1336 1337 case Tfile: 1338 break; 1339 1340 case Tsuper: 1341 case Tdir: 1342 if(!p) { 1343 p = getbuf(cw->dev, addr, Brd); 1344 if(!p) { 1345 print("cwrecur: Tdir p null %s\n", 1346 cw->name); 1347 break; 1348 } 1349 } 1350 if(tag == Tdir) { 1351 cw->namepad[0] = 0; /* force room */ 1352 np = strchr(cw->name, 0); 1353 *np++ = '/'; 1354 } else { 1355 np = 0; /* set */ 1356 cw->name[0] = 0; 1357 } 1358 1359 for(i=0; i<DIRPERBUF; i++) { 1360 d = getdir(p, i); 1361 if(!(d->mode & DALLOC)) 1362 continue; 1363 qp = d->qid.path & ~QPDIR; 1364 if(tag == Tdir) 1365 strncpy(np, d->name, NAMELEN); 1366 else 1367 if(i > 0) 1368 print("cwrecur: root with >1 directory\n"); 1369 tag1 = Tfile; 1370 if(d->mode & DDIR) 1371 tag1 = Tdir; 1372 for(j=0; j<NDBLOCK; j++) { 1373 na = d->dblock[j]; 1374 if(na) { 1375 na = cwrecur(cw, na, tag1, 0, qp); 1376 if(na) { 1377 d->dblock[j] = na; 1378 p->flags |= Bmod; 1379 } 1380 } 1381 } 1382 for (j = 0; j < NIBLOCK; j++) { 1383 na = d->iblocks[j]; 1384 if(na) { 1385 na = cwrecur(cw, na, Tind1+j, tag1, qp); 1386 if(na) { 1387 d->iblocks[j] = na; 1388 p->flags |= Bmod; 1389 } 1390 } 1391 } 1392 } 1393 break; 1394 1395 case Tind1: 1396 j = tag1; 1397 tag1 = 0; 1398 goto tind; 1399 1400 case Tind2: 1401 #ifndef COMPAT32 1402 case Tind3: 1403 case Tind4: 1404 /* add more Tind tags here ... */ 1405 #endif 1406 j = tag-1; 1407 tind: 1408 if(!p) { 1409 p = getbuf(cw->dev, addr, Brd); 1410 if(!p) { 1411 print("cwrecur: Tind p null %s\n", cw->name); 1412 break; 1413 } 1414 } 1415 for(i=0; i<INDPERBUF; i++) { 1416 na = ((Off *)p->iobuf)[i]; 1417 if(na) { 1418 na = cwrecur(cw, na, j, tag1, qp); 1419 if(na) { 1420 ((Off *)p->iobuf)[i] = na; 1421 p->flags |= Bmod; 1422 } 1423 } 1424 } 1425 break; 1426 } 1427 na = split(cw, p, addr); 1428 cw->depth--; 1429 if(na && shouldstop) { 1430 if(cw->falsehits < 10) 1431 print("shouldstop %lld %lld t=%s %s\n", 1432 (Wideoff)addr, (Wideoff)na, 1433 tagnames[tag], cw->name); 1434 cw->falsehits++; 1435 } 1436 return na; 1437 } 1438 1439 Timet nextdump(Timet t); 1440 1441 void 1442 cfsdump(Filsys *fs) 1443 { 1444 long m, n, i; 1445 Off orba, rba, oroa, roa, sba, a; 1446 Timet tim; 1447 char tstr[20]; 1448 Iobuf *pr, *p1, *p; 1449 Dentry *dr, *d1, *d; 1450 Cache *h; 1451 Superb *s; 1452 Cw *cw; 1453 1454 if(fs->dev->type != Devcw) { 1455 print("cant dump; not cw device: %Z\n", fs->dev); 1456 return; 1457 } 1458 cw = fs->dev->private; 1459 if(cw == 0) { 1460 print("cant dump: has not been inited: %Z\n", fs->dev); 1461 return; 1462 } 1463 1464 tim = toytime(); 1465 wlock(&mainlock); /* dump */ 1466 1467 /* 1468 * set up static structure 1469 * with frequent variables 1470 */ 1471 cw->ndump = 0; 1472 cw->name[0] = 0; 1473 cw->depth = 0; 1474 1475 /* 1476 * cw root 1477 */ 1478 sync("before dump"); 1479 cw->fsize = cwsize(cw->dev); 1480 orba = cwraddr(cw->dev); 1481 print("cwroot %lld", (Wideoff)orba); 1482 cons.noage = 1; 1483 cw->all = cw->allflag; 1484 rba = cwrecur(cw, orba, Tsuper, 0, QPROOT); 1485 if(rba == 0) 1486 rba = orba; 1487 print("->%lld\n", (Wideoff)rba); 1488 sync("after cw"); 1489 1490 /* 1491 * partial super block 1492 */ 1493 p = getbuf(cw->dev, cwsaddr(cw->dev), Brd|Bmod|Bimm); 1494 s = (Superb*)p->iobuf; 1495 s->fsize = cw->fsize; 1496 s->cwraddr = rba; 1497 putbuf(p); 1498 1499 /* 1500 * partial cache block 1501 */ 1502 p = getbuf(cw->cdev, CACHE_ADDR, Brd|Bmod|Bimm|Bres); 1503 h = (Cache*)p->iobuf; 1504 h->fsize = cw->fsize; 1505 h->cwraddr = rba; 1506 putbuf(p); 1507 1508 /* 1509 * ro root 1510 */ 1511 oroa = cwraddr(cw->rodev); 1512 pr = getbuf(cw->dev, oroa, Brd|Bmod); 1513 dr = getdir(pr, 0); 1514 1515 datestr(tstr, time(nil)); /* tstr = "yyyymmdd" */ 1516 n = 0; 1517 for(a=0;; a++) { 1518 p1 = dnodebuf(pr, dr, a, Tdir, 0); 1519 if(!p1) 1520 goto bad; 1521 n++; 1522 for(i=0; i<DIRPERBUF; i++) { 1523 d1 = getdir(p1, i); 1524 if(!d1) 1525 goto bad; 1526 if(!(d1->mode & DALLOC)) 1527 goto found1; 1528 if(!memcmp(d1->name, tstr, 4)) 1529 goto found2; /* found entry */ 1530 } 1531 putbuf(p1); 1532 } 1533 1534 /* 1535 * no year directory, create one 1536 */ 1537 found1: 1538 p = getbuf(cw->dev, rba, Brd); 1539 d = getdir(p, 0); 1540 d1->qid = d->qid; 1541 d1->qid.version += n; 1542 memmove(d1->name, tstr, 4); 1543 d1->mode = d->mode; 1544 d1->uid = d->uid; 1545 d1->gid = d->gid; 1546 putbuf(p); 1547 accessdir(p1, d1, FWRITE, 0); 1548 1549 /* 1550 * put mmdd[count] in year directory 1551 */ 1552 found2: 1553 accessdir(p1, d1, FREAD, 0); 1554 putbuf(pr); 1555 pr = p1; 1556 dr = d1; 1557 1558 n = 0; 1559 m = 0; 1560 for(a=0;; a++) { 1561 p1 = dnodebuf(pr, dr, a, Tdir, 0); 1562 if(!p1) 1563 goto bad; 1564 n++; 1565 for(i=0; i<DIRPERBUF; i++) { 1566 d1 = getdir(p1, i); 1567 if(!d1) 1568 goto bad; 1569 if(!(d1->mode & DALLOC)) 1570 goto found; 1571 if(!memcmp(d1->name, tstr+4, 4)) 1572 m++; 1573 } 1574 putbuf(p1); 1575 } 1576 1577 /* 1578 * empty slot put in root 1579 */ 1580 found: 1581 if(m) /* how many dumps this date */ 1582 sprint(tstr+8, "%ld", m); 1583 1584 p = getbuf(cw->dev, rba, Brd); 1585 d = getdir(p, 0); 1586 *d1 = *d; /* qid is QPROOT */ 1587 putbuf(p); 1588 strcpy(d1->name, tstr+4); 1589 d1->qid.version += n; 1590 accessdir(p1, d1, FWRITE, 0); 1591 putbuf(p1); 1592 putbuf(pr); 1593 1594 cw->fsize = cwsize(cw->dev); 1595 oroa = cwraddr(cw->rodev); /* probably redundant */ 1596 print("roroot %lld", (Wideoff)oroa); 1597 1598 cons.noage = 0; 1599 cw->all = 0; 1600 roa = cwrecur(cw, oroa, Tsuper, 0, QPROOT); 1601 if(roa == 0) { 1602 print("[same]"); 1603 roa = oroa; 1604 } 1605 print("->%lld /%.4s/%s\n", (Wideoff)roa, tstr, tstr+4); 1606 sync("after ro"); 1607 1608 /* 1609 * final super block 1610 */ 1611 a = cwsaddr(cw->dev); 1612 print("sblock %lld", (Wideoff)a); 1613 p = getbuf(cw->dev, a, Brd|Bmod|Bimm); 1614 s = (Superb*)p->iobuf; 1615 s->last = a; 1616 sba = s->next; 1617 s->next = cw->fsize; 1618 cw->fsize++; 1619 s->fsize = cw->fsize; 1620 s->roraddr = roa; 1621 1622 cwio(cw->dev, sba, 0, Ogrow); 1623 cwio(cw->dev, sba, p->iobuf, Owrite); 1624 cwio(cw->dev, sba, 0, Odump); 1625 print("->%lld (->%lld)\n", (Wideoff)sba, (Wideoff)s->next); 1626 1627 putbuf(p); 1628 1629 /* 1630 * final cache block 1631 */ 1632 p = getbuf(cw->cdev, CACHE_ADDR, Brd|Bmod|Bimm|Bres); 1633 h = (Cache*)p->iobuf; 1634 h->fsize = cw->fsize; 1635 h->roraddr = roa; 1636 h->sbaddr = sba; 1637 putbuf(p); 1638 1639 rewalk(cw); 1640 sync("all done"); 1641 1642 print("%lld blocks queued for worm\n", (Wideoff)cw->ndump); 1643 print("%lld falsehits\n", (Wideoff)cw->falsehits); 1644 cw->nodump = 0; 1645 1646 /* 1647 * extend all of the locks 1648 */ 1649 tim = toytime() - tim; 1650 for(i=0; i<NTLOCK; i++) 1651 if(tlocks[i].time > 0) 1652 tlocks[i].time += tim; 1653 1654 wunlock(&mainlock); 1655 nextdump(time(nil)); 1656 return; 1657 1658 bad: 1659 panic("dump: bad"); 1660 } 1661 1662 void 1663 mvstates(Device *dev, int s1, int s2, int side) 1664 { 1665 Iobuf *p, *cb; 1666 Cache *h; 1667 Bucket *b; 1668 Centry *c, *ce; 1669 Off m, lo, hi, msize, maddr; 1670 Cw *cw; 1671 1672 cw = dev->private; 1673 lo = 0; 1674 hi = lo + devsize(dev->cw.w); /* size of all sides totalled */ 1675 if(side >= 0) { 1676 /* operate on only a single disc side */ 1677 Sidestarts ss; 1678 1679 wormsidestarts(dev, side, &ss); 1680 lo = ss.sstart; 1681 hi = ss.s1start; 1682 } 1683 cb = getbuf(cw->cdev, CACHE_ADDR, Brd|Bres); 1684 if(!cb || checktag(cb, Tcache, QPSUPER)) 1685 panic("cwstats: checktag c bucket"); 1686 h = (Cache*)cb->iobuf; 1687 msize = h->msize; 1688 maddr = h->maddr; 1689 putbuf(cb); 1690 1691 for(m=0; m<msize; m++) { 1692 p = getbuf(cw->cdev, maddr + m/BKPERBLK, Brd|Bmod); 1693 if(!p || checktag(p, Tbuck, maddr + m/BKPERBLK)) 1694 panic("cwtest: checktag c bucket"); 1695 b = (Bucket*)p->iobuf + m%BKPERBLK; 1696 ce = b->entry + CEPERBK; 1697 for(c=b->entry; c<ce; c++) 1698 if(c->state == s1 && c->waddr >= lo && c->waddr < hi) 1699 c->state = s2; 1700 putbuf(p); 1701 } 1702 } 1703 1704 void 1705 prchain(Device *dev, Off m, int flg) 1706 { 1707 Iobuf *p; 1708 Superb *s; 1709 1710 if(m == 0) { 1711 if(flg) 1712 m = cwsaddr(dev); 1713 else 1714 m = getstartsb(dev); 1715 } 1716 p = getbuf(devnone, Cwxx2, 0); 1717 s = (Superb*)p->iobuf; 1718 for(;;) { 1719 memset(p->iobuf, 0, RBUFSIZE); 1720 if(devread(WDEV(dev), m, p->iobuf) || 1721 checktag(p, Tsuper, QPSUPER)) 1722 break; 1723 if(flg) { 1724 print("dump %lld is good; %lld prev\n", (Wideoff)m, 1725 (Wideoff)s->last); 1726 print("\t%lld cwroot; %lld roroot\n", 1727 (Wideoff)s->cwraddr, (Wideoff)s->roraddr); 1728 if(m <= s->last) 1729 break; 1730 m = s->last; 1731 } else { 1732 print("dump %lld is good; %lld next\n", (Wideoff)m, 1733 (Wideoff)s->next); 1734 print("\t%lld cwroot; %lld roroot\n", 1735 (Wideoff)s->cwraddr, (Wideoff)s->roraddr); 1736 if(m >= s->next) 1737 break; 1738 m = s->next; 1739 } 1740 } 1741 putbuf(p); 1742 } 1743 1744 void 1745 touchsb(Device *dev) 1746 { 1747 Iobuf *p; 1748 Off m; 1749 1750 m = cwsaddr(dev); 1751 p = getbuf(devnone, Cwxx2, 0); 1752 1753 memset(p->iobuf, 0, RBUFSIZE); 1754 if(devread(WDEV(dev), m, p->iobuf) || 1755 checktag(p, Tsuper, QPSUPER)) 1756 print("%Z block %lld WORM SUPER BLOCK READ FAILED\n", 1757 WDEV(dev), (Wideoff)m); 1758 else 1759 print("%Z touch superblock %lld\n", WDEV(dev), (Wideoff)m); 1760 putbuf(p); 1761 } 1762 1763 void 1764 storesb(Device *dev, Off last, int doit) 1765 { 1766 Iobuf *ph, *ps; 1767 Cache *h; 1768 Superb *s; 1769 Off sbaddr, qidgen; 1770 1771 sbaddr = cwsaddr(dev); 1772 1773 ps = getbuf(devnone, Cwxx2, 0); 1774 if(!ps) { 1775 print("sbstore: getbuf\n"); 1776 return; 1777 } 1778 1779 /* 1780 * try to read last sb 1781 */ 1782 memset(ps->iobuf, 0, RBUFSIZE); 1783 if(devread(WDEV(dev), last, ps->iobuf) || 1784 checktag(ps, Tsuper, QPSUPER)) 1785 print("read last failed\n"); 1786 else 1787 print("read last succeeded\n"); 1788 1789 s = (Superb*)ps->iobuf; 1790 qidgen = s->qidgen; 1791 if(qidgen == 0) 1792 qidgen = 0x31415; 1793 qidgen += 1000; 1794 if(s->next != sbaddr) 1795 print("next(last) is not sbaddr %lld %lld\n", 1796 (Wideoff)s->next, (Wideoff)sbaddr); 1797 else 1798 print("next(last) is sbaddr\n"); 1799 1800 /* 1801 * read cached superblock 1802 */ 1803 ph = getbuf(CDEV(dev), CACHE_ADDR, Brd|Bres); 1804 if(!ph || checktag(ph, Tcache, QPSUPER)) { 1805 print("cwstats: checktag c bucket\n"); 1806 if(ph) 1807 putbuf(ph); 1808 putbuf(ps); 1809 return; 1810 } else 1811 print("read cached sb succeeded\n"); 1812 1813 h = (Cache*)ph->iobuf; 1814 1815 memset(ps->iobuf, 0, RBUFSIZE); 1816 settag(ps, Tsuper, QPSUPER); 1817 ps->flags = 0; 1818 s = (Superb*)ps->iobuf; 1819 1820 s->cwraddr = h->cwraddr; 1821 s->roraddr = h->roraddr; 1822 s->fsize = h->fsize; 1823 s->fstart = 2; 1824 s->last = last; 1825 s->next = h->roraddr+1; 1826 1827 s->qidgen = qidgen; 1828 putbuf(ph); 1829 1830 if(s->fsize-1 != s->next || 1831 s->fsize-2 != s->roraddr || 1832 s->fsize-5 != s->cwraddr) { 1833 print("addrs not in relationship %lld %lld %lld %lld\n", 1834 (Wideoff)s->cwraddr, (Wideoff)s->roraddr, 1835 (Wideoff)s->next, (Wideoff)s->fsize); 1836 putbuf(ps); 1837 return; 1838 } else 1839 print("addresses in relation\n"); 1840 1841 if(doit) 1842 if(devwrite(WDEV(dev), sbaddr, ps->iobuf)) 1843 print("%Z block %lld WORM SUPER BLOCK WRITE FAILED\n", 1844 WDEV(dev), (Wideoff)sbaddr); 1845 ps->flags = 0; 1846 putbuf(ps); 1847 } 1848 1849 void 1850 savecache(Device *dev) 1851 { 1852 Iobuf *p, *cb; 1853 Cache *h; 1854 Bucket *b; 1855 Centry *c, *ce; 1856 long n, left; 1857 Off m, maddr, msize, *longp, nbyte; 1858 Device *cdev; 1859 1860 if(walkto("/adm/cache") || con_open(FID2, OWRITE|OTRUNC)) { 1861 print("cant open /adm/cache\n"); 1862 return; 1863 } 1864 cdev = CDEV(dev); 1865 cb = getbuf(cdev, CACHE_ADDR, Brd|Bres); 1866 if(!cb || checktag(cb, Tcache, QPSUPER)) 1867 panic("savecache: checktag c bucket"); 1868 h = (Cache*)cb->iobuf; 1869 msize = h->msize; 1870 maddr = h->maddr; 1871 putbuf(cb); 1872 1873 n = BUFSIZE; /* calculate write size */ 1874 if(n > MAXDAT) 1875 n = MAXDAT; 1876 1877 cb = getbuf(devnone, Cwxx4, 0); 1878 longp = (Off *)cb->iobuf; 1879 left = n/sizeof(Off); 1880 cons.offset = 0; 1881 1882 for(m=0; m<msize; m++) { 1883 if(left < BKPERBLK) { 1884 nbyte = (n/sizeof(Off) - left) * sizeof(Off); 1885 con_write(FID2, cb->iobuf, cons.offset, nbyte); 1886 cons.offset += nbyte; 1887 longp = (Off *)cb->iobuf; 1888 left = n/sizeof(Off); 1889 } 1890 p = getbuf(cdev, maddr + m/BKPERBLK, Brd); 1891 if(!p || checktag(p, Tbuck, maddr + m/BKPERBLK)) 1892 panic("cwtest: checktag c bucket"); 1893 b = (Bucket*)p->iobuf + m%BKPERBLK; 1894 ce = b->entry + CEPERBK; 1895 for(c = b->entry; c < ce; c++) 1896 if(c->state == Cread) { 1897 *longp++ = c->waddr; 1898 left--; 1899 } 1900 putbuf(p); 1901 } 1902 nbyte = (n/sizeof(Off) - left) * sizeof(Off); 1903 con_write(FID2, cb->iobuf, cons.offset, nbyte); 1904 putbuf(cb); 1905 } 1906 1907 void 1908 loadcache(Device *dev, int dskno) 1909 { 1910 Iobuf *p, *cb; 1911 Off m, nbyte, *longp, count; 1912 Sidestarts ss; 1913 1914 if(walkto("/adm/cache") || con_open(FID2, OREAD)) { 1915 print("cant open /adm/cache\n"); 1916 return; 1917 } 1918 1919 cb = getbuf(devnone, Cwxx4, 0); 1920 cons.offset = 0; 1921 count = 0; 1922 1923 if (dskno >= 0) 1924 wormsidestarts(dev, dskno, &ss); 1925 for(;;) { 1926 memset(cb->iobuf, 0, BUFSIZE); 1927 nbyte = con_read(FID2, cb->iobuf, cons.offset, 100) / sizeof(Off); 1928 if(nbyte <= 0) 1929 break; 1930 cons.offset += nbyte * sizeof(Off); 1931 longp = (Off *)cb->iobuf; 1932 while(nbyte > 0) { 1933 m = *longp++; 1934 nbyte--; 1935 if(m == 0) 1936 continue; 1937 /* if given a diskno, restrict to just that disc side */ 1938 if(dskno < 0 || m >= ss.sstart && m < ss.s1start) { 1939 p = getbuf(dev, m, Brd); 1940 if(p) 1941 putbuf(p); 1942 count++; 1943 } 1944 } 1945 } 1946 putbuf(cb); 1947 print("%lld blocks loaded from worm %d\n", (Wideoff)count, dskno); 1948 } 1949 1950 void 1951 morecache(Device *dev, int dskno, Off size) 1952 { 1953 Iobuf *p; 1954 Off m, ml, mh, mm, count; 1955 Cache *h; 1956 Sidestarts ss; 1957 1958 p = getbuf(CDEV(dev), CACHE_ADDR, Brd|Bres); 1959 if(!p || checktag(p, Tcache, QPSUPER)) 1960 panic("savecache: checktag c bucket"); 1961 h = (Cache*)p->iobuf; 1962 mm = h->wmax; 1963 putbuf(p); 1964 1965 wormsidestarts(dev, dskno, &ss); 1966 ml = ss.sstart; /* start at beginning of disc side #dskno */ 1967 mh = ml + size; 1968 if(mh > mm) { 1969 mh = mm; 1970 print("limited to %lld\n", (Wideoff)mh-ml); 1971 } 1972 1973 count = 0; 1974 for(m=ml; m < mh; m++) { 1975 p = getbuf(dev, m, Brd); 1976 if(p) 1977 putbuf(p); 1978 count++; 1979 } 1980 print("%lld blocks loaded from worm %d\n", (Wideoff)count, dskno); 1981 } 1982 1983 void 1984 blockcmp(Device *dev, Off wa, Off ca) 1985 { 1986 Iobuf *p1, *p2; 1987 int i, c; 1988 1989 p1 = getbuf(WDEV(dev), wa, Brd); 1990 if(!p1) { 1991 print("blockcmp: wdev error\n"); 1992 return; 1993 } 1994 1995 p2 = getbuf(CDEV(dev), ca, Brd); 1996 if(!p2) { 1997 print("blockcmp: cdev error\n"); 1998 putbuf(p1); 1999 return; 2000 } 2001 2002 c = 0; 2003 for(i=0; i<RBUFSIZE; i++) 2004 if(p1->iobuf[i] != p2->iobuf[i]) { 2005 print("%4d: %.2x %.2x\n", 2006 i, 2007 p1->iobuf[i]&0xff, 2008 p2->iobuf[i]&0xff); 2009 c++; 2010 if(c >= 10) 2011 break; 2012 } 2013 2014 if(c == 0) 2015 print("no error\n"); 2016 putbuf(p1); 2017 putbuf(p2); 2018 } 2019 2020 void 2021 wblock(Device *dev, Off addr) 2022 { 2023 Iobuf *p1; 2024 int i; 2025 2026 p1 = getbuf(dev, addr, Brd); 2027 if(p1) { 2028 i = devwrite(WDEV(dev), addr, p1->iobuf); 2029 print("i = %d\n", i); 2030 putbuf(p1); 2031 } 2032 } 2033 2034 void 2035 cwtest(Device*) 2036 { 2037 } 2038 2039 #ifdef XXX 2040 /* garbage to change sb size 2041 * probably will need it someday 2042 */ 2043 fsz = number(0, 0, 10); 2044 count = 0; 2045 if(fsz == number(0, -1, 10)) 2046 count = -1; /* really do it */ 2047 print("fsize = %ld\n", fsz); 2048 cdev = CDEV(dev); 2049 cb = getbuf(cdev, CACHE_ADDR, Brd|Bres); 2050 if(!cb || checktag(cb, Tcache, QPSUPER)) 2051 panic("cwstats: checktag c bucket"); 2052 h = (Cache*)cb->iobuf; 2053 for(m=0; m<h->msize; m++) { 2054 p = getbuf(cdev, h->maddr + m/BKPERBLK, Brd|Bmod); 2055 if(!p || checktag(p, Tbuck, h->maddr + m/BKPERBLK)) 2056 panic("cwtest: checktag c bucket"); 2057 b = (Bucket*)p->iobuf + m%BKPERBLK; 2058 ce = b->entry + CEPERBK; 2059 for(c=b->entry; c<ce; c++) { 2060 if(c->waddr < fsz) 2061 continue; 2062 if(count < 0) { 2063 c->state = Cnone; 2064 continue; 2065 } 2066 if(c->state != Cdirty) 2067 count++; 2068 } 2069 putbuf(p); 2070 } 2071 if(count < 0) { 2072 print("old cache hsize = %ld\n", h->fsize); 2073 h->fsize = fsz; 2074 cb->flags |= Bmod; 2075 p = getbuf(dev, h->sbaddr, Brd|Bmod); 2076 s = (Superb*)p->iobuf; 2077 print("old super hsize = %ld\n", s->fsize); 2078 s->fsize = fsz; 2079 putbuf(p); 2080 } 2081 putbuf(cb); 2082 print("count = %lld\n", (Wideoff)count); 2083 #endif 2084 2085 int 2086 convstate(char *name) 2087 { 2088 int i; 2089 2090 for(i=0; i<nelem(cwnames); i++) 2091 if(cwnames[i]) 2092 if(strcmp(cwnames[i], name) == 0) 2093 return i; 2094 return -1; 2095 } 2096 2097 void 2098 searchtag(Device *d, Off a, int tag, int n) 2099 { 2100 Iobuf *p; 2101 Tag *t; 2102 int i; 2103 2104 if(a == 0) 2105 a = getstartsb(d); 2106 p = getbuf(devnone, Cwxx2, 0); 2107 t = (Tag*)(p->iobuf+BUFSIZE); 2108 for(i=0; i<n; i++) { 2109 memset(p->iobuf, 0, RBUFSIZE); 2110 if(devread(WDEV(d), a+i, p->iobuf)) { 2111 if(n == 1000) 2112 break; 2113 continue; 2114 } 2115 if(t->tag == tag) { 2116 print("tag %d found at %Z %lld\n", tag, d, (Wideoff)a+i); 2117 break; 2118 } 2119 } 2120 putbuf(p); 2121 } 2122 2123 void 2124 cmd_cwcmd(int argc, char *argv[]) 2125 { 2126 Device *dev; 2127 char *arg; 2128 char str[28]; 2129 Off s1, s2, a, b, n; 2130 Cw *cw; 2131 2132 if(argc <= 1) { 2133 print("\tcwcmd mvstate state1 state2 [platter]\n"); 2134 print("\tcwcmd prchain [start] [bakflg]\n"); 2135 print("\tcwcmd searchtag [start] [tag] [blocks]\n"); 2136 print("\tcwcmd touchsb\n"); 2137 print("\tcwcmd savecache\n"); 2138 print("\tcwcmd loadcache [dskno]\n"); 2139 print("\tcwcmd morecache dskno [count]\n"); 2140 print("\tcwcmd blockcmp wbno cbno\n"); 2141 print("\tcwcmd startdump [01]\n"); 2142 print("\tcwcmd acct\n"); 2143 print("\tcwcmd clearacct\n"); 2144 return; 2145 } 2146 arg = argv[1]; 2147 2148 /* 2149 * items not depend on a cw filesystem 2150 */ 2151 if(strcmp(arg, "acct") == 0) { 2152 for(a=0; a<nelem(growacct); a++) { 2153 b = growacct[a]; 2154 if(b) { 2155 uidtostr(str, a, 1); 2156 print("%10lld %s\n", 2157 ((Wideoff)b*ADDFREE*RBUFSIZE+500000)/1000000, 2158 str); 2159 } 2160 } 2161 return; 2162 } 2163 if(strcmp(arg, "clearacct") == 0) { 2164 memset(growacct, 0, sizeof(growacct)); 2165 return; 2166 } 2167 2168 /* 2169 * items depend on cw filesystem 2170 */ 2171 dev = cons.curfs->dev; 2172 if(dev == 0 || dev->type != Devcw || dev->private == 0) { 2173 print("cfs not a cw filesystem: %Z\n", dev); 2174 return; 2175 } 2176 cw = dev->private; 2177 if(strcmp(arg, "searchtag") == 0) { 2178 a = 0; 2179 if(argc > 2) 2180 a = number(argv[2], 0, 10); 2181 b = Tsuper; 2182 if(argc > 3) 2183 b = number(argv[3], 0, 10); 2184 n = 1000; 2185 if(argc > 4) 2186 n = number(argv[4], 0, 10); 2187 searchtag(dev, a, b, n); 2188 } else if(strcmp(arg, "mvstate") == 0) { 2189 if(argc < 4) 2190 goto bad; 2191 s1 = convstate(argv[2]); 2192 s2 = convstate(argv[3]); 2193 if(s1 < 0 || s2 < 0) 2194 goto bad; 2195 a = -1; 2196 if(argc > 4) 2197 a = number(argv[4], 0, 10); 2198 mvstates(dev, s1, s2, a); 2199 return; 2200 bad: 2201 print("cwcmd mvstate: bad args\n"); 2202 } else if(strcmp(arg, "prchain") == 0) { 2203 a = 0; 2204 if(argc > 2) 2205 a = number(argv[2], 0, 10); 2206 s1 = 0; 2207 if(argc > 3) 2208 s1 = number(argv[3], 0, 10); 2209 prchain(dev, a, s1); 2210 } else if(strcmp(arg, "touchsb") == 0) 2211 touchsb(dev); 2212 else if(strcmp(arg, "savecache") == 0) 2213 savecache(dev); 2214 else if(strcmp(arg, "loadcache") == 0) { 2215 s1 = -1; 2216 if(argc > 2) 2217 s1 = number(argv[2], 0, 10); 2218 loadcache(dev, s1); 2219 } else if(strcmp(arg, "morecache") == 0) { 2220 if(argc <= 2) { 2221 print("arg count\n"); 2222 return; 2223 } 2224 s1 = number(argv[2], 0, 10); 2225 if(argc > 3) 2226 s2 = number(argv[3], 0, 10); 2227 else 2228 s2 = wormsizeside(dev, s1); /* default to 1 disc side */ 2229 morecache(dev, s1, s2); 2230 } else if(strcmp(arg, "blockcmp") == 0) { 2231 if(argc < 4) { 2232 print("cannot arg count\n"); 2233 return; 2234 } 2235 s1 = number(argv[2], 0, 10); 2236 s2 = number(argv[3], 0, 10); 2237 blockcmp(dev, s1, s2); 2238 } else if(strcmp(arg, "startdump") == 0) { 2239 if(argc > 2) 2240 cw->nodump = number(argv[2], 0, 10); 2241 cw->nodump = !cw->nodump; 2242 if(cw->nodump) 2243 print("dump stopped\n"); 2244 else 2245 print("dump allowed\n"); 2246 } else if(strcmp(arg, "allflag") == 0) { 2247 if(argc > 2) 2248 cw->allflag = number(argv[2], 0, 10); 2249 else 2250 cw->allflag = !cw->allflag; 2251 print("allflag = %d; falsehits = %lld\n", 2252 cw->allflag, (Wideoff)cw->falsehits); 2253 } else if(strcmp(arg, "storesb") == 0) { 2254 a = 4168344; 2255 b = 0; 2256 if(argc > 2) 2257 a = number(argv[2], 4168344, 10); 2258 if(argc > 3) 2259 b = number(argv[3], 0, 10); 2260 storesb(dev, a, b); 2261 } else if(strcmp(arg, "test") == 0) 2262 cwtest(dev); 2263 else 2264 print("unknown cwcmd %s\n", arg); 2265 } 2266