sys/src/cmd/cwfs/cw.c

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