![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to worm.bundle CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / worm|
Return to worm.bundle CVS log | Up to [Research Unix] / researchv10no / cmd / worm |
1.1 ! root 1: # To unbundle, sh this file ! 2: echo LL.c 1>&2 ! 3: mkdir scsi scsi/osanity scsi/scsi scsi/inc scsi/generic scsi/sony scsi/wren ! 4: sed 's/.//' >LL.c <<'//GO.SYSIN DD LL.c' ! 5: -#include <sys/param.h> ! 6: - ! 7: -/* ! 8: - * long-long support ! 9: - */ ! 10: - ! 11: -#define M 0x80000000 ! 12: - ! 13: -unsigned ! 14: -Lshift(ll, l) ! 15: -llong_t ll; ! 16: -long l; ! 17: -{ ! 18: - return (ll.hi<<(32-l)) | (ll.lo>>l); ! 19: -} ! 20: - ! 21: -llong_t ! 22: -ltoL(l) ! 23: -long l; ! 24: -{ ! 25: - llong_t t; ! 26: - ! 27: - t.hi = 0; ! 28: - t.lo = l; ! 29: - return t; ! 30: -} ! 31: - ! 32: -llong_t ! 33: -Lladd(ll, l) ! 34: -llong_t ll; ! 35: -long l; ! 36: -{ ! 37: - llong_t t; ! 38: - long cin; ! 39: - ! 40: - t = ll; ! 41: - t.lo += l; ! 42: - cin = ll.lo^t.lo; ! 43: - if (l>=0) { ! 44: - if ((ll.lo&cin)&M) ! 45: - t.hi++; ! 46: - } else { ! 47: - if ((~ll.lo&cin)&M) ! 48: - t.hi--; ! 49: - } ! 50: - return t; ! 51: -} ! 52: - ! 53: -llong_t ! 54: -Luadd(ll, u) ! 55: -llong_t ll; ! 56: -unsigned long u; ! 57: -{ ! 58: - llong_t t; ! 59: - long cin; ! 60: - ! 61: - t = ll; ! 62: - t.lo += u; ! 63: - cin = ll.lo^t.lo; ! 64: - if ((ll.lo&cin)&M) ! 65: - t.hi++; ! 66: - return t; ! 67: -} ! 68: - ! 69: -llong_t ! 70: -LLadd(lla, llb) ! 71: -llong_t lla, llb; ! 72: -{ ! 73: - llong_t t; ! 74: - ! 75: - t.hi = lla.hi+llb.hi; ! 76: - t.lo = lla.lo+llb.lo; ! 77: - if ((lla.lo&llb.lo | lla.lo&~t.lo | llb.lo&~t.lo)&M) ! 78: - t.hi++; ! 79: - return t; ! 80: -} ! 81: - ! 82: -llong_t ! 83: -Llmul(a, b) ! 84: - llong_t a; ! 85: - unsigned long b; ! 86: -{ ! 87: - llong_t r; ! 88: - ! 89: - r = ltoL(0); ! 90: - while(b){ ! 91: - if(b&1) ! 92: - r = LLadd(r, a); ! 93: - b >>= 1; ! 94: - a = LLadd(a, a); ! 95: - } ! 96: - return(r); ! 97: -} ! 98: //GO.SYSIN DD LL.c ! 99: echo btree.c 1>&2 ! 100: sed 's/.//' >btree.c <<'//GO.SYSIN DD btree.c' ! 101: -#include <libc.h> ! 102: -#include <cbt.h> ! 103: -#undef nfree ! 104: -#include "worm.h" ! 105: -#include "sym.h" ! 106: -#include <sys/types.h> ! 107: -#include <sys/stat.h> ! 108: - ! 109: -static char *inonames; ! 110: -static bfile *bf; ! 111: -static dirlk(), wormdir(); ! 112: - ! 113: -char * ! 114: -cbtinit(s, blk, doinodes) ! 115: - register Superblock *s; ! 116: - long blk; ! 117: -{ ! 118: - static char buf[64]; ! 119: - char name[256], buf1[256]; ! 120: - ! 121: - if(s->magic != SMAGIC){ ! 122: - fprint(2, "bad Superblock at %ld\n", blk); ! 123: - exit(1); ! 124: - } ! 125: - numinodes = s->ninodes; ! 126: - if(doinodes){ ! 127: - inonames = malloc(s->blocksize*(int)NBLKS(s, s->ninochars)); ! 128: - if(inonames == 0){ ! 129: - sprint(buf, "cbtinit: can't malloc %d\n", s->blocksize*(int)NBLKS(s, s->ninochars)); ! 130: - return(buf); ! 131: - } ! 132: - if(dirlk(s) == 0) ! 133: - wormdir(s); ! 134: - } else ! 135: - inonames = 0; ! 136: - return((char *)0); ! 137: -} ! 138: - ! 139: -static ! 140: -dirlk(s) ! 141: - register Superblock *s; ! 142: -{ ! 143: - char name[256], buf1[256]; ! 144: - struct stat sbuf; ! 145: - int fd; ! 146: - ! 147: - sprint(name, "/usr/worm/dirs/%s", s->vol_id); ! 148: - sprint(buf1, "%s.I", name); ! 149: - if(stat(buf1, &sbuf) < 0) ! 150: - return(0); ! 151: - if(sbuf.st_mtime < s->ctime) ! 152: - return(0); /* worm is more recent than disk */ ! 153: - if((bf = bopen(name, 0)) == 0) ! 154: - return(0); ! 155: - sprint(buf1, "%s.I", name); ! 156: - if((fd = open(buf1, 0)) < 0){ ! 157: - fprint(2, "%s: btree but no inodes\n", name); ! 158: - return(0); ! 159: - } ! 160: - if(read(fd, inonames, (int)s->ninochars) != s->ninochars){ ! 161: - fprint(2, "%s: expected %d chars\n", buf1, s->ninochars); ! 162: - close(fd); ! 163: - return(0); ! 164: - } ! 165: - close(fd); ! 166: - return(1); ! 167: -} ! 168: - ! 169: -static ! 170: -wormdir(s) ! 171: - register Superblock *s; ! 172: -{ ! 173: - char name[256], buf1[256]; ! 174: - ! 175: - sprint(name, "/tmp/worm%d", getpid()); ! 176: - Seek(s, s->binodes); ! 177: - sprint(buf1, "%s.F", name); ! 178: - copyout(s, buf1, s->nF, 0, 0); ! 179: - sprint(buf1, "%s.T", name); ! 180: - copyout(s, buf1, s->nT, 0, 0); ! 181: - if(Read(s, inonames, NBLKS(s, s->ninochars))) ! 182: - return(0); ! 183: - if((bf = bopen(name, 0)) == 0){ ! 184: - fprint(2, "can't bopen %s", name); ! 185: - return(0); ! 186: - } ! 187: - sprint(buf1, "%s.F", name); unlink(buf1); ! 188: - sprint(buf1, "%s.T", name); unlink(buf1); ! 189: - return(1); ! 190: -} ! 191: - ! 192: -copyout(s, name, len, overwrite, verbose) ! 193: - register Superblock *s; ! 194: - char *name; ! 195: - long len; ! 196: -{ ! 197: - int fd, l; ! 198: - char *buf; ! 199: - ! 200: - if(access(name, 0) == 0){ ! 201: - if(!overwrite){ ! 202: - fprint(2, "%s already exists!\n", name); ! 203: - exit(1); ! 204: - } ! 205: - if(verbose) ! 206: - fprint(2, "overwriting %s\n", name); ! 207: - } ! 208: - if((fd = creat(name, 0666)) < 0){ ! 209: - perror(name); ! 210: - exit(1); ! 211: - } ! 212: - if((buf = malloc(l = (BIGBLOCK/1024)*s->blocksize)) == 0){ ! 213: - fprint(2, "can't malloc %d\n", l); ! 214: - exit(1); ! 215: - } ! 216: - if(verbose) ! 217: - print("%s: %d bytes\n", name, len); ! 218: - while(len >= l){ ! 219: - if(Read(s, buf, NBLKS(s, l))) ! 220: - exit(1); ! 221: - if(write(fd, buf, l) != l){ ! 222: - perror(name); ! 223: - exit(2); ! 224: - } ! 225: - len -= l; ! 226: - } ! 227: - if(Read(s, buf, NBLKS(s, len))) ! 228: - exit(2); ! 229: - if(write(fd, buf, (int)len) != len){ ! 230: - perror(name); ! 231: - exit(2); ! 232: - } ! 233: - free(buf); ! 234: -} ! 235: - ! 236: -Inode * ! 237: -binodefn(s) ! 238: - char *s; ! 239: -{ ! 240: - static Inode i; ! 241: - mbuf key; ! 242: - ! 243: - if(inonames == 0) ! 244: - return((Inode *)0); ! 245: - key.mdata = s; ! 246: - key.mlen = strlen(s); ! 247: - if(bseek(bf, key) != 1) ! 248: - return((Inode *)0); ! 249: - key.mdata = (char *)&i; ! 250: - if(bread(bf, (mbuf *)0, &key)){ ! 251: - perror("inode read"); ! 252: - return((Inode *)0); ! 253: - } ! 254: - i.name.n = i.name.o+inonames; ! 255: - return(&i); ! 256: -} ! 257: - ! 258: -void ! 259: -btraverse(fn) ! 260: - void (*fn)(); ! 261: -{ ! 262: - static Inode i; ! 263: - mbuf key; ! 264: - ! 265: - if(inonames == 0) ! 266: - return; ! 267: - bfirst(bf); ! 268: - key.mdata = (char *)&i; ! 269: - while(bread(bf, (mbuf *)0, &key) == 0){ ! 270: - i.name.n = i.name.o+inonames; ! 271: - (*fn)(&i); ! 272: - } ! 273: -} ! 274: //GO.SYSIN DD btree.c ! 275: echo c.c 1>&2 ! 276: sed 's/.//' >c.c <<'//GO.SYSIN DD c.c' ! 277: -#include <sys/param.h> ! 278: -main(argc, argv) ! 279: - char **argv; ! 280: -{ ! 281: - Long off; ! 282: - long a, b; ! 283: - ! 284: - a = atoi(argv[1]); ! 285: - b = atoi(argv[2]); ! 286: - off = Llmul(ltoL(a), b); ! 287: - print("%d(#%x) x %d(#%x) = #%ux%0.8ux(%.0f)\n", a, a, b, b, off.hi, off.lo, ! 288: - ((float)off.lo) + 65536.0*65536.0*off.hi); ! 289: - if(llseek(open("/dev/null", 0), off, 0) < 0) ! 290: - perror("seek"); ! 291: -} ! 292: //GO.SYSIN DD c.c ! 293: echo crap 1>&2 ! 294: sed 's/.//' >crap <<'//GO.SYSIN DD crap' ! 295: -#include <libc.h> ! 296: -#include "sym.h" ! 297: -#include "worm.h" ! 298: - ! 299: -main(argc, argv) ! 300: - char **argv; ! 301: -{ ! 302: - Superblock s; ! 303: - char *e; ! 304: - Inode *i; ! 305: - int c; ! 306: - char *dev = "/dev/worm0"; ! 307: - extern char *optarg; ! 308: - extern int optind; ! 309: - ! 310: - while((c = getopt(argc, argv, "f:")) != -1) ! 311: - switch(c) ! 312: - { ! 313: - case 'f': dev = optarg; break; ! 314: - case '?': usage(); ! 315: - } ! 316: - if(optind+2 != argc) ! 317: - usage(); ! 318: - dev = mapdev(dev); ! 319: - if((s.fd = open(dev, 0)) < 0){ ! 320: - perror(dev); ! 321: - exit(1); ! 322: - } ! 323: - if(e = openinode(&s, DO_INODE|SPIN_DOWN)){ ! 324: - fprint(2, "%s: %s\n", dev, e); ! 325: - exit(1); ! 326: - } ! 327: - if(strcmp(s.vol_id, argv[optind])){ ! 328: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id); ! 329: - exit(1); ! 330: - } ! 331: - if(i = inodeof(argv[++optind])) ! 332: - c = pr(&s, i); ! 333: - else { ! 334: - fprint(2, "wcat: can't find %s\n", argv[optind]); ! 335: - c = 1; ! 336: - } ! 337: - exit(c); ! 338: -} ! 339: - ! 340: -usage() ! 341: -{ ! 342: - fprint(2, "Usage: worm cat [-fdevice] vol_id file\n"); ! 343: - exit(1); ! 344: -} ! 345: - ! 346: -pr(s, i) ! 347: - Superblock *s; ! 348: - register Inode *i; ! 349: -{ ! 350: - char b[BIGBLOCK]; ! 351: - register long len, n; ! 352: - long nb; ! 353: - int fd; ! 354: - ! 355: - fd = 1; ! 356: - nb = sizeof b / s->blocksize; ! 357: - Seek(s, i->block); ! 358: - for(n = i->nbytes, len = nb*s->blocksize; n > 0;){ ! 359: - if(len > n){ ! 360: - len = n; ! 361: - nb = (len+s->blocksize-1)/s->blocksize; ! 362: - } ! 363: - Read(s, b, nb); ! 364: - if(write(fd, b, (int)len) != len){ ! 365: - perror("write"); ! 366: - return(1); ! 367: - } ! 368: - n -= len; ! 369: - } ! 370: - close(fd); ! 371: - return(0); ! 372: -} ! 373: //GO.SYSIN DD crap ! 374: echo flink.c 1>&2 ! 375: sed 's/.//' >flink.c <<'//GO.SYSIN DD flink.c' ! 376: -#include <libc.h> ! 377: -#include "worm.h" ! 378: - ! 379: -static Inode *inodebase; ! 380: -static char *namebase; ! 381: -static long nnames, ninodes; ! 382: -static char *expanded; ! 383: -static readinodes; ! 384: -static ifd; ! 385: - ! 386: -static Inode *diskinode(); ! 387: - ! 388: -static Inode * ! 389: -finode(s) ! 390: - char *s; ! 391: -{ ! 392: - register lo, hi, m; ! 393: - register Inode *i; ! 394: - ! 395: - if(readinodes == 0) ! 396: - return(diskinode(s)); ! 397: -#define EXPAND(in) (i = inodebase+(in), expanded[in]?0:(i->name.n=i->name.o+namebase, expanded[in]=1)) ! 398: -#define CMP(str, in) (EXPAND(in), strcmp(str, i->name.n)) ! 399: - ! 400: - if(CMP(s, lo = 0) < 0) ! 401: - return(0); ! 402: - if(CMP(s, (hi = ninodes)-1) > 0) ! 403: - return(0); ! 404: - while(lo < hi-1){ ! 405: - m = (lo+hi)/2; ! 406: - if(CMP(s, m) < 0) ! 407: - hi = m; ! 408: - else ! 409: - lo = m; ! 410: - } ! 411: - if(CMP(s, lo) == 0) ! 412: - return(inodebase+lo); ! 413: - else ! 414: - return(0); ! 415: -} ! 416: - ! 417: -static void ! 418: -ftraverse(fn) ! 419: - void (*fn)(); ! 420: -{ ! 421: - register Inode *i; ! 422: - register n; ! 423: - ! 424: - if(readinodes == 0){ ! 425: - readinodes = 1; ! 426: - lseek(ifd, 8L, 0); ! 427: - read(ifd, (char *)inodebase, (int)ninodes*sizeof(Inode)); ! 428: - } ! 429: - for(n = 0; n < ninodes; n++){ ! 430: - EXPAND(n); ! 431: - (*fn)(i); ! 432: - } ! 433: -} ! 434: - ! 435: -fastlink(s, msg, ifn, tfn) ! 436: - Superblock *s; ! 437: - char **msg; ! 438: - Inode *(**ifn)(); ! 439: - void (**tfn)(); ! 440: -{ ! 441: - int n; ! 442: - long t; ! 443: - static char buf[256]; ! 444: - ! 445: - *msg = 0; ! 446: - *ifn = finode; ! 447: - *tfn = ftraverse; ! 448: - sprint(buf, "/usr/worm/tmp/%s", s->vol_id); ! 449: - if((ifd = open(buf, 0)) < 0) ! 450: - return(0); ! 451: - read(ifd, (char *)&t, 4); ! 452: - if(t != s->ctime) ! 453: - return(0); ! 454: - read(ifd, (char *)&ninodes, 4); ! 455: - inodebase = (Inode *)malloc(n = ninodes*sizeof(Inode)); ! 456: - expanded = malloc((int)ninodes); ! 457: - memset(expanded, 0, (int)ninodes); ! 458: - lseek(ifd, (long)n, 1); ! 459: - readinodes = 0; ! 460: - read(ifd, (char *)&nnames, 4); ! 461: - namebase = malloc((int)nnames); ! 462: - read(ifd, namebase, (int)nnames); ! 463: - numinodes = ninodes; ! 464: - numnamechars = nnames; ! 465: - return(1); ! 466: -} ! 467: - ! 468: -static ! 469: -readi(ino, ip) ! 470: - Inode *ip; ! 471: -{ ! 472: - static myino = -1; ! 473: - static Inode myi; ! 474: - ! 475: - if(ino != myino){ ! 476: - myino = ino; ! 477: - lseek(ifd, 8L+myino*sizeof(Inode), 0); ! 478: - read(ifd, (char *)&myi, sizeof myi); ! 479: - myi.name.n = myi.name.o+namebase; ! 480: - } ! 481: - *ip = myi; ! 482: -} ! 483: - ! 484: -static Inode * ! 485: -diskinode(s) ! 486: - char *s; ! 487: -{ ! 488: - register lo, hi, m; ! 489: - static Inode ii; ! 490: - register Inode *i = ⅈ ! 491: - ! 492: -#define READ(in) readi(in, i) ! 493: -#undef CMP ! 494: -#define CMP(str, in) (READ(in), strcmp(str, i->name.n)) ! 495: - ! 496: - if(ninodes <= 0) ! 497: - return(0); ! 498: - if(CMP(s, lo = 0) < 0) ! 499: - return(0); ! 500: - if(CMP(s, (hi = ninodes)-1) > 0) ! 501: - return(0); ! 502: - while(lo < hi-1){ ! 503: - m = (lo+hi)/2; ! 504: - if(CMP(s, m) < 0) ! 505: - hi = m; ! 506: - else ! 507: - lo = m; ! 508: - } ! 509: - if(CMP(s, lo) == 0) ! 510: - return(i); ! 511: - else ! 512: - return(0); ! 513: -} ! 514: //GO.SYSIN DD flink.c ! 515: echo getopt.c 1>&2 ! 516: sed 's/.//' >getopt.c <<'//GO.SYSIN DD getopt.c' ! 517: -#define ERR(str, chr) if(opterr){fprint(2, "%s%s%c\n", argv[0], str, chr);} ! 518: -int opterr = 1; ! 519: -int optind = 1; ! 520: -int optopt; ! 521: -char *optarg; ! 522: -char *strchr(); ! 523: - ! 524: -int ! 525: -getopt (argc, argv, opts) ! 526: -char **argv, *opts; ! 527: -{ ! 528: - static int sp = 1; ! 529: - register c; ! 530: - register char *cp; ! 531: - ! 532: - if (sp == 1) ! 533: - if (optind >= argc || ! 534: - argv[optind][0] != '-' || argv[optind][1] == '\0') ! 535: - return -1; ! 536: - else if (strcmp(argv[optind], "--") == 0) { ! 537: - optind++; ! 538: - return -1; ! 539: - } ! 540: - optopt = c = argv[optind][sp]; ! 541: - if (c == ':' || (cp=strchr(opts, c)) == 0) { ! 542: - ERR (": illegal option -- ", c); ! 543: - if (argv[optind][++sp] == '\0') { ! 544: - optind++; ! 545: - sp = 1; ! 546: - } ! 547: - return '?'; ! 548: - } ! 549: - if (*++cp == ':') { ! 550: - if (argv[optind][sp+1] != '\0') ! 551: - optarg = &argv[optind++][sp+1]; ! 552: - else if (++optind >= argc) { ! 553: - ERR (": option requires an argument -- ", c); ! 554: - sp = 1; ! 555: - return '?'; ! 556: - } else ! 557: - optarg = argv[optind++]; ! 558: - sp = 1; ! 559: - } else { ! 560: - if (argv[optind][++sp] == '\0') { ! 561: - sp = 1; ! 562: - optind++; ! 563: - } ! 564: - optarg = 0; ! 565: - } ! 566: - return c; ! 567: -} ! 568: //GO.SYSIN DD getopt.c ! 569: echo in.c 1>&2 ! 570: sed 's/.//' >in.c <<'//GO.SYSIN DD in.c' ! 571: -#include <libc.h> ! 572: -#include <fio.h> ! 573: -#include "worm.h" ! 574: - ! 575: -int bad = 0; ! 576: -long nbytes; ! 577: -long blkdone; ! 578: -long nfiles; ! 579: -char *argout; ! 580: - ! 581: -static Inode *inodes; ! 582: -static long ip; ! 583: -static long ninodes = 0; ! 584: -static char *nameb; ! 585: -static long np; ! 586: -static long nnameb = 0; ! 587: -static long nblocks; ! 588: -#define IINC 1024 ! 589: -#define NINC (64*IINC) ! 590: - ! 591: -ininit() ! 592: -{ ! 593: - if(nnameb == 0){ ! 594: - nameb = malloc((unsigned)(nnameb = NINC)); ! 595: - if(nameb == 0){ ! 596: - fprint(2, "wwrite: malloc fail, %d bytes\n", nnameb); ! 597: - exit(1); ! 598: - } ! 599: - } ! 600: - np = 0; ! 601: - if(ninodes == 0){ ! 602: - inodes = (Inode *)malloc(sizeof(Inode)*(unsigned)(ninodes = IINC)); ! 603: - if(inodes == 0){ ! 604: - fprint(2, "wwrite: malloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 605: - exit(1); ! 606: - } ! 607: - } ! 608: - ip = 0; ! 609: - nblocks = 0; ! 610: -} ! 611: - ! 612: -inadd(s, i) ! 613: - Superblock *s; ! 614: - register Inode *i; ! 615: -{ ! 616: - register long len; ! 617: - ! 618: - len = strlen(i->name.n)+1; ! 619: - if(np+len > nnameb){ ! 620: - while(np+len > nnameb) ! 621: - nnameb += NINC; ! 622: - nameb = realloc(nameb, (unsigned)nnameb); ! 623: - if(nameb == 0){ ! 624: - fprint(2, "wwrite: realloc fail, %d bytes\n", nnameb); ! 625: - exit(1); ! 626: - } ! 627: - } ! 628: - strcpy(nameb+np, i->name.n); ! 629: - i->name.o = np; ! 630: - np += len; ! 631: - i->block = s->nextffree + nblocks; ! 632: - if(ip == ninodes){ ! 633: - ninodes += IINC; ! 634: - inodes = (Inode *)realloc((char *)inodes, (unsigned)ninodes*sizeof(Inode)); ! 635: - if(inodes == 0){ ! 636: - fprint(2, "wwrite: realloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 637: - exit(1); ! 638: - } ! 639: - } ! 640: - inodes[ip++] = *i; ! 641: - nblocks += (i->nbytes+s->blocksize-1)/s->blocksize; ! 642: - return(0); ! 643: -} ! 644: - ! 645: -inwrite(s, arg) ! 646: - Superblock *s; ! 647: - void *arg; ! 648: -{ ! 649: - int i, j; ! 650: - long next = s->nextffree; ! 651: - char *e; ! 652: - ! 653: - if(e = lkwri(s, inodes, ip, nameb, np, nblocks)){ ! 654: - fprint(2, "%s\n", e); ! 655: - bad = 1; ! 656: - return; ! 657: - } ! 658: - Seek(s, next); ! 659: - argout[2] = ' '; ! 660: - for(i = 0; i < ip; i++){ ! 661: - inodes[i].block = next; ! 662: - inodes[i].name.n = inodes[i].name.o + nameb; ! 663: - writeout(s, &inodes[i], &next, arg); ! 664: - j = (blkdone*100)/nblocks; ! 665: - argout[0] = j/10+'0'; ! 666: - argout[1] = j%10+'0'; ! 667: - } ! 668: -} ! 669: //GO.SYSIN DD in.c ! 670: echo inode.c 1>&2 ! 671: sed 's/.//' >inode.c <<'//GO.SYSIN DD inode.c' ! 672: -#include <libc.h> ! 673: -#include "worm.h" ! 674: -#include <sys/types.h> ! 675: -#include <sys/udaioc.h> ! 676: - ! 677: -Inode *(*inodefn)(); ! 678: -void (*traversefn)(); ! 679: -extern Inode *vinodefn(), *binodefn(); ! 680: -extern void vtraverse(), btraverse(); ! 681: -extern char *lkopi(), *cbtinit(); ! 682: -long numinodes; ! 683: -long numnamechars; ! 684: - ! 685: -char * ! 686: -openinode(s, flags) ! 687: - register Superblock *s; ! 688: -{ ! 689: - short fd = s->fd; ! 690: - char *b, *z; ! 691: - long blk; ! 692: - unsigned short ibuf[3]; ! 693: - static char buf[64]; ! 694: - extern char *getenv(); ! 695: - extern long atol(); ! 696: -int goo; extern errno; int ntry; ! 697: - ! 698: - if(z = getenv("WORMZERO")) ! 699: - blk = atol(z); ! 700: - else ! 701: - blk = 0; ! 702: - ntry = 0; ! 703: -loop: ! 704: - bigseek(s->fd, blk, 1024, 0); ! 705: - if(((goo = read(s->fd, (char *)ibuf, sizeof ibuf)) != sizeof ibuf) || ! 706: - ((((long)ibuf[1])<<16|ibuf[0]) != SMAGIC)){ ! 707: - if((goo < 0) && (errno == ENXIO)) ! 708: - blk++; /* blank check (unwritten), try next blk */ ! 709: - else if((goo == sizeof ibuf) && (ibuf[0] == 0) && (ibuf[1] == 0)) ! 710: - blk++; /* zeroes(??), try next blk */ ! 711: - else { ! 712: - fprint(2, "DEBUGGING[%d]: read=%d magic=0x%lx errno=%d\n", ! 713: - ntry, goo, (((long)ibuf[1])<<16|ibuf[0]), errno); ! 714: - if(ntry++ < 3) ! 715: - goto loop; ! 716: - } ! 717: - bigseek(s->fd, blk, 1024, 0); ! 718: - if(read(s->fd, (char *)ibuf, sizeof ibuf) < sizeof ibuf) ! 719: - return("no block size"); ! 720: - } ! 721: - if(flags&SPIN_DOWN) ! 722: - ioctl(s->fd, UIOSPDW); ! 723: - s->blocksize = ibuf[2]; /* magic is 0-1 */ ! 724: - if((b = malloc(s->blocksize)) == 0){ ! 725: - sprint(buf, "couldn't malloc buffer (%d bytes)", s->blocksize); ! 726: - return(buf); ! 727: - } ! 728: - bigseek(s->fd, blk, 1024, 0); ! 729: - if(read(s->fd, b, s->blocksize) != s->blocksize) ! 730: - return("superblock read error"); ! 731: - *s = *((Superblock *)b); ! 732: - free(b); ! 733: - s->fd = fd; ! 734: - if(s->myblock == 0) ! 735: - s->myblock = blk; ! 736: - switch(s->version) ! 737: - { ! 738: - case VLINK: ! 739: - if(flags&DO_INODE){ ! 740: - Superblock tmpsb; ! 741: - ! 742: - tmpsb = *s; ! 743: - if(b = lkopi(s, blk, 0)) ! 744: - return(b); ! 745: - if(fastlink(s, &b, &inodefn, &traversefn)) ! 746: - return(b); ! 747: - *s = tmpsb; ! 748: - } ! 749: - inodefn = vinodefn; ! 750: - traversefn = vtraverse; ! 751: - return(lkopi(s, blk, flags&DO_INODE)); ! 752: - case VBTREE: ! 753: - inodefn = binodefn; ! 754: - traversefn = btraverse; ! 755: - return(cbtinit(s, blk, flags&DO_INODE)); ! 756: - default: ! 757: - sprint(buf, "unknown version %d@%ld", s->version, blk); ! 758: - return(buf); ! 759: - } ! 760: -} ! 761: //GO.SYSIN DD inode.c ! 762: echo io.c 1>&2 ! 763: sed 's/.//' >io.c <<'//GO.SYSIN DD io.c' ! 764: -#include <libc.h> ! 765: -#include "worm.h" ! 766: - ! 767: -Read(s, buf, n) ! 768: - register Superblock *s; ! 769: - char *buf; ! 770: - long n; ! 771: -{ ! 772: - register k; ! 773: - int len; ! 774: - ! 775: - n *= s->blocksize; ! 776: - if(n != (int)n){ ! 777: - fprint(2, "bad arg to Read n=%ld\n", n); ! 778: - abort(); ! 779: - } ! 780: - len = BIGBLOCK; ! 781: - while(n){ ! 782: - if(n < len) len = n; ! 783: - if((k = read(s->fd, buf, len)) != len){ ! 784: - if(k && (errno != ENXIO)){ ! 785: - perror("Read"); ! 786: - exit(1); ! 787: - } ! 788: - return(1); ! 789: - } ! 790: - n -= len; ! 791: - buf += len; ! 792: - } ! 793: - return(0); ! 794: -} ! 795: - ! 796: -Write(s, buf, n) ! 797: - register Superblock *s; ! 798: - char *buf; ! 799: - long n; ! 800: -{ ! 801: - register k; ! 802: - int len; ! 803: - char msg[256]; ! 804: - ! 805: - n *= s->blocksize; ! 806: - if(n != (int)n){ ! 807: - fprint(2, "bad arg to Write n=%d\n", n); ! 808: - abort(); ! 809: - } ! 810: - len = BIGBLOCK; ! 811: - while(n){ ! 812: - if(n < len) len = n; ! 813: - if((k = write(s->fd, buf, len)) != len){ ! 814: - sprint(msg, "Write %d blks (%dB)", n/s->blocksize, n); ! 815: - perror(msg); ! 816: - return(1); ! 817: - } ! 818: - n -= len; ! 819: - buf += len; ! 820: - } ! 821: - return(0); ! 822: -} ! 823: - ! 824: -Seek(s, blk) ! 825: - register Superblock *s; ! 826: - long blk; ! 827: -{ ! 828: - bigseek(s->fd, blk, s->blocksize, 0); ! 829: -} ! 830: - ! 831: -bigseek(fd, a, b, ptr) ! 832: -{ ! 833: -#define SEEK64 /**/ ! 834: -#ifdef SEEK64 ! 835: -#include <sys/param.h> ! 836: - llong_t off; ! 837: - extern llong_t Llmul(), ltoL(); ! 838: - ! 839: - off = Llmul(ltoL(a), b); ! 840: - llseek(fd, off, ptr); ! 841: -#else ! 842: - lseek(fd, a*(long)b, ptr); ! 843: -#endif ! 844: -} ! 845: //GO.SYSIN DD io.c ! 846: echo mapdev.c 1>&2 ! 847: sed 's/.//' >mapdev.c <<'//GO.SYSIN DD mapdev.c' ! 848: -char * ! 849: -mapdev(s) ! 850: - char *s; ! 851: -{ ! 852: - static char buf[128]; ! 853: - ! 854: - if((s[1] == 0) && (*s >= '0') && (*s <= '9')){ ! 855: - sprint(buf, "/dev/worm%c", *s); ! 856: - s = buf; ! 857: - } ! 858: - return(s); ! 859: -} ! 860: //GO.SYSIN DD mapdev.c ! 861: echo mkfile 1>&2 ! 862: sed 's/.//' >mkfile <<'//GO.SYSIN DD mkfile' ! 863: -CFLAGS=-g -I. ! 864: -CC=cc ! 865: -LIB=worm.a ! 866: -BIN=/usr/lib/worm ! 867: -L=io inode vlink flink sym getopt mapdev btree LL in timenow ! 868: -OBJ=${L:%=$LIB(%.o)} ! 869: -NPROC=2 ! 870: -# remember to change /usr/bin/worm if you add programs ! 871: -ALL=wmkfs wstat wwrite wread wls woffline wcat wbtree wrm\ ! 872: - wdir wreset wmv wtmpdir wmount wcopy jukebox scsish ! 873: -BALL=${ALL:%=$BIN/%} ! 874: - ! 875: -all:V: $ALL ! 876: - ! 877: -scsish jukebox:Pexit 1: /unix ! 878: - cd scsi; mk both ! 879: - ! 880: -$LIB:Q: $OBJ ! 881: - names=`membername $newprereq` ! 882: - ar rv $LIB $names && rm $names ! 883: - ranlib $LIB ! 884: - ! 885: -'^(w[^.]*)$':R: \\1.o $LIB #O/\\1 ! 886: - $CC $CFLAGS -o $target $stem1.o $LIB -lcbt ! 887: - ! 888: -'^(poot)$':R: \\1.o $LIB #O/\\1 ! 889: - $CC $CFLAGS -o $target $stem1.o $LIB -lcbt ! 890: - ! 891: -'^(O/w[^.]*)$':R: \\1.O $COBJ ! 892: - cyntax $prereq && > $target ! 893: - ! 894: -$BIN/'(w[^.]*)$':R: \\1 ! 895: - cp $stem1 $target && strip $target; chmod 775 $target ! 896: -$BIN/'(scsish|jukebox)':R: \\1 ! 897: - cp $stem1 $target && strip $target; chmod 775 $target ! 898: - ! 899: -sym.o wtree.o thing.o: sym.h ! 900: -wtree.o thing.o: thing.h ! 901: - ! 902: -$LIB(%.o):N: %.o ! 903: -%.o: worm.h ! 904: -O/%.O: %.c ! 905: - cyntax -c $stem.c && mv $stem.O O ! 906: -O/%.O: worm.h ! 907: - ! 908: -pp: ! 909: - smallpr mkfile worm.h *.c ! 910: - ! 911: -clean:V: ! 912: - rm -f *.o *.a $ALL core O/* ! 913: - ! 914: -install:V: $BALL ! 915: - ! 916: -ship:V: shipped ! 917: -shipped: $BALL /usr/bin/worm ! 918: - ship $newprereq && touch $target ! 919: - ! 920: -goo:V: wmv wls wwrite wmkfs ! 921: - set +e ! 922: - > temp ! 923: - wmkfs -ftemp testa ! 924: - wwrite -ftemp testa w*.[ch] ! 925: - wls -ftemp -l wreset.c; wls -ftemp -b wreset.c ! 926: - wmv -ftemp testa wreset.c xxx ! 927: - wls -ftemp -l wreset.c xxx; wls -ftemp -b xxx ! 928: - ! 929: -wild: $BALL ! 930: - dest=wild ship $newprereq && touch $target ! 931: - ! 932: -poot:V: wcopy wls wstat wmkfs ! 933: - > temp1 ! 934: - wmkfs -ftemp1 -n300 test7a; wstat -v -ftemp1 ! 935: - wls -ftemp | wcopy -ftemp -v -m0 testa temp1 test7a ! 936: - wstat -v -ftemp; wls -ftemp -b | sort | mc ! 937: - wstat -v -ftemp1; wls -ftemp1 -b | sort | mc ! 938: - #wstat -v -ftemp; wstat -v -ftemp1 ! 939: - wls -ftemp | wcopy -ftemp -v -m0 testa temp1 test7a ! 940: - wstat -v -ftemp1; wls -ftemp1 -b | sort | mc ! 941: - set +e;(wls -ftemp; echo; wls -ftemp; echo; wls -ftemp)| tee temp2 | wcopy -ftemp -v -m100 testa temp1 test7a ! 942: - wstat -v -ftemp1; wls -ftemp1 -b | sort | mc ! 943: - ! 944: -goop:V: wmkfs wstat wwrite ! 945: - > temp ! 946: - wmkfs -ftemp -n1000 testa; wstat -vftemp ! 947: - wmkfs -n666 -ftemp testa; wstat -vftemp ! 948: //GO.SYSIN DD mkfile ! 949: echo owcopy.c 1>&2 ! 950: sed 's/.//' >owcopy.c <<'//GO.SYSIN DD owcopy.c' ! 951: -#include <libc.h> ! 952: -#include "worm.h" ! 953: -#include "sym.h" ! 954: -#include <sys/types.h> ! 955: -#include <sys/stat.h> ! 956: -#include <pwd.h> ! 957: -#include <grp.h> ! 958: - ! 959: -char *timenow(); ! 960: -long minfree = 40000; ! 961: -int verbose = 0; ! 962: -static char *copy(); ! 963: - ! 964: -main(argc, argv) ! 965: - char **argv; ! 966: -{ ! 967: - char *e; ! 968: - char *dev = "/dev/worm0"; ! 969: - char *dest = 0; ! 970: - Superblock in, out; ! 971: - long start = 1; ! 972: - long count = 1000000L; ! 973: - int c; ! 974: - extern char *optarg; ! 975: - extern int optind; ! 976: - void pr(); ! 977: - ! 978: - while((c = getopt(argc, argv, "vc:m:s:f:")) != -1) ! 979: - switch(c) ! 980: - { ! 981: - case 'c': count = atol(optarg); break; ! 982: - case 'f': dev = optarg; break; ! 983: - case 'm': minfree = atol(optarg); break; ! 984: - case 's': start = atol(optarg); break; ! 985: - case 'v': verbose = 1; break; ! 986: - case '?': usage(); ! 987: - } ! 988: - dev = mapdev(dev); ! 989: - if((in.fd = open(dev, 0)) < 0){ ! 990: - perror(dev); ! 991: - exit(1); ! 992: - } ! 993: - if(optind+3 != argc) ! 994: - usage(); ! 995: - ! 996: - if(e = openinode(&in, SPIN_DOWN)){ ! 997: - fprint(2, "worm copy: %s: %s\n", dev, e); ! 998: - exit(1); ! 999: - } ! 1000: - if(strcmp(argv[optind], in.vol_id)){ ! 1001: - fprint(2, "src vol_id mismatch: expected %s, got %s\n", ! 1002: - argv[optind], in.vol_id); ! 1003: - exit(1); ! 1004: - } ! 1005: - dest = mapdev(argv[optind+1]); ! 1006: - if((out.fd = open(dest, 2)) < 0){ ! 1007: - perror(dest); ! 1008: - exit(1); ! 1009: - } ! 1010: - if(e = openinode(&out, SPIN_DOWN)){ ! 1011: - fprint(2, "worm copy: %s: %s\n", dest, e); ! 1012: - exit(1); ! 1013: - } ! 1014: - if(strcmp(argv[optind+2], out.vol_id)){ ! 1015: - fprint(2, "destination vol_id mismatch: expected %s, got %s\n", ! 1016: - argv[optind+2], out.vol_id); ! 1017: - exit(1); ! 1018: - } ! 1019: - if(e = copy(&in, start, count, &out)){ ! 1020: - fprint(2, "worm copy: %s: %s\n", dest, e); ! 1021: - exit(1); ! 1022: - } ! 1023: - exit(0); ! 1024: -} ! 1025: - ! 1026: -usage() ! 1027: -{ ! 1028: - fprint(2, "Usage: worm copy [-v] [-fdevice] [-s startblk] [-c count] [-m minfree] srcvolid destdev destvolid\n"); ! 1029: - exit(2); ! 1030: -} ! 1031: - ! 1032: -static char * ! 1033: -copy(in, blk, count, out) ! 1034: - register Superblock *in, *out; ! 1035: - long blk, count; ! 1036: -{ ! 1037: - register Inode *i; ! 1038: - short fd = in->fd; ! 1039: - char *b, *err; ! 1040: - long nb, ndata; ! 1041: - char *nameb; ! 1042: - Inode *inodes = 0; ! 1043: - Inode *iend; ! 1044: - long delta; ! 1045: - static char buf[64]; ! 1046: - extern char *lkwri(); ! 1047: - ! 1048: - in->blocksize = 1024; ! 1049: - if((b = malloc(in->blocksize)) == 0){ ! 1050: - sprint(buf, "couldn't malloc buffer (%d bytes)", in->blocksize); ! 1051: - return(buf); ! 1052: - } ! 1053: - Seek(in, blk); ! 1054: - if(Read(in, b, 1)){ ! 1055: - fprint(2, "worm copy: unexpected read error\n"); ! 1056: - exit(1); ! 1057: - } ! 1058: - *in = *((Superblock *)b); ! 1059: - in->fd = fd; ! 1060: - while(count-- > 0){ ! 1061: - if(in->magic != SMAGIC){ ! 1062: - fprint(2, "bad Superblock at %ld\n", blk); ! 1063: - exit(1); ! 1064: - } ! 1065: - if(in->ninodes){ ! 1066: - if(verbose) ! 1067: - fprint(2, "%s reading chunk %s:%ld (%.1f%%)\n", ! 1068: - timenow(), in->vol_id, in->myblock, ! 1069: - in->myblock*100./(float)in->nblocks); ! 1070: - if(out->nfree < minfree){ ! 1071: - fprint(2, "worm copy: disk %s has < %d free at input %d\n", ! 1072: - out->vol_id, minfree, in->myblock); ! 1073: - exit(1); ! 1074: - } ! 1075: - nb = (in->ninodes+(in->blocksize/sizeof(Inode))-1)/(in->blocksize/sizeof(Inode)); ! 1076: - inodes = (Inode *)malloc((unsigned)(in->blocksize*nb)); ! 1077: - if(inodes == 0){ ! 1078: - sprint(buf, "inode malloc(%d) fail, sbrk=%d\n", ! 1079: - (in->blocksize*nb), sbrk(0)); ! 1080: - return(buf); ! 1081: - } ! 1082: - Seek(in, in->binodes); ! 1083: - if(Read(in, (char *)inodes, nb)) ! 1084: - goto skip; ! 1085: - delta = out->nextffree - inodes->block; ! 1086: -print("%d inodes; delta=%d\n", in->ninodes, delta); ! 1087: - for(i = inodes, iend = inodes+in->ninodes; i < iend; i++) ! 1088: - if(i->block > 0) ! 1089: - i->block += delta; ! 1090: - nb = (in->ninochars+in->blocksize-1)/in->blocksize; ! 1091: - nameb = malloc((unsigned)(in->blocksize*nb)); ! 1092: - if(nameb == 0){ ! 1093: - sprint(buf, "name buffer malloc(%d) fail, sbrk=%d\n", ! 1094: - (in->blocksize*nb), sbrk(0)); ! 1095: - return(buf); ! 1096: - } ! 1097: - if(Read(in, nameb, nb)) ! 1098: - goto skip; ! 1099: - ndata = in->binodes - in->myblock - 1; ! 1100: - if(err = lkwri(out, inodes, in->ninodes, nameb, in->ninochars, ndata)){ ! 1101: - fprint(2, "wcopy: lkwri: %s at input %d\n", err, in->myblock); ! 1102: - exit(1); ! 1103: - } ! 1104: - dcopy(in, out, ndata); ! 1105: - } ! 1106: - skip: ! 1107: - blk = in->nextsb; ! 1108: - Seek(in, blk); ! 1109: - if(Read(in, b, 1L)) ! 1110: - break; ! 1111: - *in = *((Superblock *)b); ! 1112: - in->fd = fd; ! 1113: - if(in->myblock == 0) ! 1114: - in->myblock = blk; ! 1115: - } ! 1116: - free(b); ! 1117: - if(verbose) ! 1118: - fprint(2, "%s copy done, %s is %.1f%% full\n", timenow(), out->vol_id, ! 1119: - out->myblock*100.0/(float)out->nblocks); ! 1120: - return((char *)0); ! 1121: -} ! 1122: - ! 1123: -dcopy(in, out, n) ! 1124: - Superblock *in, *out; ! 1125: - long n; ! 1126: -{ ! 1127: - char buf[BIGBLOCK]; ! 1128: - long bs; ! 1129: - ! 1130: - bs = BIGBLOCK/in->blocksize; ! 1131: - Seek(in, in->myblock+1); ! 1132: - Seek(out, out->myblock+1); ! 1133: - while(n > 0){ ! 1134: - if(bs > n) bs = n; ! 1135: - if(Read(in, buf, bs)){ ! 1136: - fprint(2, "wcopy: warning: data read error at %d\n", in->myblock); ! 1137: - } ! 1138: - if(Write(out, buf, bs)){ ! 1139: - fprint(2, "wcopy: dcopy write error\n"); ! 1140: - exit(1); ! 1141: - } ! 1142: - n -= bs; ! 1143: - } ! 1144: -} ! 1145: - ! 1146: -char * ! 1147: -timenow() ! 1148: -{ ! 1149: - long tim; ! 1150: - char *tims; ! 1151: - ! 1152: - time(&tim); ! 1153: - tims = ctime(&tim); ! 1154: - tims[19] = 0; ! 1155: - return(tims); ! 1156: -} ! 1157: //GO.SYSIN DD owcopy.c ! 1158: echo partial.news 1>&2 ! 1159: sed 's/.//' >partial.news <<'//GO.SYSIN DD partial.news' ! 1160: -the worm programs now only run properly on systems ! 1161: -with llseek in the kernel. the three systems that matter ! 1162: //GO.SYSIN DD partial.news ! 1163: echo poot.c 1>&2 ! 1164: sed 's/.//' >poot.c <<'//GO.SYSIN DD poot.c' ! 1165: -#include <libc.h> ! 1166: -#include "sym.h" ! 1167: -#include "worm.h" ! 1168: - ! 1169: -main(argc, argv) ! 1170: - char **argv; ! 1171: -{ ! 1172: - Superblock s; ! 1173: - char buf[1024]; ! 1174: - char *e; ! 1175: - Inode *i; ! 1176: - int c; ! 1177: - char *com = 0; ! 1178: - char *dev = "/dev/worm0"; ! 1179: - extern char *optarg; ! 1180: - extern int optind; ! 1181: - ! 1182: - while((c = getopt(argc, argv, "f:c:")) != -1) ! 1183: - switch(c) ! 1184: - { ! 1185: - case 'c': com = optarg; break; ! 1186: - case 'f': dev = optarg; break; ! 1187: - case '?': usage(); ! 1188: - } ! 1189: - if(optind+2 != argc) ! 1190: - usage(); ! 1191: - dev = mapdev(dev); ! 1192: - if((s.fd = open(dev, 2)) < 0){ ! 1193: - perror(dev); ! 1194: - exit(1); ! 1195: - } ! 1196: - if(e = openinode(&s, SPIN_DOWN)){ ! 1197: - fprint(2, "%s: %s\n", dev, e); ! 1198: - exit(1); ! 1199: - } ! 1200: - if(strcmp(s.vol_id, argv[optind])){ ! 1201: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id); ! 1202: - exit(1); ! 1203: - } ! 1204: - if(s.version != VBTREE){ ! 1205: - fprint(2, "poot: %s must be a btree disk\n", s.vol_id); ! 1206: - exit(1); ! 1207: - } ! 1208: - memset(buf, sizeof buf, 0); ! 1209: - memset(s.vol_id, sizeof s.vol_id, 0); ! 1210: - strcpy(s.vol_id, argv[++optind]); ! 1211: - if(com){ ! 1212: - memset(s.comment, sizeof s.comment, 0); ! 1213: - strcpy(s.comment, com); ! 1214: - } ! 1215: - memcpy(buf, &s, 1024); ! 1216: - lseek(s.fd, 0, 0); ! 1217: - if(write(s.fd, buf, 1024) != 1024){ ! 1218: - perror("write of new superblock"); ! 1219: - exit(1); ! 1220: - } ! 1221: - exit(0); ! 1222: -} ! 1223: - ! 1224: -usage() ! 1225: -{ ! 1226: - fprint(2, "Usage: poot [-fdevice] [-ccnewcomment] vol_id new_vol_id\n"); ! 1227: - exit(1); ! 1228: -} ! 1229: //GO.SYSIN DD poot.c ! 1230: echo scsi/mkfile 1>&2 ! 1231: sed 's/.//' >scsi/mkfile <<'//GO.SYSIN DD scsi/mkfile' ! 1232: -SYS=research ! 1233: -< $SYS.mk ! 1234: -JL=juke.a ! 1235: -X=allocate cold getstatus ioshelves iodr_sh lib load nlun warm ! 1236: -JLIB=${X:%=$JL(%.o)} ! 1237: -JSRC=${X:%=%.c} ! 1238: - ! 1239: -SL=scsi.a ! 1240: -X=s_$IO ge_sense s_volid s_pperror s_fixedstr s_longat s_xd ! 1241: -SLIB=${X:%=$SL(%.o)} ! 1242: - ! 1243: -SHL=scsish.a ! 1244: -GENERIC=ge_dev ge_inq ge_stop ge_start ge_capacity ge_display\ ! 1245: - ge_reset ge_tur ge_scsi ge_readt ge_copy # ge_sense in $SL ! 1246: -SONY=so_dev so_inq so_alt so_config so_status so_eject so_rel so_set\ ! 1247: - so_shelfside so_diskid so_internal so_media so_readid so_copy\ ! 1248: - so_i0.tab so_i1.tab so_scsi.tab so_sense so_nesd.tab ! 1249: -WREN=wr_dev wr_inq wr_rmode wr_wmode wr_diag ! 1250: -X=$GENERIC $SONY $WREN ! 1251: -SHLIB=${X:%=$SHL(%.o)} ! 1252: - ! 1253: -all:V: jukebox scsish ! 1254: - ! 1255: -both:V: ../jukebox ../scsish ! 1256: - ! 1257: -../%: % ! 1258: - cp $prereq $target ! 1259: - ! 1260: -jukebox: jukebox.o $JL $SHL $SL ! 1261: - $CC $CFLAGS -o $target $prereq $LDFLAGS ! 1262: - ! 1263: -scsish: scsish.o $SHL $SL ! 1264: - $CC $CFLAGS -o $target $prereq $LDFLAGS ! 1265: - ! 1266: -jpp:V: ! 1267: - pr mkfile juke.h scsi.h jukebox.c $JSRC | lp -ddp -n2 ! 1268: - ! 1269: -poot:V: scsish ! 1270: - echo 'dev scsi ! 1271: - copy 4 0 10 5 0 1' | scsish ! 1272: - ! 1273: -scsi.cpio:V: inc/scsi.h ! 1274: - find * -print | sed -e '/\.[oa]$/d' -e '/\.cpio$/d' | cpio -oc > $target ! 1275: -inc/scsi.h:Pcmp -s: /usr/include/scsi.h ! 1276: - cp $prereq $target ! 1277: - ! 1278: - ! 1279: -# below is just magic; believe it. ! 1280: - ! 1281: -$JL(%.o):N: %.o ! 1282: -$JL:Q: $JLIB ! 1283: - names=`membername $newprereq` ! 1284: - ar rv $JL $names && rm $names ! 1285: - $RANLIB $JL ! 1286: - ! 1287: -$SL(%.o):N: %.o ! 1288: -$SL:Q: $SLIB ! 1289: - names=`membername $newprereq` ! 1290: - ar rv $SL $names && rm $names ! 1291: - $RANLIB $SL ! 1292: - ! 1293: -$SHL(%.o):N: %.o ! 1294: -$SHL:Q: $SHLIB ! 1295: - names=`membername $newprereq` ! 1296: - ar rv $SHL $names && rm $names ! 1297: - $RANLIB $SHL ! 1298: - ! 1299: -s_%.o: scsi/%.c ! 1300: - cd scsi; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target ! 1301: -so_%.o: sony/%.c ! 1302: - cd sony; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target ! 1303: -so_%.o: sony/fns.h ! 1304: -ge_%.o: generic/%.c ! 1305: - cd generic; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target ! 1306: -ge_%.o: generic/fns.h ! 1307: -wr_%.o: wren/%.c ! 1308: - cd wren; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target ! 1309: -wr_%.o: wren/fns.h ! 1310: -so_%.o wr_%.o ge_%.o: scsish.h scsi.h ! 1311: - ! 1312: -so_%.tab.o:Q: sony/%.tab ! 1313: - cd sony ! 1314: - echo generating $target ! 1315: - p=$stem.tab ! 1316: - awk -F' ' ' ! 1317: - BEGIN { h["0"]=0;h["1"]=1;h["2"]=2;h["3"]=3;h["4"]=4;h["5"]=5;h["6"]=6;h["7"]=7; ! 1318: - h["8"]=8;h["9"]=9;h["a"]=10;h["b"]=11;h["c"]=12;h["d"]=13;h["e"]=14;h["f"]=15; ! 1319: - } ! 1320: - function done( i){ ! 1321: - for(i = 0; i < 256; i++) if(x[i]){ ! 1322: - print "\t\"" x[i] "\"," ! 1323: - x[i] = "" ! 1324: - } else printf "\t\"<#%x>\",\n", i ! 1325: - print "};" ! 1326: - } ! 1327: - function hex(n, i){ ! 1328: - return(h[substr(n, 1, 1)]*16+h[substr(n, 2, 1)]); ! 1329: - } ! 1330: - NF == 1 { if(NR > 1) done(); print "char *" $1 "[] = {" } ! 1331: - NF > 1 { x[hex($1)] = $2; } ! 1332: - END { done(); }' < $p > $p.c && $CC $CFLAGS -c $p.c && mv $p.o ../$target ! 1333: - rm $p.c ! 1334: //GO.SYSIN DD scsi/mkfile ! 1335: echo scsi/cold.c 1>&2 ! 1336: sed 's/.//' >scsi/cold.c <<'//GO.SYSIN DD scsi/cold.c' ! 1337: -#include <stddef.h> ! 1338: -#include <stdio.h> ! 1339: -#include <string.h> ! 1340: -#include "scsi.h" ! 1341: -#include "juke.h" ! 1342: - ! 1343: -static sort(char *buf); ! 1344: - ! 1345: -cold_inv(char type, char *buf) ! 1346: -{ ! 1347: - Side side; ! 1348: - int drive, sh, nsh; ! 1349: - int n; ! 1350: - char vol_id[512]; ! 1351: - int didit[NSHELF]; ! 1352: - ! 1353: - if(j_getstatus(buf)) /* get the jukebox status */ ! 1354: - return(-1); ! 1355: -printf("getstatus done\n"); ! 1356: - /* first clear out nonexistent labels */ ! 1357: - n = 0; ! 1358: - for(sh = 0; sh < NSHELF; sh++){ ! 1359: - if((j_status.shelf[sh]&0xC0) == 0xC0){ ! 1360: - n++; ! 1361: - j_shelf[sh] = "there"; ! 1362: - } else ! 1363: - j_shelf[sh] = 0; ! 1364: - didit[sh] = 0; ! 1365: - } ! 1366: - printf("%d disks in shelves.\n", n); ! 1367: - /* second, clear the drives */ ! 1368: - for(sh = 0; sh < NSHELF; sh++) ! 1369: - if(j_shelf[sh] == 0) ! 1370: - break; ! 1371: - for(drive = 0; drive < 8; drive++){ ! 1372: - if(!j_status.lun[drive].diskin) ! 1373: - continue; /* no disk in drive */ ! 1374: -printf("clearing drive %d:\n", drive); ! 1375: - if(j_status.lun[drive].diskindrive && !j_status.lun[drive].shelfvalid){ ! 1376: - if(j_drive_to_shelf(drive, sh, SIDEA, buf)) ! 1377: - return(-1); ! 1378: - for(sh++; sh < NSHELF; sh++) ! 1379: - if(j_shelf[sh] == 0) ! 1380: - break; ! 1381: - n++; ! 1382: - } else ! 1383: - if(j_drive_to_shelf(drive, -1, SIDEA, buf)) ! 1384: - return(-1); ! 1385: - printf("\n"); ! 1386: - } ! 1387: - printf("reloading %d disks.\n", n); ! 1388: - side = SIDEA; ! 1389: - drive = min(nlun+1, NLUN-1); ! 1390: - j_wrshelf = 1; ! 1391: - for(sh = 0; sh < NSHELF; sh++){ ! 1392: - if(didit[sh]) ! 1393: - continue; ! 1394: - j_shelf[sh] = 0; ! 1395: - /* the C0 means disk properly present (not temp) */ ! 1396: - if((j_status.shelf[sh]&0xC0) == 0xC0){ ! 1397: - if(getvol(sh, drive, vol_id, &side)) ! 1398: - errexit(vol_id); ! 1399: - switch(type) ! 1400: - { ! 1401: - case 'c': ! 1402: - for(nsh = 0; j_shelf[nsh]; nsh++) ! 1403: - ; ! 1404: - break; ! 1405: - case 's': ! 1406: - case 'r': ! 1407: - while(j_shelf[nsh = nrand(NSHELF)]) ! 1408: - ; ! 1409: - break; ! 1410: - case 'u': ! 1411: - default: ! 1412: - nsh = sh; ! 1413: - break; ! 1414: - } ! 1415: - printf("%s@%d -> %d\n", vol_id, sh, nsh); ! 1416: - if(j_drive_to_shelf(drive, nsh, side, buf) < 0) ! 1417: - return(-1); ! 1418: - j_shelf[nsh] = strdup(vol_id); ! 1419: - didit[nsh] = 1; ! 1420: - sleep(2); ! 1421: - } ! 1422: - } ! 1423: - printf("process any new disks.\n"); ! 1424: - if(warm_inv(buf)) ! 1425: - return(-1); ! 1426: - if(type == 's') ! 1427: - return(sort(buf)); ! 1428: - return(0); ! 1429: -} ! 1430: - ! 1431: -getvol(int sh, int drive, char *vol_id, int *side) ! 1432: -{ ! 1433: - int i; ! 1434: - char buf[512]; ! 1435: - ! 1436: - if(j_shelf_to_drive(sh, SIDEA, drive, vol_id) < 0) ! 1437: - return(-1); ! 1438: - if((i = j_rvolid(drive, buf)) < 0) ! 1439: - goto softerr; ! 1440: - if(i == 0) ! 1441: - *side = SIDEA; ! 1442: - else { ! 1443: - *side = SIDEB; ! 1444: - if(j_drive_to_shelf(drive, sh, SIDEA, vol_id) < 0) ! 1445: - return(-1); ! 1446: - if(j_shelf_to_drive(sh, SIDEB, drive, vol_id) < 0) ! 1447: - return(-1); ! 1448: - if((i = j_rvolid(drive, buf)) < 0) ! 1449: - goto softerr; ! 1450: - } ! 1451: - if(i > 0) ! 1452: - strcpy(vol_id, UNALLOCATED); ! 1453: - else { ! 1454: - strcpy(vol_id, buf); ! 1455: - i = strlen(vol_id)-1; ! 1456: - if(i < 0){ ! 1457: - sprintf(buf, "apparently good superblock but null vol_id"); ! 1458: - goto softerr; ! 1459: - } else if(vol_id[i] == 'a') ! 1460: - vol_id[i] = 0; ! 1461: - else if(vol_id[i] == 'b'){ ! 1462: - vol_id[i] = 0; ! 1463: - *side = !*side; ! 1464: - } else { ! 1465: - sprintf(buf, "vol_id '%s' must end in a or b", vol_id); ! 1466: - strcpy(vol_id, buf); ! 1467: - return(-1); ! 1468: - } ! 1469: - } ! 1470: - return(0); ! 1471: -softerr: ! 1472: - *side = SIDEA; ! 1473: - fprintf(stderr, "error in reading shelf %d: %s; proceeding\n", sh, buf); ! 1474: - sprintf(vol_id, "DISK_ERROR%d", sh); ! 1475: - gen_reset(0, (int *)0, 0, (char **)0, buf); ! 1476: - return(0); ! 1477: -} ! 1478: - ! 1479: -static int index[NSHELF]; ! 1480: -static ! 1481: -cmp(int *a, int *b) ! 1482: -{ ! 1483: - char *sa = j_shelf[*a], *sb = j_shelf[*b]; ! 1484: - ! 1485: - if((sa == 0) && (sb == 0)) return(0); ! 1486: - if(sa == 0) return(-1); ! 1487: - if(sb == 0) return(1); ! 1488: - return(strcmp(sa, sb)); ! 1489: -} ! 1490: - ! 1491: -static char *disk[8]; ! 1492: - ! 1493: -static ! 1494: -sd(int a, int b, char *err) ! 1495: -{ ! 1496: - disk[b] = j_shelf[a]; ! 1497: - return(j_shelf_to_drive(a, SIDEB, b, err)); ! 1498: -} ! 1499: -static ! 1500: -ds(int a, int b, char *err) ! 1501: -{ ! 1502: - j_shelf[b] = disk[a]; ! 1503: - return(j_drive_to_shelf(a, b, SIDEB, err)); ! 1504: -} ! 1505: - ! 1506: -static ! 1507: -sort(char *errbuf) ! 1508: -{ ! 1509: - int i, j, org; ! 1510: - ! 1511: - for(i = 0; i < NSHELF; i++) ! 1512: - index[i] = i; ! 1513: - qsort(index, NSHELF, sizeof index[0], cmp); ! 1514: - for(i = 0; i < NSHELF; i++){ ! 1515: - if(index[i] < 0) continue; ! 1516: - if(sd(org = i, NLUN-1, errbuf) < 0) ! 1517: - return(-1); ! 1518: - j = index[i]; ! 1519: - index[i] = -1; ! 1520: - while(j != org){ ! 1521: - if(sd(j, NLUN-2, errbuf) < 0) ! 1522: - return(-1); ! 1523: - if(ds(NLUN-2, i, errbuf) < 0) ! 1524: - return(-1); ! 1525: - i = j; ! 1526: - if(index[i] < 0) ! 1527: - break; ! 1528: - j = index[i]; ! 1529: - index[i] = -1; ! 1530: - } ! 1531: - if(ds(NLUN-1, i, errbuf) < 0) ! 1532: - return(-1); ! 1533: - } ! 1534: - return(0); ! 1535: -} ! 1536: //GO.SYSIN DD scsi/cold.c ! 1537: echo scsi/osanity/tstfill.c 1>&2 ! 1538: sed 's/.//' >scsi/osanity/tstfill.c <<'//GO.SYSIN DD scsi/osanity/tstfill.c' ! 1539: -short pat[][8] = ! 1540: -{ ! 1541: - 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, ! 1542: - 0xb6db, 0xeb6d, 0xb6db, 0xeb6d, 0xb6db, 0xeb6d, 0xb6db, 0xeb6d, ! 1543: - 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, ! 1544: - 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, ! 1545: - 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, ! 1546: -}; ! 1547: - ! 1548: -fillbuf(buf, n) ! 1549: - char *buf; ! 1550: -{ ! 1551: - int i = 0; ! 1552: - register j; ! 1553: - ! 1554: - while(n > 0){ ! 1555: - if(i >= sizeof(pat)/sizeof(pat[0])) ! 1556: - i = 0; ! 1557: - for(j = 0; j < 64; j++, buf += 16) ! 1558: - memcpy(buf, pat[i], 16); ! 1559: - n--; ! 1560: - i++; ! 1561: - } ! 1562: -} ! 1563: //GO.SYSIN DD scsi/osanity/tstfill.c ! 1564: echo scsi/osanity/tstrd.c 1>&2 ! 1565: sed 's/.//' >scsi/osanity/tstrd.c <<'//GO.SYSIN DD scsi/osanity/tstrd.c' ! 1566: -main(argc, argv) ! 1567: - char **argv; ! 1568: -{ ! 1569: - long first, last, t; ! 1570: - char buf[32768], buf1[32768], *bufp; ! 1571: - int fd, n; ! 1572: - char *worm = "/dev/worm0"; ! 1573: - ! 1574: - if((argc < 3) || (argc > 4)){ ! 1575: - print("Usage: tstrd [device] firstblock firstnonblock\n"); ! 1576: - exit(1); ! 1577: - } ! 1578: - if(argc > 3) ! 1579: - worm = *++argv; ! 1580: - if((fd = open(worm, 0)) < 0){ ! 1581: - perror(worm); ! 1582: - exit(1); ! 1583: - } ! 1584: - first = atol(argv[1]); ! 1585: - last = atol(argv[2]); ! 1586: - if((first < 0) || (last <= first)){ ! 1587: - print("bad first=%ld last=%ld\n", first, last); ! 1588: - exit(1); ! 1589: - } ! 1590: - print("reading blocks %ld - %ld inclusive on %s\n", first, last-1, worm); ! 1591: - fillbuf(buf, 32); ! 1592: - bufp = &buf[1024*(first%5)]; ! 1593: - lseek(fd, first*1024, 0); ! 1594: - while(first < last){ ! 1595: - n = last-first; ! 1596: - if(n > 25) n = 25; ! 1597: - if(read(fd, buf1, n*1024) != n*1024){ ! 1598: - print("block %ld: ", first); ! 1599: - perror("read"); ! 1600: - exit(1); ! 1601: - } ! 1602: - if(memcmp(bufp, buf1, n*1024)){ ! 1603: - print("block %ld: bytes differ\n", first); ! 1604: - exit(1); ! 1605: - } ! 1606: - if((first%5000) == 0){ ! 1607: - t = time((long *)0); ! 1608: - print("done block %ld: %s", first, ctime(&t)); ! 1609: - } ! 1610: - first += n; ! 1611: - } ! 1612: - exit(0); ! 1613: -} ! 1614: //GO.SYSIN DD scsi/osanity/tstrd.c ! 1615: echo scsi/osanity/tstsk.c 1>&2 ! 1616: sed 's/.//' >scsi/osanity/tstsk.c <<'//GO.SYSIN DD scsi/osanity/tstsk.c' ! 1617: -main(argc, argv) ! 1618: - char **argv; ! 1619: -{ ! 1620: - long first, last, t; ! 1621: - char buf[32768], buf1[32768], *bufp; ! 1622: - int fd, n, i; ! 1623: - char *worm = "/dev/worm0"; ! 1624: - long bands[50][2]; ! 1625: - int nbands; ! 1626: - long loop; ! 1627: - double tseek, tbl; ! 1628: - float floop; ! 1629: - ! 1630: - if(argc < 3){ ! 1631: - print("Usage: tstsk [device] firstblock firstnonblock ...\n"); ! 1632: - exit(1); ! 1633: - } ! 1634: - if((argc&1) == 0) ! 1635: - worm = *++argv; ! 1636: - if((fd = open(worm, 0)) < 0){ ! 1637: - perror(worm); ! 1638: - exit(1); ! 1639: - } ! 1640: - nbands = 0; ! 1641: - while(*++argv){ ! 1642: - first = atol(*argv); ! 1643: - last = atol(*++argv); ! 1644: - if((first < 0) || (last <= first)){ ! 1645: - print("bad first=%ld last=%ld\n", first, last); ! 1646: - exit(1); ! 1647: - } ! 1648: - bands[nbands][0] = first; ! 1649: - bands[nbands][1] = last; ! 1650: - nbands++; ! 1651: - } ! 1652: - tseek = tbl = 0; ! 1653: - last = 0; ! 1654: - fillbuf(buf, 32); ! 1655: - for(loop = 0;; loop++){ ! 1656: - i = nrand(nbands); ! 1657: - first = bands[i][0] + lrand()%(bands[i][1]-bands[i][0]); ! 1658: - n = 20; ! 1659: - if(first+n > bands[i][1]) ! 1660: - first = bands[i][1]-n; ! 1661: - if(first < bands[i][0]) ! 1662: - first = bands[i][0], n = bands[i][1]-first; ! 1663: - tbl += n; ! 1664: - lseek(fd, first*1024, 0); ! 1665: - last -= first; ! 1666: - if(last < 0) last = -last; ! 1667: - tseek += last; ! 1668: - bufp = &buf[1024*(first%5)]; ! 1669: - if(read(fd, buf1, n*1024) != n*1024){ ! 1670: - print("block %ld: ", first); ! 1671: - perror("read"); ! 1672: - exit(1); ! 1673: - } ! 1674: - if(memcmp(bufp, buf1, n*1024)){ ! 1675: - print("block %ld: bytes differ\n", first); ! 1676: - exit(1); ! 1677: - } ! 1678: - if(loop && ((loop%100) == 0)){ ! 1679: - t = time((long *)0); ! 1680: - floop = loop+1; ! 1681: - print("loop %ld: ave blocks=%.1f, ave seek=%.1fk at %s", ! 1682: - loop, tbl/floop, tseek/floop, ctime(&t)); ! 1683: - } ! 1684: - last = first+n; ! 1685: - } ! 1686: -} ! 1687: //GO.SYSIN DD scsi/osanity/tstsk.c ! 1688: echo scsi/osanity/tstwr.c 1>&2 ! 1689: sed 's/.//' >scsi/osanity/tstwr.c <<'//GO.SYSIN DD scsi/osanity/tstwr.c' ! 1690: -main(argc, argv) ! 1691: - char **argv; ! 1692: -{ ! 1693: - long first, last, t; ! 1694: - char buf[32768], buf1[32768], *bufp; ! 1695: - int fd, n; ! 1696: - char *worm = "/dev/worm0"; ! 1697: - ! 1698: - if((argc < 3) || (argc > 4)){ ! 1699: - print("Usage: tstwr [device] firstblock firstnonblock\n"); ! 1700: - exit(1); ! 1701: - } ! 1702: - if(argc > 3) ! 1703: - worm = *++argv; ! 1704: - if((fd = open(worm, 1)) < 0){ ! 1705: - perror(worm); ! 1706: - exit(1); ! 1707: - } ! 1708: - first = atol(argv[1]); ! 1709: - last = atol(argv[2]); ! 1710: - if((first < 0) || (last <= first)){ ! 1711: - print("bad first=%ld last=%ld\n", first, last); ! 1712: - exit(1); ! 1713: - } ! 1714: - print("writing blocks %ld - %ld inclusive on %s\n", first, last-1, worm); ! 1715: - fillbuf(buf, 32); ! 1716: - bufp = &buf[1024*(first%5)]; ! 1717: - lseek(fd, first*1024, 0); ! 1718: - while(first < last){ ! 1719: - n = last-first; ! 1720: - if(n > 25) n = 25; ! 1721: - if(write(fd, bufp, n*1024) != n*1024){ ! 1722: - print("block %ld: ", first); ! 1723: - perror("write"); ! 1724: - exit(1); ! 1725: - } ! 1726: - if((first%5000) == 0){ ! 1727: - t = time((long *)0); ! 1728: - print("done block %ld: %s", first, ctime(&t)); ! 1729: - } ! 1730: - first += n; ! 1731: - } ! 1732: - exit(0); ! 1733: -} ! 1734: //GO.SYSIN DD scsi/osanity/tstwr.c ! 1735: echo scsi/osanity/mkfile 1>&2 ! 1736: sed 's/.//' >scsi/osanity/mkfile <<'//GO.SYSIN DD scsi/osanity/mkfile' ! 1737: -CFLAGS=-g ! 1738: -NPROC=2 ! 1739: -ALL=tstwr tstrd tstsk ! 1740: - ! 1741: -all:V: $ALL ! 1742: - ! 1743: -tst%: tst%.o tstfill.o ! 1744: - $CC $CFLAGS -o $target $prereq ! 1745: - ! 1746: -clean:V: ! 1747: - rm -f *.o $ALL core ! 1748: //GO.SYSIN DD scsi/osanity/mkfile ! 1749: echo scsi/osanity/seek 1>&2 ! 1750: sed 's/.//' >scsi/osanity/seek <<'//GO.SYSIN DD scsi/osanity/seek' ! 1751: -tstsk 5 100000 400000 500000 800000 900000 1200000 1300000 1500000 1600000 ! 1752: //GO.SYSIN DD scsi/osanity/seek ! 1753: echo scsi/juke.3 1>&2 ! 1754: sed 's/.//' >scsi/juke.3 <<'//GO.SYSIN DD scsi/juke.3' ! 1755: -.TH INTERNAL 3 ! 1756: -.CT 2 file_io ! 1757: -.SH NAME ! 1758: -jukebox routines ! 1759: -.tr %" ! 1760: -.SH SYNOPSIS ! 1761: -.B "#include %hdr.h%" ! 1762: -.PP ! 1763: -.tr %% ! 1764: -.B "int j_shelf_to_drive(int sh, Side side, int dr, char *err)" ! 1765: -.PP ! 1766: -.B "int j_drive_to_shelf(int dr, int sh, Side side, char *err)" ! 1767: -.PP ! 1768: -.B "int j_empty_drive(int tlim, char *buf)" ! 1769: -.PP ! 1770: -.B "void j_rdshelves(char *buf)" ! 1771: -.PP ! 1772: -.B "int j_getstatus(char *buf)" ! 1773: -.PP ! 1774: -.B "int j_scsiio(struct scsi_cmd *cmd, int ncmd," ! 1775: -.br ! 1776: -.B "\ \ \ \ \ \ struct scsi_return *ret, int nret, char *err)" ! 1777: -.PP ! 1778: -.B "int j_shelfof(char *vol_id)" ! 1779: -.PP ! 1780: -.B "int j_volid(int dr, char *err)" ! 1781: -.PP ! 1782: -.B "extern char *j_shelf[NSHELF];" ! 1783: -.PP ! 1784: -.B "extern void pperror(char *buf, char *mesg); ! 1785: -.SH DESCRIPTION ! 1786: -.I J_shelf_to_drive ! 1787: -places the disk in shelf ! 1788: -.I sh ! 1789: -in logical drive ! 1790: -.IR dr . ! 1791: -It returns 0 on success; ! 1792: -otherwise an error message is placed in ! 1793: -.I err . ! 1794: -.PP ! 1795: -.I J_drive_to_shelf ! 1796: -places the disk ! 1797: -in logical drive ! 1798: -.IR dr ! 1799: -in shelf ! 1800: -.IR sh . ! 1801: -If ! 1802: -.I sh ! 1803: -is negative, ! 1804: -the disk is returned to its home shelf. ! 1805: -It returns 0 on success; ! 1806: -otherwise an error message is placed in ! 1807: -.IR err . ! 1808: -.PP ! 1809: -.I J_rdshelves ! 1810: -initializes each element of ! 1811: -.I j_shelf ! 1812: -to the volid of the disk on that shelf. ! 1813: -A zero pointer means there is no disk; ! 1814: -a name of ! 1815: -.B UNALLOCATED ! 1816: -means the disk has not been allocated a name yet. ! 1817: -It returns 0 on success; ! 1818: -otherwise an error message is placed in ! 1819: -.IR err . ! 1820: -.PP ! 1821: -.I J_getstatus ! 1822: -initializes ! 1823: -.B j_status ! 1824: -which include the following fields: ! 1825: -.EX ! 1826: - struct Lunstatus lun[NLUN]; /* disk status */ ! 1827: - uchar shelf[NSHELF]; /* shelf status */ ! 1828: - uchar iounit; /* I/O unit status */ ! 1829: - uchar carrier; /* carrier status */ ! 1830: - uchar udrive; /* upper drive status */ ! 1831: - uchar ldrive; /* lower drive status */ ! 1832: -.EE ! 1833: -A return value of 0 implies success; ! 1834: -otherwise \-1 is returned and an error message is placed in ! 1835: -.IR err . ! 1836: -.PP ! 1837: -.I J_scsiio ! 1838: -performs a SCSI transaction. ! 1839: -It sends the command in ! 1840: -.I cmd ! 1841: -and ! 1842: -.I ncmd ! 1843: -data bytes and stores the return status in ! 1844: -.IR ret . ! 1845: -A return value of 0 implies success; ! 1846: -otherwise \-1 is returned and an error message is placed in ! 1847: -.IR err . ! 1848: -.PP ! 1849: -.I J_shelfof ! 1850: -returns the shelf number of the disk labelled ! 1851: -.IR vol_id . ! 1852: -If there is no such disk, ! 1853: -\-1 is returned. ! 1854: -.PP ! 1855: -.I J_volid ! 1856: -returns the volid of the disk on drive ! 1857: -.I dr ! 1858: -in ! 1859: -.IR err . ! 1860: -A return value of 0 implies success; ! 1861: -otherwise \-1 is returned and an error message is placed in ! 1862: -.IR err . ! 1863: -.PP ! 1864: -.I Pperror ! 1865: -returns an error message that is contained in ! 1866: -.IR buf. ! 1867: -.PP ! 1868: -.SH "SEE ALSO" ! 1869: -.SH DIAGNOSTICS ! 1870: //GO.SYSIN DD scsi/juke.3 ! 1871: echo scsi/warm.c 1>&2 ! 1872: sed 's/.//' >scsi/warm.c <<'//GO.SYSIN DD scsi/warm.c' ! 1873: -#include <stddef.h> ! 1874: -#include <stdio.h> ! 1875: -#include <string.h> ! 1876: -#include "scsi.h" ! 1877: -#include "juke.h" ! 1878: - ! 1879: -warm_inv(char *buf) ! 1880: -{ ! 1881: - Side side; ! 1882: - int drive, sh; ! 1883: - char vol_id[512]; ! 1884: - ! 1885: - if(j_rdshelves(buf)) /* read in shelf names */ ! 1886: - return(-1); ! 1887: - side = SIDEA; ! 1888: - drive = min(nlun+1, NLUN-1); ! 1889: - for(;;){ ! 1890: - if(j_getstatus(buf)) /* get the jukebox status */ ! 1891: - return(-1); ! 1892: - for(sh = 0; sh < NSHELF; sh++) ! 1893: - if(j_status.shelf[sh]&0x10) break; ! 1894: - if(sh >= NSHELF) ! 1895: - break; ! 1896: - if(getvol(127, drive, vol_id, &side)){ ! 1897: - strcpy(buf, vol_id); ! 1898: - return(-1); ! 1899: - } ! 1900: - for(sh = 0; j_shelf[sh]; sh++) ! 1901: - ; ! 1902: - printf("%s -> %d\n", vol_id, sh); ! 1903: - if(j_drive_to_shelf(drive, sh, side, buf) < 0) ! 1904: - return(-1); ! 1905: - j_wrshelf = 1; ! 1906: - j_shelf[sh] = strdup(vol_id); ! 1907: - sleep(1); ! 1908: - } ! 1909: - return(0); ! 1910: -} ! 1911: //GO.SYSIN DD scsi/warm.c ! 1912: echo scsi/juke.h 1>&2 ! 1913: sed 's/.//' >scsi/juke.h <<'//GO.SYSIN DD scsi/juke.h' ! 1914: -#define NLUN 8 ! 1915: -#define NSHELF 50 ! 1916: -extern int nlun; ! 1917: -extern void setnlun(void); ! 1918: -extern char *j_shelf[NSHELF]; ! 1919: -extern int j_wrshelf; /* need to write out shelves */ ! 1920: -extern j_rdshelves(char *err); ! 1921: -extern j_wrshelves(char *err); ! 1922: -extern j_inventory(char cold, int tlim, char *err); ! 1923: - ! 1924: -typedef enum { SIDEA = 0, SIDEB = 1 } Side; ! 1925: - ! 1926: -struct Lunstatus ! 1927: -{ ! 1928: - unsigned int poweron:1; /* is power on ? */ ! 1929: - unsigned int diskin:1; /* is disk in drive? */ ! 1930: - unsigned int ready:1; /* is disk spun up or spun down? */ ! 1931: - unsigned int writeprotect:1; /* is disk write protected? */ ! 1932: - unsigned int diskindrive:1; /* is driveshelf a drive number? */ ! 1933: - unsigned int shelfvalid:1; /* is retshelf valid? */ ! 1934: - uchar driveshelf; /* drive number */ ! 1935: - uchar retshelf; /* return shelf */ ! 1936: -}; ! 1937: - ! 1938: -struct Jstatus ! 1939: -{ ! 1940: - struct Lunstatus lun[NLUN]; /* disk status */ ! 1941: - uchar shelf[NSHELF]; /* shelf status */ ! 1942: - uchar iounit; /* I/O unit status */ ! 1943: - uchar carrier; /* carrier status */ ! 1944: - uchar udrive; /* upper drive status */ ! 1945: - uchar ldrive; /* lower drive status */ ! 1946: -}; ! 1947: -extern struct Jstatus j_status; ! 1948: -extern int j_getstatus(char *err); ! 1949: -extern int j_shelfof(char *vol_id); ! 1950: -extern int j_driveof(char *vol_id); ! 1951: - ! 1952: -extern char *strdup(char *); ! 1953: -extern int j_shelf_to_drive(int, Side, int, char *); ! 1954: -extern int j_drive_to_shelf(int, int, Side, char *); ! 1955: -extern int j_empty_drive(long, char *); ! 1956: -extern int j_rvolid(int, char *); ! 1957: -extern int j_wvolid(int, char *, char *); ! 1958: -extern void pperror(char *buf, char *mesg); ! 1959: -extern int reserve_drive(int, char *); ! 1960: -extern int release_drive(int, char *); ! 1961: -extern int cold_inv(char, char *); ! 1962: -extern int warm_inv(char *); ! 1963: -extern int j_load(char *vol_id, char *buf, long tlim); ! 1964: -extern int j_unload(char *vol_id, char *buf); ! 1965: - ! 1966: -#define JUKEDIR "/usr/worm/jukedir" ! 1967: -#define UNALLOCATED "<unallocated>" ! 1968: //GO.SYSIN DD scsi/juke.h ! 1969: echo scsi/scsi.h 1>&2 ! 1970: sed 's/.//' >scsi/scsi.h <<'//GO.SYSIN DD scsi/scsi.h' ! 1971: -typedef unsigned char uchar; ! 1972: - ! 1973: -struct scsi_cmd ! 1974: -{ ! 1975: - unsigned long id; ! 1976: - uchar bus_id; /* SCSI id of destination device */ ! 1977: - uchar flags; ! 1978: - uchar cmd[10]; /* SCSI command */ ! 1979: - uchar data[4096]; /* optional data */ ! 1980: -}; ! 1981: - ! 1982: -struct scsi_return ! 1983: -{ ! 1984: - unsigned long id; ! 1985: - uchar scsi_stat; /* scsi status byte */ ! 1986: - uchar scsi_msg; /* scsi message byte */ ! 1987: - uchar flags; ! 1988: - uchar type; /* 1=td 2=us */ ! 1989: - unsigned short reg1; /* td=sa, us=per */ ! 1990: - unsigned short reg2; /* td=mscp, us=per */ ! 1991: - unsigned char sense[22]; ! 1992: - char pad[2]; ! 1993: - uchar data[4096]; /* any data */ ! 1994: - uchar nread; /* chars read(-8) if ret count was -ve */ ! 1995: -}; ! 1996: - ! 1997: -#define set6(x,a,b,c,d,e,f) (x).flags=0,(x).cmd[0]=(a),(x).cmd[1]=(b),(x).cmd[2]=(c),\ ! 1998: - (x).cmd[3]=(d),(x).cmd[4]=(e),(x).cmd[5]=(f) ! 1999: -#define set10(x,a,b,c,d,e,f,g,h,i,j) (x).flags=0,(x).cmd[0]=(a),(x).cmd[1]=(b),(x).cmd[2]=(c),\ ! 2000: - (x).cmd[3]=(d),(x).cmd[4]=(e),(x).cmd[5]=(f),(x).cmd[6]=(g),(x).cmd[7]=(h),\ ! 2001: - (x).cmd[8]=(i),(x).cmd[9]=(j) ! 2002: -#define setdiag(x,lun,n) (x).flags=0,(x).cmd[0]=0x1C,(x).cmd[1]=(lun)<<5,(x).cmd[2] = 0,\ ! 2003: - (x).cmd[3]=(n)>>8,(x).cmd[4]=(n),(x).cmd[5]=0 ! 2004: - ! 2005: -extern s_io(int, struct scsi_cmd *, int, struct scsi_return *, int, char *);/* return 0 on no error, does sense on error */ ! 2006: -extern ss_io(int, struct scsi_cmd *, int, struct scsi_return *, int, char *);/* return 0 on no error */ ! 2007: -extern int s_ignua; /* should s_io ignore unit attentions? */ ! 2008: -extern void (*ss_extsense)(uchar *, char *, int); ! 2009: -extern int s_start(int, char *); ! 2010: -extern int s_stop(int, char *); ! 2011: -extern int s_eject(int, char *); ! 2012: -extern int s_id; ! 2013: -extern unsigned long longat(uchar *); ! 2014: //GO.SYSIN DD scsi/scsi.h ! 2015: echo scsi/jukebox.c 1>&2 ! 2016: sed 's/.//' >scsi/jukebox.c <<'//GO.SYSIN DD scsi/jukebox.c' ! 2017: -#include <stdio.h> ! 2018: -#include <limits.h> ! 2019: -#include "scsi.h" ! 2020: -#include "juke.h" ! 2021: - ! 2022: -main(int argc, char *argv[]) ! 2023: -{ ! 2024: - int c; ! 2025: - int aflag = 0, eflag = 0, mflag = 0, pflag = 0; ! 2026: - int rflag = 0, sflag = 0, uflag = 0, Uflag = 0; ! 2027: - long secs = 3600L*24*183; /* half a year is enough */ ! 2028: - char *vol_id; ! 2029: - char errbuf[1024]; ! 2030: - extern int optind; ! 2031: - extern char *optarg; ! 2032: - ! 2033: - setbuf(stdout, (char *)0); /* turn off buffering */ ! 2034: - while((c = getopt(argc, argv, "aemprsuUw:")) != -1) ! 2035: - switch (c) ! 2036: - { ! 2037: - case 'a': aflag = 1; break; ! 2038: - case 'e': eflag = 1; break; ! 2039: - case 'm': mflag = 1; break; ! 2040: - case 'p': pflag = 1; break; ! 2041: - case 'r': rflag = 1; break; ! 2042: - case 's': sflag = 1; break; ! 2043: - case 'u': uflag = 1; break; ! 2044: - case 'U': Uflag = 1; break; ! 2045: - case 'w': secs = atol(optarg); break; ! 2046: - default: usage(); break; ! 2047: - } ! 2048: - s_id = 2; ! 2049: - setnlun(); ! 2050: - if(!aflag&&!eflag&&!mflag&&!pflag&&!rflag&&!uflag&&!Uflag) ! 2051: - sflag = 1; ! 2052: - vol_id = (optind < argc)? argv[optind] : 0; ! 2053: - if(uflag || Uflag) ! 2054: - unload(Uflag); ! 2055: - if(eflag){ ! 2056: - if(vol_id == 0){ ! 2057: - strcpy(errbuf, "-e needs a vol_id"); ! 2058: - goto scram; ! 2059: - } ! 2060: - if(eject(vol_id, errbuf)) ! 2061: - goto scram; ! 2062: - } ! 2063: - if(rflag){ ! 2064: - unload(1); ! 2065: - sleep(1); ! 2066: - if(cold_inv(vol_id? *vol_id : 'u', errbuf) < 0) ! 2067: - goto scram; ! 2068: - } ! 2069: - if(aflag){ ! 2070: - if(vol_id == 0){ ! 2071: - strcpy(errbuf, "-a needs a vol_id"); ! 2072: - goto scram; ! 2073: - } ! 2074: - if(allocate(vol_id, errbuf)) ! 2075: - goto scram; ! 2076: - } ! 2077: - if(mflag){ ! 2078: - if((c = j_load(vol_id, errbuf, secs)) < 0) ! 2079: - goto scram; ! 2080: - if(s_start(c, errbuf) < 0) ! 2081: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2082: - if(s_stop(c, errbuf) < 0) ! 2083: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2084: - printf("%d\n", c); ! 2085: - } ! 2086: - if(sflag) ! 2087: - prstatus(); ! 2088: - if(pflag){ ! 2089: - if(j_rdshelves(errbuf) < 0) ! 2090: - goto scram; ! 2091: - for(c = 0; c < NSHELF; c++) ! 2092: - if(j_shelf[c]) ! 2093: - printf("%d: %s\n", c, j_shelf[c]); ! 2094: - } ! 2095: - if(j_wrshelf) ! 2096: - if(j_wrshelves(errbuf)) ! 2097: - errexit(errbuf); ! 2098: - exit(0); ! 2099: -scram: ! 2100: - if(j_wrshelf) ! 2101: - j_wrshelves(errbuf); ! 2102: - errexit(errbuf); ! 2103: -} ! 2104: - ! 2105: -usage() ! 2106: -{ ! 2107: - fprintf(stderr, "Usage: jukebox [-aemprsuU] [-w secs] [vol_id\n"); ! 2108: - exit(1); ! 2109: -} ! 2110: - ! 2111: -errexit(char *errbuf) ! 2112: -{ ! 2113: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2114: - exit(1); ! 2115: -} ! 2116: - ! 2117: -prstatus() ! 2118: -{ ! 2119: - struct Lunstatus *l; ! 2120: - int c; ! 2121: - char errbuf[1024]; ! 2122: - static char *spin[2] = { "offline", "online" }; ! 2123: - ! 2124: - if(j_getstatus(errbuf)){ ! 2125: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2126: - exit(1); ! 2127: - } ! 2128: - if(j_rdshelves(errbuf)){ ! 2129: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2130: - exit(1); ! 2131: - } ! 2132: - for(c = 0; c < 8; c++){ ! 2133: - l = &j_status.lun[c]; ! 2134: - if(!l->diskin) ! 2135: - continue; ! 2136: - printf("lun %d(", c); ! 2137: - if(j_status.udrive == (0x80|c)) ! 2138: - printf("upper,%s", spin[l->ready]); ! 2139: - else if(j_status.ldrive == (0x80|c)) ! 2140: - printf("lower,%s", spin[l->ready]); ! 2141: - else ! 2142: - printf("in shelf"); ! 2143: - printf("): "); ! 2144: - if(l->shelfvalid){ ! 2145: - if(j_shelf[l->retshelf>>1]) ! 2146: - printf("%s%c", j_shelf[l->retshelf>>1], "ab"[l->retshelf&1]); ! 2147: - else ! 2148: - printf("unallocated shelf number %d??", l->retshelf); ! 2149: - } else ! 2150: - printf("<unknown shelf??>"); ! 2151: - printf("\n"); ! 2152: - } ! 2153: -} ! 2154: - ! 2155: -unload(int force) ! 2156: -{ ! 2157: - struct Lunstatus *l; ! 2158: - int c; ! 2159: - char errbuf[1024]; ! 2160: - ! 2161: - if(j_getstatus(errbuf)){ ! 2162: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2163: - exit(1); ! 2164: - } ! 2165: - if(j_rdshelves(errbuf)){ ! 2166: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2167: - exit(1); ! 2168: - } ! 2169: - for(c = 0; c < 8; c++){ ! 2170: - l = &j_status.lun[c]; ! 2171: - if(!l->diskin) ! 2172: - continue; ! 2173: - if(force || !l->ready) ! 2174: - if(j_drive_to_shelf(c, -1, SIDEA, errbuf)) ! 2175: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2176: - } ! 2177: -} ! 2178: - ! 2179: -eject(char *vol_id, char *errbuf) ! 2180: -{ ! 2181: - int sh; ! 2182: - int dr; ! 2183: - ! 2184: - if(j_rdshelves(errbuf)){ ! 2185: - fprintf(stderr, "jukebox: %s\n", errbuf); ! 2186: - exit(1); ! 2187: - } ! 2188: - sh = j_shelfof(vol_id); ! 2189: - if(sh < 0){ ! 2190: - sprintf(errbuf, "xcan't find vol_id %s", vol_id); ! 2191: - return(-1); ! 2192: - } ! 2193: - j_wrshelf = 1; ! 2194: - if((dr = j_driveof(vol_id)) >= 0){ ! 2195: - j_shelf[sh] = 0; ! 2196: - return(s_eject(dr, errbuf)); ! 2197: - } ! 2198: - dr = NLUN-1; ! 2199: - if(j_shelf_to_drive(sh, SIDEA, dr, errbuf) < 0) ! 2200: - return(-1); ! 2201: - if(s_eject(dr, errbuf)) ! 2202: - return(-1); ! 2203: - j_shelf[sh] = 0; ! 2204: - return(0); ! 2205: -} ! 2206: //GO.SYSIN DD scsi/jukebox.c ! 2207: echo scsi/getstatus.c 1>&2 ! 2208: sed 's/.//' >scsi/getstatus.c <<'//GO.SYSIN DD scsi/getstatus.c' ! 2209: -#include <stddef.h> ! 2210: -#include <stdio.h> ! 2211: -#include "scsi.h" ! 2212: -#include "juke.h" ! 2213: - ! 2214: -struct Jstatus j_status; ! 2215: - ! 2216: -static ! 2217: -dolun(struct Lunstatus *lun, uchar *u) ! 2218: -{ ! 2219: - lun->poweron = ((*u)&0x80) == 0; ! 2220: - lun->diskin = ((*u)&0x40) != 0; ! 2221: - lun->ready = ((*u)&0x01) != 0; ! 2222: - u++; ! 2223: - lun->diskindrive = ((*u)&0x80) != 0; ! 2224: - lun->driveshelf = (*u)&0x7F; ! 2225: - u++; ! 2226: - lun->shelfvalid = ((*u)&0x80) != 0; ! 2227: - lun->retshelf = (*u)&0x7F; ! 2228: -} ! 2229: - ! 2230: -j_getstatus(char *err) ! 2231: -{ ! 2232: - struct scsi_cmd cmd; ! 2233: - struct scsi_return ret; ! 2234: - int i; ! 2235: - ! 2236: - set6(cmd, 0x1D, 0, 0, 0, 10, 0); ! 2237: - memset(cmd.data, 0, 10); ! 2238: - cmd.data[0] = 0xE2; ! 2239: - if(s_io(1, &cmd, 10, &ret, 0, err)) ! 2240: - return(-1); ! 2241: - set6(cmd, 0x1C, 0, 0, 0, 128, 0); ! 2242: - if(s_io(0, &cmd, 0, &ret, 128, err)) ! 2243: - return(-1); ! 2244: - for(i = 0; i < 8; i++) ! 2245: - dolun(&j_status.lun[i], &ret.data[16+4*i]); ! 2246: - for(i = 0; i < NSHELF; i++) ! 2247: - j_status.shelf[i] = ret.data[48+i]; ! 2248: - j_status.iounit = ret.data[98]; ! 2249: - j_status.carrier = ret.data[99]; ! 2250: - j_status.udrive = ret.data[100]; ! 2251: - j_status.ldrive = ret.data[101]; ! 2252: - return(0); ! 2253: -} ! 2254: //GO.SYSIN DD scsi/getstatus.c ! 2255: echo scsi/nlun.c 1>&2 ! 2256: sed 's/.//' >scsi/nlun.c <<'//GO.SYSIN DD scsi/nlun.c' ! 2257: -#include <stdio.h> ! 2258: -#include "scsi.h" ! 2259: -#include "juke.h" ! 2260: - ! 2261: -int nlun = 1; ! 2262: - ! 2263: -void ! 2264: -setnlun(void) ! 2265: -{ ! 2266: - char buf[512]; ! 2267: - ! 2268: - for(nlun = 0; nlun < NLUN; nlun++){ ! 2269: - sprintf(buf, "/dev/worm%d", nlun); ! 2270: - if(access(buf, 0) < 0) ! 2271: - return; ! 2272: - } ! 2273: -} ! 2274: //GO.SYSIN DD scsi/nlun.c ! 2275: echo scsi/allocate.c 1>&2 ! 2276: sed 's/.//' >scsi/allocate.c <<'//GO.SYSIN DD scsi/allocate.c' ! 2277: -#include <stddef.h> ! 2278: -#include <stdio.h> ! 2279: -#include <string.h> ! 2280: -#include "scsi.h" ! 2281: -#include "juke.h" ! 2282: - ! 2283: -allocate(char *vol_id, char *buf) ! 2284: -{ ! 2285: - int drive, sh; ! 2286: - char nbuf[512]; ! 2287: - ! 2288: - if(j_rdshelves(buf)) /* read in shelf names */ ! 2289: - return(-1); ! 2290: - if(j_getstatus(buf)) /* get the jukebox status */ ! 2291: - return(-1); ! 2292: - sh = j_shelfof(vol_id); ! 2293: - if(sh >= 0){ ! 2294: - sprintf(buf, "there is an existing '%s' on shelf %d", vol_id, sh); ! 2295: - return(-1); ! 2296: - } ! 2297: - sh = j_shelfof(UNALLOCATED); ! 2298: - if(sh < 0){ ! 2299: - sprintf(buf, "no unallocated disks"); ! 2300: - return(-1); ! 2301: - } ! 2302: - printf("using unallocated disk from shelf %d\n", sh); ! 2303: - drive = min(nlun+1, NLUN-1); ! 2304: - if(j_shelf_to_drive(sh, SIDEB, drive, buf) < 0) ! 2305: - return(-1); ! 2306: - sprintf(nbuf, "%sb", vol_id); ! 2307: - if(j_wvolid(drive, nbuf, buf)) ! 2308: - return(-1); ! 2309: - j_wrshelf = 1; ! 2310: - j_shelf[sh] = strdup(vol_id); ! 2311: - if(j_drive_to_shelf(drive, sh, SIDEB, buf) < 0) ! 2312: - return(-1); ! 2313: - if(j_shelf_to_drive(sh, SIDEA, drive, buf) < 0) ! 2314: - return(-1); ! 2315: - sprintf(nbuf, "%sa", vol_id); ! 2316: - if(j_wvolid(drive, nbuf, buf)) ! 2317: - return(-1); ! 2318: - if(j_drive_to_shelf(drive, sh, SIDEA, buf) < 0) ! 2319: - return(-1); ! 2320: - return(0); ! 2321: -} ! 2322: //GO.SYSIN DD scsi/allocate.c ! 2323: echo scsi/scsi/dslib.c 1>&2 ! 2324: sed 's/.//' >scsi/scsi/dslib.c <<'//GO.SYSIN DD scsi/scsi/dslib.c' ! 2325: -/* ! 2326: -|| dslib.c - library routines for /dev/scsi ! 2327: -|| ! 2328: -|| Copyright 1988, 1989, by ! 2329: -|| Gene Dronek (Vulcan Laboratory) and ! 2330: -|| Rich Morin (Canta Forda Computer Laboratory). ! 2331: -|| All rights reserved. ! 2332: -*/ ! 2333: -#ident "dslib.c: $Revision: 1.4 $" ! 2334: - ! 2335: -#include <stdio.h> ! 2336: -#include <sys/types.h> ! 2337: - ! 2338: -#include "dslib.h" ! 2339: -#ifdef aux ! 2340: -#include <sys/vio.h> ! 2341: -#include <sys/scsireq.h> ! 2342: -#endif aux ! 2343: - ! 2344: -int dsdebug=0; ! 2345: -long dsreqflags; /* flag bits always set by filldsreq */ ! 2346: - ! 2347: -#define min(i,j) ( (i) < (j) ? (i) : (j) ) ! 2348: - ! 2349: - ! 2350: -/* ! 2351: -|| Startup/shutdown ----------------------------------------------- ! 2352: -*/ ! 2353: - ! 2354: -static struct context *dsc[FDSIZ]; ! 2355: - ! 2356: - ! 2357: -/* ! 2358: -|| dsopen - open device, set up structures ! 2359: -*/ ! 2360: - ! 2361: -struct dsreq * ! 2362: -dsopen(opath, oflags) ! 2363: - char *opath; ! 2364: - int oflags; ! 2365: -{ ! 2366: - ! 2367: - struct dsreq *dsp; ! 2368: - struct context *cp; ! 2369: - int fd; ! 2370: - DSDBG(fprintf(stderr,"dsopen(%s,%x) ", opath, oflags)); ! 2371: - ! 2372: - fd = open(opath, oflags); ! 2373: - if (fd < 0) ! 2374: - return NULL; /* can't open */ ! 2375: - if (dsc[fd] != NULL) /* already in use */ ! 2376: - ds_zot("dsopen: fd already in use"); ! 2377: - ! 2378: - cp = (struct context *) calloc(1, sizeof(struct context)); ! 2379: - if (cp == NULL) /* can't allocate */ ! 2380: - ds_zot("dsopen: can't allocate space"); ! 2381: - dsc[fd] = cp; ! 2382: - cp->dsc_fd = fd; ! 2383: - dsp = &(cp->dsc_dsreq); ! 2384: - ! 2385: - dsp->ds_flags = 0; ! 2386: - dsp->ds_time = 10 * 1000; /* 10 second default timeout */ ! 2387: - dsp->ds_private = (ulong) cp; /* pointer back to context */ ! 2388: - dsp->ds_cmdbuf = cp->dsc_cmd; ! 2389: - dsp->ds_cmdlen = sizeof cp->dsc_cmd; ! 2390: - dsp->ds_databuf = 0; ! 2391: - dsp->ds_datalen = 0; ! 2392: - dsp->ds_sensebuf = cp->dsc_sense; ! 2393: - dsp->ds_senselen = sizeof cp->dsc_sense; ! 2394: - DSDBG(fprintf(stderr,"=>cp %x, dsp %x\n", cp, dsp)); ! 2395: - return dsp; ! 2396: -} ! 2397: - ! 2398: - ! 2399: -/* ! 2400: -|| dsclose - close device, release context struct. ! 2401: -*/ ! 2402: - ! 2403: -dsclose(dsp) ! 2404: - struct dsreq *dsp; ! 2405: -{ ! 2406: - int fd; ! 2407: - struct context *cp; ! 2408: - ! 2409: - if (dsp == NULL) ! 2410: - ds_zot("dsclose: dsp is NULL"); ! 2411: - ! 2412: - cp = (struct context *)dsp->ds_private; ! 2413: - fd = getfd(dsp); ! 2414: - if ( cp == NULL ) ! 2415: - ds_zot("dsclose: private is NULL"); ! 2416: - ! 2417: - cfree(cp); ! 2418: - dsc[fd] = (struct context *)NULL; ! 2419: - return; ! 2420: -} ! 2421: - ! 2422: - ! 2423: -/* ! 2424: -|| Generic SCSI CCS Command functions ------------------------------------ ! 2425: -|| ! 2426: -|| dsp dsreq pointer ! 2427: -|| data data buffer pointer ! 2428: -|| datalen data buffer length ! 2429: -|| lba logical block address ! 2430: -|| vu vendor unique bits ! 2431: -*/ ! 2432: - ! 2433: -/* ! 2434: -|| testunitready00 - issue group 0 "Test Unit Ready" command (0x00) ! 2435: -*/ ! 2436: - ! 2437: -testunitready00(dsp) ! 2438: - struct dsreq *dsp; ! 2439: -{ ! 2440: - fillg0cmd(dsp, CMDBUF(dsp), G0_TEST, 0, 0, 0, 0, 0); ! 2441: - filldsreq(dsp, 0, 0, DSRQ_READ|DSRQ_SENSE); ! 2442: - return(doscsireq(getfd(dsp), dsp)); ! 2443: -} ! 2444: - ! 2445: - ! 2446: -/* ! 2447: -|| requestsense03 - issue group 0 "Request Sense" command (0x03) ! 2448: -*/ ! 2449: - ! 2450: -requestsense03(dsp, data, datalen, vu) ! 2451: - struct dsreq *dsp; ! 2452: - caddr_t data; ! 2453: - long datalen; ! 2454: - char vu; ! 2455: -{ ! 2456: - fillg0cmd(dsp, CMDBUF(dsp), G0_REQU, 0, 0, 0, B1(datalen), B1(vu<<6)); ! 2457: - filldsreq(dsp, data, datalen, DSRQ_READ); ! 2458: - return(doscsireq(getfd(dsp), dsp)); ! 2459: -} ! 2460: - ! 2461: - ! 2462: -/* ! 2463: -|| write0a - issue group 0 "Write" command (0x0a) ! 2464: -*/ ! 2465: - ! 2466: -write0a(dsp, data, datalen, lba, vu) ! 2467: - struct dsreq *dsp; ! 2468: - caddr_t data; ! 2469: - long datalen, lba; ! 2470: - char vu; ! 2471: -{ ! 2472: - fillg0cmd(dsp, CMDBUF(dsp), G0_WRIT, B3(lba), B1(datalen), B1(vu<<6)); ! 2473: - filldsreq(dsp, data, datalen, DSRQ_READ); ! 2474: - return(doscsireq(getfd(dsp), dsp)); ! 2475: -} ! 2476: - ! 2477: - ! 2478: -/* ! 2479: -|| inquiry12 - issue group 0 "Inquiry" command (0x12) ! 2480: -*/ ! 2481: - ! 2482: -inquiry12(dsp, data, datalen, vu) ! 2483: - struct dsreq *dsp; ! 2484: - caddr_t data; ! 2485: - long datalen; ! 2486: - char vu; ! 2487: -{ ! 2488: - fillg0cmd(dsp, CMDBUF(dsp), G0_INQU, 0, 0, 0, B1(datalen), B1(vu<<6)); ! 2489: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE); ! 2490: - return(doscsireq(getfd(dsp), dsp)); ! 2491: -} ! 2492: - ! 2493: - ! 2494: -/* ! 2495: -|| modeselect15 - issue group 0 "Mode Select" command (0x15) ! 2496: -|| ! 2497: -|| save 0 - don't save saveable pages ! 2498: -|| 1 - save saveable pages ! 2499: -*/ ! 2500: - ! 2501: -modeselect15(dsp, data, datalen, save, vu) ! 2502: - struct dsreq *dsp; ! 2503: - caddr_t data; ! 2504: - long datalen; ! 2505: - char save, vu; ! 2506: -{ ! 2507: - fillg0cmd(dsp, CMDBUF(dsp), G0_MSEL, save&1, 0, 0, B1(datalen), B1(vu<<6)); ! 2508: - filldsreq(dsp, data, datalen, DSRQ_WRITE|DSRQ_SENSE); ! 2509: - return(doscsireq(getfd(dsp), dsp)); ! 2510: -} ! 2511: - ! 2512: - ! 2513: -/* ! 2514: -|| modesense1a - issue group 0 "Mode Sense" command (0x1a) ! 2515: -|| ! 2516: -|| pagectrl 0 - current values ! 2517: -|| 1 - changeable values ! 2518: -|| 2 - default values ! 2519: -|| 3 - saved values ! 2520: -|| ! 2521: -|| pagecode 0 - vendor unique ! 2522: -|| 1 - error recovery ! 2523: -|| 2 - disconnect/reconnect ! 2524: -|| 3 - direct access dev. fmt. ! 2525: -|| 4 - rigid disk geometry ! 2526: -|| 5 - flexible disk ! 2527: -|| 6-9 - see specific dev. types ! 2528: -|| 0a - implemented options ! 2529: -|| 0b - medium types supported ! 2530: -|| 3f - return all pages ! 2531: -*/ ! 2532: - ! 2533: -modesense1a(dsp, data, datalen, pagectrl, pagecode, vu) ! 2534: - struct dsreq *dsp; ! 2535: - caddr_t data; ! 2536: - long datalen; ! 2537: - char pagectrl, pagecode, vu; ! 2538: -{ ! 2539: - fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN, 0x10, ! 2540: - ((pagectrl&3)<<6) | (pagecode&0x3F), ! 2541: - 0, B1(datalen), B1(vu<<6)); ! 2542: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE); ! 2543: - return(doscsireq(getfd(dsp), dsp)); ! 2544: -} ! 2545: - ! 2546: - ! 2547: -/* ! 2548: -|| senddiagnostic1d - issue group 0 "Send Diagnostic" command (0x1d) ! 2549: -|| ! 2550: -|| self 0 - run test, hold results ! 2551: -|| 1 - run test, return status ! 2552: -|| ! 2553: -|| dofl 0 - device online ! 2554: -|| 1 - device offline ! 2555: -|| ! 2556: -|| uofl 0 - unit online ! 2557: -|| 1 - unit offline ! 2558: -*/ ! 2559: - ! 2560: -senddiagnostic1d(dsp, data, datalen, self, dofl, uofl, vu) ! 2561: - struct dsreq *dsp; ! 2562: - caddr_t data; ! 2563: - long datalen; ! 2564: - char self, dofl, uofl, vu; ! 2565: -{ ! 2566: - fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN, ! 2567: - (self&1)<<2 | (dofl&1)<<1 | (uofl&1), ! 2568: - 0, B2(datalen), B1(vu<<6)); ! 2569: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE); ! 2570: - return(doscsireq(getfd(dsp), dsp)); ! 2571: -} ! 2572: - ! 2573: - ! 2574: -/* ! 2575: -|| readcapacity25 - issue group 1 "Read Capacity" command (0x25) ! 2576: -|| ! 2577: -|| pmi 0 - return last logical block, entire unit ! 2578: -|| 1 - return last logical block, current track ! 2579: -*/ ! 2580: - ! 2581: -readcapacity25(dsp, data, datalen, lba, pmi, vu) ! 2582: - struct dsreq *dsp; ! 2583: - caddr_t data; ! 2584: - long datalen, lba; ! 2585: - char pmi, vu; ! 2586: -{ ! 2587: - fillg1cmd(dsp, CMDBUF(dsp), G1_RCAP, 0, B4(lba), 0, 0, pmi&1, B1(vu<<6)); ! 2588: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE ! 2589: - /* |DSRQ_CTRL2 */ ); ! 2590: - /* dsp->ds_time = 100; /* often takes a while */ ! 2591: - return(doscsireq(getfd(dsp), dsp)); ! 2592: -} ! 2593: - ! 2594: - ! 2595: -/* ! 2596: -|| readextended28 - issue group 1 "Read Extended" command (0x28) ! 2597: -*/ ! 2598: - ! 2599: -readextended28(dsp, data, datalen, lba, vu) ! 2600: - struct dsreq *dsp; ! 2601: - caddr_t data; ! 2602: - long datalen, lba; ! 2603: - char vu; ! 2604: -{ ! 2605: - fillg1cmd(dsp, CMDBUF(dsp), G1_READ, 0, B4(lba), 0, B2(datalen), B1(vu<<6)); ! 2606: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE ! 2607: - /* |DSRQ_CTRL2 */ ); ! 2608: - /* dsp->ds_time = 100; /* often takes a while */ ! 2609: - return(doscsireq(getfd(dsp), dsp)); ! 2610: -} ! 2611: - ! 2612: - ! 2613: -/* ! 2614: -|| writeextended2a - issue group 1 "Write Extended" command (0x2a) ! 2615: -*/ ! 2616: - ! 2617: -writeextended2a(dsp, data, datalen, lba, vu) ! 2618: - struct dsreq *dsp; ! 2619: - caddr_t data; ! 2620: - long datalen, lba; ! 2621: - char vu; ! 2622: -{ ! 2623: - fillg1cmd(dsp, CMDBUF(dsp), G1_WRIT, 0, B4(lba), 0, B2(datalen), B1(vu<<6)); ! 2624: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE ! 2625: - /* |DSRQ_CTRL2 */ ); ! 2626: - /* dsp->ds_time = 100; /* often takes a while */ ! 2627: - return(doscsireq(getfd(dsp), dsp)); ! 2628: -} ! 2629: - ! 2630: - ! 2631: -/* ! 2632: -|| Support functions ---------------------------------------------------- ! 2633: -*/ ! 2634: - ! 2635: -/* ! 2636: -|| fillg0cmd - Fill a Group 0 command buffer ! 2637: -*/ ! 2638: - ! 2639: -fillg0cmd(dsp, cmd, b0,b1,b2,b3,b4,b5) ! 2640: - struct dsreq *dsp; ! 2641: - uchar_t *cmd, b0,b1,b2,b3,b4,b5; ! 2642: -{ ! 2643: - uchar_t *c = cmd; ! 2644: - DSDBG(fprintf(stderr,"fillg0cmd(%x,%x, %02x %02x %02x %02x %02x %02x)\n", ! 2645: - dsp, cmd, b0,b1,b2,b3,b4,b5)); ! 2646: - *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5; ! 2647: - ! 2648: - CMDBUF(dsp) = (caddr_t) cmd; ! 2649: - CMDLEN(dsp) = 6; ! 2650: -} ! 2651: - ! 2652: - ! 2653: -/* ! 2654: -|| fillg1cmd - Fill a Group 1 command buffer ! 2655: -*/ ! 2656: - ! 2657: -fillg1cmd(dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9) ! 2658: - struct dsreq *dsp; ! 2659: - uchar_t *cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9; ! 2660: -{ ! 2661: - uchar_t *c = cmd; ! 2662: - DSDBG(fprintf(stderr, ! 2663: - "fillg1cmd(%x,%x, %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x)\n", ! 2664: - dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9)); ! 2665: - ! 2666: - *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5; ! 2667: - *c++ = b6, *c++ = b7, *c++ = b8, *c++ = b9; ! 2668: - ! 2669: - CMDBUF(dsp) = (caddr_t) cmd; ! 2670: - CMDLEN(dsp) = 10; ! 2671: -} ! 2672: - ! 2673: - ! 2674: -/* ! 2675: -|| filldsreq - Fill a dsreq structure ! 2676: -*/ ! 2677: - ! 2678: -filldsreq(dsp,data,datalen,flags) ! 2679: - struct dsreq *dsp; ! 2680: - uchar_t *data; ! 2681: -{ ! 2682: - DSDBG(fprintf(stderr,"filldsreq(%x,%x,%d,%x) cmdlen %d\n", ! 2683: - dsp,data,datalen,flags,CMDLEN(dsp))); ! 2684: - dsp->ds_flags = flags | dsreqflags | ! 2685: - (((dsdebug&1) ? DSRQ_TRACE : 0) | ! 2686: - ((dsdebug&2) ? DSRQ_PRINT : 0)); ! 2687: - dsp->ds_time = 10 * 1000; /* default to 10 seconds */ ! 2688: - dsp->ds_link = 0; ! 2689: - dsp->ds_synch = 0; ! 2690: - dsp->ds_ret = 0; ! 2691: - ! 2692: - DATABUF(dsp) = (caddr_t) data; ! 2693: - DATALEN(dsp) = datalen; ! 2694: -} ! 2695: - ! 2696: - ! 2697: -/* ! 2698: -|| bprint - print array of bytes, in hex. ! 2699: -*/ ! 2700: - ! 2701: -#define hex(x) "0123456789ABCDEF" [ (x) & 0xF ] ! 2702: - ! 2703: -bprint(s,n,nperline,space) ! 2704: - char *s; ! 2705: -{ ! 2706: - int i, x; ! 2707: - char *sp = (space) ? " ": ""; ! 2708: - ! 2709: - for(i=0;i<n;i++) { ! 2710: - x = s[i]; ! 2711: - fprintf(stderr,((i%4==3)?"%c%c%s%s":"%c%c%s"), ! 2712: - hex(x>>4), hex(x), sp, sp); ! 2713: - if ( i%nperline == (nperline - 1) ) ! 2714: - fprintf(stderr,"\n"); ! 2715: - } ! 2716: - if ( space ) ! 2717: - fprintf(stderr,"\n"); ! 2718: -} ! 2719: - ! 2720: - ! 2721: -/* ! 2722: -|| doscsireq - issue scsi command, return status or -1 error. ! 2723: -*/ ! 2724: - ! 2725: -doscsireq( fd, dsp) ! 2726: - int fd; /* ioctl file descriptor */ ! 2727: - struct dsreq *dsp; /* devscsi request packet */ ! 2728: -{ ! 2729: - int cc; ! 2730: - int retries = 4; ! 2731: - uchar_t sbyte; ! 2732: - ! 2733: - DSDBG(fprintf(stderr,"doscsireq(%d,%x) %x ---- %s\n",fd,dsp, ! 2734: - (CMDBUF(dsp))[0], ! 2735: - ds_vtostr( (CMDBUF(dsp))[0], cmdnametab))); ! 2736: - ! 2737: - /* ! 2738: - * loop, issuing command ! 2739: - * until done, or further retry pointless ! 2740: - */ ! 2741: - ! 2742: - while ( --retries > 0 ) { ! 2743: - ! 2744: - caddr_t sp; ! 2745: - ! 2746: - sp = SENSEBUF(dsp); ! 2747: - DSDBG(fprintf(stderr,"cmdbuf = "); ! 2748: - bprint(CMDBUF(dsp),CMDLEN(dsp),16,1)); ! 2749: - if ( (dsp->ds_flags & DSRQ_WRITE) ) ! 2750: - DSDBG(bprint( DATABUF(dsp), min(50,DATALEN(dsp)),16,1 )); ! 2751: - ! 2752: -DSDBG(fprintf(stderr,"databuf datalen %x %d\n",DATABUF(dsp), DATALEN(dsp))); ! 2753: - cc = ioctl( fd, DS_ENTER, dsp); ! 2754: - if ( cc < 0) { ! 2755: - ds_panic(dsp, "cannot ioctl fd %d\n",fd); ! 2756: - } ! 2757: - ! 2758: - DSDBG(fprintf(stderr,"cmdlen after ioctl=%d\n",CMDLEN(dsp))); ! 2759: - DSDBG(fprintf(stderr,"ioctl=%d ret=%x %s", ! 2760: - cc, RET(dsp), ! 2761: - RET(dsp) ? ds_vtostr(RET(dsp),dsrtnametab) : "")); ! 2762: - DSDBG(if (SENSESENT(dsp)) fprintf(stderr," sensesent=%d", ! 2763: - SENSESENT(dsp))); ! 2764: - ! 2765: - DSDBG(fprintf(stderr, ! 2766: - " cmdsent=%d datasent=%d sbyte=%x %s\n", ! 2767: - CMDSENT(dsp), DATASENT(dsp), STATUS(dsp), ! 2768: - ds_vtostr(STATUS(dsp), cmdstatustab))); ! 2769: - DSDBG(if ( FLAGS(dsp) & DSRQ_READ ) ! 2770: - bprint( DATABUF(dsp), min(16*16,DATASENT(dsp)), 16,1)); ! 2771: - ! 2772: -#ifdef aux ! 2773: - /* ! 2774: - * check for AUX bus-error ! 2775: - * we retry with poll-dma ! 2776: - */ ! 2777: - if ( RET(dsp) == DSRT_AGAIN ) { ! 2778: - int n = SDC_RDPOLL|SDC_WRPOLL; ! 2779: - DSDBG(fprintf(stderr,"setting rd/wr-poll")); ! 2780: - cc = ioctl( fd, DS_SET, n); /* set bits */ ! 2781: - if ( cc != 0 ) ! 2782: - return -1; ! 2783: - } ! 2784: -#endif aux ! 2785: - ! 2786: - if ( RET(dsp) == DSRT_NOSEL ) ! 2787: - continue; /* retry noselect 3X */ ! 2788: - ! 2789: - /* decode sense data returned */ ! 2790: - if ( SENSESENT(dsp) ) { ! 2791: - DSDBG( ! 2792: - fprintf(stderr, "sense key %x - %s\n", ! 2793: - SENSEKEY(sp), ! 2794: - ds_vtostr( SENSEKEY(sp), sensekeytab)); ! 2795: - bprint( SENSEBUF(dsp), ! 2796: - min(100, SENSESENT(dsp)), ! 2797: - 16,1); ! 2798: - ); ! 2799: - } ! 2800: - DSDBG(fprintf(stderr, "sbyte %x\n", STATUS(dsp))); ! 2801: - ! 2802: - /* decode scsi command status byte */ ! 2803: - sbyte = STATUS(dsp); ! 2804: - switch (sbyte) { ! 2805: - case 0x08: /* BUSY */ ! 2806: - case 0x18: /* RESERV CONFLICT */ ! 2807: - sleep(2); ! 2808: - continue; ! 2809: - case 0x00: /* GOOD */ ! 2810: - case 0x02: /* CHECK CONDITION */ ! 2811: - case 0x10: /* INTERM/GOOD */ ! 2812: - default: ! 2813: - return sbyte; ! 2814: - } ! 2815: - } ! 2816: - return -1; /* fail retry limit */ ! 2817: -} ! 2818: - ! 2819: - ! 2820: -/* ! 2821: -|| opttovar - lookup option in table, return var addr (NULL if fail) ! 2822: -*/ ! 2823: - ! 2824: -int * ! 2825: -opttovar( ostr, table) ! 2826: - char *ostr; ! 2827: - struct opttab{ ! 2828: - char *opt; ! 2829: - int *var; ! 2830: - } *table; ! 2831: -{ ! 2832: - register struct opttab *tp; ! 2833: - ! 2834: - for (tp=table; (tp->var); tp++) ! 2835: - if ( strncmp( ostr, tp->opt, 3) == 0 ) ! 2836: - break; ! 2837: - ! 2838: - if ( !tp->var ) ! 2839: - fprintf(stderr,"unknown option %s", ostr); ! 2840: - ! 2841: - return (tp->var); ! 2842: -} ! 2843: - ! 2844: - ! 2845: -/* ! 2846: -|| ds_vtostr - lookup value in table to return string pointer ! 2847: -*/ ! 2848: - ! 2849: -char * ! 2850: -ds_vtostr( v, table) ! 2851: - long v; ! 2852: - struct vtab *table; ! 2853: -{ ! 2854: - register struct vtab *tp; ! 2855: - ! 2856: - for (tp=table; (tp->string); tp++) ! 2857: - if ( v == tp->val ) ! 2858: - break; ! 2859: - ! 2860: - return (tp->string) ? tp->string : ""; ! 2861: -} ! 2862: - ! 2863: - ! 2864: -/* ! 2865: -|| ds_panic - yelp, leave... ! 2866: -*/ ! 2867: - ! 2868: -ds_panic( fmt, v) ! 2869: - char *fmt; ! 2870: - int v; ! 2871: -{ ! 2872: - extern errno; ! 2873: - ! 2874: - fprintf(stderr,fmt,v); ! 2875: - fprintf(stderr,"\nerrno = %d\n",errno); ! 2876: - exit(1); ! 2877: -} ! 2878: - ! 2879: - ! 2880: -/* ! 2881: -|| ds_zot - go away, with a message. ! 2882: -*/ ! 2883: - ! 2884: -ds_zot(message) ! 2885: - char *message; ! 2886: -{ ! 2887: - fprintf(stderr, "%s\n", message); ! 2888: - exit(1); ! 2889: -} ! 2890: //GO.SYSIN DD scsi/scsi/dslib.c ! 2891: echo scsi/scsi/volid.c 1>&2 ! 2892: sed 's/.//' >scsi/scsi/volid.c <<'//GO.SYSIN DD scsi/scsi/volid.c' ! 2893: -#include <stddef.h> ! 2894: -#include <stdio.h> ! 2895: -#include "../scsi.h" ! 2896: -#include "../juke.h" ! 2897: - ! 2898: -static ! 2899: -myread(int drive, long block, struct scsi_return *ret, char *err) ! 2900: -{ ! 2901: - struct scsi_cmd cmd; ! 2902: - ! 2903: - cmd.bus_id = s_id; ! 2904: - set10(cmd, 0x28, drive<<5, block>>24, block>>16, block>>8, block, 0, 0, 1, 0); ! 2905: - return(s_io(0, &cmd, 0, ret, 1024, err)); ! 2906: -} ! 2907: - ! 2908: -j_rvolid(int drive, char *err) ! 2909: -{ ! 2910: - struct scsi_return ret; ! 2911: - long b, lastb; ! 2912: - char buf[1024]; ! 2913: - int debug = 0; ! 2914: - ! 2915: - err[0] = 0; ! 2916: - if(s_start(drive, err) < 0) ! 2917: - return(-1); ! 2918: - if(myread(drive, 0L, &ret, err) == 0){ ! 2919: - memset(buf, 0, 1024); ! 2920: - if(memcmp(buf, ret.data, 1024)){ ! 2921: - if(debug) ! 2922: - fprintf(stderr, "superblok at 0\n"); ! 2923: - goto done; /* found a superblock at 0 */ ! 2924: - } ! 2925: - } ! 2926: - for(b = 1, lastb = -1;;){ ! 2927: -hack: ! 2928: - if(debug) ! 2929: - fprintf(stderr, "read block %d\n", b); ! 2930: - if(myread(drive, b, &ret, err)) ! 2931: - break; ! 2932: - lastb = b; ! 2933: - b = ((long *)ret.data)[9]; ! 2934: - } ! 2935: - if(lastb < 0){ ! 2936: - if(b == 1){ /* for disks with a bad block 1 */ ! 2937: - b = 2; ! 2938: - goto hack; ! 2939: - } ! 2940: - if(debug) ! 2941: - fprintf(stderr, "tried for superblock at blocks 1,2\n"); ! 2942: - sprintf(err, "no superblock"); ! 2943: - s_stop(drive, buf); ! 2944: - return(1); ! 2945: - } ! 2946: - if(myread(drive, lastb, &ret, err) < 0){ ! 2947: - s_stop(drive, buf); ! 2948: - fprintf(stderr, "read fail on block %d (b=%d)\n", lastb, b);/**/ ! 2949: - return(-1); ! 2950: - } ! 2951: - if(debug) ! 2952: - fprintf(stderr, "superblock at %d\n", lastb); ! 2953: -done: ! 2954: - strncpy(err, (char *)&ret.data[42], 128); ! 2955: - err[127] = 0; ! 2956: - s_stop(drive, buf); ! 2957: - return(0); ! 2958: -} ! 2959: - ! 2960: -static ! 2961: -mywrite(int drive, long block, struct scsi_cmd *cmd, struct scsi_return *ret, char *err) ! 2962: -{ ! 2963: - set10((*cmd), 0x2A, drive<<5, block>>24, block>>16, block>>8, block, 0, 0, 1, 0); ! 2964: - return(s_io(0, cmd, 1024, ret, 0, err)); ! 2965: -} ! 2966: - ! 2967: -j_wvolid(int drive, char *vol_id, char *err) ! 2968: -{ ! 2969: - char tmpfile[L_tmpnam]; ! 2970: - char buf[512]; ! 2971: - struct scsi_return ret; ! 2972: - struct scsi_cmd cmd; ! 2973: - FILE *fp; ! 2974: - int n; ! 2975: - ! 2976: - printf("mkfs %s\n", vol_id); ! 2977: - /* first get the capacity/size for mkfs to make a valid superblock */ ! 2978: - tmpnam(tmpfile); ! 2979: - if((fp = fopen(tmpfile, "w+r")) == NULL){ ! 2980: - pperror(err, tmpfile); ! 2981: - return(-1); ! 2982: - } ! 2983: - if(s_start(drive, err) < 0) ! 2984: - return(-1); ! 2985: - set10(cmd, 0x25, drive<<5, 0, 0, 0, 0, 0, 0, 0, 0); ! 2986: - if(n = s_io(0, &cmd, 0, &ret, 8, err)) ! 2987: - return(n); ! 2988: - switch(longat(&ret.data[0])) ! 2989: - { ! 2990: - case 1637999: /* sony 12in clv single density */ ! 2991: - sprintf(buf, "worm mkfs -n %d -f %s %s", 1600000, tmpfile, vol_id); ! 2992: - break; ! 2993: - case 3275999: /* sony 12in clv double density */ ! 2994: - sprintf(buf, "worm mkfs -n %d -f %s %s", 3250000, tmpfile, vol_id); ! 2995: - break; ! 2996: - default: ! 2997: - fprintf(stderr, "warning: bad capacity %d\n", longat(&ret.data[0])); ! 2998: - sprintf(buf, "worm mkfs -f %s %s", tmpfile, vol_id); ! 2999: - break; ! 3000: - } ! 3001: - if(system(buf)){ ! 3002: - sprintf(err, "%s: error", buf); ! 3003: - return(-1); ! 3004: - } ! 3005: - unlink(tmpfile); ! 3006: - fseek(fp, 1024L, 0); ! 3007: - if(fread(cmd.data, 1, 1024, fp) == 0){ ! 3008: - pperror(err, "mkfs read"); ! 3009: - return(-1); ! 3010: - } ! 3011: - fclose(fp); ! 3012: - if(mywrite(drive, 1L, &cmd, &ret, err)) ! 3013: - return(-1); ! 3014: - unlink(tmpfile); ! 3015: - s_stop(drive, err); ! 3016: - return(0); ! 3017: -} ! 3018: //GO.SYSIN DD scsi/scsi/volid.c ! 3019: echo scsi/scsi/pperror.c 1>&2 ! 3020: sed 's/.//' >scsi/scsi/pperror.c <<'//GO.SYSIN DD scsi/scsi/pperror.c' ! 3021: -#include "../scsi.h" ! 3022: - ! 3023: -void ! 3024: -pperror(char *buf, char *mesg) ! 3025: -{ ! 3026: - extern int sys_nerr; ! 3027: - extern char *sys_errlist[]; ! 3028: - extern int errno; ! 3029: - ! 3030: - if((errno < 0) || (errno >= sys_nerr)) ! 3031: - sprintf(buf, "%s: unknown errno %d", mesg, errno); ! 3032: - else ! 3033: - sprintf(buf, "%s: %s", mesg, sys_errlist[errno]); ! 3034: -} ! 3035: //GO.SYSIN DD scsi/scsi/pperror.c ! 3036: echo scsi/scsi/fixedstr.c 1>&2 ! 3037: sed 's/.//' >scsi/scsi/fixedstr.c <<'//GO.SYSIN DD scsi/scsi/fixedstr.c' ! 3038: -#include "../scsi.h" ! 3039: - ! 3040: -void ! 3041: -fixedstr(uchar *src, int len, char *dest) ! 3042: -{ ! 3043: - uchar *s; ! 3044: - ! 3045: - while((*src == ' ') && (len > 0)) ! 3046: - src++, len--; ! 3047: - for(s = src+len-1; s >= src; s--) ! 3048: - if(*s != ' ') ! 3049: - break; ! 3050: - memcpy(dest, (char *)src, len = s-src+1); ! 3051: - dest[len] = 0; ! 3052: -} ! 3053: //GO.SYSIN DD scsi/scsi/fixedstr.c ! 3054: echo scsi/scsi/longat.c 1>&2 ! 3055: sed 's/.//' >scsi/scsi/longat.c <<'//GO.SYSIN DD scsi/scsi/longat.c' ! 3056: -#include "../scsi.h" ! 3057: - ! 3058: -unsigned long ! 3059: -longat(uchar *src) ! 3060: -{ ! 3061: - unsigned long n; ! 3062: - ! 3063: - n = *src++; ! 3064: - n = (n<<8) | *src++; ! 3065: - n = (n<<8) | *src++; ! 3066: - n = (n<<8) | *src; ! 3067: - return(n); ! 3068: -} ! 3069: //GO.SYSIN DD scsi/scsi/longat.c ! 3070: echo scsi/scsi/xd.c 1>&2 ! 3071: sed 's/.//' >scsi/scsi/xd.c <<'//GO.SYSIN DD scsi/scsi/xd.c' ! 3072: -#include <stdio.h> ! 3073: -#include "../scsi.h" ! 3074: -#include "../scsish.h" ! 3075: - ! 3076: -#define WIDTH 32 ! 3077: - ! 3078: -void ! 3079: -xd(uchar *p, int n, FILE *fp) ! 3080: -{ ! 3081: - register i, nd, l; ! 3082: - unsigned char buf[WIDTH]; ! 3083: - int didstar; ! 3084: - unsigned char *s; ! 3085: - ! 3086: - for(nd = 0; n > 0; n -= l, nd += l){ ! 3087: - l = min(WIDTH, n); ! 3088: - if(nd && (l == WIDTH) && (memcmp(buf, p, l) == 0)){ ! 3089: - p += WIDTH; ! 3090: - if(didstar++ == 0) ! 3091: - fprintf(fp, "*\n"); ! 3092: - continue; ! 3093: - } ! 3094: - memcpy(buf, p, l); ! 3095: - didstar = 0; ! 3096: - fprintf(fp, "%5.5d", nd); ! 3097: - s = p; ! 3098: - for(i = 0; i < l; i++){ ! 3099: - if((i%4) == 0) putc(' ', fp); ! 3100: - fprintf(fp, "%2.2x", *p++); ! 3101: - } ! 3102: - putc('\n', fp); ! 3103: - fprintf(fp, " "); ! 3104: - for(i = 0; i < l; i++){ ! 3105: - if((i%4) == 0) putc(' ', fp); ! 3106: - if((*s >= ' ') && (*s < 0177)) ! 3107: - fprintf(fp, " %c", *s++); ! 3108: - else switch(*s++) ! 3109: - { ! 3110: - case '\n': fprintf(fp, "\\n"); break; ! 3111: - case '\t': fprintf(fp, "\\t"); break; ! 3112: - default: fprintf(fp, ".."); break; ! 3113: - } ! 3114: - } ! 3115: - putc('\n', fp); ! 3116: - } ! 3117: - fprintf(fp, "%5.5d\n", nd); ! 3118: -} ! 3119: //GO.SYSIN DD scsi/scsi/xd.c ! 3120: echo scsi/scsi/md_io.c 1>&2 ! 3121: sed 's/.//' >scsi/scsi/md_io.c <<'//GO.SYSIN DD scsi/scsi/md_io.c' ! 3122: -#include <stdio.h> ! 3123: -#include "../scsi.h" ! 3124: -#include "../scsish.h" ! 3125: -#include <sys/types.h> ! 3126: -#include <sys/dsreq.h> ! 3127: - ! 3128: -#define DEV(buf, target, lun) sprintf(buf, "/dev/scsi/sc0d%dl%d", target, lun) ! 3129: - ! 3130: -static fd = -1; ! 3131: -int s_id; ! 3132: -void (*ss_extsense)(uchar *, char *, int); ! 3133: - ! 3134: -ss_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err) ! 3135: -{ ! 3136: - int retv; ! 3137: - dsreq_t ds; ! 3138: - char dev[512]; ! 3139: - ! 3140: - err[0] = 0; ! 3141: - retv = -1; ! 3142: - if(ncmd && nret){ ! 3143: - sprintf(err, "both input (%d bytes) and output (%d bytes) expected", ncmd, nret); ! 3144: - return(retv); ! 3145: - } ! 3146: - if(cmd->bus_id & 0x8000){ ! 3147: - sprintf(err, "reset not supported"); ! 3148: - return(retv); ! 3149: - } ! 3150: - if(fd < 0){ ! 3151: - DEV(dev, cmd->bus_id, ((cmd->cmd[1]>>5)&7)); ! 3152: - if((fd = open(dev, 2)) < 0){ ! 3153: - pperror(err, dev); ! 3154: - return(-1); ! 3155: - } ! 3156: - } ! 3157: - ds.ds_flags = DSRQ_SENSE; ! 3158: - ds.ds_time = 30000; ! 3159: - ds.ds_cmdbuf = (char *)cmd->cmd; ! 3160: - ds.ds_cmdlen = 10; ! 3161: - if(ncmd){ ! 3162: - ds.ds_databuf = (char *)cmd->data; ! 3163: - ds.ds_datalen = ncmd; ! 3164: - ds.ds_flags |= DSRQ_WRITE; ! 3165: - } else { ! 3166: - ds.ds_databuf = (char *)ret->data; ! 3167: - ds.ds_datalen = nret; ! 3168: - ds.ds_flags |= DSRQ_READ; ! 3169: - } ! 3170: - ds.ds_sensebuf = (char *)ret->sense; ! 3171: - ds.ds_senselen = sizeof ret->sense; ! 3172: - ds.ds_iovbuf = 0; ! 3173: - ds.ds_link = 0; ! 3174: - if(ioctl(fd, DS_ENTER, &ds) < 0){ ! 3175: - pperror(err, "DS_ENTER ioctl"); ! 3176: -err_ret: ! 3177: - close(fd); ! 3178: - fd = -1; ! 3179: - return(retv); ! 3180: - } ! 3181: - if(ds.ds_ret ! 3182: - && (ds.ds_ret != DSRT_SHORT) ! 3183: - && (ds.ds_ret != DSRT_OK) ! 3184: - ) /* an error */ ! 3185: - fprintf(stderr, "ds_ret = #%x\n", ds.ds_ret); ! 3186: - ret->type = 3; ! 3187: - ret->scsi_stat = ds.ds_status; ! 3188: - ret->scsi_msg = ds.ds_msg; ! 3189: - ret->reg1 = ret->reg2 = 0; ! 3190: - if(nret >= 0){ ! 3191: - if(ds.ds_datasent != nret){ ! 3192: - if(ds.ds_datasent == 0) ! 3193: - retv = 1; ! 3194: - else ! 3195: - sprintf(err, "data transfer error; wanted %d, got %d", nret, ds.ds_datasent); ! 3196: - goto err_ret; ! 3197: - } ! 3198: - } else { ! 3199: - ret->nread = ds.ds_datasent; ! 3200: - } ! 3201: - if(!preserve){ ! 3202: - close(fd); ! 3203: - fd = -1; ! 3204: - } ! 3205: - return(0); ! 3206: -} ! 3207: - ! 3208: -static char *smsg[16] = ! 3209: -{ ! 3210: - "good", "check condition", "met/good", "reserved", ! 3211: - "busy", "reserved", "reserved", "reserved", ! 3212: - "intermediate good", "reserved", "intermediate good/met", "reserved", ! 3213: - "reservation conflict", "reserved", "reserved", "reserved", ! 3214: -}; ! 3215: - ! 3216: -s_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err) ! 3217: -{ ! 3218: - int n; ! 3219: - int status; ! 3220: - char buf[512]; ! 3221: - char ioerr[512]; ! 3222: - ! 3223: - cmd->bus_id = s_id; ! 3224: - if(n = ss_io(preserve, cmd, ncmd, ret, nret, err)){ ! 3225: - if(n < 0) ! 3226: - return(n); ! 3227: - strcpy(ioerr, err); ! 3228: - err[0] = 0; ! 3229: - } else ! 3230: - ioerr[0] = 0; ! 3231: - if(status = ret->scsi_stat){ ! 3232: - (*ss_extsense)(ret->data, buf, sizeof buf); ! 3233: - sprintf(err, "%s; %s", ioerr[0]? ioerr : smsg[(status>>1)&0xF], buf); ! 3234: - return(1); ! 3235: - } ! 3236: - return(0); ! 3237: -} ! 3238: //GO.SYSIN DD scsi/scsi/md_io.c ! 3239: echo scsi/scsi/h_io.c 1>&2 ! 3240: sed 's/.//' >scsi/scsi/h_io.c <<'//GO.SYSIN DD scsi/scsi/h_io.c' ! 3241: -#include <stdio.h> ! 3242: -#include "../scsi.h" ! 3243: -#include "../scsish.h" ! 3244: -#include <scsi.h> ! 3245: - ! 3246: -#define DEV "/dev/scsi" ! 3247: - ! 3248: -static fd = -1; ! 3249: -int s_id; ! 3250: -int s_ignua = 1; ! 3251: -void (*ss_extsense)(uchar *, char *, int); ! 3252: - ! 3253: -ss_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err) ! 3254: -{ ! 3255: - int n; ! 3256: - int retv; ! 3257: - ! 3258: - err[0] = 0; ! 3259: - retv = -1; ! 3260: - if(fd < 0){ ! 3261: - if((fd = open(DEV, 2)) < 0){ ! 3262: - pperror(err, DEV); ! 3263: - return(-1); ! 3264: - } ! 3265: - } ! 3266: - cmd->flags |= (ncmd == 0)? SCSI_RD:SCSI_WR; ! 3267: - if((n = write(fd, cmd, 16+ncmd)) != 16+ncmd){ ! 3268: - pperror(err, "scsiio write"); ! 3269: -err_ret: ! 3270: - close(fd); ! 3271: - fd = -1; ! 3272: - return(retv); ! 3273: - } ! 3274: - if(nret >= 0){ ! 3275: - if((n = read(fd, ret, 36+nret)) != 36+nret){ ! 3276: - if(n == 36) ! 3277: - retv = 1; ! 3278: - else ! 3279: - pperror(err, "scsiio read"); ! 3280: - goto err_ret; ! 3281: - } ! 3282: - } else { ! 3283: - if((n = read(fd, ret, 36-nret)) < 0){ ! 3284: - pperror(err, "scsiio read"); ! 3285: - goto err_ret; ! 3286: - } ! 3287: - ret->nread = n-36; ! 3288: - } ! 3289: - if(!preserve){ ! 3290: - close(fd); ! 3291: - fd = -1; ! 3292: - } ! 3293: - return(0); ! 3294: -} ! 3295: - ! 3296: -static char *smsg[16] = ! 3297: -{ ! 3298: - "good", "check condition", "met/good", "reserved", ! 3299: - "busy", "reserved", "reserved", "reserved", ! 3300: - "intermediate good", "reserved", "intermediate good/met", "reserved", ! 3301: - "reservation conflict", "reserved", "reserved", "reserved", ! 3302: -}; ! 3303: - ! 3304: -s_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err) ! 3305: -{ ! 3306: - int n; ! 3307: - int status; ! 3308: - char buf[512]; ! 3309: - char ioerr[512]; ! 3310: - struct scsi_cmd mycmd; ! 3311: - int ignoredua = 0; ! 3312: - ! 3313: - cmd->bus_id = s_id; ! 3314: -again: ! 3315: - if(n = ss_io(preserve, cmd, ncmd, ret, nret, err)){ ! 3316: - if(n < 0) ! 3317: - return(n); ! 3318: - strcpy(ioerr, err); ! 3319: - err[0] = 0; ! 3320: - } else ! 3321: - ioerr[0] = 0; ! 3322: - if(status = ret->scsi_stat){ ! 3323: - mycmd.bus_id = s_id; ! 3324: - set6(mycmd, 0x03, cmd->cmd[1]&0xE0, 0, 0, 100, 0); ! 3325: - if(n = ss_io(0, &mycmd, 0, ret, -100, err)) ! 3326: - return(n); ! 3327: - if(s_ignua){ /* ignore unit attention ?? */ ! 3328: - if((ret->data[2]&0xF) == 6){ /* it is */ ! 3329: - if(ignoredua++ == 0){ /* but only ignore once */ ! 3330: - mycmd.bus_id = s_id; ! 3331: - set6(mycmd, 0x12, cmd->cmd[1]&0xE0, 0, 0, 5, 0); ! 3332: - if(n = ss_io(0, &mycmd, 0, ret, 5, err)) ! 3333: - return(n); ! 3334: - goto again; ! 3335: - } ! 3336: - } ! 3337: - } ! 3338: - if(ss_extsense == 0) ! 3339: - ss_extsense = gen_extsense; ! 3340: - (*ss_extsense)(ret->data, buf, sizeof buf); ! 3341: - sprintf(err, "%s; %s", ioerr[0]? ioerr : smsg[(status>>1)&0xF], buf); ! 3342: - return(1); ! 3343: - } ! 3344: - return(0); ! 3345: -} ! 3346: //GO.SYSIN DD scsi/scsi/h_io.c ! 3347: echo scsi/scsi/gendev 1>&2 ! 3348: sed 's/.//' >scsi/scsi/gendev <<'//GO.SYSIN DD scsi/scsi/gendev' ! 3349: -awk 'END { for(t = 1; t < 8; t++) for(l=0; l < 8; l++){ ! 3350: - printf "/etc/mknod sc0d%dl%d c 43 %d\n", t, l, l*8+t ! 3351: - } ! 3352: - print "chmod 600 *; chown andrew *" ! 3353: - }' < /dev/null ! 3354: //GO.SYSIN DD scsi/scsi/gendev ! 3355: echo scsi/iodr_sh.c 1>&2 ! 3356: sed 's/.//' >scsi/iodr_sh.c <<'//GO.SYSIN DD scsi/iodr_sh.c' ! 3357: -#include "scsi.h" ! 3358: -#include "juke.h" ! 3359: - ! 3360: -j_shelf_to_drive(int sh, Side side, int dr, char *err) ! 3361: -{ ! 3362: - struct scsi_cmd cmd; ! 3363: - struct scsi_return ret; ! 3364: - ! 3365: - set6(cmd, 0xD6, dr<<5, 0, (sh<<1)|side, 0, 0); ! 3366: - return(s_io(0, &cmd, 0, &ret, 0, err)); ! 3367: -} ! 3368: - ! 3369: -j_drive_to_shelf(int dr, int sh, Side side, char *err) ! 3370: -{ ! 3371: - struct scsi_cmd cmd; ! 3372: - struct scsi_return ret; ! 3373: - ! 3374: - if(sh < 0) ! 3375: - set6(cmd, 0xD7, dr<<5, 0, 0, 0, 0); ! 3376: - else ! 3377: - set6(cmd, 0xD7, (dr<<5)|1, 0, (sh<<1)|side, 0, 0); ! 3378: - return(s_io(0, &cmd, 0, &ret, 0, err)); ! 3379: -} ! 3380: - ! 3381: -int ! 3382: -j_empty_drive(long tlimit, char *buf) ! 3383: -{ ! 3384: - int i, tstop; ! 3385: - ! 3386: - tstop = time((long *)0) + tlimit; ! 3387: - while(time((long *)0) <= tstop){ ! 3388: - setnlun(); /* in case it changes */ ! 3389: - /* look for empty drives */ ! 3390: - for(i = 0; i < nlun; i++) ! 3391: - if(!j_status.lun[i].diskin) ! 3392: - return(i); ! 3393: - /* look for spun down drives */ ! 3394: - for(i = 0; i < nlun; i++){ ! 3395: - if(!j_status.lun[i].ready){ ! 3396: - if(j_drive_to_shelf(i, -1, SIDEA, buf)) ! 3397: - return(-1); ! 3398: - else ! 3399: - return(i); ! 3400: - } ! 3401: - } ! 3402: - sleep(10); ! 3403: - if(j_getstatus(buf)) /* get the jukebox status */ ! 3404: - return(-1); ! 3405: - } ! 3406: - return(-1); ! 3407: -} ! 3408: //GO.SYSIN DD scsi/iodr_sh.c ! 3409: echo scsi/ioshelves.c 1>&2 ! 3410: sed 's/.//' >scsi/ioshelves.c <<'//GO.SYSIN DD scsi/ioshelves.c' ! 3411: -#include <stddef.h> ! 3412: -#include <stdio.h> ! 3413: -#include <string.h> ! 3414: -#include "scsi.h" ! 3415: -#include "juke.h" ! 3416: - ! 3417: -char *j_shelf[NSHELF]; ! 3418: -int j_wrshelf = 0; ! 3419: - ! 3420: -j_rdshelves(char *err) ! 3421: -{ ! 3422: - FILE *fp; ! 3423: - static haveread = 0; ! 3424: - int shno; ! 3425: - char vname[256]; ! 3426: - ! 3427: - if(haveread) ! 3428: - return(0); ! 3429: - for(shno = 0; shno < NSHELF; shno++) ! 3430: - j_shelf[shno] = 0; ! 3431: - if((fp = fopen(JUKEDIR, "r")) == NULL){ ! 3432: - pperror(err, JUKEDIR); ! 3433: - return(-1); ! 3434: - } ! 3435: - while(fscanf(fp, "%d %s\n", &shno, vname) == 2){ ! 3436: - if((shno < 0) || (shno >= NSHELF)){ ! 3437: - fprintf(stderr, "Warning: bad shelf number in %s: %d (vol_id=%s)\n", ! 3438: - JUKEDIR, shno, vname); ! 3439: - continue; ! 3440: - ! 3441: - } ! 3442: - j_shelf[shno] = strdup(vname); ! 3443: - } ! 3444: - fclose(fp); ! 3445: - haveread = 1; ! 3446: - return(0); ! 3447: -} ! 3448: - ! 3449: -j_wrshelves(char *err) ! 3450: -{ ! 3451: - FILE *fp; ! 3452: - int shno; ! 3453: - ! 3454: - if((fp = fopen(JUKEDIR, "w")) == NULL){ ! 3455: - pperror(err, JUKEDIR); ! 3456: - return(-1); ! 3457: - } ! 3458: - for(shno = 0; shno < NSHELF; shno++) ! 3459: - if(j_shelf[shno]) ! 3460: - fprintf(fp, "%d %s\n", shno, j_shelf[shno]); ! 3461: - fclose(fp); ! 3462: - return(0); ! 3463: -} ! 3464: - ! 3465: -int ! 3466: -j_shelfof(char *vol_id) ! 3467: -{ ! 3468: - int i; ! 3469: - char buf[512]; ! 3470: - ! 3471: - for(;;){ ! 3472: - for(i = 0; i < NSHELF; i++) ! 3473: - if(j_shelf[i] && (strcmp(j_shelf[i], vol_id) == 0)) ! 3474: - return(i); ! 3475: - if((i = warm_inv(buf)) <= 0) ! 3476: - break; ! 3477: - } ! 3478: - if(i < 0) ! 3479: - fprintf(stderr, "jukebox: %s\n", buf); ! 3480: - return(-1); ! 3481: -} ! 3482: - ! 3483: -int ! 3484: -j_driveof(char *vol_id) ! 3485: -{ ! 3486: - int i, sh; ! 3487: - ! 3488: - if((sh = j_shelfof(vol_id)) < 0) ! 3489: - return(-1); ! 3490: - for(i = 0; i < NLUN; i++) ! 3491: - if(j_status.lun[i].shelfvalid && (j_status.lun[i].retshelf == sh)) ! 3492: - return(i); ! 3493: - return(-1); ! 3494: -} ! 3495: //GO.SYSIN DD scsi/ioshelves.c ! 3496: echo scsi/scsish.c 1>&2 ! 3497: sed 's/.//' >scsi/scsish.c <<'//GO.SYSIN DD scsi/scsish.c' ! 3498: -#include <stddef.h> ! 3499: -#include <stdio.h> ! 3500: -#include <string.h> ! 3501: -#include "scsi.h" ! 3502: -#include "scsish.h" ! 3503: - ! 3504: -extern Device genericdev; ! 3505: -static Device *dev = 0; ! 3506: -static Function *function(char *, Device **); ! 3507: -static void parse(FILE *); ! 3508: - ! 3509: -main() ! 3510: -{ ! 3511: - setbuf(stdout, (char *)0); ! 3512: - scsi_target(2); ! 3513: - set_sony(); ! 3514: - printf("dev=%s, target=%d:\n", dev? dev->name:genericdev.name, s_id); ! 3515: - parse(stdin); ! 3516: - exit(0); ! 3517: -} ! 3518: - ! 3519: -static void ! 3520: -parse(FILE *fp) ! 3521: -{ ! 3522: - int i, n; ! 3523: - char *param; ! 3524: - char buf[4096]; ! 3525: - char *ptrs[100], *cargs[20]; ! 3526: - int iargs[20]; ! 3527: - int nc, ni; ! 3528: - Function *fn; ! 3529: - Device *thatdev; ! 3530: - char err[512]; ! 3531: - ! 3532: - for(;;){ ! 3533: - printf("> "); ! 3534: - fflush(stdout); ! 3535: - if(fgets(buf, sizeof buf, fp) == NULL) ! 3536: - break; ! 3537: - if(param = strchr(buf, '\n')) ! 3538: - *param = 0; ! 3539: - n = getmfields(buf, ptrs, sizeof ptrs/sizeof ptrs[0]); ! 3540: - if(n < 1) ! 3541: - continue; ! 3542: - if((fn = function(ptrs[0], &thatdev)) == 0){ ! 3543: - fprintf(stderr, "can't find cmd '%s'\n", ptrs[0]); ! 3544: - continue; ! 3545: - } ! 3546: - ni = nc = 0; ! 3547: - param = fn->param; ! 3548: - for(i = 1; i < n; i++){ ! 3549: - switch(*param++) ! 3550: - { ! 3551: - case 'I': ! 3552: - iargs[ni++] = atoi(ptrs[i]); ! 3553: - break; ! 3554: - case 'L': ! 3555: - iargs[ni++] = atoi(ptrs[i]); ! 3556: - if((iargs[ni-1] < 0) || (iargs[ni-1] > 7)){ ! 3557: - fprintf(stderr, "%s: lun %d out of range\n", ptrs[0], iargs[ni-1]); ! 3558: - continue; ! 3559: - } ! 3560: - break; ! 3561: - case 'S': ! 3562: - cargs[nc++] = ptrs[i]; ! 3563: - break; ! 3564: - default: ! 3565: - break; ! 3566: - } ! 3567: - if(*param == '?') ! 3568: - param++; ! 3569: - } ! 3570: - while(param[0] && param[1] && (param[1] == '?')) ! 3571: - param += 2; ! 3572: - if((i == n) != (*param == 0)){ ! 3573: - printf("param mismatch: %s: i=%d/n=%d param='%s'\n", ! 3574: - ptrs[0], i, n, param); ! 3575: - printf("device %s: %s\n", thatdev->name, fn->help); ! 3576: - continue; ! 3577: - } ! 3578: - if((*fn->fn)(ni, iargs, nc, cargs, err)) ! 3579: - fprintf(stderr, "error in '%s': %s\n", fn->name, err); ! 3580: - } ! 3581: -} ! 3582: - ! 3583: -static Function * ! 3584: -flook(Function *f, char *name) ! 3585: -{ ! 3586: - for(; f->help; f++) ! 3587: - if(strncmp(f->name, name, strlen(f->name)) == 0) ! 3588: - return(f); ! 3589: - return(0); ! 3590: -} ! 3591: - ! 3592: -static Function * ! 3593: -function(char *name, Device **devptr) ! 3594: -{ ! 3595: - Function *f = 0; ! 3596: - ! 3597: - if(dev && dev->fns && (f = flook(dev->fns, name))) ! 3598: - *devptr = dev; ! 3599: - else if(f = flook(genericdev.fns, name)) ! 3600: - *devptr = &genericdev; ! 3601: - return(f); ! 3602: -} ! 3603: - ! 3604: -void ! 3605: -setdevice(Device *d) ! 3606: -{ ! 3607: - dev = d; ! 3608: - ss_extsense = dev->extsense; ! 3609: -} ! 3610: - ! 3611: -static ! 3612: -help(Device *d, char *cmd, Device *prec) ! 3613: -{ ! 3614: - Function *f; ! 3615: - Function *base; ! 3616: - ! 3617: - base = (prec && prec->fns)? prec->fns:0; ! 3618: - if(cmd == 0){ ! 3619: - printf("device %s(%s):\n", d->name, d->verbose); ! 3620: - if(f = d->fns) ! 3621: - while(f->name){ ! 3622: - if((base == 0) || (flook(base, f->name) == 0)) ! 3623: - printf("\t%s\n", f->help); ! 3624: - f++; ! 3625: - } ! 3626: - return(0); ! 3627: - } else { ! 3628: - if(f = d->fns) ! 3629: - while(f->name) ! 3630: - if(strcmp(f->name, cmd) == 0){ ! 3631: - printf("(%s) %s\n", d->name, f->help); ! 3632: - return(1); ! 3633: - } else ! 3634: - f++; ! 3635: - return(0); ! 3636: - } ! 3637: -} ! 3638: - ! 3639: -int ! 3640: -gen_help(int niargs, int *iargs, int ncargs, char **cargs) ! 3641: -{ ! 3642: -#pragma ref niargs ! 3643: -#pragma ref iargs ! 3644: - ! 3645: - if(dev) ! 3646: - if(help(dev, ncargs == 0? 0:cargs[0], (Device *)0)) ! 3647: - return(0); ! 3648: - help(&genericdev, ncargs == 0? 0:cargs[0], dev); ! 3649: - return(0); ! 3650: -} ! 3651: - ! 3652: -extern Device sonydev; ! 3653: -extern Device wrendev; ! 3654: -static Device *devs[] = { ! 3655: - &genericdev, ! 3656: - &sonydev, ! 3657: - &wrendev, ! 3658: - 0 ! 3659: -}; ! 3660: - ! 3661: -int ! 3662: -gen_dev(int niargs, int *iargs, int ncargs, char **cargs) ! 3663: -{ ! 3664: - Device **d; ! 3665: - ! 3666: -#pragma ref niargs ! 3667: -#pragma ref iargs ! 3668: - ! 3669: - if(ncargs == 0) ! 3670: - printf("dev=%s\n", dev? dev->name : genericdev.name); ! 3671: - else if(strcmp(cargs[0], "?") == 0){ ! 3672: - printf("available devices:\n"); ! 3673: - for(d = devs; *d; d++) ! 3674: - printf("\t%s(%s)\n", (*d)->name, (*d)->verbose); ! 3675: - } else { ! 3676: - for(d = devs; *d; d++) ! 3677: - if(strcmp(cargs[0], (*d)->name) == 0) ! 3678: - break; ! 3679: - if(*d) ! 3680: - setdevice(*d); ! 3681: - else ! 3682: - fprintf(stderr, "device '%s' unknown\n", cargs[0]); ! 3683: - } ! 3684: - return(0); ! 3685: -} ! 3686: - ! 3687: -void ! 3688: -scsi_target(int n) ! 3689: -{ ! 3690: - if((n < 0) || (n >= 8)) ! 3691: - fprintf(stderr, "%d is an invalid target\n", n); ! 3692: - else ! 3693: - s_id = n; ! 3694: -} ! 3695: - ! 3696: -set_sony() ! 3697: -{ ! 3698: - int iargs[1]; ! 3699: - char *cargs[1]; ! 3700: - ! 3701: - cargs[0] = "sony"; ! 3702: - gen_dev(0, iargs, 1, cargs); ! 3703: -} ! 3704: //GO.SYSIN DD scsi/scsish.c ! 3705: echo scsi/dslib.c 1>&2 ! 3706: sed 's/.//' >scsi/dslib.c <<'//GO.SYSIN DD scsi/dslib.c' ! 3707: -/* ! 3708: -|| dslib.c - library routines for /dev/scsi ! 3709: -|| ! 3710: -|| Copyright 1988, 1989, by ! 3711: -|| Gene Dronek (Vulcan Laboratory) and ! 3712: -|| Rich Morin (Canta Forda Computer Laboratory). ! 3713: -|| All rights reserved. ! 3714: -*/ ! 3715: -#ident "dslib.c: $Revision: 1.4 $" ! 3716: - ! 3717: -#include <stdio.h> ! 3718: -#include <sys/types.h> ! 3719: - ! 3720: -#include "dslib.h" ! 3721: -#ifdef aux ! 3722: -#include <sys/vio.h> ! 3723: -#include <sys/scsireq.h> ! 3724: -#endif aux ! 3725: - ! 3726: -int dsdebug=0; ! 3727: -long dsreqflags; /* flag bits always set by filldsreq */ ! 3728: - ! 3729: -#define min(i,j) ( (i) < (j) ? (i) : (j) ) ! 3730: - ! 3731: - ! 3732: -/* ! 3733: -|| Startup/shutdown ----------------------------------------------- ! 3734: -*/ ! 3735: - ! 3736: -static struct context *dsc[FDSIZ]; ! 3737: - ! 3738: - ! 3739: -/* ! 3740: -|| dsopen - open device, set up structures ! 3741: -*/ ! 3742: - ! 3743: -struct dsreq * ! 3744: -dsopen(opath, oflags) ! 3745: - char *opath; ! 3746: - int oflags; ! 3747: -{ ! 3748: - ! 3749: - struct dsreq *dsp; ! 3750: - struct context *cp; ! 3751: - int fd; ! 3752: - DSDBG(fprintf(stderr,"dsopen(%s,%x) ", opath, oflags)); ! 3753: - ! 3754: - fd = open(opath, oflags); ! 3755: - if (fd < 0) ! 3756: - return NULL; /* can't open */ ! 3757: - if (dsc[fd] != NULL) /* already in use */ ! 3758: - ds_zot("dsopen: fd already in use"); ! 3759: - ! 3760: - cp = (struct context *) calloc(1, sizeof(struct context)); ! 3761: - if (cp == NULL) /* can't allocate */ ! 3762: - ds_zot("dsopen: can't allocate space"); ! 3763: - dsc[fd] = cp; ! 3764: - cp->dsc_fd = fd; ! 3765: - dsp = &(cp->dsc_dsreq); ! 3766: - ! 3767: - dsp->ds_flags = 0; ! 3768: - dsp->ds_time = 10 * 1000; /* 10 second default timeout */ ! 3769: - dsp->ds_private = (ulong) cp; /* pointer back to context */ ! 3770: - dsp->ds_cmdbuf = cp->dsc_cmd; ! 3771: - dsp->ds_cmdlen = sizeof cp->dsc_cmd; ! 3772: - dsp->ds_databuf = 0; ! 3773: - dsp->ds_datalen = 0; ! 3774: - dsp->ds_sensebuf = cp->dsc_sense; ! 3775: - dsp->ds_senselen = sizeof cp->dsc_sense; ! 3776: - DSDBG(fprintf(stderr,"=>cp %x, dsp %x\n", cp, dsp)); ! 3777: - return dsp; ! 3778: -} ! 3779: - ! 3780: - ! 3781: -/* ! 3782: -|| dsclose - close device, release context struct. ! 3783: -*/ ! 3784: - ! 3785: -dsclose(dsp) ! 3786: - struct dsreq *dsp; ! 3787: -{ ! 3788: - int fd; ! 3789: - struct context *cp; ! 3790: - ! 3791: - if (dsp == NULL) ! 3792: - ds_zot("dsclose: dsp is NULL"); ! 3793: - ! 3794: - cp = (struct context *)dsp->ds_private; ! 3795: - fd = getfd(dsp); ! 3796: - if ( cp == NULL ) ! 3797: - ds_zot("dsclose: private is NULL"); ! 3798: - ! 3799: - cfree(cp); ! 3800: - dsc[fd] = (struct context *)NULL; ! 3801: - return; ! 3802: -} ! 3803: - ! 3804: - ! 3805: -/* ! 3806: -|| Generic SCSI CCS Command functions ------------------------------------ ! 3807: -|| ! 3808: -|| dsp dsreq pointer ! 3809: -|| data data buffer pointer ! 3810: -|| datalen data buffer length ! 3811: -|| lba logical block address ! 3812: -|| vu vendor unique bits ! 3813: -*/ ! 3814: - ! 3815: -/* ! 3816: -|| testunitready00 - issue group 0 "Test Unit Ready" command (0x00) ! 3817: -*/ ! 3818: - ! 3819: -testunitready00(dsp) ! 3820: - struct dsreq *dsp; ! 3821: -{ ! 3822: - fillg0cmd(dsp, CMDBUF(dsp), G0_TEST, 0, 0, 0, 0, 0); ! 3823: - filldsreq(dsp, 0, 0, DSRQ_READ|DSRQ_SENSE); ! 3824: - return(doscsireq(getfd(dsp), dsp)); ! 3825: -} ! 3826: - ! 3827: - ! 3828: -/* ! 3829: -|| requestsense03 - issue group 0 "Request Sense" command (0x03) ! 3830: -*/ ! 3831: - ! 3832: -requestsense03(dsp, data, datalen, vu) ! 3833: - struct dsreq *dsp; ! 3834: - caddr_t data; ! 3835: - long datalen; ! 3836: - char vu; ! 3837: -{ ! 3838: - fillg0cmd(dsp, CMDBUF(dsp), G0_REQU, 0, 0, 0, B1(datalen), B1(vu<<6)); ! 3839: - filldsreq(dsp, data, datalen, DSRQ_READ); ! 3840: - return(doscsireq(getfd(dsp), dsp)); ! 3841: -} ! 3842: - ! 3843: - ! 3844: -/* ! 3845: -|| write0a - issue group 0 "Write" command (0x0a) ! 3846: -*/ ! 3847: - ! 3848: -write0a(dsp, data, datalen, lba, vu) ! 3849: - struct dsreq *dsp; ! 3850: - caddr_t data; ! 3851: - long datalen, lba; ! 3852: - char vu; ! 3853: -{ ! 3854: - fillg0cmd(dsp, CMDBUF(dsp), G0_WRIT, B3(lba), B1(datalen), B1(vu<<6)); ! 3855: - filldsreq(dsp, data, datalen, DSRQ_READ); ! 3856: - return(doscsireq(getfd(dsp), dsp)); ! 3857: -} ! 3858: - ! 3859: - ! 3860: -/* ! 3861: -|| inquiry12 - issue group 0 "Inquiry" command (0x12) ! 3862: -*/ ! 3863: - ! 3864: -inquiry12(dsp, data, datalen, vu) ! 3865: - struct dsreq *dsp; ! 3866: - caddr_t data; ! 3867: - long datalen; ! 3868: - char vu; ! 3869: -{ ! 3870: - fillg0cmd(dsp, CMDBUF(dsp), G0_INQU, 0, 0, 0, B1(datalen), B1(vu<<6)); ! 3871: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE); ! 3872: - return(doscsireq(getfd(dsp), dsp)); ! 3873: -} ! 3874: - ! 3875: - ! 3876: -/* ! 3877: -|| modeselect15 - issue group 0 "Mode Select" command (0x15) ! 3878: -|| ! 3879: -|| save 0 - don't save saveable pages ! 3880: -|| 1 - save saveable pages ! 3881: -*/ ! 3882: - ! 3883: -modeselect15(dsp, data, datalen, save, vu) ! 3884: - struct dsreq *dsp; ! 3885: - caddr_t data; ! 3886: - long datalen; ! 3887: - char save, vu; ! 3888: -{ ! 3889: - fillg0cmd(dsp, CMDBUF(dsp), G0_MSEL, save&1, 0, 0, B1(datalen), B1(vu<<6)); ! 3890: - filldsreq(dsp, data, datalen, DSRQ_WRITE|DSRQ_SENSE); ! 3891: - return(doscsireq(getfd(dsp), dsp)); ! 3892: -} ! 3893: - ! 3894: - ! 3895: -/* ! 3896: -|| modesense1a - issue group 0 "Mode Sense" command (0x1a) ! 3897: -|| ! 3898: -|| pagectrl 0 - current values ! 3899: -|| 1 - changeable values ! 3900: -|| 2 - default values ! 3901: -|| 3 - saved values ! 3902: -|| ! 3903: -|| pagecode 0 - vendor unique ! 3904: -|| 1 - error recovery ! 3905: -|| 2 - disconnect/reconnect ! 3906: -|| 3 - direct access dev. fmt. ! 3907: -|| 4 - rigid disk geometry ! 3908: -|| 5 - flexible disk ! 3909: -|| 6-9 - see specific dev. types ! 3910: -|| 0a - implemented options ! 3911: -|| 0b - medium types supported ! 3912: -|| 3f - return all pages ! 3913: -*/ ! 3914: - ! 3915: -modesense1a(dsp, data, datalen, pagectrl, pagecode, vu) ! 3916: - struct dsreq *dsp; ! 3917: - caddr_t data; ! 3918: - long datalen; ! 3919: - char pagectrl, pagecode, vu; ! 3920: -{ ! 3921: - fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN, 0x10, ! 3922: - ((pagectrl&3)<<6) | (pagecode&0x3F), ! 3923: - 0, B1(datalen), B1(vu<<6)); ! 3924: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE); ! 3925: - return(doscsireq(getfd(dsp), dsp)); ! 3926: -} ! 3927: - ! 3928: - ! 3929: -/* ! 3930: -|| senddiagnostic1d - issue group 0 "Send Diagnostic" command (0x1d) ! 3931: -|| ! 3932: -|| self 0 - run test, hold results ! 3933: -|| 1 - run test, return status ! 3934: -|| ! 3935: -|| dofl 0 - device online ! 3936: -|| 1 - device offline ! 3937: -|| ! 3938: -|| uofl 0 - unit online ! 3939: -|| 1 - unit offline ! 3940: -*/ ! 3941: - ! 3942: -senddiagnostic1d(dsp, data, datalen, self, dofl, uofl, vu) ! 3943: - struct dsreq *dsp; ! 3944: - caddr_t data; ! 3945: - long datalen; ! 3946: - char self, dofl, uofl, vu; ! 3947: -{ ! 3948: - fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN, ! 3949: - (self&1)<<2 | (dofl&1)<<1 | (uofl&1), ! 3950: - 0, B2(datalen), B1(vu<<6)); ! 3951: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE); ! 3952: - return(doscsireq(getfd(dsp), dsp)); ! 3953: -} ! 3954: - ! 3955: - ! 3956: -/* ! 3957: -|| readcapacity25 - issue group 1 "Read Capacity" command (0x25) ! 3958: -|| ! 3959: -|| pmi 0 - return last logical block, entire unit ! 3960: -|| 1 - return last logical block, current track ! 3961: -*/ ! 3962: - ! 3963: -readcapacity25(dsp, data, datalen, lba, pmi, vu) ! 3964: - struct dsreq *dsp; ! 3965: - caddr_t data; ! 3966: - long datalen, lba; ! 3967: - char pmi, vu; ! 3968: -{ ! 3969: - fillg1cmd(dsp, CMDBUF(dsp), G1_RCAP, 0, B4(lba), 0, 0, pmi&1, B1(vu<<6)); ! 3970: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE ! 3971: - /* |DSRQ_CTRL2 */ ); ! 3972: - /* dsp->ds_time = 100; /* often takes a while */ ! 3973: - return(doscsireq(getfd(dsp), dsp)); ! 3974: -} ! 3975: - ! 3976: - ! 3977: -/* ! 3978: -|| readextended28 - issue group 1 "Read Extended" command (0x28) ! 3979: -*/ ! 3980: - ! 3981: -readextended28(dsp, data, datalen, lba, vu) ! 3982: - struct dsreq *dsp; ! 3983: - caddr_t data; ! 3984: - long datalen, lba; ! 3985: - char vu; ! 3986: -{ ! 3987: - fillg1cmd(dsp, CMDBUF(dsp), G1_READ, 0, B4(lba), 0, B2(datalen), B1(vu<<6)); ! 3988: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE ! 3989: - /* |DSRQ_CTRL2 */ ); ! 3990: - /* dsp->ds_time = 100; /* often takes a while */ ! 3991: - return(doscsireq(getfd(dsp), dsp)); ! 3992: -} ! 3993: - ! 3994: - ! 3995: -/* ! 3996: -|| writeextended2a - issue group 1 "Write Extended" command (0x2a) ! 3997: -*/ ! 3998: - ! 3999: -writeextended2a(dsp, data, datalen, lba, vu) ! 4000: - struct dsreq *dsp; ! 4001: - caddr_t data; ! 4002: - long datalen, lba; ! 4003: - char vu; ! 4004: -{ ! 4005: - fillg1cmd(dsp, CMDBUF(dsp), G1_WRIT, 0, B4(lba), 0, B2(datalen), B1(vu<<6)); ! 4006: - filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE ! 4007: - /* |DSRQ_CTRL2 */ ); ! 4008: - /* dsp->ds_time = 100; /* often takes a while */ ! 4009: - return(doscsireq(getfd(dsp), dsp)); ! 4010: -} ! 4011: - ! 4012: - ! 4013: -/* ! 4014: -|| Support functions ---------------------------------------------------- ! 4015: -*/ ! 4016: - ! 4017: -/* ! 4018: -|| fillg0cmd - Fill a Group 0 command buffer ! 4019: -*/ ! 4020: - ! 4021: -fillg0cmd(dsp, cmd, b0,b1,b2,b3,b4,b5) ! 4022: - struct dsreq *dsp; ! 4023: - uchar_t *cmd, b0,b1,b2,b3,b4,b5; ! 4024: -{ ! 4025: - uchar_t *c = cmd; ! 4026: - DSDBG(fprintf(stderr,"fillg0cmd(%x,%x, %02x %02x %02x %02x %02x %02x)\n", ! 4027: - dsp, cmd, b0,b1,b2,b3,b4,b5)); ! 4028: - *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5; ! 4029: - ! 4030: - CMDBUF(dsp) = (caddr_t) cmd; ! 4031: - CMDLEN(dsp) = 6; ! 4032: -} ! 4033: - ! 4034: - ! 4035: -/* ! 4036: -|| fillg1cmd - Fill a Group 1 command buffer ! 4037: -*/ ! 4038: - ! 4039: -fillg1cmd(dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9) ! 4040: - struct dsreq *dsp; ! 4041: - uchar_t *cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9; ! 4042: -{ ! 4043: - uchar_t *c = cmd; ! 4044: - DSDBG(fprintf(stderr, ! 4045: - "fillg1cmd(%x,%x, %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x)\n", ! 4046: - dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9)); ! 4047: - ! 4048: - *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5; ! 4049: - *c++ = b6, *c++ = b7, *c++ = b8, *c++ = b9; ! 4050: - ! 4051: - CMDBUF(dsp) = (caddr_t) cmd; ! 4052: - CMDLEN(dsp) = 10; ! 4053: -} ! 4054: - ! 4055: - ! 4056: -/* ! 4057: -|| filldsreq - Fill a dsreq structure ! 4058: -*/ ! 4059: - ! 4060: -filldsreq(dsp,data,datalen,flags) ! 4061: - struct dsreq *dsp; ! 4062: - uchar_t *data; ! 4063: -{ ! 4064: - DSDBG(fprintf(stderr,"filldsreq(%x,%x,%d,%x) cmdlen %d\n", ! 4065: - dsp,data,datalen,flags,CMDLEN(dsp))); ! 4066: - dsp->ds_flags = flags | dsreqflags | ! 4067: - (((dsdebug&1) ? DSRQ_TRACE : 0) | ! 4068: - ((dsdebug&2) ? DSRQ_PRINT : 0)); ! 4069: - dsp->ds_time = 10 * 1000; /* default to 10 seconds */ ! 4070: - dsp->ds_link = 0; ! 4071: - dsp->ds_synch = 0; ! 4072: - dsp->ds_ret = 0; ! 4073: - ! 4074: - DATABUF(dsp) = (caddr_t) data; ! 4075: - DATALEN(dsp) = datalen; ! 4076: -} ! 4077: - ! 4078: - ! 4079: -/* ! 4080: -|| bprint - print array of bytes, in hex. ! 4081: -*/ ! 4082: - ! 4083: -#define hex(x) "0123456789ABCDEF" [ (x) & 0xF ] ! 4084: - ! 4085: -bprint(s,n,nperline,space) ! 4086: - char *s; ! 4087: -{ ! 4088: - int i, x; ! 4089: - char *sp = (space) ? " ": ""; ! 4090: - ! 4091: - for(i=0;i<n;i++) { ! 4092: - x = s[i]; ! 4093: - fprintf(stderr,((i%4==3)?"%c%c%s%s":"%c%c%s"), ! 4094: - hex(x>>4), hex(x), sp, sp); ! 4095: - if ( i%nperline == (nperline - 1) ) ! 4096: - fprintf(stderr,"\n"); ! 4097: - } ! 4098: - if ( space ) ! 4099: - fprintf(stderr,"\n"); ! 4100: -} ! 4101: - ! 4102: - ! 4103: -/* ! 4104: -|| doscsireq - issue scsi command, return status or -1 error. ! 4105: -*/ ! 4106: - ! 4107: -doscsireq( fd, dsp) ! 4108: - int fd; /* ioctl file descriptor */ ! 4109: - struct dsreq *dsp; /* devscsi request packet */ ! 4110: -{ ! 4111: - int cc; ! 4112: - int retries = 4; ! 4113: - uchar_t sbyte; ! 4114: - ! 4115: - DSDBG(fprintf(stderr,"doscsireq(%d,%x) %x ---- %s\n",fd,dsp, ! 4116: - (CMDBUF(dsp))[0], ! 4117: - ds_vtostr( (CMDBUF(dsp))[0], cmdnametab))); ! 4118: - ! 4119: - /* ! 4120: - * loop, issuing command ! 4121: - * until done, or further retry pointless ! 4122: - */ ! 4123: - ! 4124: - while ( --retries > 0 ) { ! 4125: - ! 4126: - caddr_t sp; ! 4127: - ! 4128: - sp = SENSEBUF(dsp); ! 4129: - DSDBG(fprintf(stderr,"cmdbuf = "); ! 4130: - bprint(CMDBUF(dsp),CMDLEN(dsp),16,1)); ! 4131: - if ( (dsp->ds_flags & DSRQ_WRITE) ) ! 4132: - DSDBG(bprint( DATABUF(dsp), min(50,DATALEN(dsp)),16,1 )); ! 4133: - ! 4134: -DSDBG(fprintf(stderr,"databuf datalen %x %d\n",DATABUF(dsp), DATALEN(dsp))); ! 4135: - cc = ioctl( fd, DS_ENTER, dsp); ! 4136: - if ( cc < 0) { ! 4137: - ds_panic(dsp, "cannot ioctl fd %d\n",fd); ! 4138: - } ! 4139: - ! 4140: - DSDBG(fprintf(stderr,"cmdlen after ioctl=%d\n",CMDLEN(dsp))); ! 4141: - DSDBG(fprintf(stderr,"ioctl=%d ret=%x %s", ! 4142: - cc, RET(dsp), ! 4143: - RET(dsp) ? ds_vtostr(RET(dsp),dsrtnametab) : "")); ! 4144: - DSDBG(if (SENSESENT(dsp)) fprintf(stderr," sensesent=%d", ! 4145: - SENSESENT(dsp))); ! 4146: - ! 4147: - DSDBG(fprintf(stderr, ! 4148: - " cmdsent=%d datasent=%d sbyte=%x %s\n", ! 4149: - CMDSENT(dsp), DATASENT(dsp), STATUS(dsp), ! 4150: - ds_vtostr(STATUS(dsp), cmdstatustab))); ! 4151: - DSDBG(if ( FLAGS(dsp) & DSRQ_READ ) ! 4152: - bprint( DATABUF(dsp), min(16*16,DATASENT(dsp)), 16,1)); ! 4153: - ! 4154: -#ifdef aux ! 4155: - /* ! 4156: - * check for AUX bus-error ! 4157: - * we retry with poll-dma ! 4158: - */ ! 4159: - if ( RET(dsp) == DSRT_AGAIN ) { ! 4160: - int n = SDC_RDPOLL|SDC_WRPOLL; ! 4161: - DSDBG(fprintf(stderr,"setting rd/wr-poll")); ! 4162: - cc = ioctl( fd, DS_SET, n); /* set bits */ ! 4163: - if ( cc != 0 ) ! 4164: - return -1; ! 4165: - } ! 4166: -#endif aux ! 4167: - ! 4168: - if ( RET(dsp) == DSRT_NOSEL ) ! 4169: - continue; /* retry noselect 3X */ ! 4170: - ! 4171: - /* decode sense data returned */ ! 4172: - if ( SENSESENT(dsp) ) { ! 4173: - DSDBG( ! 4174: - fprintf(stderr, "sense key %x - %s\n", ! 4175: - SENSEKEY(sp), ! 4176: - ds_vtostr( SENSEKEY(sp), sensekeytab)); ! 4177: - bprint( SENSEBUF(dsp), ! 4178: - min(100, SENSESENT(dsp)), ! 4179: - 16,1); ! 4180: - ); ! 4181: - } ! 4182: - DSDBG(fprintf(stderr, "sbyte %x\n", STATUS(dsp))); ! 4183: - ! 4184: - /* decode scsi command status byte */ ! 4185: - sbyte = STATUS(dsp); ! 4186: - switch (sbyte) { ! 4187: - case 0x08: /* BUSY */ ! 4188: - case 0x18: /* RESERV CONFLICT */ ! 4189: - sleep(2); ! 4190: - continue; ! 4191: - case 0x00: /* GOOD */ ! 4192: - case 0x02: /* CHECK CONDITION */ ! 4193: - case 0x10: /* INTERM/GOOD */ ! 4194: - default: ! 4195: - return sbyte; ! 4196: - } ! 4197: - } ! 4198: - return -1; /* fail retry limit */ ! 4199: -} ! 4200: - ! 4201: - ! 4202: -/* ! 4203: -|| opttovar - lookup option in table, return var addr (NULL if fail) ! 4204: -*/ ! 4205: - ! 4206: -int * ! 4207: -opttovar( ostr, table) ! 4208: - char *ostr; ! 4209: - struct opttab{ ! 4210: - char *opt; ! 4211: - int *var; ! 4212: - } *table; ! 4213: -{ ! 4214: - register struct opttab *tp; ! 4215: - ! 4216: - for (tp=table; (tp->var); tp++) ! 4217: - if ( strncmp( ostr, tp->opt, 3) == 0 ) ! 4218: - break; ! 4219: - ! 4220: - if ( !tp->var ) ! 4221: - fprintf(stderr,"unknown option %s", ostr); ! 4222: - ! 4223: - return (tp->var); ! 4224: -} ! 4225: - ! 4226: - ! 4227: -/* ! 4228: -|| ds_vtostr - lookup value in table to return string pointer ! 4229: -*/ ! 4230: - ! 4231: -char * ! 4232: -ds_vtostr( v, table) ! 4233: - long v; ! 4234: - struct vtab *table; ! 4235: -{ ! 4236: - register struct vtab *tp; ! 4237: - ! 4238: - for (tp=table; (tp->string); tp++) ! 4239: - if ( v == tp->val ) ! 4240: - break; ! 4241: - ! 4242: - return (tp->string) ? tp->string : ""; ! 4243: -} ! 4244: - ! 4245: - ! 4246: -/* ! 4247: -|| ds_panic - yelp, leave... ! 4248: -*/ ! 4249: - ! 4250: -ds_panic( fmt, v) ! 4251: - char *fmt; ! 4252: - int v; ! 4253: -{ ! 4254: - extern errno; ! 4255: - ! 4256: - fprintf(stderr,fmt,v); ! 4257: - fprintf(stderr,"\nerrno = %d\n",errno); ! 4258: - exit(1); ! 4259: -} ! 4260: - ! 4261: - ! 4262: -/* ! 4263: -|| ds_zot - go away, with a message. ! 4264: -*/ ! 4265: - ! 4266: -ds_zot(message) ! 4267: - char *message; ! 4268: -{ ! 4269: - fprintf(stderr, "%s\n", message); ! 4270: - exit(1); ! 4271: -} ! 4272: //GO.SYSIN DD scsi/dslib.c ! 4273: echo scsi/load.c 1>&2 ! 4274: sed 's/.//' >scsi/load.c <<'//GO.SYSIN DD scsi/load.c' ! 4275: -#include <stdio.h> ! 4276: -#include <stddef.h> ! 4277: -#include <string.h> ! 4278: -#include "scsi.h" ! 4279: -#include "juke.h" ! 4280: - ! 4281: -j_load(char *vol_id, char *buf, long tlimit) ! 4282: -{ ! 4283: - Side side; ! 4284: - int n, sh, dr; ! 4285: - char disk_to_load[256]; ! 4286: - struct Lunstatus *l; ! 4287: - ! 4288: - if(j_rdshelves(buf)) /* read in shelf names */ ! 4289: - return(-1); ! 4290: - if(j_getstatus(buf)) /* get the jukebox status */ ! 4291: - return(-1); ! 4292: - /* now check which side we want */ ! 4293: - n = strlen(vol_id); ! 4294: - strcpy(disk_to_load, vol_id); ! 4295: - if(disk_to_load[n-1] == 'a') ! 4296: - side = SIDEA; ! 4297: - else if(disk_to_load[n-1] == 'b') ! 4298: - side = SIDEB; ! 4299: - else { ! 4300: - sprintf(buf, "vol_id '%s' must end in a or b", vol_id); ! 4301: - return(-1); ! 4302: - } ! 4303: - disk_to_load[n-1] = 0; ! 4304: - /* which shelf is that? */ ! 4305: - sh = j_shelfof(disk_to_load); ! 4306: - if(sh < 0){ ! 4307: - sprintf(buf, "can't find vol_id %s", disk_to_load); ! 4308: - return(-1); ! 4309: - } ! 4310: - while(tlimit >= 0){ ! 4311: - for(n = 0; n < NLUN; n++){ ! 4312: - l = &j_status.lun[n]; ! 4313: - if(l->diskin && l->shelfvalid && (sh == (l->retshelf>>1))){ ! 4314: - if(((l->retshelf&1) == side) && (n < nlun)) ! 4315: - return(n); ! 4316: - if(l->ready) ! 4317: - goto await; ! 4318: - if(j_drive_to_shelf(n, -1, 0, buf)) ! 4319: - return(-1); ! 4320: - if(j_getstatus(buf)) /* get the jukebox status */ ! 4321: - return(-1); ! 4322: - break; ! 4323: - } ! 4324: - } ! 4325: - /* disk is available */ ! 4326: - dr = j_empty_drive(tlimit, buf); ! 4327: - if(dr < 0){ ! 4328: - sprintf(buf, "can't find a free drive"); ! 4329: - return(-1); ! 4330: - } ! 4331: - if(j_shelf_to_drive(sh, side, dr, buf) < 0) ! 4332: - return(-1); ! 4333: - return(dr); ! 4334: -await: ! 4335: - sleep(10); ! 4336: - tlimit -= 10; ! 4337: - if(j_getstatus(buf)) /* get the jukebox status */ ! 4338: - return(-1); ! 4339: - } ! 4340: - sprintf(buf, "disk '%s' busy", disk_to_load); ! 4341: - return(-1); ! 4342: -} ! 4343: //GO.SYSIN DD scsi/load.c ! 4344: echo scsi/main.c 1>&2 ! 4345: sed 's/.//' >scsi/main.c <<'//GO.SYSIN DD scsi/main.c' ! 4346: -#include <stdio.h> ! 4347: -#include "jukebox.h" ! 4348: -#include "hdr.h" ! 4349: - ! 4350: -main(int argc, char *argv[]) ! 4351: -{ ! 4352: - int c; ! 4353: - int err = 0, cold = 0, warm = 0; ! 4354: - char *toload = 0, *uload = 0; ! 4355: - char *drive = 0; ! 4356: - char buf[256]; ! 4357: - extern int optind; ! 4358: - extern char *optarg; ! 4359: - ! 4360: - setbuf(stdout, (char *)0); /* turn off buffering */ ! 4361: - /* gather options */ ! 4362: - while ((c = getopt(argc,argv,"cn:l:wu:")) != -1) ! 4363: - switch (c) ! 4364: - { ! 4365: - case 'l': toload = optarg; break; ! 4366: - case 'c': cold = 1; break; ! 4367: - case 'w': warm = 1; break; ! 4368: - case 'u': uload = optarg ; break; ! 4369: - case 'n': drive = optarg ; break; ! 4370: - default: err = 1; break; ! 4371: - } ! 4372: - if(err) ! 4373: - exit(1); ! 4374: - /* now actually do some work */ ! 4375: - if (toload){ ! 4376: - if (j_load(toload, buf, 30)) ! 4377: - printf("load %s failed: %s\n", toload, buf); ! 4378: - else ! 4379: - printf("loaded %s on %s\n", toload, buf); ! 4380: - } ! 4381: - if(drive){ ! 4382: - if(j_volid(atoi(drive), buf)) ! 4383: - printf("j_volid(%s) failed: %s\n", drive, buf); ! 4384: - else ! 4385: - printf("%s is mounted on drive %d\n", buf, atoi(drive)); ! 4386: - } ! 4387: - if(cold){ ! 4388: - printf("invent cold: %d\n", cold); ! 4389: - cold_inventory(30, buf); ! 4390: - ! 4391: - } ! 4392: - if (warm) { ! 4393: - printf("invent warm: %d\n", warm); ! 4394: - warm_inventory(buf); ! 4395: - ! 4396: - } ! 4397: - ! 4398: - ! 4399: - if (uload){ ! 4400: - if (j_unload(uload, buf)) ! 4401: - printf("unload %s failed: %s\n", uload, buf); ! 4402: - else ! 4403: - printf("unloaded %s from %s\n", uload, buf); ! 4404: - ! 4405: - ! 4406: - } ! 4407: - exit(0); ! 4408: -} ! 4409: //GO.SYSIN DD scsi/main.c ! 4410: echo scsi/inc/scsi.h 1>&2 ! 4411: sed 's/.//' >scsi/inc/scsi.h <<'//GO.SYSIN DD scsi/inc/scsi.h' ! 4412: -#define SCSI_WR 0x80 ! 4413: -#define SCSI_RD 0x40 ! 4414: -#define SCSI_BRESET 0x20 ! 4415: -#define SCSI_RESET 0x10 ! 4416: -#define SCSI_SENSE 0x08 ! 4417: -#define SCSI_LTMOUT 0x04 ! 4418: - ! 4419: - ! 4420: -#define SCSI_CERR 0x01 ! 4421: //GO.SYSIN DD scsi/inc/scsi.h ! 4422: echo scsi/research.mk 1>&2 ! 4423: sed 's/.//' >scsi/research.mk <<'//GO.SYSIN DD scsi/research.mk' ! 4424: -# config stuff: research unix ! 4425: -CC=lcc ! 4426: -CFLAGS=-g ! 4427: -RANLIB=ranlib ! 4428: -LDFLAGS= ! 4429: -IO=h_io ! 4430: -NPROC=2 ! 4431: //GO.SYSIN DD scsi/research.mk ! 4432: echo scsi/sgi.mk 1>&2 ! 4433: sed 's/.//' >scsi/sgi.mk <<'//GO.SYSIN DD scsi/sgi.mk' ! 4434: -# config stuff: sgi; system v with moran/droneck /dev/scsi ! 4435: -CC=pcc # must be ansi ! 4436: -RANLIB=: ! 4437: -LDFLAGS= -lds ! 4438: -IO=md_io ! 4439: -CFLAGS=-g -I../inc ! 4440: -NPROC=4 ! 4441: //GO.SYSIN DD scsi/sgi.mk ! 4442: echo scsi/unload.c 1>&2 ! 4443: sed 's/.//' >scsi/unload.c <<'//GO.SYSIN DD scsi/unload.c' ! 4444: -#include <stdio.h> ! 4445: -#include <stddef.h> ! 4446: -#include <string.h> ! 4447: -#include "scsi.h" ! 4448: -#include "juke.h" ! 4449: - ! 4450: -j_unload(char *vol_id, char *buf) ! 4451: -{ ! 4452: - Side side; ! 4453: - int i, sh, dr; ! 4454: - char disk_to_unload[256]; ! 4455: - ! 4456: - if(j_rdshelves(buf)) /* read in shelf names */ ! 4457: - return(-1); ! 4458: - if(j_getstatus(buf)) /* get the jukebox status */ ! 4459: - return(-1); ! 4460: - /* now check which side we want */ ! 4461: - ! 4462: - strcpy(disk_to_unload, vol_id); ! 4463: - side = SIDEA; ! 4464: - sh = j_shelfof(disk_to_unload); ! 4465: - if(sh < 0){ ! 4466: - sprintf(buf, "can not find vol_id %s", disk_to_unload); ! 4467: - return(-1); ! 4468: - } ! 4469: - dr = -1; ! 4470: - for(i = 0; i < NLUN; i++){ ! 4471: - printf("dr:.. %d ", i); ! 4472: - printf(" rtsh: %d\n", j_status.lun[i].retshelf); ! 4473: - ! 4474: - /* is sh = retshelf? */ ! 4475: - ! 4476: - if( (j_status.lun[i].retshelf>>1 == sh) || ! 4477: - (j_status.lun[i].retshelf == sh*2+1) ){ dr = i; ! 4478: - break; ! 4479: - } } ! 4480: - printf("dr: %d, sh: %d, side: %d, i: %d\n", dr, sh, side, i); ! 4481: - if (dr == -1){ ! 4482: - sprintf(buf, "no drive has vol_id %s", disk_to_unload); ! 4483: - return(-1); ! 4484: - } ! 4485: - /* put vol_id in it's shelf*/ ! 4486: - if (j_drive_to_shelf(dr, sh, side, buf) >= 0){ ! 4487: - sprintf(buf,"/dev/worm%d\n", dr); ! 4488: - return(0); ! 4489: - } ! 4490: - return(-1); ! 4491: -} ! 4492: //GO.SYSIN DD scsi/unload.c ! 4493: echo scsi/README 1>&2 ! 4494: sed 's/.//' >scsi/README <<'//GO.SYSIN DD scsi/README' ! 4495: - This is a simple extensible shell (scsish) for poking at scsi ! 4496: -devices, particularly the simpler kinds commonly called toasters. ! 4497: -it is supposed to be self-documenting in use; try the help command. ! 4498: -my use of the moran-dronek /dev/scsi library is still imperfect; ! 4499: -there is still some some debugging showing. ! 4500: - ! 4501: - To compile, you first need mk. you then have to pick a system type ! 4502: -to set some flags; currently we support research and sgi. ! 4503: -yours may differ, particularly as no one else has our ansi C compiler for the sgi. ! 4504: -the only problem i would expect is the normal header file crap you get ! 4505: -mixing ansi and non-ansi files. i recommend setting NPROC=1 while debugging hdr files. ! 4506: -if you change (header) files, try putting them in the directory inc ! 4507: -(then others may benefit). To support a new system (say sgi-gcc), just create ! 4508: -a new file sgi-gcc.mk and so on. you may be missing some devices in ! 4509: -your /dev/scsi; the script scsi/gendev may help (but check the major/minor ! 4510: -numbers and permissions). ! 4511: - ! 4512: - As for modifying/extending scsish, it has been designed to be not too hard. ! 4513: -Adding a new device means adding a new set of rules (like the other rules) ! 4514: -to mkfile and creating a new directory (say exabyte) and at least two files in it ! 4515: -(dev.c and fns.h). The wren directory is a small example you can clone. ! 4516: -Adding new functions to any device means updating a file list in mkfile, ! 4517: -updating dev.c and fns.h in the device directory. The argument syntax ! 4518: -scheme is arguably pokey, but liveable. at some future point we should probably ! 4519: -switch over to osterhout's tcl. ! 4520: - ! 4521: - as always, i invite you send extensions/fixes etc back to ! 4522: [email protected] ! 4523: //GO.SYSIN DD scsi/README ! 4524: echo scsi/TODO 1>&2 ! 4525: sed 's/.//' >scsi/TODO <<'//GO.SYSIN DD scsi/TODO' ! 4526: - | COPY drive NUMBER NUMBER drive NUMBER {/*:COPY sdrive sstart nblocks ddrive dstart:: */ ! 4527: - s_copy($2, $3, $4, $5, $6); ! 4528: - } ! 4529: - | READ drive NUMBER { ! 4530: - struct scsi_ret output; ! 4531: - s_read($2, $3, 1, &output); ! 4532: - scsiodump(output.data, 1024); ! 4533: - } ! 4534: - | WRITE drive NUMBER { s_write($2, $3, 1); } ! 4535: - | WRITE drive NUMBER NUMBER { s_write($2, $3, $4); } /*:WRITE drive start n:: */ ! 4536: //GO.SYSIN DD scsi/TODO ! 4537: echo scsi/scsish.h 1>&2 ! 4538: sed 's/.//' >scsi/scsish.h <<'//GO.SYSIN DD scsi/scsish.h' ! 4539: -typedef int (*Functionfn)(int, int *, int, char **, char *); ! 4540: - ! 4541: -typedef struct ! 4542: -{ ! 4543: - char *name; ! 4544: - char *help; ! 4545: - char *param; ! 4546: - Functionfn fn; ! 4547: -} Function; ! 4548: - ! 4549: -typedef struct ! 4550: -{ ! 4551: - char *name; ! 4552: - char *verbose; ! 4553: - void (*extsense)(uchar *, char *, int); ! 4554: - Function *fns; ! 4555: -} Device; ! 4556: -extern void setdevice(Device *); ! 4557: - ! 4558: -extern void scsi_target(int); ! 4559: -extern void fixedstr(uchar *src, int len, char *dest); ! 4560: -extern void gen_extsense(uchar *, char *, int); ! 4561: -extern int shelfside(char *arg, char *err); ! 4562: -extern void xd(uchar *base, int, FILE *fp); ! 4563: //GO.SYSIN DD scsi/scsish.h ! 4564: echo scsi/generic/dev.c 1>&2 ! 4565: sed 's/.//' >scsi/generic/dev.c <<'//GO.SYSIN DD scsi/generic/dev.c' ! 4566: -#include <stdio.h> ! 4567: -#include "../scsi.h" ! 4568: -#include "../scsish.h" ! 4569: -#include "fns.h" ! 4570: - ! 4571: -static int gen_id(int, int *, int, char **, char *); ! 4572: - ! 4573: -static Function fns[] = { ! 4574: - { "capacity", "capacity [lun=0]", "L?", gen_capacity }, ! 4575: - { "copy", "copy srclun start n destlun dest", "LIILII?", gen_copy }, ! 4576: - { "display", "display", "", gen_display }, ! 4577: - { "dev", "dev [type] # dev ? for list", "S?", gen_dev }, ! 4578: - { "help", "help [cmd]", "S?", gen_help }, ! 4579: - { "id", "id [target=0]", "L?", gen_id }, ! 4580: - { "inq", "inq [lun=0]", "L?", gen_inq }, ! 4581: - { "readt", "readt count [lun=0]", "IL?", gen_readt }, ! 4582: - { "reset", "reset", "", gen_reset }, ! 4583: - { "scsi", "scsi bytes... # 6 or 10", "I?I?I?I?I?I?I?I?I?I?", gen_scsi }, ! 4584: - { "sense", "sense [lun=0]", "L?", gen_sense }, ! 4585: - { "start", "start [lun=0]", "L?", gen_start }, ! 4586: - { "stop", "stop [lun=0]", "L?", gen_stop }, ! 4587: - { "testunit", "testunit [lun=0", "L?", gen_tur }, ! 4588: - { 0 } ! 4589: -}; ! 4590: - ! 4591: -Device genericdev = { ! 4592: - "scsi", "generic scsi", ! 4593: - gen_extsense, ! 4594: - fns ! 4595: -}; ! 4596: - ! 4597: -static int ! 4598: -gen_id(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4599: -{ ! 4600: -#pragma ref ncargs ! 4601: -#pragma ref cargs ! 4602: -#pragma ref err ! 4603: - ! 4604: - if(niargs == 0) ! 4605: - printf("current SCSI id = %d\n", s_id); ! 4606: - else ! 4607: - scsi_target(iargs[0]); ! 4608: - return(0); ! 4609: -} ! 4610: //GO.SYSIN DD scsi/generic/dev.c ! 4611: echo scsi/generic/inq.c 1>&2 ! 4612: sed 's/.//' >scsi/generic/inq.c <<'//GO.SYSIN DD scsi/generic/inq.c' ! 4613: -#include <stdio.h> ! 4614: -#include "../scsi.h" ! 4615: -#include "../scsish.h" ! 4616: -#include "fns.h" ! 4617: - ! 4618: -char *gen_rmb[2] = { "nonremovable", "removable" }; ! 4619: -char *gen_devtype[256] = { ! 4620: - "direct access", ! 4621: - "sequential access", ! 4622: - "printer", ! 4623: - "processor", ! 4624: - "worm", ! 4625: - "cd-rom" ! 4626: -}; ! 4627: - ! 4628: -int ! 4629: -gen_inq(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4630: -{ ! 4631: - struct scsi_cmd cmd; ! 4632: - struct scsi_return ret; ! 4633: - int n, i; ! 4634: - ! 4635: -#pragma ref ncargs ! 4636: -#pragma ref cargs ! 4637: - ! 4638: - if(niargs == 0) ! 4639: - for(niargs = 0; niargs < 8; niargs++) ! 4640: - iargs[niargs] = niargs; ! 4641: - for(i = 0; i < niargs; i++){ ! 4642: - set6(cmd, 0x12, iargs[i]<<5, 0, 0, 36, 0); ! 4643: - if(n = s_io(0, &cmd, 0, &ret, -36, err)) ! 4644: - return(n); ! 4645: - printf("inq(%d,%d): %s %s;", s_id, iargs[i], ! 4646: - gen_rmb[ret.data[1]>>7], gen_devtype[ret.data[0]]); ! 4647: - if(ret.data[4] >= 16){ ! 4648: - char buf[256]; ! 4649: - ! 4650: - fixedstr(&ret.data[8], 8, buf); ! 4651: - printf(" %s", buf); ! 4652: - if(ret.data[4] >= 32){ ! 4653: - fixedstr(&ret.data[16], 16, buf); ! 4654: - printf("/%s", buf); ! 4655: - if(ret.data[4] >= 36){ ! 4656: - fixedstr(&ret.data[32], 4, buf); ! 4657: - printf(" rev=%s", buf); ! 4658: - } ! 4659: - } ! 4660: - } ! 4661: - printf(" [%d bytes]\n", ret.data[4]); ! 4662: - } ! 4663: - return(0); ! 4664: -} ! 4665: //GO.SYSIN DD scsi/generic/inq.c ! 4666: echo scsi/generic/sense.c 1>&2 ! 4667: sed 's/.//' >scsi/generic/sense.c <<'//GO.SYSIN DD scsi/generic/sense.c' ! 4668: -#include <stdio.h> ! 4669: -#include "../scsi.h" ! 4670: -#include "../scsish.h" ! 4671: -#include "fns.h" ! 4672: - ! 4673: -int ! 4674: -gen_sense(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4675: -{ ! 4676: - struct scsi_cmd cmd; ! 4677: - struct scsi_return ret; ! 4678: - int n; ! 4679: - ! 4680: -#pragma ref ncargs ! 4681: -#pragma ref cargs ! 4682: - ! 4683: - if(niargs == 0) ! 4684: - iargs[0] = 0; ! 4685: - set6(cmd, 0x03, iargs[0]<<5, 0, 0, 4, 0); ! 4686: - if(n = s_io(0, &cmd, 0, &ret, 4, err)) ! 4687: - return(n); ! 4688: - printf("sense(%d,%d): ", s_id, iargs[0]); ! 4689: - if((ret.data[0]&0x7F) == 0) ! 4690: - printf("no error\n"); ! 4691: - else { ! 4692: - printf("error class=0x%x, code=0x%x, sense=0x%x", ! 4693: - (ret.data[0]>>4)&7, ret.data[0]&0xF, ret.data[2]&0xF); ! 4694: - if(ret.data[0]&0x80) ! 4695: - printf(", addr=0x%x", ret.data[3]+256L*ret.data[2]+256L*256*ret.data[1]); ! 4696: - printf("\n"); ! 4697: - } ! 4698: - return(0); ! 4699: -} ! 4700: - ! 4701: -static char *exstab[16] = ! 4702: -{ ! 4703: - "no sense", ! 4704: - "recovered error", ! 4705: - "not ready", ! 4706: - "medium error", ! 4707: - "hardware error", ! 4708: - "illegal request", ! 4709: - "unit attention", ! 4710: - "data protect", ! 4711: - "blank check", ! 4712: - "vendor specific (#9)", ! 4713: - "copy aborted", ! 4714: - "aborted command", ! 4715: - "equal", ! 4716: - "volume overflow", ! 4717: - "miscompare", ! 4718: - "reserved (#f)", ! 4719: -}; ! 4720: - ! 4721: -void ! 4722: -gen_extsense(uchar *data, char *dest, int ndata) ! 4723: -{ ! 4724: - int class; ! 4725: - ! 4726: - class = (data[0]>>4)&7; ! 4727: - if(class == 7){ ! 4728: - if(data[0]&0x80) ! 4729: - sprintf(dest, "extended sense: %s info=#%2.2x#%2.2x#%2.2x#%2.2x", exstab[data[2]&0xF], data[3], data[4], data[5], data[6]); ! 4730: - else ! 4731: - sprintf(dest, "extended sense: %s", exstab[data[2]&0xF]); ! 4732: - } else { ! 4733: - sprintf(dest, "sense: class=#%x, code=#%x", class, data[0]&0xF); ! 4734: - } ! 4735: -} ! 4736: //GO.SYSIN DD scsi/generic/sense.c ! 4737: echo scsi/generic/start.c 1>&2 ! 4738: sed 's/.//' >scsi/generic/start.c <<'//GO.SYSIN DD scsi/generic/start.c' ! 4739: -#include <stdio.h> ! 4740: -#include "../scsi.h" ! 4741: -#include "../scsish.h" ! 4742: -#include "fns.h" ! 4743: - ! 4744: -int ! 4745: -gen_start(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4746: -{ ! 4747: - struct scsi_cmd cmd; ! 4748: - struct scsi_return ret; ! 4749: - int n; ! 4750: - ! 4751: -#pragma ref ncargs ! 4752: -#pragma ref cargs ! 4753: - ! 4754: - if(niargs == 0) ! 4755: - iargs[0] = 0; ! 4756: - set6(cmd, 0x1B, iargs[0]<<5, 0, 0, 1, 0); ! 4757: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 4758: - return(n); ! 4759: - return(0); ! 4760: -} ! 4761: //GO.SYSIN DD scsi/generic/start.c ! 4762: echo scsi/generic/stop.c 1>&2 ! 4763: sed 's/.//' >scsi/generic/stop.c <<'//GO.SYSIN DD scsi/generic/stop.c' ! 4764: -#include <stdio.h> ! 4765: -#include "../scsi.h" ! 4766: -#include "../scsish.h" ! 4767: -#include "fns.h" ! 4768: - ! 4769: -int ! 4770: -gen_stop(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4771: -{ ! 4772: - struct scsi_cmd cmd; ! 4773: - struct scsi_return ret; ! 4774: - int n; ! 4775: - ! 4776: -#pragma ref ncargs ! 4777: -#pragma ref cargs ! 4778: - ! 4779: - if(niargs == 0) ! 4780: - iargs[0] = 0; ! 4781: - set6(cmd, 0x1B, iargs[0]<<5, 0, 0, 0, 0); ! 4782: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 4783: - return(n); ! 4784: - return(0); ! 4785: -} ! 4786: //GO.SYSIN DD scsi/generic/stop.c ! 4787: echo scsi/generic/capacity.c 1>&2 ! 4788: sed 's/.//' >scsi/generic/capacity.c <<'//GO.SYSIN DD scsi/generic/capacity.c' ! 4789: -#include <stdio.h> ! 4790: -#include "../scsi.h" ! 4791: -#include "../scsish.h" ! 4792: -#include "fns.h" ! 4793: - ! 4794: -int ! 4795: -gen_capacity(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4796: -{ ! 4797: - struct scsi_cmd cmd; ! 4798: - struct scsi_return ret; ! 4799: - int n; ! 4800: - unsigned long ns, ss; ! 4801: - ! 4802: -#pragma ref ncargs ! 4803: -#pragma ref cargs ! 4804: - ! 4805: - if(niargs == 0) ! 4806: - iargs[0] = 0; ! 4807: - set10(cmd, 0x25, iargs[0]<<5, 0, 0, 0, 0, 0, 0, 0, 0); ! 4808: - if(n = s_io(0, &cmd, 0, &ret, 8, err)) ! 4809: - return(n); ! 4810: - ns = longat(&ret.data[0]); ! 4811: - ss = longat(&ret.data[4]); ! 4812: - printf("capacity(%d,%d): %ld blocks of %ld bytes (#%xx#%x)\n", s_id, iargs[0], ! 4813: - ns, ss, ns, ss); ! 4814: - return(0); ! 4815: -} ! 4816: //GO.SYSIN DD scsi/generic/capacity.c ! 4817: echo scsi/generic/display.c 1>&2 ! 4818: sed 's/.//' >scsi/generic/display.c <<'//GO.SYSIN DD scsi/generic/display.c' ! 4819: -#include <stdio.h> ! 4820: -#include "../scsi.h" ! 4821: -#include "../scsish.h" ! 4822: -#include "fns.h" ! 4823: - ! 4824: -extern char *gen_rmb[2]; ! 4825: -extern char *gen_devtype[256]; ! 4826: - ! 4827: -int ! 4828: -gen_display(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4829: -{ ! 4830: - struct scsi_cmd cmd; ! 4831: - struct scsi_return ret; ! 4832: - int n, i, old_id; ! 4833: - int retv = 0; ! 4834: - char rev[100], vendor[100], product[100]; ! 4835: - ! 4836: -#pragma ref niargs ! 4837: -#pragma ref iargs ! 4838: -#pragma ref ncargs ! 4839: -#pragma ref cargs ! 4840: - ! 4841: - old_id = s_id; ! 4842: - for(s_id = 0; s_id < 8; s_id++){ ! 4843: - printf("target %d:\n"); ! 4844: - set6(cmd, 0x00, 0, 0, 0, 0, 0); ! 4845: - if(s_io(0, &cmd, 0, &ret, 0, err)) ! 4846: - continue; ! 4847: - printf("responded to test unit ready\n"); ! 4848: - continue; ! 4849: - for(i = 0; i < 8; i++){ ! 4850: - set6(cmd, 0x12, i<<5, 0, 0, 36, 0); ! 4851: - if(n = s_io(0, &cmd, 0, &ret, -36, err)){ ! 4852: - retv = n; ! 4853: - break; ! 4854: - } ! 4855: - if(ret.nread >= 16) ! 4856: - fixedstr(&ret.data[8], 8, vendor); ! 4857: - else ! 4858: - sprintf(vendor, "??"); ! 4859: - if(ret.nread >= 32) ! 4860: - fixedstr(&ret.data[16], 16, product); ! 4861: - else ! 4862: - sprintf(product, "??"); ! 4863: - if(ret.nread >= 16) ! 4864: - fixedstr(&ret.data[32], 4, rev); ! 4865: - else ! 4866: - sprintf(vendor, "??"); ! 4867: - printf("\tlun(%d): %s %s, %s/%s rev=%s\n", i, ! 4868: - gen_rmb[ret.data[1]>>7], gen_devtype[ret.data[0]], ! 4869: - vendor, product, rev); ! 4870: - } ! 4871: - } ! 4872: - s_id = old_id; ! 4873: - return(retv); ! 4874: -} ! 4875: //GO.SYSIN DD scsi/generic/display.c ! 4876: echo scsi/generic/reset.c 1>&2 ! 4877: sed 's/.//' >scsi/generic/reset.c <<'//GO.SYSIN DD scsi/generic/reset.c' ! 4878: -#include <stdio.h> ! 4879: -#include "../scsi.h" ! 4880: -#include "../scsish.h" ! 4881: -#include "fns.h" ! 4882: -#include <scsi.h> ! 4883: - ! 4884: -int ! 4885: -gen_reset(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4886: -{ ! 4887: - struct scsi_cmd cmd; ! 4888: - struct scsi_return ret; ! 4889: - ! 4890: -#pragma ref niargs ! 4891: -#pragma ref iargs ! 4892: -#pragma ref ncargs ! 4893: -#pragma ref cargs ! 4894: - ! 4895: - set6(cmd, 0, 0, 0, 0, 0, 0); ! 4896: - cmd.bus_id = s_id; ! 4897: - cmd.flags |= SCSI_RESET | SCSI_BRESET; ! 4898: - /* should probably test for some kind of error... */ ! 4899: - ss_io(0, &cmd, 0, &ret, 0, err); ! 4900: - return(0); ! 4901: -} ! 4902: //GO.SYSIN DD scsi/generic/reset.c ! 4903: echo scsi/generic/tur.c 1>&2 ! 4904: sed 's/.//' >scsi/generic/tur.c <<'//GO.SYSIN DD scsi/generic/tur.c' ! 4905: -#include <stdio.h> ! 4906: -#include "../scsi.h" ! 4907: -#include "../scsish.h" ! 4908: -#include "fns.h" ! 4909: - ! 4910: -int ! 4911: -gen_tur(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4912: -{ ! 4913: - struct scsi_cmd cmd; ! 4914: - struct scsi_return ret; ! 4915: - int n; ! 4916: - ! 4917: -#pragma ref ncargs ! 4918: -#pragma ref cargs ! 4919: - ! 4920: - if(niargs == 0) ! 4921: - iargs[0] = 0; ! 4922: - set6(cmd, 0x00, iargs[0]<<5, 0, 0, 0, 0); ! 4923: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 4924: - return(n); ! 4925: - printf("(%d,%d): good status\n", s_id, iargs[0]); ! 4926: - return(0); ! 4927: -} ! 4928: //GO.SYSIN DD scsi/generic/tur.c ! 4929: echo scsi/generic/scsi.c 1>&2 ! 4930: sed 's/.//' >scsi/generic/scsi.c <<'//GO.SYSIN DD scsi/generic/scsi.c' ! 4931: -#include <stdio.h> ! 4932: -#include "../scsi.h" ! 4933: -#include "../scsish.h" ! 4934: -#include "fns.h" ! 4935: - ! 4936: -int ! 4937: -gen_scsi(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4938: -{ ! 4939: - struct scsi_cmd cmd; ! 4940: - struct scsi_return ret; ! 4941: - int n; ! 4942: - ! 4943: -#pragma ref ncargs ! 4944: -#pragma ref cargs ! 4945: - ! 4946: - switch(niargs) ! 4947: - { ! 4948: - case 6: ! 4949: - set6(cmd, iargs[0], iargs[1], iargs[2], iargs[3], iargs[4], iargs[5]); ! 4950: - break; ! 4951: - case 10: ! 4952: - set10(cmd, iargs[0], iargs[1], iargs[2], iargs[3], iargs[4], iargs[5], iargs[6], iargs[7], iargs[8], iargs[9]); ! 4953: - break; ! 4954: - default: ! 4955: - sprintf(err, "number of bytes (%d) must be 6 or 10\n", niargs); ! 4956: - return(1); ! 4957: - } ! 4958: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 4959: - return(n); ! 4960: - return(0); ! 4961: -} ! 4962: //GO.SYSIN DD scsi/generic/scsi.c ! 4963: echo scsi/generic/fns.h 1>&2 ! 4964: sed 's/.//' >scsi/generic/fns.h <<'//GO.SYSIN DD scsi/generic/fns.h' ! 4965: -extern int gen_inq(int, int *, int, char **, char *); ! 4966: -extern int gen_dev(int, int *, int, char **, char *); ! 4967: -extern int gen_help(int, int *, int, char **, char *); ! 4968: -extern int gen_sense(int, int *, int, char **, char *); ! 4969: -extern int gen_start(int, int *, int, char **, char *); ! 4970: -extern int gen_stop(int, int *, int, char **, char *); ! 4971: -extern int gen_capacity(int, int *, int, char **, char *); ! 4972: -extern int gen_display(int, int *, int, char **, char *); ! 4973: -extern int gen_reset(int, int *, int, char **, char *); ! 4974: -extern int gen_tur(int, int *, int, char **, char *); ! 4975: -extern int gen_scsi(int, int *, int, char **, char *); ! 4976: -extern int gen_readt(int, int *, int, char **, char *); ! 4977: -extern int gen_copy(int, int *, int, char **, char *); ! 4978: //GO.SYSIN DD scsi/generic/fns.h ! 4979: echo scsi/generic/readt.c 1>&2 ! 4980: sed 's/.//' >scsi/generic/readt.c <<'//GO.SYSIN DD scsi/generic/readt.c' ! 4981: -#include <stdio.h> ! 4982: -#include "../scsi.h" ! 4983: -#include "../scsish.h" ! 4984: -#include "fns.h" ! 4985: - ! 4986: -int ! 4987: -gen_readt(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 4988: -{ ! 4989: - struct scsi_cmd cmd; ! 4990: - struct scsi_return ret; ! 4991: - int n, i; ! 4992: - unsigned long ns, ss; ! 4993: - long bs, addr; ! 4994: - long t1, t2; ! 4995: - ! 4996: -#pragma ref ncargs ! 4997: -#pragma ref cargs ! 4998: - ! 4999: - if(niargs == 1) ! 5000: - iargs[1] = 0; ! 5001: - set10(cmd, 0x25, iargs[1]<<5, 0, 0, 0, 0, 0, 0, 0, 0); ! 5002: - if(n = s_io(0, &cmd, 0, &ret, 8, err)) ! 5003: - return(n); ! 5004: - ns = longat(&ret.data[0]); ! 5005: - ss = longat(&ret.data[4]); ! 5006: - bs = ss? sizeof(ret.data)/ss : 1; ! 5007: - time(&t1); ! 5008: - srand(t1); ! 5009: - addr = nrand(ns-iargs[0])-1; ! 5010: - printf("read(%d,%d): %d blocks @%d (chunk=%dx%d),", s_id, iargs[1], iargs[0], addr, bs, ss); ! 5011: - fflush(stdout); ! 5012: - time(&t1); ! 5013: - for(i = iargs[0]; i > 0; i -= bs){ ! 5014: - set10(cmd, 0x28, iargs[1]<<5, addr>>24, addr>>16, addr>>8, addr, ! 5015: - 0, 0, bs*0, 0); ! 5016: - if(n = s_io(0, &cmd, 0, &ret, bs*ss, err)) ! 5017: - return(n); ! 5018: - addr += bs; ! 5019: - } ! 5020: - time(&t2); ! 5021: - printf(" t=%ds (%.0fKB/s)\n", t2-t1, (iargs[0]*(float)ss/1024.)/((t1 == t2)? 1:t2-t1)); ! 5022: - return(0); ! 5023: -} ! 5024: //GO.SYSIN DD scsi/generic/readt.c ! 5025: echo scsi/generic/copy.c 1>&2 ! 5026: sed 's/.//' >scsi/generic/copy.c <<'//GO.SYSIN DD scsi/generic/copy.c' ! 5027: -#include <stdio.h> ! 5028: -#include "../scsi.h" ! 5029: -#include "../scsish.h" ! 5030: -#include "fns.h" ! 5031: - ! 5032: -#define PROGRESS \ ! 5033: - if(sbase/TALK != goo){\ ! 5034: - goo = sbase/TALK;\ ! 5035: - time(&t2);\ ! 5036: - printf("\tdoing block %ld at %s", goo*TALK, ctime(&t2));\ ! 5037: - } ! 5038: - ! 5039: -static int copy1(int, int, int, int, int, int, int, char *); ! 5040: - ! 5041: -int ! 5042: -gen_copy(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5043: -{ ! 5044: - int n; ! 5045: - int sdr = 0; ! 5046: - int sbase = iargs[1]; ! 5047: - int nblocks = iargs[2]; ! 5048: - int ddr = 0; ! 5049: - int dbase = iargs[4]; ! 5050: - int starget = iargs[0]; ! 5051: - int dtarget = iargs[3]; ! 5052: - int block = 256; ! 5053: - long nb = nblocks; ! 5054: - long t1, t2; ! 5055: - long goo; ! 5056: - ! 5057: -#define TALK 10000 ! 5058: - extern char *ctime(); ! 5059: - ! 5060: -#pragma ref ncargs ! 5061: -#pragma ref cargs ! 5062: - ! 5063: - if(niargs == 6) ! 5064: - block = iargs[5]; ! 5065: - printf("copying drive (%d,%d)[%d-%d] to drive (%d,%d)[%d-%d] blk=%dK\n", ! 5066: - starget, sdr, sbase, sbase+nblocks-1, ! 5067: - dtarget, ddr, dbase, dbase+nblocks-1, block); ! 5068: - time(&t1); ! 5069: - goo = -1; ! 5070: - while(nblocks > 0){ ! 5071: - n = min(block, nblocks); ! 5072: - printf("writing %d-%d\n", sbase, sbase+n-1);/**/ ! 5073: - if(copy1(starget, sdr, sbase, n, dtarget, ddr, dbase, err)) ! 5074: - break; ! 5075: - sbase += n; ! 5076: - dbase += n; ! 5077: - nblocks -= n; ! 5078: - PROGRESS ! 5079: - } ! 5080: - time(&t2); ! 5081: - t2 -= t1; ! 5082: - if(t2 == 0) t2 = 1; ! 5083: - printf("%ds: ", t2); ! 5084: - if(nblocks){ ! 5085: - printf("copy buggered up: sbase=%d nblks=%d dbase=%d\n", ! 5086: - sbase, nblocks, dbase); ! 5087: - return(1); ! 5088: - } ! 5089: - printf("%d blocks at %.1fKB/s\n", nb, nb/(float)t2); ! 5090: - return(0); ! 5091: -} ! 5092: - ! 5093: -static int ! 5094: -copy1(int st, int sd, int sb, int n, int dt, int dd, int db, char *err) ! 5095: -{ ! 5096: - struct scsi_cmd cmd; ! 5097: - struct scsi_return ret; ! 5098: - ! 5099: - set6(cmd, 0x18, sd<<5, 0, 0, 20, 0); ! 5100: - cmd.data[0] = 0x10; /* copy */ ! 5101: - cmd.data[1] = 0; ! 5102: - cmd.data[2] = 0; ! 5103: - cmd.data[3] = 0; ! 5104: - cmd.data[4] = (st<<5)|sd; ! 5105: - cmd.data[5] = (dt<<5)|dd; ! 5106: - cmd.data[6] = 0; ! 5107: - cmd.data[7] = 0; ! 5108: - cmd.data[8] = n>>24; ! 5109: - cmd.data[9] = n>>16; ! 5110: - cmd.data[10] = n>>8; ! 5111: - cmd.data[11] = n; ! 5112: - cmd.data[12] = sb>>24; ! 5113: - cmd.data[13] = sb>>16; ! 5114: - cmd.data[14] = sb>>8; ! 5115: - cmd.data[15] = sb; ! 5116: - cmd.data[16] = db>>24; ! 5117: - cmd.data[17] = db>>16; ! 5118: - cmd.data[18] = db>>8; ! 5119: - cmd.data[19] = db; ! 5120: - return(s_io(0, &cmd, 20, &ret, 0, err)); ! 5121: -} ! 5122: //GO.SYSIN DD scsi/generic/copy.c ! 5123: echo scsi/sony/dev.c 1>&2 ! 5124: sed 's/.//' >scsi/sony/dev.c <<'//GO.SYSIN DD scsi/sony/dev.c' ! 5125: -#include <stdio.h> ! 5126: -#include "../scsi.h" ! 5127: -#include "../scsish.h" ! 5128: -#include "fns.h" ! 5129: - ! 5130: -static Function fns[] = { ! 5131: - { "alternate", "alternate [lun]", "L?", sony_alt }, ! 5132: - { "config", "config", "", sony_conf }, ! 5133: - { "copy", "copy srclun start n destlun dest", "LIILI", sony_copy }, ! 5134: - { "diskid", "diskid [lun]", "L?", sony_diskid }, ! 5135: - { "eject", "eject lun", "L", sony_eject }, ! 5136: - { "inq", "inq [lun]", "L?", sony_inq }, ! 5137: - { "internal", "internal test [drive] # internal -1 for list", "II?", sony_internal }, ! 5138: - { "media", "media lun start count [file]", "LIIS?", sony_media }, ! 5139: - { "readid", "readid lun [start]", "LI?", sony_readid }, ! 5140: - { "rel", "rel lun [shelfside]", "LS?", sony_rel }, ! 5141: - { "sense", "sense [lun=0]", "L?", sony_sense }, ! 5142: - { "set", "set shelfside lun", "SL", sony_set }, ! 5143: - { "status", "status", "", sony_status }, ! 5144: - { 0 } ! 5145: -}; ! 5146: - ! 5147: -Device sonydev = { ! 5148: - "sony", "Sony WDA-3000", ! 5149: - sony_extsense, ! 5150: - fns ! 5151: -}; ! 5152: //GO.SYSIN DD scsi/sony/dev.c ! 5153: echo scsi/sony/inq.c 1>&2 ! 5154: sed 's/.//' >scsi/sony/inq.c <<'//GO.SYSIN DD scsi/sony/inq.c' ! 5155: -#include <stdio.h> ! 5156: -#include "../scsi.h" ! 5157: -#include "../scsish.h" ! 5158: -#include "fns.h" ! 5159: - ! 5160: -int ! 5161: -sony_inq(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5162: -{ ! 5163: - struct scsi_cmd cmd; ! 5164: - struct scsi_return ret; ! 5165: - int n, i; ! 5166: - ! 5167: -#pragma ref ncargs ! 5168: -#pragma ref cargs ! 5169: - ! 5170: - if(niargs == 0) ! 5171: - for(niargs = 0; niargs < 8; niargs++) ! 5172: - iargs[niargs] = niargs; ! 5173: - for(i = 0; i < niargs; i++){ ! 5174: - set6(cmd, 0x12, iargs[i]<<5, 0, 0, 6, 0); ! 5175: - if(n = s_io(0, &cmd, 0, &ret, 6, err)) ! 5176: - return(n); ! 5177: - printf("inq(%d,%d): ", s_id, iargs[i]); ! 5178: - if(ret.data[5]&0x80) ! 5179: - printf("power off (0x%x)\n", ret.data[5]&0xFF); ! 5180: - else if(ret.data[5]&0x40) ! 5181: - printf("empty (0x%x)\n", ret.data[5]&0xFF); ! 5182: - else ! 5183: - printf("%s,%s,%s,%s (0x%x)\n", ! 5184: - (ret.data[5]&0x08)?"write protect":"writable", ! 5185: - (ret.data[5]&0x04)?"no alternate":"", ! 5186: - (ret.data[5]&0x02)?"drive error":"", ! 5187: - (ret.data[5]&0x01)?"ready":"not ready", ! 5188: - ret.data[5]&0xFF); ! 5189: - } ! 5190: - return(0); ! 5191: -} ! 5192: //GO.SYSIN DD scsi/sony/inq.c ! 5193: echo scsi/sony/alt.c 1>&2 ! 5194: sed 's/.//' >scsi/sony/alt.c <<'//GO.SYSIN DD scsi/sony/alt.c' ! 5195: -#include <stdio.h> ! 5196: -#include "../scsi.h" ! 5197: -#include "../scsish.h" ! 5198: -#include "fns.h" ! 5199: - ! 5200: -static ! 5201: -table(int drive, int tab, uchar *data) ! 5202: -{ ! 5203: - int n, i; ! 5204: - ! 5205: - n = data[6]; ! 5206: - printf("(%d,%d): alternate table %d (%d entries)\n", s_id, drive, tab, n); ! 5207: - for(data += 0x18, i = 0; i < n; data += 4, i++) ! 5208: - printf("%ld%c", data[0]+256L*data[1]+256L*256*data[2], ! 5209: - (i%10 == 9)? '\n':' '); ! 5210: - if((i%10) && n) ! 5211: - putchar('\n'); ! 5212: -} ! 5213: - ! 5214: -int ! 5215: -sony_alt(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5216: -{ ! 5217: - struct scsi_cmd cmd; ! 5218: - struct scsi_return ret; ! 5219: - int n, i; ! 5220: - ! 5221: -#pragma ref ncargs ! 5222: -#pragma ref cargs ! 5223: - ! 5224: - if(niargs == 0) ! 5225: - iargs[0] = 0; ! 5226: - set6(cmd, 0xC3, iargs[0]<<5, 0, 0, 0, 0); ! 5227: - if(n = s_io(0, &cmd, 0, &ret, 4096, err)) ! 5228: - return(n); ! 5229: - for(i = 0; i < 4; i++) ! 5230: - table(iargs[0], i+1, &ret.data[1024*i]); ! 5231: - return(0); ! 5232: -} ! 5233: //GO.SYSIN DD scsi/sony/alt.c ! 5234: echo scsi/sony/config.c 1>&2 ! 5235: sed 's/.//' >scsi/sony/config.c <<'//GO.SYSIN DD scsi/sony/config.c' ! 5236: -#include <stdio.h> ! 5237: -#include "../scsi.h" ! 5238: -#include "../scsish.h" ! 5239: -#include "fns.h" ! 5240: - ! 5241: -static char mtab[5][2] = ! 5242: -{ ! 5243: - '0', '0', '1', '1', '1', '2', '2', '2', '?', '?' ! 5244: -}; ! 5245: -static char *brdname[] = { ! 5246: - "no doard", "T.D. Systems Viking", "U.S. Design 1158" ! 5247: -}; ! 5248: - ! 5249: -int ! 5250: -sony_conf(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5251: -{ ! 5252: - struct scsi_cmd cmd; ! 5253: - struct scsi_return ret; ! 5254: - int n, i; ! 5255: - char buf[512]; ! 5256: - ! 5257: -#pragma ref niargs ! 5258: -#pragma ref iargs ! 5259: -#pragma ref ncargs ! 5260: -#pragma ref cargs ! 5261: - ! 5262: - set6(cmd, 0x12, 0, 0, 0, 44, 0); ! 5263: - if(n = s_io(0, &cmd, 0, &ret, 44, err)) ! 5264: - return(n); ! 5265: - i = min(ret.data[37], 4); ! 5266: - fixedstr(&ret.data[8], 28, buf); ! 5267: - printf("config(%d,%d): %s device, '%s', %c controller%s, %c drive%s\n", ! 5268: - s_id, 0, (ret.data[0] == 0x4)? "WORM":"Unknown", ! 5269: - buf, mtab[i][0], (mtab[i][0] == '1')?"":"s", ! 5270: - mtab[i][1], (mtab[i][1] == '1')?"":"s"); ! 5271: - printf("\tUnibus-SCSI controller=%s\n", brdname[ret.type]); ! 5272: - printf("\tROMS:"); ! 5273: - if(ret.data[38] != 0xFF) ! 5274: - printf(" upper controller=0x%x,", ret.data[38]); ! 5275: - if(ret.data[40] != 0xFF) ! 5276: - printf(" lower controller=0x%x,", ret.data[40]); ! 5277: - printf( " IF-129=0x%x, SY-46=0x%x, SS-30=0x%x\n", ret.data[36], ! 5278: - ret.data[42], ret.data[43]); ! 5279: - return(0); ! 5280: -} ! 5281: //GO.SYSIN DD scsi/sony/config.c ! 5282: echo scsi/sony/status.c 1>&2 ! 5283: sed 's/.//' >scsi/sony/status.c <<'//GO.SYSIN DD scsi/sony/status.c' ! 5284: -#include <stdio.h> ! 5285: -#include "../scsi.h" ! 5286: -#include "../scsish.h" ! 5287: - ! 5288: -static ! 5289: -shelf(int i) ! 5290: -{ ! 5291: - printf(": "); ! 5292: - if(i&0x80){ ! 5293: - printf("%s,", (i&0x40)? "disk":"temporary"); ! 5294: - if(i&0x10) printf("wait loading,"); ! 5295: - if(i&0x08) printf("wait ejection,"); ! 5296: - if(i&0x20) printf("use shelf instead of drive for LUN %d", i&7); ! 5297: - } else ! 5298: - printf("no disk"); ! 5299: - printf("\n"); ! 5300: -} ! 5301: - ! 5302: -int ! 5303: -sony_istatus(struct scsi_return *ret, char *err) ! 5304: -{ ! 5305: - struct scsi_cmd cmd; ! 5306: - int n; ! 5307: - ! 5308: - set6(cmd, 0x1D, 0, 0, 0, 10, 0); ! 5309: - cmd.data[0] = 0xE2; /* internal status */ ! 5310: - cmd.data[1] = 0; ! 5311: - cmd.data[2] = 0; ! 5312: - cmd.data[3] = 0; ! 5313: - cmd.data[4] = 0; ! 5314: - cmd.data[5] = 0; ! 5315: - cmd.data[6] = 0; ! 5316: - cmd.data[7] = 0; ! 5317: - cmd.data[8] = 0; ! 5318: - cmd.data[9] = 0; ! 5319: - if(n = s_io(0, &cmd, 10, ret, 0, err)) ! 5320: - return(n); ! 5321: - setdiag(cmd, 0, 128); ! 5322: - if(n = s_io(0, &cmd, 0, ret, 128, err)) ! 5323: - return(n); ! 5324: - return(0); ! 5325: -} ! 5326: - ! 5327: -int ! 5328: -sony_status(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5329: -{ ! 5330: - struct scsi_return ret; ! 5331: - int n, i, start; ! 5332: - uchar *d; ! 5333: - ! 5334: -#pragma ref niargs ! 5335: -#pragma ref iargs ! 5336: -#pragma ref ncargs ! 5337: -#pragma ref cargs ! 5338: - ! 5339: - if(n = sony_istatus(&ret, err)) ! 5340: - return(n); ! 5341: - d = &ret.data[16]; ! 5342: - for(i = 0; i < 8; i++, d += 4){ ! 5343: - printf("drive %d: %sready,%sdisk in LUN,power %s,", i, ! 5344: - (d[0]&1)?"":"not ", (d[0]&0x40)?"":"no ", ! 5345: - (d[0]&0x80)?"off":"on"); ! 5346: - if(d[0]&0x40){ ! 5347: - if(d[1]&0x80){ ! 5348: - printf("disk in drive %d", d[1]&0x7f); ! 5349: - if(d[2]&0x80) ! 5350: - printf(", return shelf %d%c", (d[2]&0x7F)/2, "ab"[d[2]&1]); ! 5351: - } else ! 5352: - printf("disk in shelf %d%c (%d)", (d[1]&0x7f)/2, (d[1]&1)+'a', d[1]&0x7f); ! 5353: - } ! 5354: - printf("\n"); ! 5355: - } ! 5356: - for(i = 0; i < 50;){ ! 5357: - for(start = i; ++i < 50;) ! 5358: - if(d[i] != d[start]) ! 5359: - break; ! 5360: - if(i == start+1) ! 5361: - printf("%d", start); ! 5362: - else ! 5363: - printf("%d-%d", start, i-1); ! 5364: - shelf(d[start]); ! 5365: - } ! 5366: - d += 50; ! 5367: - printf("I/O shelf"); ! 5368: - shelf(*d); ! 5369: - d++; ! 5370: - printf("carrier: "); ! 5371: - i = *d&0x7F; ! 5372: - if(*d&0x80) ! 5373: - printf("disk shelf=%d%c (%d)\n", i/2, 'a'+(i&1), i); ! 5374: - else ! 5375: - printf("no disk\n"); ! 5376: - d++; ! 5377: - if(*d&0x80) ! 5378: - printf("upper drive: disk, LUN=%d\n", *d&7); ! 5379: - else ! 5380: - printf("upper drive: no disk\n"); ! 5381: - d++; ! 5382: - if(*d&0x80) ! 5383: - printf("lower drive: disk, LUN=%d\n", *d&7); ! 5384: - else ! 5385: - printf("lower drive: no disk\n"); ! 5386: - return(0); ! 5387: -} ! 5388: //GO.SYSIN DD scsi/sony/status.c ! 5389: echo scsi/sony/rel.c 1>&2 ! 5390: sed 's/.//' >scsi/sony/rel.c <<'//GO.SYSIN DD scsi/sony/rel.c' ! 5391: -#include <stdio.h> ! 5392: -#include "../scsi.h" ! 5393: -#include "../scsish.h" ! 5394: -#include "fns.h" ! 5395: - ! 5396: -int ! 5397: -sony_rel(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5398: -{ ! 5399: - struct scsi_cmd cmd; ! 5400: - struct scsi_return ret; ! 5401: - int n, i, j; ! 5402: - ! 5403: -#pragma ref niargs ! 5404: - ! 5405: - if(ncargs == 0){ ! 5406: - i = 0; ! 5407: - j = 0; /* its ignored anyway */ ! 5408: - } else { ! 5409: - i = 1; ! 5410: - if((j = shelfside(cargs[0], err)) < 0) ! 5411: - return(1); ! 5412: - } ! 5413: - set6(cmd, 0xD7, (iargs[0]<<5)|i, 0, j, 0, 0); ! 5414: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 5415: - return(n); ! 5416: - return(0); ! 5417: -} ! 5418: //GO.SYSIN DD scsi/sony/rel.c ! 5419: echo scsi/sony/set.c 1>&2 ! 5420: sed 's/.//' >scsi/sony/set.c <<'//GO.SYSIN DD scsi/sony/set.c' ! 5421: -#include <stdio.h> ! 5422: -#include "../scsi.h" ! 5423: -#include "../scsish.h" ! 5424: -#include "fns.h" ! 5425: - ! 5426: -int ! 5427: -sony_set(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5428: -{ ! 5429: - struct scsi_cmd cmd; ! 5430: - struct scsi_return ret; ! 5431: - int n, i; ! 5432: - ! 5433: -#pragma ref niargs ! 5434: -#pragma ref ncargs ! 5435: - ! 5436: - if((i = shelfside(cargs[0], err)) < 0) ! 5437: - return(1); ! 5438: - set6(cmd, 0xD6, iargs[0]<<5, 0, i, 0, 0); ! 5439: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 5440: - return(n); ! 5441: - return(0); ! 5442: -} ! 5443: //GO.SYSIN DD scsi/sony/set.c ! 5444: echo scsi/sony/eject.c 1>&2 ! 5445: sed 's/.//' >scsi/sony/eject.c <<'//GO.SYSIN DD scsi/sony/eject.c' ! 5446: -#include <stdio.h> ! 5447: -#include "../scsi.h" ! 5448: -#include "../scsish.h" ! 5449: -#include "fns.h" ! 5450: - ! 5451: -int ! 5452: -sony_eject(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5453: -{ ! 5454: - struct scsi_cmd cmd; ! 5455: - struct scsi_return ret; ! 5456: - int n; ! 5457: - ! 5458: -#pragma ref niargs ! 5459: -#pragma ref ncargs ! 5460: -#pragma ref cargs ! 5461: - ! 5462: - set6(cmd, 0xC0, iargs[0]<<5, 0, 0, 0, 0); ! 5463: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 5464: - return(n); ! 5465: - return(0); ! 5466: -} ! 5467: //GO.SYSIN DD scsi/sony/eject.c ! 5468: echo scsi/sony/shelfside.c 1>&2 ! 5469: sed 's/.//' >scsi/sony/shelfside.c <<'//GO.SYSIN DD scsi/sony/shelfside.c' ! 5470: -#include <stdio.h> ! 5471: -#include "../scsi.h" ! 5472: -#include "../scsish.h" ! 5473: -#include "fns.h" ! 5474: - ! 5475: -int ! 5476: -shelfside(char *arg, char *err) ! 5477: -{ ! 5478: - char *oarg = arg; ! 5479: - int shelf; ! 5480: - ! 5481: - if((*arg < '0') || (*arg > '9')){ ! 5482: -usage: ! 5483: - sprintf(err, "shelfside '%s' must be numa or numb", oarg); ! 5484: - return(-1); ! 5485: - } ! 5486: - shelf = 0; ! 5487: - while((*arg >= '0') && (*arg <= '9')) ! 5488: - shelf = 10*shelf + *arg++ - '0'; ! 5489: - shelf <<= 1; ! 5490: - if(*arg == 'a') ! 5491: - ; ! 5492: - else if(*arg == 'b') ! 5493: - shelf |= 1; ! 5494: - else ! 5495: - goto usage; ! 5496: - if(*++arg) ! 5497: - goto usage; ! 5498: - return(shelf); ! 5499: -} ! 5500: //GO.SYSIN DD scsi/sony/shelfside.c ! 5501: echo scsi/sony/diskid.c 1>&2 ! 5502: sed 's/.//' >scsi/sony/diskid.c <<'//GO.SYSIN DD scsi/sony/diskid.c' ! 5503: -#include <stdio.h> ! 5504: -#include "../scsi.h" ! 5505: -#include "../scsish.h" ! 5506: -#include "fns.h" ! 5507: - ! 5508: -int ! 5509: -sony_diskid(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5510: -{ ! 5511: - struct scsi_cmd cmd; ! 5512: - struct scsi_return ret; ! 5513: - int n; ! 5514: - ! 5515: -#pragma ref ncargs ! 5516: -#pragma ref cargs ! 5517: - ! 5518: - if(niargs == 0) ! 5519: - iargs[0] = 0; ! 5520: - set6(cmd, 0xC2, iargs[0]<<5, 0, 0, 0, 0); ! 5521: - if(n = s_io(0, &cmd, 0, &ret, 1024, err)) ! 5522: - return(n); ! 5523: - printf("(%d,%d) disk id block:\n", s_id, iargs[0]); ! 5524: - xd(ret.data, 1024, stdout); ! 5525: - return(0); ! 5526: -} ! 5527: //GO.SYSIN DD scsi/sony/diskid.c ! 5528: echo scsi/sony/internal.c 1>&2 ! 5529: sed 's/.//' >scsi/sony/internal.c <<'//GO.SYSIN DD scsi/sony/internal.c' ! 5530: -#include <stdio.h> ! 5531: -#include "../scsi.h" ! 5532: -#include "../scsish.h" ! 5533: -#include "fns.h" ! 5534: - ! 5535: -static ! 5536: -internal(int n, int b1, int nb, struct scsi_return *ret, char *err) ! 5537: -{ ! 5538: - struct scsi_cmd cmd; ! 5539: - ! 5540: - set6(cmd, 0x1D, b1, 0, 0, 10, 0); ! 5541: - cmd.data[0] = n; ! 5542: - cmd.data[1] = b1>>8; ! 5543: - cmd.data[2] = 0; ! 5544: - cmd.data[3] = 0; ! 5545: - cmd.data[4] = 0; ! 5546: - cmd.data[5] = 0; ! 5547: - cmd.data[6] = 0; ! 5548: - cmd.data[7] = 0; ! 5549: - cmd.data[8] = 0; ! 5550: - cmd.data[9] = 0; ! 5551: - if(n = s_io(0, &cmd, 10, ret, 0, err)) ! 5552: - return(n); ! 5553: - setdiag(cmd, 0, nb); ! 5554: - if(n = s_io(0, &cmd, 0, ret, nb, err)) ! 5555: - return(n); ! 5556: - return(0); ! 5557: -} ! 5558: - ! 5559: -static char *cmds[] = { ! 5560: - "internal command table", ! 5561: - "error information table", ! 5562: - "arm controller diagnostics", ! 5563: - "scsi control board diagnostics", ! 5564: - "drive controller diagnostics", ! 5565: - "jukebox status", ! 5566: - 0 ! 5567: -}; ! 5568: - ! 5569: -static char *msg1[16] = ! 5570: -{ ! 5571: - "drive not connected or powered off", ! 5572: - "drive connected but no disk", ! 5573: - "diagnostic aborted: write-protect", ! 5574: - "diagnostic aborted: write area full", ! 5575: - "urk 4", "urk 5", "urk 6", "urk 7", "urk 8", "urk 9", "urk 10", ! 5576: - "urk 11", "urk 12", "urk 13", "urk 14", "urk 15" ! 5577: -}; ! 5578: - ! 5579: -static char *testn[10] = ! 5580: -{ ! 5581: - "drive on/off", ! 5582: - "read disk id", ! 5583: - "move", ! 5584: - "seek", ! 5585: - "blank sector search", ! 5586: - "written sector search", ! 5587: - "search writable area", ! 5588: - "write", ! 5589: - "ECC margin check", ! 5590: - "read data compare" ! 5591: -}; ! 5592: - ! 5593: -int ! 5594: -sony_internal(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5595: -{ ! 5596: - struct scsi_cmd cmd; ! 5597: - struct scsi_return ret; ! 5598: - int n; ! 5599: - register unsigned char *d; ! 5600: - int i, drive, lower; ! 5601: - long t1, t2; ! 5602: - extern char *cmesg[]; ! 5603: - extern char *i0com[], *i1err[], *scsicmd[], *busid[], *scsiident[]; ! 5604: - ! 5605: -#pragma ref ncargs ! 5606: -#pragma ref cargs ! 5607: - ! 5608: - switch(iargs[0]) ! 5609: - { ! 5610: - case -1: ! 5611: - printf("available internal commands:\n"); ! 5612: - for(i = 0; cmds[i]; i++) ! 5613: - printf("\tinternal %d: %s\n", i, cmds[i]); ! 5614: - break; ! 5615: - case 0: ! 5616: - if(internal(0xE5, 0, 256, &ret, err)) ! 5617: - return(1); ! 5618: - printf("internal 0 (%s):\n", cmds[iargs[0]]); ! 5619: - printf("Diagnostic #E5: last 16 internal tasks (drive,shelf)\n"); ! 5620: - for(i = 0, d = ret.data; i < 16; i++, d += 16){ ! 5621: - printf("[%d] %s (%d,%d)\n", ! 5622: - d[0], i0com[d[1]], d[2], d[3]); ! 5623: - } ! 5624: - break; ! 5625: - case 1: ! 5626: - if(internal(0xE4, 0, 256, &ret, err)) ! 5627: - return(1); ! 5628: - printf("internal 1 (%s):\n", cmds[iargs[0]]); ! 5629: - printf("Diagnostic #E4: last 16 errors; initiator[identify] error[sense] (cmd)\n"); ! 5630: - for(i = 0, d = ret.data; i < 16; i++, d += 16){ ! 5631: - printf("%s[%s]: %s[#%x] (%s)\n", ! 5632: - busid[d[0]], scsiident[d[1]], i1err[d[14]], d[15], scsicmd[d[4]]); ! 5633: - } ! 5634: - break; ! 5635: - case 2: ! 5636: - printf("internal 2 (%s):\n", cmds[iargs[0]]); ! 5637: - fflush(stdout); ! 5638: - time(&t1); ! 5639: - if(internal(0x90, 0, 8, &ret, err)) ! 5640: - return(1); ! 5641: - time(&t2); ! 5642: - d = ret.data; ! 5643: - if(d[0] == 0) ! 5644: - printf("\tended normally"); ! 5645: - else ! 5646: - printf("\tfailed, error codes=#%x, #%x, #%x", ! 5647: - d[0], d[1], d[2]); ! 5648: - printf(" (time: %lds)\n", t2-t1); ! 5649: - break; ! 5650: - case 3: ! 5651: - printf("internal 3 (%s):\n", cmds[iargs[0]]); ! 5652: - fflush(stdout); ! 5653: - time(&t1); ! 5654: - if(internal(0xe0, 0, 8, &ret, err)) ! 5655: - return(1); ! 5656: - time(&t2); ! 5657: - d = ret.data; ! 5658: - if(d[0] == 0) ! 5659: - printf("\tended normally"); ! 5660: - else ! 5661: - printf("\tfailed, error codes=#%x, #%x, #%x", ! 5662: - d[0], d[1], d[2]); ! 5663: - printf(" (time: %lds)\n", t2-t1); ! 5664: - break; ! 5665: - case 4: ! 5666: - if(niargs == 1) ! 5667: - iargs[1] = 0; /* zero default */ ! 5668: - drive = iargs[1]; ! 5669: - if(sony_istatus(&ret, err)) ! 5670: - return(1); ! 5671: - if((ret.data[100]&0x80) && (drive == (ret.data[100]&7))) ! 5672: - lower = 0x100; ! 5673: - else if((ret.data[101]&0x80) && (drive == (ret.data[101]&7))) ! 5674: - lower = 0x200; ! 5675: - else { ! 5676: - fprintf(stderr, "drive %d not occupied\n", drive); ! 5677: - return(1); ! 5678: - } ! 5679: - printf("drive %d[%ser]: %s\n", drive, (lower == 0x200)?"low":"upp", cmds[iargs[0]]); ! 5680: - fflush(stdout); ! 5681: - time(&t1); ! 5682: - if(internal(0x18, lower, 256, &ret, err)) ! 5683: - return(1); ! 5684: - time(&t2); ! 5685: - d = ret.data; ! 5686: - if(d[1]&0x80){ ! 5687: - printf("diagnostic result:"); ! 5688: - if((d[1]&0x70) == 0) ! 5689: - printf(" no faults"); ! 5690: - else { ! 5691: - if(d[1]&0x10) ! 5692: - printf(" controller-fault"); ! 5693: - if(d[1]&0x20) ! 5694: - printf(" drive-fault"); ! 5695: - if(d[1]&0x10) ! 5696: - printf(" disk-fault"); ! 5697: - printf(" (last error code 0x%2.2ux)", d[4]); ! 5698: - } ! 5699: - } else ! 5700: - printf("diagnostic not performed: %s", msg1[d[1]&0xF]); ! 5701: - printf(" (time: %lds)\n", t2-t1); ! 5702: - for(i = 0; i < 10; i++) ! 5703: - printf("test %d[%s]: %s\n", i, testn[i], cmesg[d[i*8+drive+8]]); ! 5704: - printf("diagnostic count (drive:avail):"); ! 5705: - for(d += 104, i = 0; i < 8; i++, d += 2) ! 5706: - printf(" %d:%d", i, d[0]+d[1]*256); ! 5707: - printf("\n"); ! 5708: - break; ! 5709: - case 5: ! 5710: - set10(cmd, 0xD3, 0, 0, 0, 0, 0, 0, 0, 0, 0); ! 5711: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 5712: - return(n); ! 5713: - printf("%s: component(fatal err/err/cmds)\n", cmds[iargs[0]]); ! 5714: - d = ret.data; ! 5715: -#define ONE(str, x, sep) printf("%s(%d/%d/%d)%c", str, d[x+3], d[x+2], d[x+1]+256*d[x], sep) ! 5716: - ! 5717: - ONE("upper drive", 4, ' '); ! 5718: - ONE("lower drive", 8, ' '); ! 5719: - ONE("sys control", 12, ' '); ! 5720: - printf("backup mem(0/%d/%d)\n", d[19]+256*d[18], d[17]+256*d[16]); ! 5721: - break; ! 5722: - } ! 5723: - return(0); ! 5724: -} ! 5725: //GO.SYSIN DD scsi/sony/internal.c ! 5726: echo scsi/sony/i0.tab 1>&2 ! 5727: sed 's/.//' >scsi/sony/i0.tab <<'//GO.SYSIN DD scsi/sony/i0.tab' ! 5728: -i0com ! 5729: -00 nop ! 5730: -01 sense result ! 5731: -02 version check ! 5732: -04 recover disk warning ! 5733: -08 sense alternate information ! 5734: -0a error margin check ! 5735: -18 diagnostics ! 5736: -20 sense drive status ! 5737: -21 recalibrate ! 5738: -22 drive on ! 5739: -23 drive off ! 5740: -24 disk out ! 5741: -30 seek ! 5742: -31 move ! 5743: -32 read ! 5744: -a1 disk check ! 5745: -a2 carrier move ! 5746: -b1 disk set ! 5747: -b2 disk release ! 5748: -b3 disk rotate ! 5749: //GO.SYSIN DD scsi/sony/i0.tab ! 5750: echo scsi/sony/i1.tab 1>&2 ! 5751: sed 's/.//' >scsi/sony/i1.tab <<'//GO.SYSIN DD scsi/sony/i1.tab' ! 5752: -i1err ! 5753: -94 drive error (SONY) ! 5754: -a0 invalid command ! 5755: -a1 invalid LUN ! 5756: -a2 reserved bit nonzero ! 5757: -a3 illegal logical address ! 5758: -a4 illegal shelf number ! 5759: -a5 illegal parameter length ! 5760: -a6 illegal parameter ! 5761: -a7 unacceptable diagnostics parameter ! 5762: -a8 unit attention ! 5763: -a9 drive not ready ! 5764: -aa medium removal prevented ! 5765: -ab reserved ! 5766: -ac no disk in LUN ! 5767: //GO.SYSIN DD scsi/sony/i1.tab ! 5768: echo scsi/sony/scsi.tab 1>&2 ! 5769: sed 's/.//' >scsi/sony/scsi.tab <<'//GO.SYSIN DD scsi/sony/scsi.tab' ! 5770: -scsicmd ! 5771: -00 test unit ready ! 5772: -01 rezero unit ! 5773: -03 request sense ! 5774: -08 read ! 5775: -0a write ! 5776: -0b seek ! 5777: -0c move ! 5778: -12 inquiry ! 5779: -15 mode select ! 5780: -16 reserve ! 5781: -17 release ! 5782: -18 copy ! 5783: -1a mode sense ! 5784: -1b start/stop unit ! 5785: -1c receive diagnostics ! 5786: -1d send diagnostics ! 5787: -1e prevent/allow medium removal ! 5788: -25 read capacity ! 5789: -28 read ! 5790: -2a write ! 5791: -2c blank sector search ! 5792: -2d written sector search ! 5793: -c0 disk eject ! 5794: -c2 read disk id ! 5795: -c3 sense alternate information ! 5796: -c4 recover disk warning ! 5797: -d3 request recovered status ! 5798: -d6 disk set ! 5799: -d7 disk release ! 5800: -busid ! 5801: -01 0 ! 5802: -02 1 ! 5803: -80 7 ! 5804: -scsiident ! 5805: -80 no dis/reconnect-LUN 0 ! 5806: -81 no dis/reconnect-LUN 1 ! 5807: -82 no dis/reconnect-LUN 2 ! 5808: -83 no dis/reconnect-LUN 3 ! 5809: -84 no dis/reconnect-LUN 4 ! 5810: -85 no dis/reconnect-LUN 5 ! 5811: -86 no dis/reconnect-LUN 6 ! 5812: -87 no dis/reconnect-LUN 7 ! 5813: -c0 dis/reconnect-LUN 0 ! 5814: -c1 dis/reconnect-LUN 1 ! 5815: -c2 dis/reconnect-LUN 2 ! 5816: -c3 dis/reconnect-LUN 3 ! 5817: -c4 dis/reconnect-LUN 4 ! 5818: -c5 dis/reconnect-LUN 5 ! 5819: -c6 dis/reconnect-LUN 6 ! 5820: -c7 dis/reconnect-LUN 7 ! 5821: -cmesg ! 5822: -0 good ! 5823: -e0 test not done ! 5824: -ee diagnostic could not be done ! 5825: -fe drive not ready (no disk) ! 5826: -ff not connected or power off ! 5827: //GO.SYSIN DD scsi/sony/scsi.tab ! 5828: echo scsi/sony/media.c 1>&2 ! 5829: sed 's/.//' >scsi/sony/media.c <<'//GO.SYSIN DD scsi/sony/media.c' ! 5830: -#include <stdio.h> ! 5831: -#include <stddef.h> ! 5832: -#include "../scsi.h" ! 5833: -#include "../scsish.h" ! 5834: -#include "fns.h" ! 5835: - ! 5836: -static int cnts[256]; ! 5837: -static char *cmsg[256]; ! 5838: - ! 5839: -sony_media1(int drive, long lbn, int lower, struct scsi_return *ret, char *err) ! 5840: -{ ! 5841: - struct scsi_cmd cmd; ! 5842: - int n; ! 5843: - ! 5844: - set6(cmd, 0x1D, drive<<5, 0, 0, 10, 0); ! 5845: - cmd.data[0] = 0x0A; /* error margin check */ ! 5846: - cmd.data[1] = lower? 2:1; ! 5847: - cmd.data[2] = 0; ! 5848: - cmd.data[3] = 0; ! 5849: - cmd.data[4] = drive; ! 5850: - cmd.data[5] = lbn; ! 5851: - cmd.data[6] = lbn>>8; ! 5852: - cmd.data[7] = lbn>>16; ! 5853: - cmd.data[8] = 0; ! 5854: - cmd.data[9] = 0; ! 5855: - if(n = s_io(0, &cmd, 10, ret, 0, err)) ! 5856: - return(n); ! 5857: - setdiag(cmd, drive, 256); ! 5858: - if(n = s_io(0, &cmd, 0, ret, 256, err)) ! 5859: - return(n); ! 5860: - return(0); ! 5861: -} ! 5862: - ! 5863: -int ! 5864: -sony_media(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5865: -{ ! 5866: - struct scsi_return ret; ! 5867: - uchar *d; ! 5868: - int bn, c; ! 5869: - char buf[256]; ! 5870: - int lower; ! 5871: - int nline; ! 5872: - int cur, curb; ! 5873: - int drive = iargs[0]; ! 5874: - long lbn = iargs[1]; ! 5875: - int count = iargs[2]; ! 5876: - extern char *strdup(char *); ! 5877: - int verbose = 0; ! 5878: - FILE *fp = 0; ! 5879: - ! 5880: -#pragma ref niargs ! 5881: - ! 5882: - if(ncargs == 1){ ! 5883: - if(strcmp(cargs[0], "-v") == 0) ! 5884: - verbose = 1; ! 5885: - else if((fp = fopen(cargs[0], "w")) == NULL){ ! 5886: - pperror(err, cargs[0]); ! 5887: - return(1); ! 5888: - } ! 5889: - } ! 5890: - if(sony_istatus(&ret, err)) ! 5891: - return(1); ! 5892: - if((ret.data[100]&0x80) && (drive == (ret.data[100]&7))) ! 5893: - lower = 0; ! 5894: - else if((ret.data[101]&0x80) && (drive == (ret.data[101]&7))) ! 5895: - lower = 1; ! 5896: - else { ! 5897: - sprintf(err, "drive %d not occupied and ready\n", drive); ! 5898: - return(1); ! 5899: - } ! 5900: - printf("media margin check for %d blocks [%d-%d] on %s drive (%d,%d):", ! 5901: - count, lbn, lbn+count-1, lower? "lower":"upper", s_id, drive); ! 5902: - if(fp) ! 5903: - printf(" stored in '%s'", cargs[0]); ! 5904: - putchar('\n'); ! 5905: - if(cmsg[0] == 0){ ! 5906: - for(bn = 0; bn < 256; bn++){ ! 5907: - sprintf(buf, "rare error 0x%x", bn); ! 5908: - cmsg[bn] = strdup(buf); ! 5909: - } ! 5910: - cmsg[0] = "good"; ! 5911: - cmsg[0x40] = "seek error 1 (alternated)"; ! 5912: - cmsg[0x41] = "seek error 2 (alternated)"; ! 5913: - cmsg[0x42] = "seek error 3 (alternated)"; ! 5914: - cmsg[0x44] = "read error 1 (alternated)"; ! 5915: - cmsg[0x45] = "unwritten"; ! 5916: - cmsg[0x46] = "read error 3 (alternated)"; ! 5917: - cmsg[0x81] = "<50% burst"; ! 5918: - cmsg[0x82] = "50-96% burst (alternated)"; ! 5919: - cmsg[0x83] = ">96% burst (alternated)"; ! 5920: - cmsg[0x84] = "uncorrectable (alternated)"; ! 5921: - } ! 5922: -#define DO(ch,cp) if(fp) putc(ch,fp); else if(ch != cur){\ ! 5923: - int newb = bn+cp-ret.data;\ ! 5924: - if(verbose && (curb>=0)){\ ! 5925: - printf("%d %s@%d, ", newb-curb, cmsg[cur], curb);\ ! 5926: - if(++nline == 5){nline = 0; putchar('\n');}\ ! 5927: - }\ ! 5928: - cur = ch;\ ! 5929: - curb = newb;\ ! 5930: - } ! 5931: - cur = 256; ! 5932: - curb = -1; ! 5933: - nline = 0; ! 5934: - for(bn = 0; bn < 256; bn++) ! 5935: - cnts[bn] = 0; ! 5936: - for(bn = lbn, c = count; c >= 256; c -= 256, bn += 256){ ! 5937: - if(sony_media1(drive, bn, lower, &ret, err)) ! 5938: - return(1); ! 5939: - for(d = ret.data; d < &ret.data[256];){ ! 5940: - DO(*d, d); ! 5941: - cnts[*d++]++; ! 5942: - } ! 5943: - } ! 5944: - if(c){ ! 5945: - if(sony_media1(drive, bn, lower, &ret, err)) ! 5946: - return(1); ! 5947: - for(d = ret.data; c; c--){ ! 5948: - DO(*d, d); ! 5949: - cnts[*d++]++; ! 5950: - } ! 5951: - } ! 5952: - DO(256, d); ! 5953: - if(nline) ! 5954: - putchar('\n'); ! 5955: - printf("\t"); ! 5956: - for(c = 0; c < 256; c++) ! 5957: - if(cnts[c]) ! 5958: - printf("%d %s, ", cnts[c], cmsg[c]); ! 5959: - printf("\n"); ! 5960: - return(0); ! 5961: -} ! 5962: //GO.SYSIN DD scsi/sony/media.c ! 5963: echo scsi/sony/readid.c 1>&2 ! 5964: sed 's/.//' >scsi/sony/readid.c <<'//GO.SYSIN DD scsi/sony/readid.c' ! 5965: -#include <stdio.h> ! 5966: -#include "../scsi.h" ! 5967: -#include "../scsish.h" ! 5968: -#include "fns.h" ! 5969: - ! 5970: -static int ! 5971: -my_read(int lun, long blk, struct scsi_return *ret, char *err) ! 5972: -{ ! 5973: - struct scsi_cmd cmd; ! 5974: - int n; ! 5975: - ! 5976: - cmd.bus_id = s_id; ! 5977: - set10(cmd, 0x28, lun<<5, blk>>24, blk>>16, blk>>8, blk, 0, 0, 1, 0); ! 5978: - n = ss_io(0, &cmd, 0, ret, 1024, err); ! 5979: - return(n); ! 5980: -} ! 5981: - ! 5982: -int ! 5983: -sony_readid(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 5984: -{ ! 5985: - struct scsi_return ret; ! 5986: - char buf[128]; ! 5987: - int drive = iargs[0]; ! 5988: - long blk, lastb; ! 5989: - int pr = 0; ! 5990: - ! 5991: -#pragma ref ncargs ! 5992: -#pragma ref cargs ! 5993: - ! 5994: - buf[0] = 0; ! 5995: - if(niargs == 2){ ! 5996: - if((blk = iargs[1]) < 0){ ! 5997: - blk = -blk; ! 5998: - pr = 1; ! 5999: - } ! 6000: - } else { ! 6001: - if(my_read(drive, 0L, &ret, err) == 0) ! 6002: - goto done; ! 6003: - blk = 1; ! 6004: - } ! 6005: - for(lastb = -1;;){ ! 6006: - if(pr){ ! 6007: - printf("%d: ", blk); ! 6008: - } ! 6009: - if(my_read(drive, blk, &ret, err)) ! 6010: - break; ! 6011: - lastb = blk; ! 6012: - blk = ((long *)ret.data)[9]; ! 6013: - } ! 6014: - if(lastb < 0){ ! 6015: - printf("read(blk=%d) failed\n", blk); ! 6016: - return(1); ! 6017: - } ! 6018: - if(my_read(drive, lastb, &ret, err) != 0) ! 6019: - return(1); ! 6020: -done: ! 6021: - strncpy(buf, (char *)&ret.data[42], 128); ! 6022: - buf[127] = 0; ! 6023: - printf("(%d,%d): '%s'\n", s_id, drive, buf); ! 6024: - return(0); ! 6025: -} ! 6026: //GO.SYSIN DD scsi/sony/readid.c ! 6027: echo scsi/sony/copy.c 1>&2 ! 6028: sed 's/.//' >scsi/sony/copy.c <<'//GO.SYSIN DD scsi/sony/copy.c' ! 6029: -#include <stdio.h> ! 6030: -#include "../scsi.h" ! 6031: -#include "../scsish.h" ! 6032: -#include "fns.h" ! 6033: - ! 6034: -#define PROGRESS \ ! 6035: - if(sbase/TALK != goo){\ ! 6036: - goo = sbase/TALK;\ ! 6037: - time(&t2);\ ! 6038: - printf("\tdoing block %ld at %s", goo*TALK, ctime(&t2));\ ! 6039: - } ! 6040: - ! 6041: -static char good[256]; /* by default, all BAD */ ! 6042: -typedef enum { BAD = 0, GOOD } Searchtype; ! 6043: -static int copy1(int, int, int, int, int, int, int, char *); ! 6044: -static int search(int, int, int, int, Searchtype, char *); ! 6045: - ! 6046: -int ! 6047: -sony_copy(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6048: -{ ! 6049: - int n; ! 6050: - int sdr = iargs[0]; ! 6051: - int sbase = iargs[1]; ! 6052: - int nblocks = iargs[2]; ! 6053: - int ddr = iargs[3]; ! 6054: - int dbase = iargs[4]; ! 6055: - int starget = s_id; ! 6056: - int dtarget = s_id; ! 6057: - int wr, unwr; ! 6058: - long nb = nblocks; ! 6059: - long t1, t2; ! 6060: - long goo; ! 6061: - int lower; ! 6062: - struct scsi_return ret; ! 6063: -#define TALK 10000 ! 6064: - extern char *ctime(); ! 6065: - ! 6066: -#pragma ref niargs ! 6067: -#pragma ref ncargs ! 6068: -#pragma ref cargs ! 6069: - ! 6070: - printf("copying drive (%d,%d)[%d-%d] to drive (%d,%d)[%d-%d]\n", ! 6071: - starget, sdr, sbase, sbase+nblocks-1, ! 6072: - dtarget, ddr, dbase, dbase+nblocks-1); ! 6073: - if(sony_istatus(&ret, err)) ! 6074: - return(1); ! 6075: - if((ret.data[100]&0x80) && (sdr == (ret.data[100]&7))) ! 6076: - lower = 0; ! 6077: - else if((ret.data[101]&0x80) && (sdr == (ret.data[101]&7))) ! 6078: - lower = 1; ! 6079: - else { ! 6080: - sprintf(err, "drive %d not occupied\n", sdr); ! 6081: - return(1); ! 6082: - } ! 6083: - good[0] = good[0x81] = good[0x82] = good[0x83] = GOOD; ! 6084: - time(&t1); ! 6085: - goo = -1; ! 6086: - while(nblocks > 0){ ! 6087: - /* search for a block to copy */ ! 6088: - while(n = min(256, nblocks)){ ! 6089: - wr = search(sdr, lower, sbase, n, GOOD, err); ! 6090: - if(wr < 0) ! 6091: - break; ! 6092: - sbase += wr; ! 6093: - dbase += wr; ! 6094: - nblocks -= wr; ! 6095: - if(wr < n) ! 6096: - break; ! 6097: - PROGRESS ! 6098: - } ! 6099: - /* now copy until the first bad block */ ! 6100: - while(n = min(256, nblocks)){ ! 6101: - unwr = search(sdr, lower, sbase, n, BAD, err); ! 6102: - if(unwr < 0) ! 6103: - break; ! 6104: - /*printf("writing %d-%d\n", sbase, sbase+unwr-1);/**/ ! 6105: - if(copy1(starget, sdr, sbase, unwr, dtarget, ddr, dbase, err)) ! 6106: - break; ! 6107: - sbase += unwr; ! 6108: - dbase += unwr; ! 6109: - nblocks -= unwr; ! 6110: - PROGRESS ! 6111: - } ! 6112: - } ! 6113: - time(&t2); ! 6114: - t2 -= t1; ! 6115: - if(t2 == 0) t2 = 1; ! 6116: - printf("%ds: ", t2); ! 6117: - if(nblocks){ ! 6118: - printf("copy buggered up: sbase=%d nblks=%d dbase=%d\n", ! 6119: - sbase, nblocks, dbase); ! 6120: - return(1); ! 6121: - } ! 6122: - printf("%d blocks at %.1fKB/s\n", nb, nb/(float)t2); ! 6123: - return(0); ! 6124: -} ! 6125: - ! 6126: -static int ! 6127: -copy1(int st, int sd, int sb, int n, int dt, int dd, int db, char *err) ! 6128: -{ ! 6129: - struct scsi_cmd cmd; ! 6130: - struct scsi_return ret; ! 6131: - ! 6132: - set6(cmd, 0x18, sd<<5, 0, 0, 20, 0); ! 6133: - cmd.data[0] = 0x10; /* copy */ ! 6134: - cmd.data[1] = 0; ! 6135: - cmd.data[2] = 0; ! 6136: - cmd.data[3] = 0; ! 6137: - cmd.data[4] = (st<<5)|sd; ! 6138: - cmd.data[5] = (dt<<5)|dd; ! 6139: - cmd.data[6] = 0; ! 6140: - cmd.data[7] = 0; ! 6141: - cmd.data[8] = n>>24; ! 6142: - cmd.data[9] = n>>16; ! 6143: - cmd.data[10] = n>>8; ! 6144: - cmd.data[11] = n; ! 6145: - cmd.data[12] = sb>>24; ! 6146: - cmd.data[13] = sb>>16; ! 6147: - cmd.data[14] = sb>>8; ! 6148: - cmd.data[15] = sb; ! 6149: - cmd.data[16] = db>>24; ! 6150: - cmd.data[17] = db>>16; ! 6151: - cmd.data[18] = db>>8; ! 6152: - cmd.data[19] = db; ! 6153: - return(s_io(0, &cmd, 20, &ret, 0, err)); ! 6154: -} ! 6155: - ! 6156: -static int ! 6157: -search(int dr, int lower, int sbase, int n, Searchtype s, char *err) ! 6158: -{ ! 6159: - uchar *cp; ! 6160: - struct scsi_return ret; ! 6161: - ! 6162: - if(n <= 0) ! 6163: - return(0); ! 6164: - if(n > 256) ! 6165: - n = 256; ! 6166: - if(sony_media1(dr, sbase, lower, &ret, err)) ! 6167: - return(-1); ! 6168: - for(cp = ret.data; n-- > 0; cp++) ! 6169: - if(good[*cp] != s) ! 6170: - break; ! 6171: - return(cp-ret.data); ! 6172: -} ! 6173: //GO.SYSIN DD scsi/sony/copy.c ! 6174: echo scsi/sony/fns.h 1>&2 ! 6175: sed 's/.//' >scsi/sony/fns.h <<'//GO.SYSIN DD scsi/sony/fns.h' ! 6176: -extern int sony_inq(int, int *, int, char **, char *); ! 6177: -extern int sony_alt(int, int *, int, char **, char *); ! 6178: -extern int sony_conf(int, int *, int, char **, char *); ! 6179: -extern int sony_status(int, int *, int, char **, char *); ! 6180: -extern int sony_set(int, int *, int, char **, char *); ! 6181: -extern int sony_rel(int, int *, int, char **, char *); ! 6182: -extern int sony_eject(int, int *, int, char **, char *); ! 6183: -extern int sony_diskid(int, int *, int, char **, char *); ! 6184: -extern int sony_internal(int, int *, int, char **, char *); ! 6185: -extern int sony_media(int, int *, int, char **, char *); ! 6186: -extern int sony_readid(int, int *, int, char **, char *); ! 6187: -extern int sony_copy(int, int *, int, char **, char *); ! 6188: -extern int sony_sense(int, int *, int, char **, char *); ! 6189: -extern void sony_extsense(uchar *, char *, int); ! 6190: - ! 6191: -extern int shelfside(char *arg, char *err); ! 6192: //GO.SYSIN DD scsi/sony/fns.h ! 6193: echo scsi/sony/sense.c 1>&2 ! 6194: sed 's/.//' >scsi/sony/sense.c <<'//GO.SYSIN DD scsi/sony/sense.c' ! 6195: -#include <stdio.h> ! 6196: -#include "../scsi.h" ! 6197: -#include "../scsish.h" ! 6198: -#include "fns.h" ! 6199: - ! 6200: -int ! 6201: -sony_sense(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6202: -{ ! 6203: - struct scsi_cmd cmd; ! 6204: - struct scsi_return ret; ! 6205: - int n; ! 6206: - char buf[4096]; ! 6207: - ! 6208: -#pragma ref ncargs ! 6209: -#pragma ref cargs ! 6210: - ! 6211: - if(niargs == 0) ! 6212: - iargs[0] = 0; ! 6213: - set6(cmd, 0x03, iargs[0]<<5, 0, 0, 32, 0); ! 6214: - if(n = s_io(0, &cmd, 0, &ret, -32, err)) ! 6215: - return(n); ! 6216: - printf("sense(%d,%d): ", s_id, iargs[0]); ! 6217: - sony_extsense(ret.data, buf, sizeof buf); ! 6218: - printf("%s\n", buf); ! 6219: - return(0); ! 6220: -} ! 6221: - ! 6222: -static char *exstab[16] = ! 6223: -{ ! 6224: - "no sense", ! 6225: - "recovered error", ! 6226: - "not ready", ! 6227: - "medium error", ! 6228: - "hardware error", ! 6229: - "illegal request", ! 6230: - "unit attention", ! 6231: - "data protect", ! 6232: - "blank check", ! 6233: - "key #9", ! 6234: - "copy aborted", ! 6235: - "aborted command", ! 6236: - "key #c", ! 6237: - "volume overflow", ! 6238: - "miscompare", ! 6239: - "key #f", ! 6240: -}; ! 6241: - ! 6242: -void ! 6243: -sony_extsense(uchar *data, char *dest, int ndata) ! 6244: -{ ! 6245: - char buf[4096]; ! 6246: - extern char *nesd[]; ! 6247: - ! 6248: - dest[0] = 0; ! 6249: - switch(data[2]) ! 6250: - { ! 6251: - case 0: ! 6252: - sprintf(dest, "no error"); ! 6253: - break; ! 6254: - case 0x1: /* recovered error */ ! 6255: - sprintf(dest, "recovered error"); ! 6256: - break; ! 6257: - case 0xA: /* recovered error */ ! 6258: - sprintf(dest, "recovered error"); ! 6259: - break; ! 6260: - default: ! 6261: - if(data[7] != 4) ! 6262: - sprintf((char *)data, "warning: extra data is %d, not 4! ", data[7]); ! 6263: - sprintf(buf, "sense: %s", nesd[data[8]&0x7f]); ! 6264: - strcat(dest, buf); ! 6265: - if(data[8]&0x80){ ! 6266: - sprintf(buf, " at addr #%x", data[11]+256L*data[10]+256L*256*data[9]); ! 6267: - strcat(dest, buf); ! 6268: - } ! 6269: - sprintf(buf, ", ext sense: %s", exstab[data[2]]); ! 6270: - strcat(dest, buf); ! 6271: - if(data[0]&0x80){ ! 6272: - sprintf(buf, " info=#%x", data[6]+256L*data[5]+256L*256L*data[4]+256L*256L*256L*data[3]); ! 6273: - strcat(dest, buf); ! 6274: - } ! 6275: - break; ! 6276: - } ! 6277: -} ! 6278: //GO.SYSIN DD scsi/sony/sense.c ! 6279: echo scsi/sony/nesd.tab 1>&2 ! 6280: sed 's/.//' >scsi/sony/nesd.tab <<'//GO.SYSIN DD scsi/sony/nesd.tab' ! 6281: -nesd ! 6282: -00 no sense ! 6283: -01 invalid command ! 6284: -02 recovered error ! 6285: -03 illegal request ! 6286: -06 unit attention ! 6287: -07 parity error ! 6288: -08 message reject error ! 6289: -0a copy aborted ! 6290: -10 ecc trouible occurred ! 6291: -11 time out error ! 6292: -12 controller error ! 6293: -13 SONY I/F II hardware/firmware error ! 6294: -14 scsi hardware/firmware error ! 6295: -20 command not terminated ! 6296: -21 drive interface parity error ! 6297: -22 loading trouble ! 6298: -23 focus trouble ! 6299: -24 tracking trouble ! 6300: -25 spindle trouble ! 6301: -26 slide trouible ! 6302: -27 skew trouble ! 6303: -28 head lead out ! 6304: -29 write modulation trouble ! 6305: -2a under laser power ! 6306: -2b over laser power ! 6307: -2f drive error ! 6308: -30 drive power off ! 6309: -31 no disk in drive ! 6310: -32 drive not ready ! 6311: -38 disk already exists in drive ! 6312: -39 no disk in drive ! 6313: -3a disk already exists in shelf ! 6314: -40 write warning ! 6315: -41 write error ! 6316: -42 disk error ! 6317: -43 cannot read disk id ! 6318: -44 write protect error 1 ! 6319: -45 write protect error 2 ! 6320: -46 disk warning ! 6321: -47 alternation trouble ! 6322: -50 specified address not found ! 6323: -51 address block not found ! 6324: -52 all address could not be read ! 6325: -53 data could not be read ! 6326: -54 uncorrectable read error ! 6327: -55 tracking error ! 6328: -60 no data in specified address ! 6329: -68 z-axis servo error ! 6330: -69 roter servo error ! 6331: -6a hook servo error ! 6332: -6b i/o shelf error ! 6333: -6c drive 0 error ! 6334: -6d drive 1 error ! 6335: -6e shelf error ! 6336: -6f carrier error ! 6337: //GO.SYSIN DD scsi/sony/nesd.tab ! 6338: echo scsi/lib.c 1>&2 ! 6339: sed 's/.//' >scsi/lib.c <<'//GO.SYSIN DD scsi/lib.c' ! 6340: -#include <stdio.h> ! 6341: -#include "scsi.h" ! 6342: -#include "scsish.h" ! 6343: -#include "generic/fns.h" ! 6344: -#include "sony/fns.h" ! 6345: - ! 6346: -s_start(int dr, char *err) ! 6347: -{ ! 6348: - int iargs[1]; ! 6349: - char *cargs[1]; ! 6350: - ! 6351: - iargs[0] = dr; ! 6352: - return(gen_start(1, iargs, 0, cargs, err)); ! 6353: -} ! 6354: - ! 6355: -s_stop(int dr, char *err) ! 6356: -{ ! 6357: - int iargs[1]; ! 6358: - char *cargs[1]; ! 6359: - ! 6360: - iargs[0] = dr; ! 6361: - return(gen_stop(1, iargs, 0, cargs, err)); ! 6362: -} ! 6363: - ! 6364: -s_eject(int dr, char *err) ! 6365: -{ ! 6366: - int iargs[1]; ! 6367: - char *cargs[1]; ! 6368: - ! 6369: - iargs[0] = dr; ! 6370: - return(sony_eject(1, iargs, 0, cargs, err)); ! 6371: -} ! 6372: //GO.SYSIN DD scsi/lib.c ! 6373: echo scsi/wren/dev.c 1>&2 ! 6374: sed 's/.//' >scsi/wren/dev.c <<'//GO.SYSIN DD scsi/wren/dev.c' ! 6375: -#include <stdio.h> ! 6376: -#include "../scsi.h" ! 6377: -#include "../scsish.h" ! 6378: -#include "fns.h" ! 6379: - ! 6380: -static Function fns[] = { ! 6381: - { "diag", "diag", "", wr_diag }, ! 6382: - { "extinq", "extinq", "", wr_extinq }, ! 6383: - { "modesense", "modesense", "", wr_modesense }, ! 6384: - { "modeselect", "modeselect er-param er-retries read-recon write-recon cache-enable cache-thr cache-pre cache-size", "IIIIIIIII", wr_modeselect }, ! 6385: - { 0 } ! 6386: -}; ! 6387: -Device wrendev = { ! 6388: - "wren", "Wren V/VI/Runner-2", ! 6389: - gen_extsense, ! 6390: - fns ! 6391: -}; ! 6392: //GO.SYSIN DD scsi/wren/dev.c ! 6393: echo scsi/wren/inq.c 1>&2 ! 6394: sed 's/.//' >scsi/wren/inq.c <<'//GO.SYSIN DD scsi/wren/inq.c' ! 6395: -#include <stdio.h> ! 6396: -#include "../scsi.h" ! 6397: -#include "../scsish.h" ! 6398: -#include "fns.h" ! 6399: - ! 6400: -extern char *gen_rmb[2]; ! 6401: -extern char *gen_devtype[256]; ! 6402: - ! 6403: -int ! 6404: -wr_extinq(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6405: -{ ! 6406: - struct scsi_cmd cmd; ! 6407: - struct scsi_return ret; ! 6408: - int n; ! 6409: - char vendor[9], product[17]; ! 6410: - ! 6411: -#pragma ref niargs ! 6412: -#pragma ref iargs ! 6413: -#pragma ref ncargs ! 6414: -#pragma ref cargs ! 6415: - ! 6416: - set6(cmd, 0x12, 0, 0, 0, 96, 0); ! 6417: - if(n = s_io(0, &cmd, 0, &ret, 96, err)) ! 6418: - return(n); ! 6419: - fixedstr(&ret.data[8], 8, vendor); ! 6420: - fixedstr(&ret.data[16], 16, product); ! 6421: - printf("inq(%d,%d): %s %s, %s/%s rev=%0.4s serial=%0.8s\n", ! 6422: - s_id, 0, gen_rmb[ret.data[1]>>7], gen_devtype[ret.data[0]], ! 6423: - vendor, product, &ret.data[32], &ret.data[36]); ! 6424: - return(0); ! 6425: -} ! 6426: //GO.SYSIN DD scsi/wren/inq.c ! 6427: echo scsi/wren/wmode.c 1>&2 ! 6428: sed 's/.//' >scsi/wren/wmode.c <<'//GO.SYSIN DD scsi/wren/wmode.c' ! 6429: -#include <stdio.h> ! 6430: -#include "../scsi.h" ! 6431: -#include "../scsish.h" ! 6432: -#include "fns.h" ! 6433: - ! 6434: -int ! 6435: -wr_modeselect(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6436: -{ ! 6437: - struct scsi_cmd cmd; ! 6438: - struct scsi_return ret; ! 6439: - int n; ! 6440: - ! 6441: -#pragma ref niargs ! 6442: -#pragma ref ncargs ! 6443: -#pragma ref cargs ! 6444: - ! 6445: - printf("changing modes to "); ! 6446: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 6447: - printf("er-param=%d(=#%x), ", iargs[0], iargs[0]); ! 6448: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 6449: - printf("er-retries=%d, ", iargs[1]); ! 6450: - if((iargs[2] < 256) && (iargs[2] >= 0)) ! 6451: - printf("read-recon=%d/256, ", iargs[2]); ! 6452: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 6453: - printf("write-recon=%d/256, ", iargs[3]); ! 6454: - if((iargs[4] < 256) && (iargs[4] >= 0)) ! 6455: - printf("read cache %sable, ", iargs[4]?"dis":"en"); ! 6456: - if((iargs[5] < 256) && (iargs[5] >= 0)) ! 6457: - printf("write cache %sable, ", iargs[5]?"en":"dis"); ! 6458: - if((iargs[6] < 256) && (iargs[6] >= 0)) ! 6459: - printf("cache max prefetch=%d, ", iargs[6]); ! 6460: - if((iargs[7] < 256) && (iargs[7] >= 0)) ! 6461: - printf("cache size=%d, ", iargs[7]); ! 6462: - if((iargs[8] < 256) && (iargs[8] >= 0)) ! 6463: - printf("cross cyl %sable, ", iargs[8]?"en":"dis"); ! 6464: - printf("\nsleep(10); kill me if you disagree\n"); ! 6465: - fflush(stdout); ! 6466: - sleep(10); ! 6467: - /* do error recovery */ ! 6468: - if(((iargs[0] < 256) && (iargs[0] >= 0)) || ((iargs[1] < 256) && (iargs[1] >= 0))){ ! 6469: - set6(cmd, 0x1A, 0, (0<<6)|0x01, 0, 20, 0); ! 6470: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 6471: - return(n); ! 6472: - memcpy(cmd.data, ret.data, 20); ! 6473: - cmd.data[14] &= ~0x10; ! 6474: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 6475: - cmd.data[14] = iargs[0]; ! 6476: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 6477: - cmd.data[15] = iargs[1]; ! 6478: - set6(cmd, 0x15, 0x11, 0, 0, 20, 0); ! 6479: - if(n = s_io(0, &cmd, 20, &ret, 0, err)) ! 6480: - return(n); ! 6481: - } ! 6482: - /* reconnect */ ! 6483: - if(((iargs[2] < 256) && (iargs[2] >= 0)) || ((iargs[3] < 256) && (iargs[3] >= 0))){ ! 6484: - set6(cmd, 0x1A, 0, (0<<6)|0x02, 0, 24, 0); ! 6485: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 6486: - return(n); ! 6487: - memcpy(cmd.data, ret.data, 24); ! 6488: - if((iargs[2] < 256) && (iargs[2] >= 0)) ! 6489: - cmd.data[14] = iargs[2]; ! 6490: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 6491: - cmd.data[15] = iargs[3]; ! 6492: - set6(cmd, 0x15, 0x11, 0, 0, 24, 0); ! 6493: - if(n = s_io(0, &cmd, 24, &ret, 0, err)) ! 6494: - return(n); ! 6495: - } ! 6496: - /* do cache params*/ ! 6497: - if(((iargs[4] < 256) && (iargs[4] >= 0)) ! 6498: - || ((iargs[5] < 256) && (iargs[5] >= 0)) ! 6499: - || ((iargs[6] < 65536) && (iargs[6] >= 0))){ ! 6500: - set6(cmd, 0x1A, 0, (0<<6)|0x08, 0, 28, 0); ! 6501: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 6502: - return(n); ! 6503: - memcpy(cmd.data, ret.data, 24); ! 6504: - if((iargs[4] < 256) && (iargs[4] >= 0)){ ! 6505: - cmd.data[14] &= ~0x01; ! 6506: - cmd.data[14] |= iargs[4]; ! 6507: - } ! 6508: - if((iargs[5] < 256) && (iargs[5] >= 0)){ ! 6509: - cmd.data[14] &= ~0x04; ! 6510: - cmd.data[14] |= iargs[5]? 0x04:0; ! 6511: - } ! 6512: - if((iargs[6] < 65536) && (iargs[6] >= 0)){ ! 6513: - cmd.data[20] = iargs[6]>>8; ! 6514: - cmd.data[21] = iargs[6]; ! 6515: - } ! 6516: - set6(cmd, 0x15, 0x11, 0, 0, 24, 0); ! 6517: - if(n = s_io(0, &cmd, 24, &ret, 0, err)) ! 6518: - return(n); ! 6519: - } ! 6520: - /* do cache control */ ! 6521: - if(((iargs[8] < 256) && (iargs[8] >= 0)) ! 6522: - || ((iargs[7] < 256) && (iargs[7] >= 0))){ ! 6523: - set6(cmd, 0x1A, 0, (0<<6)|0x38, 0, 28, 0); ! 6524: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 6525: - return(n); ! 6526: - memcpy(cmd.data, ret.data, 28); ! 6527: - cmd.data[14] &= ~0x80; ! 6528: - if(iargs[8]) ! 6529: - cmd.data[14] |= 0x80; ! 6530: - if((iargs[7] < 256) && (iargs[7] >= 0)){ ! 6531: - cmd.data[14] &= 0xF0; ! 6532: - cmd.data[14] |= iargs[7]&0xF; ! 6533: - } ! 6534: - set6(cmd, 0x15, 0x11, 0, 0, 28, 0); ! 6535: - if(n = s_io(0, &cmd, 28, &ret, 0, err)) ! 6536: - return(n); ! 6537: - } ! 6538: - return(0); ! 6539: -} ! 6540: //GO.SYSIN DD scsi/wren/wmode.c ! 6541: echo scsi/wren/diag.c 1>&2 ! 6542: sed 's/.//' >scsi/wren/diag.c <<'//GO.SYSIN DD scsi/wren/diag.c' ! 6543: -#include <stdio.h> ! 6544: -#include "../scsi.h" ! 6545: -#include "../scsish.h" ! 6546: -#include "fns.h" ! 6547: - ! 6548: -int ! 6549: -wr_diag(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6550: -{ ! 6551: - struct scsi_cmd cmd; ! 6552: - struct scsi_return ret; ! 6553: - int n; ! 6554: - long t; ! 6555: - ! 6556: -#pragma ref niargs ! 6557: -#pragma ref iargs ! 6558: -#pragma ref ncargs ! 6559: -#pragma ref cargs ! 6560: - ! 6561: - t = time((long *)0); ! 6562: - set6(cmd, 0x1D, 0x04, 0, 0, 0, 0); ! 6563: - if(n = s_io(0, &cmd, 0, &ret, 0, err)) ! 6564: - return(n); ! 6565: - set6(cmd, 0x1C, 0, 0, 0, 8, 0); ! 6566: - if(n = s_io(0, &cmd, 0, &ret, 8, err)) ! 6567: - return(n); ! 6568: - t = time((long *)0)-t; ! 6569: - printf("selftest diagnostic (%ds)\n", t); ! 6570: - if((ret.data[7] == 0) && (ret.data[2] == 0)) ! 6571: - printf("\tno errors\n"); ! 6572: - else ! 6573: - printf("\terror==#%x,#%x FRU=(#%x,#%x,#%x,#%x)\n", ! 6574: - ret.data[6], ret.data[7], ret.data[2], ! 6575: - ret.data[3], ret.data[4], ret.data[5]); ! 6576: - return(0); ! 6577: -} ! 6578: //GO.SYSIN DD scsi/wren/diag.c ! 6579: echo scsi/wren/fns.h 1>&2 ! 6580: sed 's/.//' >scsi/wren/fns.h <<'//GO.SYSIN DD scsi/wren/fns.h' ! 6581: -extern int wr_extinq(int, int *, int, char **, char *); ! 6582: -extern int wr_modesense(int, int *, int, char **, char *); ! 6583: -extern int wr_modeselect(int, int *, int, char **, char *); ! 6584: -extern int wr_diag(int, int *, int, char **, char *); ! 6585: //GO.SYSIN DD scsi/wren/fns.h ! 6586: echo scsi/wren/omode.c 1>&2 ! 6587: sed 's/.//' >scsi/wren/omode.c <<'//GO.SYSIN DD scsi/wren/omode.c' ! 6588: -#include <stdio.h> ! 6589: -#include "../scsi.h" ! 6590: -#include "../scsish.h" ! 6591: -#include "fns.h" ! 6592: - ! 6593: -#define SHORT(n) ((ret.data[n]<<8)|(ret.data[n+1])) ! 6594: - ! 6595: -static int ! 6596: -er(int pcf, char *err) ! 6597: -{ ! 6598: - struct scsi_cmd cmd; ! 6599: - struct scsi_return ret; ! 6600: - int n; ! 6601: - static char *bit[8] = { "DCR", "DTE", "PER", "EEC", "RC", "TB", "ARRE", "AWRE" }; ! 6602: - ! 6603: - set6(cmd, 0x1A, 0, (pcf<<6)|0x01, 0, 20, 0); ! 6604: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 6605: - return(n); ! 6606: - printf("error recovery:\n\t"); ! 6607: - for(n = 7; n >= 0; n--) ! 6608: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 6609: - printf("\n\t%d retries, max ecc span=%d\n", ret.data[15], ret.data[16]); ! 6610: - return(0); ! 6611: -} ! 6612: - ! 6613: -static int ! 6614: -dr(int pcf, char *err) ! 6615: -{ ! 6616: - struct scsi_cmd cmd; ! 6617: - struct scsi_return ret; ! 6618: - int n; ! 6619: - ! 6620: - set6(cmd, 0x1A, 0, (pcf<<6)|0x02, 0, 24, 0); ! 6621: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 6622: - return(n); ! 6623: - printf("disconnect/reconnect:\n"); ! 6624: - printf("\tread reconnect=%d/256,", ret.data[14]); ! 6625: - printf(" write reconnect=%d/256\n", ret.data[15]); ! 6626: - return(0); ! 6627: -} ! 6628: - ! 6629: -static int ! 6630: -fp(int pcf, char *err) ! 6631: -{ ! 6632: - struct scsi_cmd cmd; ! 6633: - struct scsi_return ret; ! 6634: - int n; ! 6635: - static char *bit[8] = { "", "", "", "INS", "SURF", "Remove", "HardSec", "SoftSec" }; ! 6636: - ! 6637: - set6(cmd, 0x1A, 0, (pcf<<6)|0x03, 0, 36, 0); ! 6638: - if(n = s_io(0, &cmd, 0, &ret, 36, err)) ! 6639: - return(n); ! 6640: - printf("format parameters:\n"); ! 6641: - printf("\tsec=%dB, trk=%d secs, interleave=%d trk skew=%d cyl skew=%d\n", ! 6642: - SHORT(24), SHORT(22), SHORT(26), SHORT(28), SHORT(30)); ! 6643: - printf("\t%d alt sec/%d alt trk per zone(=%d trks), %d alt trks per vol\n", ! 6644: - SHORT(16), SHORT(18), SHORT(14), SHORT(20)); ! 6645: - printf("\tdrive type:"); ! 6646: - for(n = 7; n >= 3; n--) ! 6647: - printf(" %s%s", (ret.data[32]&(1<<n))? "":"~", bit[n]); ! 6648: - printf("\n"); ! 6649: - return(0); ! 6650: -} ! 6651: - ! 6652: -static int ! 6653: -geom(int pcf, char *err) ! 6654: -{ ! 6655: - struct scsi_cmd cmd; ! 6656: - struct scsi_return ret; ! 6657: - int n; ! 6658: - ! 6659: - set6(cmd, 0x1A, 0, (pcf<<6)|0x04, 0, 32, 0); ! 6660: - if(n = s_io(0, &cmd, 0, &ret, 32, err)) ! 6661: - return(n); ! 6662: - printf("drive geometry:\n\t%d cyls, %d heads\n", ! 6663: - (ret.data[14]<<16)|SHORT(15), ret.data[17]); ! 6664: - return(0); ! 6665: -} ! 6666: - ! 6667: -static int ! 6668: -cc(int pcf, char *err) ! 6669: -{ ! 6670: - struct scsi_cmd cmd; ! 6671: - struct scsi_return ret; ! 6672: - int n; ! 6673: - static char *bit[8] = { "", "", "", "", "CacheEnable", "RSVD", "WIE", "RSVD" }; ! 6674: - ! 6675: - set6(cmd, 0x1A, 0, (pcf<<6)|0x38, 0, 28, 0); ! 6676: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 6677: - return(n); ! 6678: - printf("cache control:\n\t"); ! 6679: - for(n = 7; n >= 4; n--) ! 6680: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 6681: - printf(", cache size=%d\n", ret.data[14]&0xF); ! 6682: - printf("\tprefetch: thr=%d max=%d(mult %d) min=%d(mult %d)\n", ! 6683: - ret.data[15], ret.data[16], ret.data[17], ret.data[18], ret.data[19]); ! 6684: - return(0); ! 6685: -} ! 6686: - ! 6687: -int ! 6688: -wr_modesense(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6689: -{ ! 6690: - int n; ! 6691: - ! 6692: -#pragma ref ncargs ! 6693: -#pragma ref cargs ! 6694: -#pragma ref niargs ! 6695: -#pragma ref iargs ! 6696: - ! 6697: -#define PCF 0 /* current values */ ! 6698: - ! 6699: - printf("mode sense(%d,0):\n", s_id); ! 6700: - if(n = er(PCF, err)) ! 6701: - return(n); ! 6702: - if(n = dr(PCF, err)) ! 6703: - return(n); ! 6704: - if(n = fp(PCF, err)) ! 6705: - return(n); ! 6706: - if(n = geom(PCF, err)) ! 6707: - return(n); ! 6708: - if(n = cc(PCF, err)) ! 6709: - return(n); ! 6710: - return(0); ! 6711: -} ! 6712: - ! 6713: -int ! 6714: -wr_modeselect(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6715: -{ ! 6716: - struct scsi_cmd cmd; ! 6717: - struct scsi_return ret; ! 6718: - int n; ! 6719: - ! 6720: -#pragma ref niargs ! 6721: -#pragma ref ncargs ! 6722: -#pragma ref cargs ! 6723: - ! 6724: - printf("changing modes to "); ! 6725: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 6726: - printf("er-param=%d(=#%x), ", iargs[0], iargs[0]); ! 6727: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 6728: - printf("er-retries=%d, ", iargs[1]); ! 6729: - if((iargs[2] < 256) && (iargs[2] >= 0)) ! 6730: - printf("read-recon=%d/256, ", iargs[2]); ! 6731: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 6732: - printf("write-recon=%d/256, ", iargs[3]); ! 6733: - if((iargs[4] < 256) && (iargs[4] >= 0)) ! 6734: - printf("cache %sable, ", iargs[4]?"en":"dis"); ! 6735: - if((iargs[5] < 256) && (iargs[5] >= 0)) ! 6736: - printf("cache threshold=%d, ", iargs[5]); ! 6737: - if((iargs[6] < 256) && (iargs[6] >= 0)) ! 6738: - printf("cache max prefetch=%d, ", iargs[6]); ! 6739: - if((iargs[7] < 256) && (iargs[7] >= 0)) ! 6740: - printf("cache size=%d, ", iargs[7]); ! 6741: - printf("\nsleep(10); kill me if you disagree\n"); ! 6742: - fflush(stdout); ! 6743: - sleep(10); ! 6744: - /* do error recovery */ ! 6745: - if(((iargs[0] < 256) && (iargs[0] >= 0)) || ((iargs[1] < 256) && (iargs[1] >= 0))){ ! 6746: - set6(cmd, 0x1A, 0, (0<<6)|0x01, 0, 20, 0); ! 6747: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 6748: - return(n); ! 6749: - memcpy(cmd.data, ret.data, 20); ! 6750: - cmd.data[14] &= ~0x10; ! 6751: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 6752: - cmd.data[14] = iargs[0]; ! 6753: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 6754: - cmd.data[15] = iargs[1]; ! 6755: - set6(cmd, 0x15, 0x11, 0, 0, 20, 0); ! 6756: - if(n = s_io(0, &cmd, 20, &ret, 0, err)) ! 6757: - return(n); ! 6758: - } ! 6759: - /* reconnect */ ! 6760: - if(((iargs[2] < 256) && (iargs[2] >= 0)) || ((iargs[3] < 256) && (iargs[3] >= 0))){ ! 6761: - set6(cmd, 0x1A, 0, (0<<6)|0x02, 0, 24, 0); ! 6762: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 6763: - return(n); ! 6764: - memcpy(cmd.data, ret.data, 24); ! 6765: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 6766: - cmd.data[14] = iargs[3]; ! 6767: - if((iargs[4] < 256) && (iargs[4] >= 0)) ! 6768: - cmd.data[15] = iargs[4]; ! 6769: - set6(cmd, 0x15, 0x11, 0, 0, 24, 0); ! 6770: - if(n = s_io(0, &cmd, 24, &ret, 0, err)) ! 6771: - return(n); ! 6772: - } ! 6773: - /* do cache control */ ! 6774: - if(((iargs[4] < 256) && (iargs[4] >= 0)) ! 6775: - || ((iargs[5] < 256) && (iargs[5] >= 0)) ! 6776: - || ((iargs[6] < 256) && (iargs[6] >= 0)) ! 6777: - || ((iargs[7] < 256) && (iargs[7] >= 0))){ ! 6778: - set6(cmd, 0x1A, 0, (0<<6)|0x38, 0, 28, 0); ! 6779: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 6780: - return(n); ! 6781: - memcpy(cmd.data, ret.data, 28); ! 6782: - cmd.data[14] &= ~0x10; ! 6783: - if(iargs[4]) ! 6784: - cmd.data[14] |= 0x10; ! 6785: - if((iargs[7] < 256) && (iargs[7] >= 0)){ ! 6786: - cmd.data[14] &= 0xF0; ! 6787: - cmd.data[14] |= iargs[7]&0xF; ! 6788: - } ! 6789: - if((iargs[5] < 256) && (iargs[5] >= 0)) ! 6790: - cmd.data[15] = iargs[5]; ! 6791: - if((iargs[6] < 256) && (iargs[6] >= 0)) ! 6792: - cmd.data[16] = iargs[6]; ! 6793: - set6(cmd, 0x15, 0x11, 0, 0, 28, 0); ! 6794: - if(n = s_io(0, &cmd, 28, &ret, 0, err)) ! 6795: - return(n); ! 6796: - } ! 6797: - return(0); ! 6798: -} ! 6799: //GO.SYSIN DD scsi/wren/omode.c ! 6800: echo scsi/wren/oomode.c 1>&2 ! 6801: sed 's/.//' >scsi/wren/oomode.c <<'//GO.SYSIN DD scsi/wren/oomode.c' ! 6802: -#include <stdio.h> ! 6803: -#include "../scsi.h" ! 6804: -#include "../scsish.h" ! 6805: -#include "fns.h" ! 6806: - ! 6807: -#define SHORT(n) ((ret.data[n]<<8)|(ret.data[n+1])) ! 6808: - ! 6809: -static int ! 6810: -er(int pcf, char *err) ! 6811: -{ ! 6812: - struct scsi_cmd cmd; ! 6813: - struct scsi_return ret; ! 6814: - int n; ! 6815: - static char *bit[8] = { "DCR", "DTE", "PER", "EEC", "RC", "TB", "ARRE", "AWRE" }; ! 6816: - ! 6817: - set6(cmd, 0x1A, 0, (pcf<<6)|0x01, 0, 20, 0); ! 6818: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 6819: - return(n); ! 6820: - printf("error recovery:\n\t"); ! 6821: - for(n = 7; n >= 0; n--) ! 6822: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 6823: - printf("\n\t%d retries, max ecc span=%d\n", ret.data[15], ret.data[16]); ! 6824: - return(0); ! 6825: -} ! 6826: - ! 6827: -static int ! 6828: -dr(int pcf, char *err) ! 6829: -{ ! 6830: - struct scsi_cmd cmd; ! 6831: - struct scsi_return ret; ! 6832: - int n; ! 6833: - ! 6834: - set6(cmd, 0x1A, 0, (pcf<<6)|0x02, 0, 24, 0); ! 6835: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 6836: - return(n); ! 6837: - printf("disconnect/reconnect:\n"); ! 6838: - printf("\tread reconnect=%d/256,", ret.data[14]); ! 6839: - printf(" write reconnect=%d/256\n", ret.data[15]); ! 6840: - return(0); ! 6841: -} ! 6842: - ! 6843: -static int ! 6844: -fp(int pcf, char *err) ! 6845: -{ ! 6846: - struct scsi_cmd cmd; ! 6847: - struct scsi_return ret; ! 6848: - int n; ! 6849: - static char *bit[8] = { "", "", "", "INS", "SURF", "Remove", "HardSec", "SoftSec" }; ! 6850: - ! 6851: - set6(cmd, 0x1A, 0, (pcf<<6)|0x03, 0, 36, 0); ! 6852: - if(n = s_io(0, &cmd, 0, &ret, 36, err)) ! 6853: - return(n); ! 6854: - printf("format parameters:\n"); ! 6855: - printf("\tsec=%dB, trk=%d secs, interleave=%d trk skew=%d cyl skew=%d\n", ! 6856: - SHORT(24), SHORT(22), SHORT(26), SHORT(28), SHORT(30)); ! 6857: - printf("\t%d alt sec/%d alt trk per zone(=%d trks), %d alt trks per vol\n", ! 6858: - SHORT(16), SHORT(18), SHORT(14), SHORT(20)); ! 6859: - printf("\tdrive type:"); ! 6860: - for(n = 7; n >= 3; n--) ! 6861: - printf(" %s%s", (ret.data[32]&(1<<n))? "":"~", bit[n]); ! 6862: - printf("\n"); ! 6863: - return(0); ! 6864: -} ! 6865: - ! 6866: -static int ! 6867: -geom(int pcf, char *err) ! 6868: -{ ! 6869: - struct scsi_cmd cmd; ! 6870: - struct scsi_return ret; ! 6871: - int n; ! 6872: - ! 6873: - set6(cmd, 0x1A, 0, (pcf<<6)|0x04, 0, 32, 0); ! 6874: - if(n = s_io(0, &cmd, 0, &ret, 32, err)) ! 6875: - return(n); ! 6876: - printf("drive geometry:\n\t%d cyls, %d heads\n", ! 6877: - (ret.data[14]<<16)|SHORT(15), ret.data[17]); ! 6878: - return(0); ! 6879: -} ! 6880: - ! 6881: -static int ! 6882: -cc(int pcf, char *err) ! 6883: -{ ! 6884: - struct scsi_cmd cmd; ! 6885: - struct scsi_return ret; ! 6886: - int n; ! 6887: - static char *bit[8] = { "", "", "", "", "CacheEnable", "RSVD", "WIE", "RSVD" }; ! 6888: - ! 6889: - set6(cmd, 0x1A, 0, (pcf<<6)|0x38, 0, 28, 0); ! 6890: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 6891: - return(n); ! 6892: - printf("cache control:\n\t"); ! 6893: - for(n = 7; n >= 4; n--) ! 6894: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 6895: - printf(", cache size=%d\n", ret.data[14]&0xF); ! 6896: - printf("\tprefetch: thr=%d max=%dx%d min=%dx%d\n", ! 6897: - ret.data[15], ret.data[16], ret.data[17], ret.data[18], ret.data[19]); ! 6898: - return(0); ! 6899: -} ! 6900: - ! 6901: -int ! 6902: -wr_modesense(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6903: -{ ! 6904: - int n; ! 6905: - ! 6906: -#pragma ref ncargs ! 6907: -#pragma ref cargs ! 6908: -#pragma ref niargs ! 6909: -#pragma ref iargs ! 6910: - ! 6911: -#define PCF 0 /* current values */ ! 6912: - ! 6913: - printf("mode sense(%d,0):\n", s_id); ! 6914: - if(n = er(PCF, err)) ! 6915: - return(n); ! 6916: - if(n = dr(PCF, err)) ! 6917: - return(n); ! 6918: - if(n = fp(PCF, err)) ! 6919: - return(n); ! 6920: - if(n = geom(PCF, err)) ! 6921: - return(n); ! 6922: - if(n = cc(PCF, err)) ! 6923: - return(n); ! 6924: - return(0); ! 6925: -} ! 6926: - ! 6927: -int ! 6928: -wr_modeselect(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 6929: -{ ! 6930: - struct scsi_cmd cmd; ! 6931: - struct scsi_return ret; ! 6932: - int n; ! 6933: - ! 6934: -#pragma ref niargs ! 6935: -#pragma ref ncargs ! 6936: -#pragma ref cargs ! 6937: - ! 6938: - printf("changing modes to "); ! 6939: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 6940: - printf("er-param=%d(=#%x), ", iargs[0], iargs[0]); ! 6941: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 6942: - printf("er-retries=%d, ", iargs[1]); ! 6943: - if((iargs[2] < 256) && (iargs[2] >= 0)) ! 6944: - printf("read-recon=%d/256, ", iargs[2]); ! 6945: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 6946: - printf("write-recon=%d/256, ", iargs[3]); ! 6947: - if((iargs[4] < 256) && (iargs[4] >= 0)) ! 6948: - printf("cache %sable, ", iargs[4]?"en":"dis"); ! 6949: - printf("\nsleep(10); kill me if you disagree\n"); ! 6950: - fflush(stdout); ! 6951: - sleep(10); ! 6952: - /* do error recovery */ ! 6953: - if(((iargs[0] < 256) && (iargs[0] >= 0)) || ((iargs[1] < 256) && (iargs[1] >= 0))){ ! 6954: - set6(cmd, 0x1A, 0, (0<<6)|0x01, 0, 20, 0); ! 6955: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 6956: - return(n); ! 6957: - memcpy(cmd.data, ret.data, 20); ! 6958: - cmd.data[14] &= ~0x10; ! 6959: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 6960: - cmd.data[14] = iargs[0]; ! 6961: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 6962: - cmd.data[15] = iargs[1]; ! 6963: - set6(cmd, 0x15, 0x11, 0, 0, 20, 0); ! 6964: - if(n = s_io(0, &cmd, 20, &ret, 0, err)) ! 6965: - return(n); ! 6966: - } ! 6967: - /* reconnect */ ! 6968: - if(((iargs[2] < 256) && (iargs[2] >= 0)) || ((iargs[3] < 256) && (iargs[3] >= 0))){ ! 6969: - set6(cmd, 0x1A, 0, (0<<6)|0x02, 0, 24, 0); ! 6970: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 6971: - return(n); ! 6972: - memcpy(cmd.data, ret.data, 24); ! 6973: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 6974: - cmd.data[14] = iargs[3]; ! 6975: - if((iargs[4] < 256) && (iargs[4] >= 0)) ! 6976: - cmd.data[15] = iargs[4]; ! 6977: - set6(cmd, 0x15, 0x11, 0, 0, 24, 0); ! 6978: - if(n = s_io(0, &cmd, 24, &ret, 0, err)) ! 6979: - return(n); ! 6980: - } ! 6981: - /* do cache control */ ! 6982: - if((iargs[4] < 256) && (iargs[4] >= 0)){ ! 6983: - set6(cmd, 0x1A, 0, (0<<6)|0x38, 0, 28, 0); ! 6984: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 6985: - return(n); ! 6986: - memcpy(cmd.data, ret.data, 28); ! 6987: - cmd.data[14] &= ~0x10; ! 6988: - if(iargs[4]) ! 6989: - cmd.data[14] |= 0x10; ! 6990: - set6(cmd, 0x15, 0x11, 0, 0, 28, 0); ! 6991: - if(n = s_io(0, &cmd, 28, &ret, 0, err)) ! 6992: - return(n); ! 6993: - } ! 6994: - return(0); ! 6995: -} ! 6996: //GO.SYSIN DD scsi/wren/oomode.c ! 6997: echo scsi/wren/rmode.c 1>&2 ! 6998: sed 's/.//' >scsi/wren/rmode.c <<'//GO.SYSIN DD scsi/wren/rmode.c' ! 6999: -#include <stdio.h> ! 7000: -#include "../scsi.h" ! 7001: -#include "../scsish.h" ! 7002: -#include "fns.h" ! 7003: - ! 7004: -#define SHORT(n) ((ret.data[n]<<8)|(ret.data[n+1])) ! 7005: - ! 7006: -static int ! 7007: -er_w6(int pcf, char *err) ! 7008: -{ ! 7009: - struct scsi_cmd cmd; ! 7010: - struct scsi_return ret; ! 7011: - int n; ! 7012: - static char *bit[8] = { "DCR", "DTE", "PER", "EEC", "RC", "TB", "ARRE", "AWRE" }; ! 7013: - ! 7014: - set6(cmd, 0x1A, 0, (pcf<<6)|0x01, 0, 20, 0); ! 7015: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 7016: - return(n); ! 7017: - printf("error recovery:\n\t"); ! 7018: - for(n = 7; n >= 0; n--) ! 7019: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 7020: - printf("\n\t%d retries, max ecc span=%d, recov tlimit=%d\n", ! 7021: - ret.data[15], ret.data[16], ret.data[17]); ! 7022: - return(0); ! 7023: -} ! 7024: - ! 7025: -static int ! 7026: -dr_w6(int pcf, char *err) ! 7027: -{ ! 7028: - struct scsi_cmd cmd; ! 7029: - struct scsi_return ret; ! 7030: - int n; ! 7031: - ! 7032: - set6(cmd, 0x1A, 0, (pcf<<6)|0x02, 0, 24, 0); ! 7033: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 7034: - return(n); ! 7035: - printf("disconnect/reconnect:\n"); ! 7036: - printf("\tread reconnect=%d/256 full,", ret.data[14]); ! 7037: - printf(" write reconnect=%d/256 empty\n", ret.data[15]); ! 7038: - return(0); ! 7039: -} ! 7040: - ! 7041: -static int ! 7042: -fp_w6(int pcf, char *err) ! 7043: -{ ! 7044: - struct scsi_cmd cmd; ! 7045: - struct scsi_return ret; ! 7046: - int n; ! 7047: - static char *bit[8] = { "", "", "", "INS", "SURF", "Remove", "HardSec", "SoftSec" }; ! 7048: - ! 7049: - set6(cmd, 0x1A, 0, (pcf<<6)|0x03, 0, 36, 0); ! 7050: - if(n = s_io(0, &cmd, 0, &ret, 36, err)) ! 7051: - return(n); ! 7052: - printf("format parameters:\n"); ! 7053: - printf("\tsec=%d B, trk=%d secs, interleave=%d, trk_skew=%d, cyl_skew=%d\n", ! 7054: - SHORT(24), SHORT(22), SHORT(26), SHORT(28), SHORT(30)); ! 7055: - printf("\t%d alt_sec/%d alt_trk per zone(=%d trks), %d alt_trk per vol\n", ! 7056: - SHORT(16), SHORT(18), SHORT(14), SHORT(20)); ! 7057: - printf("\tdrive type:"); ! 7058: - for(n = 7; n >= 3; n--) ! 7059: - printf(" %s%s", (ret.data[32]&(1<<n))? "":"~", bit[n]); ! 7060: - printf("\n"); ! 7061: - return(0); ! 7062: -} ! 7063: - ! 7064: -static int ! 7065: -geom_w6(int pcf, char *err) ! 7066: -{ ! 7067: - struct scsi_cmd cmd; ! 7068: - struct scsi_return ret; ! 7069: - int n; ! 7070: - ! 7071: - set6(cmd, 0x1A, 0, (pcf<<6)|0x04, 0, 32, 0); ! 7072: - if(n = s_io(0, &cmd, 0, &ret, 32, err)) ! 7073: - return(n); ! 7074: - printf("drive geometry:\n\t%d cyls, %d heads\n", ! 7075: - (ret.data[14]<<16)|SHORT(15), ret.data[17]); ! 7076: - return(0); ! 7077: -} ! 7078: - ! 7079: -static int ! 7080: -cc_w6(int pcf, char *err) ! 7081: -{ ! 7082: - struct scsi_cmd cmd; ! 7083: - struct scsi_return ret; ! 7084: - int n; ! 7085: - static char *bit[8] = { "", "", "", "", "CacheEnable", "RSVD", "WIE", "RSVD" }; ! 7086: - ! 7087: - set6(cmd, 0x1A, 0, (pcf<<6)|0x38, 0, 28, 0); ! 7088: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 7089: - return(n); ! 7090: - printf("cache control:\n\t"); ! 7091: - for(n = 7; n >= 4; n--) ! 7092: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 7093: - printf(", cache size=%d\n", ret.data[14]&0xF); ! 7094: - printf("\tprefetch: thr=%d max=%d(mult %d) min=%d(mult %d)\n", ! 7095: - ret.data[15], ret.data[16], ret.data[17], ret.data[18], ret.data[19]); ! 7096: - return(0); ! 7097: -} ! 7098: - ! 7099: -static int ! 7100: -er_wr2(int pcf, char *err) ! 7101: -{ ! 7102: - struct scsi_cmd cmd; ! 7103: - struct scsi_return ret; ! 7104: - int n; ! 7105: - static char *bit[8] = { "DCR", "DTE", "PER", "EEC", "RC", "TB", "ARRE", "AWRE" }; ! 7106: - ! 7107: - set6(cmd, 0x1A, 0, (pcf<<6)|0x01, 0, 20, 0); ! 7108: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 7109: - return(n); ! 7110: - printf("error recovery:\n\t"); ! 7111: - for(n = 7; n >= 0; n--) ! 7112: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 7113: - printf("\n\t%d retries, max ecc span=%d, %d wr retries, recov tlimit=%d\n", ! 7114: - ret.data[15], ret.data[16], ret.data[20], SHORT(22)); ! 7115: - return(0); ! 7116: -} ! 7117: - ! 7118: -static int ! 7119: -geom_wr2(int pcf, char *err) ! 7120: -{ ! 7121: - struct scsi_cmd cmd; ! 7122: - struct scsi_return ret; ! 7123: - int n; ! 7124: - static char *sspin[4] = { ! 7125: - "no spindle synch", ! 7126: - "synch-spindle slave", ! 7127: - "synch-spindle master", ! 7128: - "synch-spindle master control", ! 7129: - }; ! 7130: - ! 7131: - set6(cmd, 0x1A, 0, (pcf<<6)|0x04, 0, 32, 0); ! 7132: - if(n = s_io(0, &cmd, 0, &ret, 32, err)) ! 7133: - return(n); ! 7134: - printf("drive geometry:\n\t%d cyls, %d heads, %s, rotation rate %d\n", ! 7135: - (ret.data[14]<<16)|SHORT(15), ret.data[17], ! 7136: - sspin[ret.data[29]&3], SHORT(32)); ! 7137: - return(0); ! 7138: -} ! 7139: - ! 7140: -static int ! 7141: -cp_wr2(int pcf, char *err) ! 7142: -{ ! 7143: - struct scsi_cmd cmd; ! 7144: - struct scsi_return ret; ! 7145: - int n; ! 7146: - static char *bit[8] = { "ReadCacheDisable", "", "WriteCacheEnable", "", "", "", "", "" }; ! 7147: - ! 7148: - set6(cmd, 0x1A, 0, (pcf<<6)|0x08, 0, 24, 0); ! 7149: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 7150: - return(n); ! 7151: - printf("caching parameters:\n\t"); ! 7152: - for(n = 2; n >= 0; n -= 2) ! 7153: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 7154: - printf("\n\tprefetch: min=%d, max=%d, ceiling=%d\n", ! 7155: - SHORT(18), SHORT(20), SHORT(22)); ! 7156: - return(0); ! 7157: -} ! 7158: - ! 7159: -static int ! 7160: -cc_wr2(int pcf, char *err) ! 7161: -{ ! 7162: - struct scsi_cmd cmd; ! 7163: - struct scsi_return ret; ! 7164: - int n; ! 7165: - static char *bit[8] = { "", "", "", "", "CacheEnable", "SSM", "WIE", "CCEN" }; ! 7166: - ! 7167: - set6(cmd, 0x1A, 0, (pcf<<6)|0x38, 0, 28, 0); ! 7168: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 7169: - return(n); ! 7170: - printf("cache control:\n\t"); ! 7171: - for(n = 7; n >= 4; n--) ! 7172: - printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]); ! 7173: - printf(", cache size=%d\n", ret.data[14]&0xF); ! 7174: - printf("\tprefetch: thr=%d max=%d(mult %d) min=%d(mult %d)\n", ! 7175: - ret.data[15], ret.data[16], ret.data[17], ret.data[18], ret.data[19]); ! 7176: - return(0); ! 7177: -} ! 7178: - ! 7179: -typedef (*Fn)(int, char *); ! 7180: -static struct Drive ! 7181: -{ ! 7182: - char *type; /* match inq field */ ! 7183: - char *desc; /* print at the user */ ! 7184: - Fn fns[10]; ! 7185: -} drive[] = { /* first one is default when none match */ ! 7186: - { "94181-15", "Wren VI", er_w6, dr_w6, fp_w6, geom_w6, cc_w6, 0 }, ! 7187: - { "ST4767", "Wren Runner-2", er_wr2, dr_w6, fp_w6, geom_wr2, cp_wr2, cc_wr2, 0 }, ! 7188: - { 0 } ! 7189: -}; ! 7190: - ! 7191: -int ! 7192: -wr_modesense(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 7193: -{ ! 7194: - int n, i, retv; ! 7195: - char product[17]; ! 7196: - int found; ! 7197: - struct scsi_cmd cmd; ! 7198: - struct scsi_return ret; ! 7199: - ! 7200: -#pragma ref ncargs ! 7201: -#pragma ref cargs ! 7202: -#pragma ref niargs ! 7203: -#pragma ref iargs ! 7204: - ! 7205: -#define PCF 0 /* current values */ ! 7206: - ! 7207: - /* find drive type */ ! 7208: - set6(cmd, 0x12, 0, 0, 0, 32, 0); ! 7209: - if(n = s_io(0, &cmd, 0, &ret, 32, err)) ! 7210: - return(n); ! 7211: - fixedstr(&ret.data[16], 16, product); ! 7212: - for(n = 0, found = 0; drive[n].type; n++) ! 7213: - if(strcmp(product, drive[n].type) == 0){ ! 7214: - found = 1; ! 7215: - break; ! 7216: - } ! 7217: - if(!found) ! 7218: - n = 0; ! 7219: - ! 7220: - if(found) ! 7221: - printf("mode sense(%d,0)[%s(%s)]:\n", s_id, drive[n].desc, product); ! 7222: - else ! 7223: - printf("mode sense(%d,0)[using %s, found '%s']:\n", s_id, drive[n].desc, product); ! 7224: - for(i = 0; drive[n].fns[i]; i++) ! 7225: - if(retv = (*drive[n].fns[i])(PCF, err)) ! 7226: - return(retv); ! 7227: - return(0); ! 7228: -} ! 7229: //GO.SYSIN DD scsi/wren/rmode.c ! 7230: echo scsi/wren/w6mode.c 1>&2 ! 7231: sed 's/.//' >scsi/wren/w6mode.c <<'//GO.SYSIN DD scsi/wren/w6mode.c' ! 7232: -#include <stdio.h> ! 7233: -#include "../scsi.h" ! 7234: -#include "../scsish.h" ! 7235: -#include "fns.h" ! 7236: - ! 7237: -int ! 7238: -wr_modeselect(int niargs, int *iargs, int ncargs, char **cargs, char *err) ! 7239: -{ ! 7240: - struct scsi_cmd cmd; ! 7241: - struct scsi_return ret; ! 7242: - int n; ! 7243: - ! 7244: -#pragma ref niargs ! 7245: -#pragma ref ncargs ! 7246: -#pragma ref cargs ! 7247: - ! 7248: - printf("changing modes to "); ! 7249: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 7250: - printf("er-param=%d(=#%x), ", iargs[0], iargs[0]); ! 7251: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 7252: - printf("er-retries=%d, ", iargs[1]); ! 7253: - if((iargs[2] < 256) && (iargs[2] >= 0)) ! 7254: - printf("read-recon=%d/256, ", iargs[2]); ! 7255: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 7256: - printf("write-recon=%d/256, ", iargs[3]); ! 7257: - if((iargs[4] < 256) && (iargs[4] >= 0)) ! 7258: - printf("cache %sable, ", iargs[4]?"en":"dis"); ! 7259: - if((iargs[5] < 256) && (iargs[5] >= 0)) ! 7260: - printf("cache threshold=%d, ", iargs[5]); ! 7261: - if((iargs[6] < 256) && (iargs[6] >= 0)) ! 7262: - printf("cache max prefetch=%d, ", iargs[6]); ! 7263: - if((iargs[7] < 256) && (iargs[7] >= 0)) ! 7264: - printf("cache size=%d, ", iargs[7]); ! 7265: - printf("\nsleep(10); kill me if you disagree\n"); ! 7266: - fflush(stdout); ! 7267: - sleep(10); ! 7268: - /* do error recovery */ ! 7269: - if(((iargs[0] < 256) && (iargs[0] >= 0)) || ((iargs[1] < 256) && (iargs[1] >= 0))){ ! 7270: - set6(cmd, 0x1A, 0, (0<<6)|0x01, 0, 20, 0); ! 7271: - if(n = s_io(0, &cmd, 0, &ret, 20, err)) ! 7272: - return(n); ! 7273: - memcpy(cmd.data, ret.data, 20); ! 7274: - cmd.data[14] &= ~0x10; ! 7275: - if((iargs[0] < 256) && (iargs[0] >= 0)) ! 7276: - cmd.data[14] = iargs[0]; ! 7277: - if((iargs[1] < 256) && (iargs[1] >= 0)) ! 7278: - cmd.data[15] = iargs[1]; ! 7279: - set6(cmd, 0x15, 0x11, 0, 0, 20, 0); ! 7280: - if(n = s_io(0, &cmd, 20, &ret, 0, err)) ! 7281: - return(n); ! 7282: - } ! 7283: - /* reconnect */ ! 7284: - if(((iargs[2] < 256) && (iargs[2] >= 0)) || ((iargs[3] < 256) && (iargs[3] >= 0))){ ! 7285: - set6(cmd, 0x1A, 0, (0<<6)|0x02, 0, 24, 0); ! 7286: - if(n = s_io(0, &cmd, 0, &ret, 24, err)) ! 7287: - return(n); ! 7288: - memcpy(cmd.data, ret.data, 24); ! 7289: - if((iargs[3] < 256) && (iargs[3] >= 0)) ! 7290: - cmd.data[14] = iargs[3]; ! 7291: - if((iargs[4] < 256) && (iargs[4] >= 0)) ! 7292: - cmd.data[15] = iargs[4]; ! 7293: - set6(cmd, 0x15, 0x11, 0, 0, 24, 0); ! 7294: - if(n = s_io(0, &cmd, 24, &ret, 0, err)) ! 7295: - return(n); ! 7296: - } ! 7297: - /* do cache control */ ! 7298: - if(((iargs[4] < 256) && (iargs[4] >= 0)) ! 7299: - || ((iargs[5] < 256) && (iargs[5] >= 0)) ! 7300: - || ((iargs[6] < 256) && (iargs[6] >= 0)) ! 7301: - || ((iargs[7] < 256) && (iargs[7] >= 0))){ ! 7302: - set6(cmd, 0x1A, 0, (0<<6)|0x38, 0, 28, 0); ! 7303: - if(n = s_io(0, &cmd, 0, &ret, 28, err)) ! 7304: - return(n); ! 7305: - memcpy(cmd.data, ret.data, 28); ! 7306: - cmd.data[14] &= ~0x10; ! 7307: - if(iargs[4]) ! 7308: - cmd.data[14] |= 0x10; ! 7309: - if((iargs[7] < 256) && (iargs[7] >= 0)){ ! 7310: - cmd.data[14] &= 0xF0; ! 7311: - cmd.data[14] |= iargs[7]&0xF; ! 7312: - } ! 7313: - if((iargs[5] < 256) && (iargs[5] >= 0)) ! 7314: - cmd.data[15] = iargs[5]; ! 7315: - if((iargs[6] < 256) && (iargs[6] >= 0)) ! 7316: - cmd.data[16] = iargs[6]; ! 7317: - set6(cmd, 0x15, 0x11, 0, 0, 28, 0); ! 7318: - if(n = s_io(0, &cmd, 28, &ret, 0, err)) ! 7319: - return(n); ! 7320: - } ! 7321: - return(0); ! 7322: -} ! 7323: //GO.SYSIN DD scsi/wren/w6mode.c ! 7324: echo scsi/nohup.out 1>&2 ! 7325: sed 's/.//' >scsi/nohup.out <<'//GO.SYSIN DD scsi/nohup.out' ! 7326: //GO.SYSIN DD scsi/nohup.out ! 7327: echo shipped 1>&2 ! 7328: sed 's/.//' >shipped <<'//GO.SYSIN DD shipped' ! 7329: //GO.SYSIN DD shipped ! 7330: echo sym.c 1>&2 ! 7331: sed 's/.//' >sym.c <<'//GO.SYSIN DD sym.c' ! 7332: -#include <libc.h> ! 7333: -#include "worm.h" ! 7334: -#include "sym.h" ! 7335: - ! 7336: -#define NHASH 20011 /* prime please */ ! 7337: -#define HASHMUL 79L /* this is a good value */ ! 7338: -static Symtab *hash[NHASH]; ! 7339: -int sym_mem_fail; ! 7340: - ! 7341: -syminit() ! 7342: -{ ! 7343: - register Symtab **s, *ss; ! 7344: - ! 7345: - for(s = hash; s < &hash[NHASH]; s++){ ! 7346: - for(ss = *s; ss; ss = ss->next) ! 7347: - free((char *)ss); ! 7348: - *s = 0; ! 7349: - } ! 7350: -} ! 7351: - ! 7352: -void * ! 7353: -symlook(sym, space, install) ! 7354: - char *sym; ! 7355: - void *install; ! 7356: -{ ! 7357: - register long h; ! 7358: - register char *p; ! 7359: - register Symtab *s; ! 7360: - ! 7361: - for(p = sym, h = space; *p; h += *p++) ! 7362: - h *= HASHMUL; ! 7363: - if(h < 0) ! 7364: - h = ~h; ! 7365: - h %= NHASH; ! 7366: - for(s = hash[h]; s; s = s->next) ! 7367: - if((s->space == space) && (strcmp(s->name, sym) == 0)){ ! 7368: - if(install) ! 7369: - s->value = install; ! 7370: - return(s->value); ! 7371: - } ! 7372: - if(install){ ! 7373: - s = (Symtab *)malloc((unsigned)sizeof(Symtab)); ! 7374: - if(s == 0){ ! 7375: - sym_mem_fail++; ! 7376: - return(install); ! 7377: - } ! 7378: - s->space = space; ! 7379: - s->name = sym; ! 7380: - s->value = install; ! 7381: - s->next = hash[h]; ! 7382: - hash[h] = s; ! 7383: - } ! 7384: - return(install); ! 7385: -} ! 7386: - ! 7387: -symdel(sym, space) ! 7388: - char *sym; ! 7389: -{ ! 7390: - register long h; ! 7391: - register char *p; ! 7392: - register Symtab *s, *ls; ! 7393: - ! 7394: - for(p = sym, h = space; *p; h += *p++) ! 7395: - h *= HASHMUL; ! 7396: - if(h < 0) ! 7397: - h = ~h; ! 7398: - h %= NHASH; ! 7399: - for(s = hash[h], ls = 0; s; ls = s, s = s->next) ! 7400: - if((s->space == space) && (strcmp(s->name, sym) == 0)){ ! 7401: - if(ls) ! 7402: - ls->next = s->next; ! 7403: - else ! 7404: - hash[h] = s->next; ! 7405: - free((char *)s); ! 7406: - } ! 7407: -} ! 7408: - ! 7409: -symtraverse(space, fn) ! 7410: - void (*fn)(); ! 7411: -{ ! 7412: - register Symtab **s, *ss, *next; ! 7413: - ! 7414: - for(s = hash; s < &hash[NHASH]; s++) ! 7415: - for(ss = *s; ss; ss = next){ ! 7416: - next = ss->next; ! 7417: - if(ss->space == space) ! 7418: - (*fn)(ss->value); ! 7419: - } ! 7420: -} ! 7421: - ! 7422: -symstat() ! 7423: -{ ! 7424: - register Symtab **s, *ss; ! 7425: - int n[NHASH]; ! 7426: - register i, j; ! 7427: - int tot; ! 7428: - double d; ! 7429: - ! 7430: - for(i = 0; i < NHASH; i++) ! 7431: - n[i] = 0; ! 7432: - for(s = hash; s < &hash[NHASH]; s++){ ! 7433: - for(j = 0, ss = *s; ss; ss = ss->next) ! 7434: - j++; ! 7435: - n[j]++; ! 7436: - } ! 7437: - Fprint(1, "N=%ld mul=%ld\n", NHASH, HASHMUL); ! 7438: - for(i = 0, d = 0, tot = 0; i < NHASH; i++){ ! 7439: - if(n[i]) Fprint(1, "%d of length %d\n", n[i], i); ! 7440: - d += n[i]*i; ! 7441: - if(i) tot += n[i]; ! 7442: - } ! 7443: - Fprint(1, "ave len = %g\n", d/tot); ! 7444: -} ! 7445: - ! 7446: -symdump(sym, space) ! 7447: - char *sym; ! 7448: -{ ! 7449: - register long h; ! 7450: - register char *p; ! 7451: - register Symtab *s; ! 7452: - ! 7453: - for(p = sym, h = space; *p; h += *p++) ! 7454: - h *= HASHMUL; ! 7455: - if(h < 0) ! 7456: - h = ~h; ! 7457: - h %= NHASH; ! 7458: - print("symdump(%s):\n", sym); ! 7459: - for(s = hash[h]; s; s = s->next) ! 7460: - print("\t%s: space=%d value=%ld\n", s->name, s->space, s->value); ! 7461: -} ! 7462: //GO.SYSIN DD sym.c ! 7463: echo sym.h 1>&2 ! 7464: sed 's/.//' >sym.h <<'//GO.SYSIN DD sym.h' ! 7465: -typedef struct Symtab ! 7466: -{ ! 7467: - short space; ! 7468: - char *name; ! 7469: - void *value; ! 7470: - struct Symtab *next; ! 7471: -} Symtab; ! 7472: -extern void *symlook(); ! 7473: - ! 7474: -#define S_INODE 1 ! 7475: -#define S_UID 2 ! 7476: -#define S_GID 3 ! 7477: -#define S_FAIL 4 /* fetch */ ! 7478: -#define S_TOGO 5 /* wormy */ ! 7479: - ! 7480: -extern int sym_mem_fail; ! 7481: //GO.SYSIN DD sym.h ! 7482: echo t0 1>&2 ! 7483: sed 's/.//' >t0 <<'//GO.SYSIN DD t0' ! 7484: - ! 7485: -static Inode *inodes; ! 7486: -static long ip; ! 7487: -static long ninodes = 0; ! 7488: -static char *nameb; ! 7489: -static long np; ! 7490: -static long nnameb = 0; ! 7491: -static long nblocks; ! 7492: -#define IINC 1024 ! 7493: -#define NINC (64*IINC) ! 7494: - ! 7495: -ininit() ! 7496: -{ ! 7497: - if(nnameb == 0){ ! 7498: - nameb = malloc((unsigned)(nnameb = NINC)); ! 7499: - if(nameb == 0){ ! 7500: - fprint(2, "wmv: malloc fail, %d bytes\n", nnameb); ! 7501: - exit(1); ! 7502: - } ! 7503: - } ! 7504: - np = 0; ! 7505: - if(ninodes == 0){ ! 7506: - inodes = (Inode *)malloc(sizeof(Inode)*(unsigned)(ninodes = IINC)); ! 7507: - if(inodes == 0){ ! 7508: - fprint(2, "wmv: malloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 7509: - exit(1); ! 7510: - } ! 7511: - } ! 7512: - ip = 0; ! 7513: -} ! 7514: - ! 7515: -inadd(s, i) ! 7516: - Superblock *s; ! 7517: - register Inode *i; ! 7518: -{ ! 7519: - register long len; ! 7520: - ! 7521: - len = strlen(i->name.n)+1; ! 7522: - if(np+len > nnameb){ ! 7523: - while(np+len > nnameb) ! 7524: - nnameb += NINC; ! 7525: - nameb = realloc(nameb, (unsigned)nnameb); ! 7526: - if(nameb == 0){ ! 7527: - fprint(2, "wmv: realloc fail, %d bytes\n", nnameb); ! 7528: - exit(1); ! 7529: - } ! 7530: - } ! 7531: - strcpy(nameb+np, i->name.n); ! 7532: - i->name.o = np; ! 7533: - np += len; ! 7534: - if(ip == ninodes){ ! 7535: - ninodes += IINC; ! 7536: - inodes = (Inode *)realloc((char *)inodes, (unsigned)ninodes*sizeof(Inode)); ! 7537: - if(inodes == 0){ ! 7538: - fprint(2, "wmv: realloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 7539: - exit(1); ! 7540: - } ! 7541: - } ! 7542: - inodes[ip++] = *i; ! 7543: -} ! 7544: - ! 7545: -inwrite(s) ! 7546: - Superblock *s; ! 7547: -{ ! 7548: - char *e; ! 7549: - ! 7550: - if(e = lkwri(s, inodes, ip, nameb, np, 0L)){ ! 7551: - fprint(2, "%s\n", e); ! 7552: - return(1); ! 7553: - } ! 7554: - return(0); ! 7555: -} ! 7556: //GO.SYSIN DD t0 ! 7557: echo t1 1>&2 ! 7558: sed 's/.//' >t1 <<'//GO.SYSIN DD t1' ! 7559: - ! 7560: -static Inode *inodes; ! 7561: -static long ip; ! 7562: -static long ninodes = 0; ! 7563: -static char *nameb; ! 7564: -static long np; ! 7565: -static long nnameb = 0; ! 7566: -static long nblocks; ! 7567: -#define IINC 1024 ! 7568: -#define NINC (64*IINC) ! 7569: - ! 7570: -ininit() ! 7571: -{ ! 7572: - if(nnameb == 0) ! 7573: - nameb = malloc((unsigned)(nnameb = NINC)); ! 7574: - np = 0; ! 7575: - if(ninodes == 0) ! 7576: - inodes = (Inode *)malloc(sizeof(Inode)*(unsigned)(ninodes = IINC)); ! 7577: - ip = 0; ! 7578: -} ! 7579: - ! 7580: -inadd(s, i) ! 7581: - Superblock *s; ! 7582: - register Inode *i; ! 7583: -{ ! 7584: - register long len; ! 7585: - ! 7586: - len = strlen(i->name.n)+1; ! 7587: - if(np+len > nnameb){ ! 7588: - while(np+len > nnameb) ! 7589: - nnameb += NINC; ! 7590: - nameb = realloc(nameb, (unsigned)nnameb); ! 7591: - } ! 7592: - strcpy(nameb+np, i->name.n); ! 7593: - i->name.o = np; ! 7594: - np += len; ! 7595: - if(ip == ninodes){ ! 7596: - ninodes += IINC; ! 7597: - inodes = (Inode *)realloc((char *)inodes, (unsigned)ninodes*sizeof(Inode)); ! 7598: - } ! 7599: - inodes[ip++] = *i; ! 7600: - return(0); ! 7601: -} ! 7602: - ! 7603: -inwrite(s) ! 7604: - Superblock *s; ! 7605: -{ ! 7606: - char *e; ! 7607: - ! 7608: - if(e = lkwri(s, inodes, ip, nameb, np, 0L)){ ! 7609: - fprint(2, "%s\n", e); ! 7610: - bad = 1; ! 7611: - return; ! 7612: - } ! 7613: -} ! 7614: //GO.SYSIN DD t1 ! 7615: echo timenow.c 1>&2 ! 7616: sed 's/.//' >timenow.c <<'//GO.SYSIN DD timenow.c' ! 7617: -#include <libc.h> ! 7618: -#include "worm.h" ! 7619: - ! 7620: -char * ! 7621: -timenow() ! 7622: -{ ! 7623: - long tim; ! 7624: - char *tims; ! 7625: - ! 7626: - time(&tim); ! 7627: - tims = ctime(&tim); ! 7628: - tims[19] = 0; ! 7629: - return(tims); ! 7630: -} ! 7631: //GO.SYSIN DD timenow.c ! 7632: echo vlink.c 1>&2 ! 7633: sed 's/.//' >vlink.c <<'//GO.SYSIN DD vlink.c' ! 7634: -#include <libc.h> ! 7635: -#include "worm.h" ! 7636: -#include "sym.h" ! 7637: - ! 7638: -char * ! 7639: -lkopi(s, blk, doinodes) ! 7640: - register Superblock *s; ! 7641: - long blk; ! 7642: -{ ! 7643: - register Inode *i; ! 7644: - short fd = s->fd; ! 7645: - char *b; ! 7646: - long nb; ! 7647: - char *nameb; ! 7648: - Inode *inodes; ! 7649: - static char buf[64]; ! 7650: - ! 7651: - if((b = malloc(s->blocksize)) == 0){ ! 7652: - sprint(buf, "couldn't malloc buffer (%d bytes)", s->blocksize); ! 7653: - return(buf); ! 7654: - } ! 7655: - numinodes = 0; ! 7656: - numnamechars = 0; ! 7657: - for(;;){ ! 7658: - if(s->magic != SMAGIC){ ! 7659: - fprint(2, "bad Superblock at %ld\n", blk); ! 7660: - exit(1); ! 7661: - } ! 7662: - if(s->ninodes){ ! 7663: - numinodes += s->ninodes; ! 7664: - numnamechars += s->ninochars; ! 7665: - } ! 7666: - if(doinodes && s->ninodes){ ! 7667: - nb = (s->ninodes+IPERB-1)/IPERB; ! 7668: - inodes = (Inode *)malloc((unsigned)(s->blocksize*nb)); ! 7669: - if(inodes == 0){ ! 7670: - sprint(buf, "inode malloc(%d) fail, sbrk=%d\n", ! 7671: - (s->blocksize*nb), sbrk(0)); ! 7672: - return(buf); ! 7673: - } ! 7674: - Seek(s, s->binodes); ! 7675: - if(Read(s, (char *)inodes, nb)) ! 7676: - goto skip; ! 7677: - nb = (s->ninochars+s->blocksize-1)/s->blocksize; ! 7678: - nameb = malloc((unsigned)(s->blocksize*nb)); ! 7679: - if(nameb == 0){ ! 7680: - sprint(buf, "name buffer malloc(%d) fail, sbrk=%d\n", ! 7681: - (s->blocksize*nb), sbrk(0)); ! 7682: - return(buf); ! 7683: - } ! 7684: - if(Read(s, nameb, nb)) ! 7685: - goto skip; ! 7686: - for(nb = 0, i = inodes; nb < s->ninodes; nb++, i++){ ! 7687: - i->name.n = i->name.o+nameb; ! 7688: - if(i->block < 0) ! 7689: - (void)symdel(i->name.n, S_INODE); ! 7690: - else ! 7691: - (void)symlook(i->name.n, S_INODE, (void *)i); ! 7692: - } ! 7693: - if(sym_mem_fail){ ! 7694: - sprint(buf, "%d inode malloc fails: %d, %d sbrk=%d\n", ! 7695: - sym_mem_fail, numinodes, s->ninodes, sbrk(0)); ! 7696: - return(buf); ! 7697: - } ! 7698: - } ! 7699: - skip: ! 7700: - blk = s->nextsb; ! 7701: - Seek(s, blk); ! 7702: - if(Read(s, b, 1L)) ! 7703: - break; ! 7704: - *s = *((Superblock *)b); ! 7705: - s->fd = fd; ! 7706: - if(s->myblock == 0) ! 7707: - s->myblock = blk; ! 7708: - } ! 7709: - free(b); ! 7710: - return((char *)0); ! 7711: -} ! 7712: - ! 7713: -char * ! 7714: -lkwri(s, i, ni, c, nc, ndata) ! 7715: - Superblock *s; ! 7716: - Inode *i; ! 7717: - long ni, nc, ndata; ! 7718: - char *c; ! 7719: -{ ! 7720: - char *b; ! 7721: - long blk; ! 7722: - static char buf[256]; ! 7723: - long ib, ic; ! 7724: - ! 7725: - s->ninodes = ni; ! 7726: - s->ninochars = nc; ! 7727: - ib = (ni+IPERB-1)/IPERB; ! 7728: - ic = (nc+s->blocksize-1)/s->blocksize; ! 7729: - if(ndata+ib+ic+1 > s->nfree) /* one for superblock */ ! 7730: - return("not enough space for new files"); ! 7731: - s->binodes = s->nextffree+ndata; ! 7732: - s->nextffree += ndata+ib+ic; ! 7733: - s->nfree -= ndata+ib+ic; ! 7734: - ! 7735: - if((b = malloc(s->blocksize)) == 0){ ! 7736: - sprint(buf, "couldn't malloc buffer (%d bytes)", s->blocksize); ! 7737: - return(buf); ! 7738: - } ! 7739: - blk = s->nextsb; ! 7740: - s->nextsb = s->nextffree++; ! 7741: - s->nfree--; ! 7742: - s->myblock = blk; ! 7743: - time(&s->ctime); ! 7744: - memset(b, 0, s->blocksize); ! 7745: - *((Superblock *)b) = *s; ! 7746: - Seek(s, blk); ! 7747: - if(Write(s, b, 1L)){ ! 7748: - sprint(buf, "couldn't write superblock at %d", blk); ! 7749: - return(buf); ! 7750: - } ! 7751: - free(b); ! 7752: - Seek(s, s->binodes); ! 7753: - if(Write(s, (char *)i, ib)) ! 7754: - return("write1 error"); ! 7755: - if(Write(s, c, ic)) ! 7756: - return("write2 error"); ! 7757: - return((char *)0); ! 7758: -} ! 7759: - ! 7760: - ! 7761: -char * ! 7762: -lkwsb(s) ! 7763: - Superblock *s; ! 7764: -{ ! 7765: - char *b; ! 7766: - long blk; ! 7767: - static char buf[64]; ! 7768: - ! 7769: - if((b = malloc(s->blocksize)) == 0){ ! 7770: - sprint(buf, "couldn't malloc buffer (%d bytes)", s->blocksize); ! 7771: - return(buf); ! 7772: - } ! 7773: - blk = s->nextsb; ! 7774: - s->nextsb = s->nextffree++; ! 7775: - s->nfree--; ! 7776: - memset(b, 0, s->blocksize); ! 7777: - s->myblock = blk; ! 7778: - *((Superblock *)b) = *s; ! 7779: - Seek(s, blk); ! 7780: - if(Write(s, b, 1L)) ! 7781: - return("couldn't write superblock"); ! 7782: - free(b); ! 7783: - return((char *)0); ! 7784: -} ! 7785: - ! 7786: -Inode * ! 7787: -vinodefn(s) ! 7788: - char *s; ! 7789: -{ ! 7790: - return((Inode *)symlook(s, S_INODE, (void *)0)); ! 7791: -} ! 7792: - ! 7793: -void ! 7794: -vtraverse(fn) ! 7795: - void (*fn)(); ! 7796: -{ ! 7797: - symtraverse(S_INODE, fn); ! 7798: -} ! 7799: //GO.SYSIN DD vlink.c ! 7800: echo wbtree.c 1>&2 ! 7801: sed 's/.//' >wbtree.c <<'//GO.SYSIN DD wbtree.c' ! 7802: -#include <libc.h> ! 7803: -#include "worm.h" ! 7804: -#include "sym.h" ! 7805: -#include <sys/types.h> ! 7806: -#include <sys/stat.h> ! 7807: -#include <fio.h> ! 7808: - ! 7809: -Inode **inos; ! 7810: -long nino; ! 7811: -int fdT, fdF; ! 7812: -char *inonames; ! 7813: -char *timenow(); ! 7814: -char *tmp = "/tmp"; ! 7815: - ! 7816: -cmp(a, b) ! 7817: - Inode **a, **b; ! 7818: -{ ! 7819: - return(strcmp((*a)->name.n, (*b)->name.n)); ! 7820: -} ! 7821: - ! 7822: -main(argc, argv) ! 7823: - char **argv; ! 7824: -{ ! 7825: - Superblock s, news; ! 7826: - char *e; ! 7827: - char *dev = "/dev/worm0"; ! 7828: - int c, fd; ! 7829: - char dbname[256]; ! 7830: - extern char *optarg; ! 7831: - extern int optind; ! 7832: - void blkfn(); ! 7833: - ! 7834: - while((c = getopt(argc, argv, "t:f:")) != -1) ! 7835: - switch(c) ! 7836: - { ! 7837: - case 'f': dev = optarg; break; ! 7838: - case 't': tmp = optarg; break; ! 7839: - case '?': usage(); ! 7840: - } ! 7841: - dev = mapdev(dev); ! 7842: - if(optind != argc-1) ! 7843: - usage(); ! 7844: - sprint(dbname, "%s/cbt%d", tmp, getpid()); ! 7845: - fd = dbinit(dbname); ! 7846: - if((s.fd = open(dev, 2)) < 0){ ! 7847: - perror(dev); ! 7848: - exit(1); ! 7849: - } ! 7850: - if(e = openinode(&s, DO_INODE|SPIN_DOWN)){ ! 7851: - fprint(2, "%s: %s\n", dev, e); ! 7852: - exit(1); ! 7853: - } ! 7854: - if(strcmp(argv[optind], s.vol_id)){ ! 7855: - fprint(2, "wanted volid '%s'; got '%s'\n", argv[optind], s.vol_id); ! 7856: - exit(1); ! 7857: - } ! 7858: - if((inos = (Inode **)malloc(sizeof(inos[0])*(int)numinodes)) == 0){ ! 7859: - fprint(2, "out of memory (%d inodes, %d bytes)\n", numinodes, sizeof(inos[0])*(int)numinodes); ! 7860: - exit(1); ! 7861: - } ! 7862: - nino = 0; ! 7863: - inodetraverse(blkfn); ! 7864: - fprint(2, "%s: sorting inodes\n", timenow()); ! 7865: - qsort((char *)inos, (int)nino, sizeof(inos[0]), cmp); ! 7866: - news = s; ! 7867: - news.ninodes = nino; ! 7868: - creatdb(fd, dbname, &news); /* fills in nF, nT, inochars */ ! 7869: - c = NBLKS(&news, news.nF)+NBLKS(&news, news.nT)+NBLKS(&news, news.ninochars); ! 7870: - if(c > news.nfree){ ! 7871: - fprint(2, "%s: sorry, not enough blocks; %d+%d+%d>%d\n", ! 7872: - NBLKS(&news, news.nF), NBLKS(&news, news.nT), ! 7873: - NBLKS(&news, news.ninochars), news.nfree); ! 7874: - exit(1); ! 7875: - } ! 7876: - Seek(&s, news.binodes = s.nextffree); ! 7877: - fdwrite(&s, fdF, (int)news.nF); ! 7878: - fdwrite(&s, fdT, (int)news.nT); ! 7879: - memwrite(&s, inonames, (int)news.ninochars); ! 7880: - /* set up link ptrs so that zeroing block zero undoes btreeing */ ! 7881: - s.nfree -= c; ! 7882: - s.nextffree += c; ! 7883: - s.ninodes = 0; ! 7884: - if(e = lkwsb(&s)) ! 7885: - fprint(2, "%s\n", e); ! 7886: - news.nextffree = s.nextffree; ! 7887: - news.nfree = s.nfree; ! 7888: - news.myblock = 0; ! 7889: - news.version = VBTREE; ! 7890: - news.nextsb = s.myblock; ! 7891: - time(&news.ctime); ! 7892: - Seek(&s, news.myblock); ! 7893: - free((char *)inos); ! 7894: - e = malloc(news.blocksize); ! 7895: - if(e == 0){ ! 7896: - fprint(2, "wbtree: unbelievable malloc fail of %d\n", news.blocksize); ! 7897: - exit(1); ! 7898: - } ! 7899: - memset(e, 0, news.blocksize); ! 7900: - *((Superblock *)e) = news; ! 7901: - Write(&s, e, 1L); ! 7902: - exit(0); ! 7903: -} ! 7904: - ! 7905: -usage() ! 7906: -{ ! 7907: - fprint(2, "Usage: worm btree [-fdevice] [-ttmpdir] vol_id\n"); ! 7908: - exit(2); ! 7909: -} ! 7910: - ! 7911: -dbinit(name) ! 7912: - char *name; ! 7913: -{ ! 7914: - char buf[256]; ! 7915: - struct stat sbuf; ! 7916: - int pid, pip[2]; ! 7917: - ! 7918: - fprint(2, "%s: init db '%s'\n", timenow(), name); ! 7919: - sprint(buf, "cbt creat %s", name); ! 7920: - if(system(buf)) ! 7921: - exit(1); ! 7922: - pipe(pip); ! 7923: - pid = fork(); ! 7924: - if(pid < 0){ ! 7925: - perror("fork"); ! 7926: - exit(1); ! 7927: - } ! 7928: - if(pid){ ! 7929: - close(pip[0]); ! 7930: - return(pip[1]); ! 7931: - } else { ! 7932: - close(pip[1]); ! 7933: - dup2(pip[0], 0); ! 7934: - close(pip[0]); ! 7935: - execl("/usr/lib/btree/btbuild", "btbuild", name, 0); ! 7936: - perror("execl"); ! 7937: - exit(1); ! 7938: - return(0); ! 7939: - } ! 7940: -} ! 7941: - ! 7942: -creatdb(fd, name, s) ! 7943: - char *name; ! 7944: - Superblock *s; /* fills in nF, nT, inochars */ ! 7945: -{ ! 7946: - char buf[256]; ! 7947: - struct stat sbuf; ! 7948: - int status, i; ! 7949: - short n; ! 7950: - char *np; ! 7951: - ! 7952: - fprint(2, "%s: creating db '%s'\n", timenow(), name); ! 7953: - inonames = malloc((int)numnamechars+1024); ! 7954: - if(inonames == 0){ ! 7955: - sprint(buf, "malloc(%d) namechars failed", numnamechars+1024); ! 7956: - perror(buf); ! 7957: - exit(1); ! 7958: - } ! 7959: - Finit(fd, (char *)0); ! 7960: - np = inonames; ! 7961: - for(i = 0; i < nino; i++){ ! 7962: - n = strlen(inos[i]->name.n); ! 7963: - Fwrite(fd, (char *)&n, 2L); ! 7964: - Fwrite(fd, inos[i]->name.n, (long)n); ! 7965: - memcpy(np, inos[i]->name.n, n+1); ! 7966: - inos[i]->name.o = np - inonames; ! 7967: - np += n+1; ! 7968: - n = sizeof(Inode); ! 7969: - Fwrite(fd, (char *)&n, 2L); ! 7970: - Fwrite(fd, (char *)inos[i], (long)n); ! 7971: - } ! 7972: - s->ninochars = np-inonames; ! 7973: - Fflush(fd); ! 7974: - close(fd); ! 7975: - if(wait(&status) < 0){ ! 7976: - perror("wbtree: wait"); ! 7977: - exit(1); ! 7978: - } ! 7979: - if(status){ ! 7980: - fprint(2, "wbtree: bad status %d from btbuild\n", status); ! 7981: - exit(1); ! 7982: - } ! 7983: - sprint(buf, "%s.F", name); ! 7984: - if(((fdF = open(buf, 0)) < 0) || (fstat(fdF, &sbuf) < 0)){ ! 7985: - perror(buf); ! 7986: - exit(1); ! 7987: - } ! 7988: - unlink(buf); ! 7989: - s->nF = sbuf.st_size; ! 7990: - sprint(buf, "%s.T", name); ! 7991: - if(((fdT = open(buf, 0)) < 0) || (fstat(fdT, &sbuf) < 0)){ ! 7992: - perror(buf); ! 7993: - exit(1); ! 7994: - } ! 7995: - unlink(buf); ! 7996: - s->nT = sbuf.st_size; ! 7997: - fprint(2, "%s: db done\n", timenow()); ! 7998: -} ! 7999: - ! 8000: -void ! 8001: -blkfn(i) ! 8002: - Inode *i; ! 8003: -{ ! 8004: - inos[nino++] = i; ! 8005: -} ! 8006: - ! 8007: -fdwrite(s, fd, cnt) ! 8008: - Superblock *s; ! 8009: -{ ! 8010: - char b[BIGBLOCK]; ! 8011: - int n; ! 8012: - ! 8013: - lseek(fd, 0L, 0); ! 8014: - while(cnt >= sizeof b){ ! 8015: - n = read(fd, b, sizeof b); ! 8016: - if(n != sizeof b){ ! 8017: - perror("short read"); ! 8018: - exit(3); ! 8019: - } ! 8020: - Write(s, b, NBLKS(s, sizeof b)); ! 8021: - cnt -= sizeof b; ! 8022: - } ! 8023: - if(cnt){ ! 8024: - if(read(fd, b, cnt) != cnt){ ! 8025: - perror("short read"); ! 8026: - exit(4); ! 8027: - } ! 8028: - memset(b+cnt, 0, sizeof b - cnt); ! 8029: - Write(s, b, NBLKS(s, cnt)); ! 8030: - } ! 8031: -} ! 8032: - ! 8033: -memwrite(s, base, cnt) ! 8034: - Superblock *s; ! 8035: - char *base; ! 8036: -{ ! 8037: - int chunk = (BIGBLOCK/1024)*s->blocksize; ! 8038: - ! 8039: - while(cnt >= chunk){ ! 8040: - Write(s, base, NBLKS(s, chunk)); ! 8041: - cnt -= chunk; ! 8042: - base += chunk; ! 8043: - } ! 8044: - if(cnt) ! 8045: - Write(s, base, NBLKS(s, cnt)); ! 8046: -} ! 8047: - ! 8048: -char * ! 8049: -timenow() ! 8050: -{ ! 8051: - long tim; ! 8052: - char *tims; ! 8053: - ! 8054: - time(&tim); ! 8055: - tims = ctime(&tim); ! 8056: - tims[19] = 0; ! 8057: - return(tims); ! 8058: -} ! 8059: //GO.SYSIN DD wbtree.c ! 8060: echo wcat.c 1>&2 ! 8061: sed 's/.//' >wcat.c <<'//GO.SYSIN DD wcat.c' ! 8062: -#include <libc.h> ! 8063: -#include "sym.h" ! 8064: -#include "worm.h" ! 8065: - ! 8066: -main(argc, argv) ! 8067: - char **argv; ! 8068: -{ ! 8069: - Superblock s; ! 8070: - char *e; ! 8071: - Inode *i; ! 8072: - int c; ! 8073: - char *dev = "/dev/worm0"; ! 8074: - extern char *optarg; ! 8075: - extern int optind; ! 8076: - ! 8077: - while((c = getopt(argc, argv, "f:")) != -1) ! 8078: - switch(c) ! 8079: - { ! 8080: - case 'f': dev = optarg; break; ! 8081: - case '?': usage(); ! 8082: - } ! 8083: - if(optind+2 != argc) ! 8084: - usage(); ! 8085: - dev = mapdev(dev); ! 8086: - if((s.fd = open(dev, 0)) < 0){ ! 8087: - perror(dev); ! 8088: - exit(1); ! 8089: - } ! 8090: - if(e = openinode(&s, DO_INODE|SPIN_DOWN)){ ! 8091: - fprint(2, "%s: %s\n", dev, e); ! 8092: - exit(1); ! 8093: - } ! 8094: - if(strcmp(s.vol_id, argv[optind])){ ! 8095: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id); ! 8096: - exit(1); ! 8097: - } ! 8098: - if(i = inodeof(argv[++optind])) ! 8099: - c = pr(&s, i); ! 8100: - else { ! 8101: - fprint(2, "wcat: can't find %s\n", argv[optind]); ! 8102: - c = 1; ! 8103: - } ! 8104: - exit(c); ! 8105: -} ! 8106: - ! 8107: -usage() ! 8108: -{ ! 8109: - fprint(2, "Usage: worm cat [-fdevice] vol_id file\n"); ! 8110: - exit(1); ! 8111: -} ! 8112: - ! 8113: -pr(s, i) ! 8114: - Superblock *s; ! 8115: - register Inode *i; ! 8116: -{ ! 8117: - char b[BIGBLOCK]; ! 8118: - register long len, n; ! 8119: - long nb; ! 8120: - int fd; ! 8121: - ! 8122: - fd = 1; ! 8123: - nb = sizeof b / s->blocksize; ! 8124: - Seek(s, i->block); ! 8125: - for(n = i->nbytes, len = nb*s->blocksize; n > 0;){ ! 8126: - if(len > n){ ! 8127: - len = n; ! 8128: - nb = (len+s->blocksize-1)/s->blocksize; ! 8129: - } ! 8130: - Read(s, b, nb); ! 8131: - if(write(fd, b, (int)len) != len){ ! 8132: - perror("write"); ! 8133: - return(1); ! 8134: - } ! 8135: - n -= len; ! 8136: - } ! 8137: - close(fd); ! 8138: - return(0); ! 8139: -} ! 8140: //GO.SYSIN DD wcat.c ! 8141: echo wcopy.c 1>&2 ! 8142: sed 's/.//' >wcopy.c <<'//GO.SYSIN DD wcopy.c' ! 8143: -#include <libc.h> ! 8144: -#include <fio.h> ! 8145: -#include <sys/types.h> ! 8146: -#include <sys/stat.h> ! 8147: -#include <signal.h> ! 8148: -#include "worm.h" ! 8149: - ! 8150: -long minfree = 40000; ! 8151: -int verbose = 0; ! 8152: - ! 8153: -main(argc, argv) ! 8154: - char **argv; ! 8155: -{ ! 8156: - Superblock in, out; ! 8157: - char *e; ! 8158: - char buf[4096]; ! 8159: - int n; ! 8160: - long lineno; ! 8161: - int c; ! 8162: - char *dev = "/dev/worm0"; ! 8163: - long tfiles, tbytes; ! 8164: - int eof; ! 8165: - char first[4096]; ! 8166: - extern char *optarg; ! 8167: - extern int optind; ! 8168: - ! 8169: - argout = argv[0]; ! 8170: - while((c = getopt(argc, argv, "vm:f:")) != -1) ! 8171: - switch(c) ! 8172: - { ! 8173: - case 'f': dev = optarg; break; ! 8174: - case 'm': minfree = atol(optarg); break; ! 8175: - case 'v': verbose = 1; break; ! 8176: - case '?': usage(); ! 8177: - } ! 8178: - ! 8179: - if(optind+3 != argc) ! 8180: - usage(); ! 8181: - e = mapdev(argv[optind+1]); ! 8182: - if((out.fd = open(e, 2)) < 0){ ! 8183: - perror(e); ! 8184: - exit(1); ! 8185: - } ! 8186: - if(e = openinode(&out, SPIN_DOWN)){ ! 8187: - fprint(2, "%s: %s\n", *argv, e); ! 8188: - exit(1); ! 8189: - } ! 8190: - if(strcmp(out.vol_id, argv[optind+2])){ ! 8191: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind+2], out.vol_id); ! 8192: - exit(1); ! 8193: - } ! 8194: - if(out.version != VLINK){ ! 8195: - fprint(2, "%s: can't write on a b-tree disk\n", out.vol_id); ! 8196: - exit(1); ! 8197: - } ! 8198: - dev = mapdev(dev); ! 8199: - if((in.fd = open(dev, 2)) < 0){ ! 8200: - perror(*argv); ! 8201: - exit(1); ! 8202: - } ! 8203: - if(e = openinode(&in, DO_INODE|SPIN_DOWN)){ ! 8204: - fprint(2, "%s: %s\n", *argv, e); ! 8205: - exit(1); ! 8206: - } ! 8207: - if(strcmp(in.vol_id, argv[optind])){ ! 8208: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], in.vol_id); ! 8209: - exit(1); ! 8210: - } ! 8211: - for(n = 1; n <= NSIG; n++) ! 8212: - signal(n, SIG_IGN); ! 8213: - eof = 0; ! 8214: - tfiles = tbytes = 0; ! 8215: - lineno = 0; ! 8216: - while(!eof){ ! 8217: - /* flush seperater lines */ ! 8218: - while(e = Frdline(0)){ ! 8219: - lineno++; ! 8220: - if(*e) ! 8221: - break; ! 8222: - } ! 8223: - if(e == 0) ! 8224: - break; ! 8225: - ininit(); ! 8226: - proc(&out, e); ! 8227: - strncpy(first, e, sizeof first); ! 8228: - if(out.nfree < minfree){ ! 8229: - fprint(2, "wcopy: disk %s full before copying group '%s' line %d\n", ! 8230: - out.vol_id, first, lineno); ! 8231: - exit(1); ! 8232: - } ! 8233: - while(e = Frdline(0)){ ! 8234: - lineno++; ! 8235: - if(*e == 0) ! 8236: - break; ! 8237: - proc(&out, e); ! 8238: - } ! 8239: - if(e == 0) ! 8240: - eof = 1; ! 8241: - if(bad) ! 8242: - exit(1); ! 8243: - nfiles = nbytes = 0; ! 8244: - blkdone = 0; ! 8245: - inwrite(&out, &in); ! 8246: - if(bad) ! 8247: - exit(1); ! 8248: - if(verbose) ! 8249: - fprint(1, "%s group('%s' %d files, %.6fMB) done\n", ! 8250: - timenow(), first, nfiles, nbytes/1e6); ! 8251: - tfiles += nfiles; ! 8252: - tbytes += nbytes; ! 8253: - } ! 8254: - if(verbose) ! 8255: - fprint(1, "%s total: %d files, %.6fMB\n", timenow(), tfiles, tbytes/1e6); ! 8256: - exit(0); ! 8257: -} ! 8258: - ! 8259: -usage() ! 8260: -{ ! 8261: - fprint(2, "Usage: worm copy [-v] [-m minfree] [-f src_dev] src_id dest_dev dest_id < files\n"); ! 8262: - exit(1); ! 8263: -} ! 8264: - ! 8265: -proc(s, file) ! 8266: - Superblock *s; ! 8267: - char *file; ! 8268: -{ ! 8269: - struct stat sbuf; ! 8270: - unsigned short mode; ! 8271: - Inode i; ! 8272: - Inode *srci; ! 8273: - ! 8274: - if((srci = inodeof(file)) == 0){ ! 8275: - fprint(2, "can't find file '%s'\n", file); ! 8276: - return; ! 8277: - } ! 8278: - memset((char *)&i, 0, sizeof(i)); ! 8279: - i = *srci; ! 8280: - i.block = 0; ! 8281: - nbytes += i.nbytes; ! 8282: - if(inadd(s, &i)) ! 8283: - bad = 1; ! 8284: -} ! 8285: - ! 8286: -writeout(dest, i, blk, src) ! 8287: - Superblock *dest, *src; ! 8288: - Inode *i; ! 8289: - long *blk; ! 8290: -{ ! 8291: - char b[BIGBLOCK]; ! 8292: - Inode *srci; ! 8293: - long n, len, blen; ! 8294: - char *name; ! 8295: - ! 8296: - n = (i->nbytes+dest->blocksize-1)/dest->blocksize; ! 8297: - *blk += n; ! 8298: - blkdone += n; ! 8299: - blen = sizeof b/dest->blocksize; ! 8300: - len = blen*dest->blocksize; ! 8301: - nbytes += i->nbytes; ! 8302: - nfiles++; ! 8303: - name = i->name.n; ! 8304: - srci = inodeof(name); ! 8305: - Seek(src, srci->block); ! 8306: - for(n = i->nbytes; n > len; n -= len){ ! 8307: - if(Read(src, b, blen)){ ! 8308: - out: ! 8309: - fprint(2, "read problem: seek=%d n=%d blen=%d len=%d; ", ! 8310: - srci->block, n, blen, len); ! 8311: - perror(name); ! 8312: - bad = 1; ! 8313: - return; ! 8314: - } ! 8315: - if(Write(dest, b, blen)){ ! 8316: -fprint(2, "nb=%d, n=%d len=%d blen=%d\n", i->nbytes, n, len, blen); ! 8317: - perror("data write"); ! 8318: - exit(1); ! 8319: - } ! 8320: - } ! 8321: - if(n){ ! 8322: - n += dest->blocksize-1; ! 8323: - n /= dest->blocksize; ! 8324: - if(Read(src, b, n)) ! 8325: - goto out; ! 8326: - if(Write(dest, b, n)){ ! 8327: - perror("data write"); ! 8328: - exit(1); ! 8329: - } ! 8330: - } ! 8331: -} ! 8332: //GO.SYSIN DD wcopy.c ! 8333: echo wdir.c 1>&2 ! 8334: sed 's/.//' >wdir.c <<'//GO.SYSIN DD wdir.c' ! 8335: -#include <libc.h> ! 8336: -#include "worm.h" ! 8337: -#include "sym.h" ! 8338: -#include <sys/types.h> ! 8339: -#include <sys/stat.h> ! 8340: - ! 8341: -char *dumpdir(); ! 8342: -int verbose = 0; ! 8343: - ! 8344: -main(argc, argv) ! 8345: - char **argv; ! 8346: -{ ! 8347: - Superblock s, news; ! 8348: - char *e; ! 8349: - char *dev = "/dev/worm0"; ! 8350: - int update = 0; ! 8351: - int c; ! 8352: - char buf[1024]; ! 8353: - extern char *optarg; ! 8354: - extern int optind; ! 8355: - void blkfn(); ! 8356: - ! 8357: - while((c = getopt(argc, argv, "f:vu")) != -1) ! 8358: - switch(c) ! 8359: - { ! 8360: - case 'f': dev = optarg; break; ! 8361: - case 'u': update = 1; break; ! 8362: - case 'v': verbose = 1; break; ! 8363: - case '?': usage(); ! 8364: - } ! 8365: - dev = mapdev(dev); ! 8366: - if(optind != argc-1) ! 8367: - usage(); ! 8368: - if((s.fd = open(dev, 2)) < 0){ ! 8369: - perror(dev); ! 8370: - exit(1); ! 8371: - } ! 8372: - if(e = openinode(&s, SPIN_DOWN)){ ! 8373: - fprint(2, "%s: %s\n", dev, e); ! 8374: - exit(2); ! 8375: - } ! 8376: - if(s.version != VBTREE){ ! 8377: - fprint(2, "%s is not a btree!\n", s.vol_id); ! 8378: - exit(2); ! 8379: - } ! 8380: - if(strcmp(argv[optind], s.vol_id)){ ! 8381: - fprint(2, "wanted volid '%s'; got '%s'\n", argv[optind], s.vol_id); ! 8382: - exit(1); ! 8383: - } ! 8384: - if(e = dumpdir(&s, update)){ ! 8385: - fprint(2, "%s: %s\n", dev, e); ! 8386: - exit(2); ! 8387: - } ! 8388: - sprint(buf, "/usr/worm/tmp/%s", s.vol_id); ! 8389: - unlink(buf); ! 8390: - exit(0); ! 8391: -} ! 8392: - ! 8393: -usage() ! 8394: -{ ! 8395: - fprint(2, "Usage: dir [-fdevice] -v] [-u] vol_id\n"); ! 8396: - exit(2); ! 8397: -} ! 8398: - ! 8399: -char * ! 8400: -dumpdir(s, update) ! 8401: - register Superblock *s; ! 8402: -{ ! 8403: - char *b; ! 8404: - static char buf[64]; ! 8405: - char name[256], buf1[256]; ! 8406: - ! 8407: - if((b = malloc(s->blocksize)) == 0){ ! 8408: - sprint(buf, "couldn't malloc buffer (%d bytes)", s->blocksize); ! 8409: - return(buf); ! 8410: - } ! 8411: - numinodes = s->ninodes; ! 8412: - sprint(name, "/usr/worm/dirs/%s", s->vol_id); ! 8413: - Seek(s, s->binodes); ! 8414: - sprint(buf1, "%s.F", name); ! 8415: - copyout(s, buf1, s->nF, update, verbose); ! 8416: - sprint(buf1, "%s.T", name); ! 8417: - copyout(s, buf1, s->nT, update, verbose); ! 8418: - sprint(buf1, "%s.I", name); ! 8419: - copyout(s, buf1, s->ninochars, update, verbose); ! 8420: - free(b); ! 8421: - return((char *)0); ! 8422: -} ! 8423: //GO.SYSIN DD wdir.c ! 8424: echo wild 1>&2 ! 8425: sed 's/.//' >wild <<'//GO.SYSIN DD wild' ! 8426: //GO.SYSIN DD wild ! 8427: echo wls.c 1>&2 ! 8428: sed 's/.//' >wls.c <<'//GO.SYSIN DD wls.c' ! 8429: -#include <libc.h> ! 8430: -#include "worm.h" ! 8431: -#include "sym.h" ! 8432: -#include <sys/types.h> ! 8433: -#include <sys/stat.h> ! 8434: -#include <pwd.h> ! 8435: -#include <grp.h> ! 8436: - ! 8437: -int lflag = 0; ! 8438: -int bflag = 0; ! 8439: - ! 8440: -main(argc, argv) ! 8441: - char **argv; ! 8442: -{ ! 8443: - Superblock s; ! 8444: - register Inode *i; ! 8445: - char *e; ! 8446: - char *dev = "/dev/worm0"; ! 8447: - int c; ! 8448: - extern char *optarg; ! 8449: - extern int optind; ! 8450: - void pr(); ! 8451: - ! 8452: - while((c = getopt(argc, argv, "lbf:")) != -1) ! 8453: - switch(c) ! 8454: - { ! 8455: - case 'f': dev = optarg; break; ! 8456: - case 'l': lflag = 1; break; ! 8457: - case 'b': bflag = 1; break; ! 8458: - case '?': usage(); ! 8459: - } ! 8460: - dev = mapdev(dev); ! 8461: - if((s.fd = open(dev, 0)) < 0){ ! 8462: - perror(dev); ! 8463: - exit(1); ! 8464: - } ! 8465: - if(e = openinode(&s, DO_INODE|SPIN_DOWN)){ ! 8466: - fprint(2, "%s: %s\n", dev, e); ! 8467: - exit(1); ! 8468: - } ! 8469: - c = 0; ! 8470: - if(optind < argc) ! 8471: - while(optind < argc){ ! 8472: - if(i = inodeof(argv[optind])) ! 8473: - pr(i); ! 8474: - else { ! 8475: - Fprint(2, "%s not found\n", argv[optind]); ! 8476: - c = 1; ! 8477: - } ! 8478: - optind++; ! 8479: - } ! 8480: - else ! 8481: - inodetraverse(pr); ! 8482: - exit(c); ! 8483: -} ! 8484: - ! 8485: -char * ! 8486: -suid(n) ! 8487: -{ ! 8488: - static char buf[24]; ! 8489: - struct passwd *p; ! 8490: - char *s; ! 8491: - ! 8492: - sprint(buf, "#%d", n); ! 8493: - if(s = (char *)symlook(buf, S_UID, (void *)0)) ! 8494: - strcpy(buf, s); ! 8495: - else { ! 8496: - s = strdup(buf); ! 8497: - if(p = getpwuid(n)) ! 8498: - strcpy(buf, p->pw_name); ! 8499: - (void)symlook(s, S_UID, (void *)strdup(buf)); ! 8500: - } ! 8501: - return(buf); ! 8502: -} ! 8503: - ! 8504: -char * ! 8505: -sgid(n) ! 8506: -{ ! 8507: - static char buf[24]; ! 8508: - struct group *g; ! 8509: - char *s; ! 8510: - ! 8511: - sprint(buf, "#%d", n); ! 8512: - if(s = (char *)symlook(buf, S_GID, (void *)0)) ! 8513: - strcpy(buf, s); ! 8514: - else { ! 8515: - s = strdup(buf); ! 8516: - if(g = getgrgid(n)) ! 8517: - strcpy(buf, g->gr_name); ! 8518: - (void)symlook(s, S_GID, (void *)strdup(buf)); ! 8519: - } ! 8520: - return(buf); ! 8521: -} ! 8522: - ! 8523: -mode(n, sx) ! 8524: -{ ! 8525: - Fputc(1, (n&4)? 'r':'-'); ! 8526: - Fputc(1, (n&2)? 'w':'-'); ! 8527: - Fputc(1, (n&1)? sx:'-'); ! 8528: -} ! 8529: - ! 8530: -void ! 8531: -pr(i) ! 8532: - register Inode *i; ! 8533: -{ ! 8534: - char *s; ! 8535: - ! 8536: - if(lflag){ ! 8537: - Fputc(1, ((i->mode&S_IFMT) == S_IFDIR)? 'd':'-'); ! 8538: - mode(i->mode>>6, ((i->mode&S_IFMT) == S_ISUID)? 's':'x'); ! 8539: - mode(i->mode>>3, ((i->mode&S_IFMT) == S_ISGID)? 's':'x'); ! 8540: - mode(i->mode, 'x'); ! 8541: - Fputc(1, ((i->mode&S_IFMT) == S_IFLNK)? 'L':' '); ! 8542: - s = ctime(&i->ctime); ! 8543: - s += 4; ! 8544: - s[12] = 0; ! 8545: - Fprint(1, "%2d%8s%7s %6ld %s %s\n", 1, suid(i->uid), sgid(i->gid), ! 8546: - i->nbytes, s, i->name.n); ! 8547: - return; ! 8548: - } ! 8549: - if(bflag) ! 8550: - Fprint(1, "%s\t%ld\n", i->name.n, i->block); ! 8551: - else ! 8552: - Fprint(1, "%s\n", i->name.n); ! 8553: -} ! 8554: - ! 8555: -usage() ! 8556: -{ ! 8557: - fprint(2, "Usage: worm ls [-fdevice] [-l] [-b] [files ...]\n"); ! 8558: - exit(2); ! 8559: -} ! 8560: //GO.SYSIN DD wls.c ! 8561: echo wmkfs.c 1>&2 ! 8562: sed 's/.//' >wmkfs.c <<'//GO.SYSIN DD wmkfs.c' ! 8563: -#include <libc.h> ! 8564: -#include "worm.h" ! 8565: -#include <sys/types.h> ! 8566: -#include <sys/udaioc.h> ! 8567: - ! 8568: -usage() ! 8569: -{ ! 8570: - fprint(2, "Usage: worm mkfs [-fdevice] [-ccomments] [-bblksize] [-nnblks] [-vnewvol_id] vol_id\n"); ! 8571: - fprint(2, "e.g. worm mkfs -f1 -c\"512x512x24 movies\" tdmovies1a\n"); ! 8572: - exit(1); ! 8573: -} ! 8574: - ! 8575: -main(argc, argv) ! 8576: - char **argv; ! 8577: -{ ! 8578: - Superblock s, os; ! 8579: - char *b; ! 8580: - long sb; ! 8581: - int c; ! 8582: - char *volid; ! 8583: - char *dev = "/dev/worm0"; ! 8584: - char *nblks = 0; ! 8585: - char *bsize = 0; ! 8586: - char *nvolid = 0; ! 8587: - char *comments = 0; ! 8588: - char *e; ! 8589: - int virgin; ! 8590: - extern optind; ! 8591: - extern char *optarg; ! 8592: - ! 8593: - while((c = getopt(argc, argv, "f:n:b:c:v:")) != -1) ! 8594: - switch(c) ! 8595: - { ! 8596: - case 'b': bsize = optarg; break; ! 8597: - case 'c': comments = optarg; break; ! 8598: - case 'f': dev = optarg; break; ! 8599: - case 'n': nblks = optarg; break; ! 8600: - case 'v': nvolid = optarg; break; ! 8601: - case '?': usage(); ! 8602: - } ! 8603: - if(optind != argc-1) ! 8604: - usage(); ! 8605: - volid = argv[optind]; ! 8606: - if(strlen(volid) > sizeof(s.vol_id)-1) ! 8607: - volid[sizeof(s.vol_id)-1] = 0; ! 8608: - c = volid[strlen(volid)-1]; ! 8609: - if((c != 'a') && (c != 'b')){ ! 8610: - if(nvolid == 0){ ! 8611: - fprint(2, "worm mkfs: vol_id '%s' must end in 'a' or 'b'\n", volid); ! 8612: - exit(1); ! 8613: - } ! 8614: - fprint(2, "worm mkfs: warning: vol_id '%s' should end in 'a' or 'b'\n", volid); ! 8615: - } ! 8616: - if(nvolid){ ! 8617: - if(strlen(nvolid) > sizeof(s.vol_id)-1) ! 8618: - nvolid[sizeof(s.vol_id)-1] = 0; ! 8619: - c = nvolid[strlen(nvolid)-1]; ! 8620: - if((c != 'a') && (c != 'b')){ ! 8621: - fprint(2, "worm mkfs: vol_id '%s' must end in 'a' or 'b'\n", nvolid); ! 8622: - exit(1); ! 8623: - } ! 8624: - } ! 8625: - dev = mapdev(dev); ! 8626: - if((s.fd = open(dev, 2)) < 0){ ! 8627: - perror(dev); ! 8628: - exit(1); ! 8629: - } ! 8630: - /* ! 8631: - now, do we read the current superblock or make one up? ! 8632: - this is hard to answer in general, push the answer off to virginal() ! 8633: - */ ! 8634: - virgin = virginal(&s); ! 8635: - if(virgin){ ! 8636: - setdefaults(&s, nblks); ! 8637: - if((s.blocksize < 512) || (s.blocksize%512)){ ! 8638: - fprint(2, "worm mkfs: bad blocksize '%s'\n", bsize); ! 8639: - exit(1); ! 8640: - } ! 8641: - strcpy(s.vol_id, volid); ! 8642: - } else { ! 8643: - if(strcmp(volid, s.vol_id)){ ! 8644: - fprint(2, "worm mkfs: volid mismatch; expected %s, got %s\n", ! 8645: - volid, s.vol_id); ! 8646: - exit(1); ! 8647: - } ! 8648: - } ! 8649: - /* set any new parameters */ ! 8650: - if(nvolid) ! 8651: - strcpy(s.vol_id, nvolid); ! 8652: - if(bsize) ! 8653: - s.blocksize = atoi(bsize); ! 8654: - if(s.blocksize < 512){ ! 8655: - fprint(2, "wormmkfs: bad nblocks = '%s'\n", nblks); ! 8656: - exit(1); ! 8657: - } ! 8658: - if(s.blocksize % sizeof(Inode)){ ! 8659: - fprint(2, "worm mkfs: sizeof(Inode)=%d does not divide blocksize %d\n", ! 8660: - sizeof(Inode), s.blocksize); ! 8661: - exit(1); ! 8662: - } ! 8663: - if(comments){ ! 8664: - if(strlen(comments) > sizeof(s.comment)-1) ! 8665: - comments[sizeof(s.comment)-1] = 0; ! 8666: - strcpy(s.comment, comments); ! 8667: - } ! 8668: - /* only check if we are changing it */ ! 8669: - if(nblks && !virgin){ ! 8670: - s.nblocks = atoi(nblks); ! 8671: - s.nfree = s.nblocks - s.nextffree; ! 8672: - if(s.nfree <= 1){ ! 8673: - fprint(2, "worm mkfs: new nblocks(%d) is too small\n", s.nblocks); ! 8674: - exit(1); ! 8675: - } ! 8676: - } ! 8677: - /* now allocate the new superblock */ ! 8678: - sb = s.nextsb; ! 8679: - s.myblock = sb; ! 8680: - s.nextsb = sb+1; ! 8681: - s.nextffree = sb+2; ! 8682: - s.nfree -= 1; ! 8683: - s.ninodes = 0; ! 8684: - s.ninochars = 0; ! 8685: - s.binodes = 0; ! 8686: - time(&s.ctime); ! 8687: - /* write it */ ! 8688: - if((b = malloc(s.blocksize)) == 0){ ! 8689: - fprint(2, "worm mkfs: cannot malloc buffer %d bytes\n", s.blocksize); ! 8690: - exit(1); ! 8691: - } ! 8692: - memset(b, 0, s.blocksize); ! 8693: - memcpy(b, (char *)&s, sizeof(s)); ! 8694: - Seek(&s, sb); ! 8695: - if(Write(&s, b, 1L)) ! 8696: - exit(1); ! 8697: - ioctl(s.fd, UIOSPDW); ! 8698: - exit(0); ! 8699: -} ! 8700: - ! 8701: -setdefaults(s, nblks) ! 8702: - Superblock *s; ! 8703: - char *nblks; ! 8704: -{ ! 8705: - struct ud_unit sz; ! 8706: - char buf[1024]; ! 8707: - ! 8708: - s->magic = SMAGIC; ! 8709: - s->blocksize = 1024; ! 8710: - s->version = VLINK; ! 8711: - if(nblks){ ! 8712: - s->nblocks = atoi(nblks); ! 8713: - if(s->nblocks <= 2){ ! 8714: - fprint(2, "worm mkfs: nblocks(%d) too small\n", s->nblocks); ! 8715: - exit(1); ! 8716: - } ! 8717: - } else { ! 8718: - read(s->fd, buf, sizeof buf); /* ignore error */ ! 8719: - if(ioctl(s->fd, UIOCHAR, &sz) >= 0){ ! 8720: - switch(sz.radsize) ! 8721: - { /* note below figures/2 used in scsi/volid.c */ ! 8722: - case 3275999: /* sony 12in clv single density */ ! 8723: - s->nblocks = 1600000; ! 8724: - break; ! 8725: - case 6551999: /* sony 12in clv double density */ ! 8726: - s->nblocks = 3250000; ! 8727: - break; ! 8728: - default: ! 8729: - fprint(2, "worm mkfs: unknown size %d\n", sz.radsize); ! 8730: - exit(1); ! 8731: - } ! 8732: - } else ! 8733: - s->nblocks = 1600000; ! 8734: - fprint(2, "worm mkfs: using disk size %d\n", s->nblocks); ! 8735: - } ! 8736: - s->zero = 0; ! 8737: - s->nfree = s->nblocks-1; ! 8738: - s->nextffree = 0; ! 8739: - s->nextsb = 1; ! 8740: - s->vol_id[0] = 0; ! 8741: - s->comment[0] = 0; ! 8742: - s->myblock = 0; ! 8743: - s->ctime = 0; ! 8744: -} ! 8745: - ! 8746: -virginal(s) ! 8747: - Superblock *s; ! 8748: -{ ! 8749: - char buf[1024]; ! 8750: - static char zeros[1024]; ! 8751: - long sb; ! 8752: - char *e; ! 8753: - extern char *getenv(); ! 8754: - ! 8755: - if(e = getenv("WORMZERO")) ! 8756: - sb = atoi(e); ! 8757: - else ! 8758: - sb = 1; ! 8759: - bigseek(s->fd, sb, 1024, 0); ! 8760: - errno = 0; ! 8761: - if(read(s->fd, buf, 1024) == 1024) ! 8762: - goto valid; ! 8763: - if((errno != ENXIO) && (errno != 0) && memcmp(buf, zeros, 1024)) ! 8764: - goto invalid; ! 8765: - errno = 0; ! 8766: - if(read(s->fd, buf, 1024) == 1024){ /* try next block */ ! 8767: -valid: ! 8768: - if(e = openinode(s, SPIN_DOWN)){ ! 8769: - fprint(2, "worm mkfs: %s\n", e); ! 8770: - exit(1); ! 8771: - } ! 8772: - return(0); ! 8773: - } else { ! 8774: - if((errno == ENXIO) || (errno == 0) || (memcmp(buf, zeros, 1024) == 0)) ! 8775: - return(1); ! 8776: -invalid: ! 8777: - perror("worm mkfs: I/O errors probing for superblock"); ! 8778: - exit(1); ! 8779: - } ! 8780: -} ! 8781: //GO.SYSIN DD wmkfs.c ! 8782: echo wmount.c 1>&2 ! 8783: sed 's/.//' >wmount.c <<'//GO.SYSIN DD wmount.c' ! 8784: -#include <libc.h> ! 8785: -#include "worm.h" ! 8786: - ! 8787: -main(argc, argv) ! 8788: - char **argv; ! 8789: -{ ! 8790: - Superblock s; ! 8791: - char *e, *vol_id = 0, *vol; ! 8792: - char *dev = "/dev/worm0"; ! 8793: - int c; ! 8794: - long nf = 0; ! 8795: - char wflag[512]; ! 8796: - char buf[512]; ! 8797: - int i; ! 8798: - extern char *optarg; ! 8799: - extern int optind; ! 8800: - extern long atol(); ! 8801: - ! 8802: - wflag[0] = 0; ! 8803: - while((c = getopt(argc, argv, "w:")) != -1) ! 8804: - switch(c) ! 8805: - { ! 8806: - case 'w': sprint(wflag, "-w%s", optarg); break; ! 8807: - case '?': usage(); ! 8808: - } ! 8809: - if(optind < argc){ ! 8810: - vol_id = argv[optind++]; ! 8811: - if(optind != argc) ! 8812: - usage(); ! 8813: - } ! 8814: - if(vol_id == 0){ ! 8815: - for(i = 0; ; i++){ ! 8816: - sprint(buf, "%d", i); ! 8817: - dev = mapdev(buf); ! 8818: - if((s.fd = open(dev, 0)) < 0){ ! 8819: - if(errno == ENOENT) ! 8820: - break; ! 8821: - if(errno == ENXIO) ! 8822: - continue; ! 8823: - perror(dev); ! 8824: - exit(2); ! 8825: - } ! 8826: - if(e = openinode(&s, SPIN_DOWN)){ ! 8827: - fprint(2, "%s: %s\n", dev, e); ! 8828: - exit(2); ! 8829: - } ! 8830: - print("%s: %s\n", dev, s.vol_id); ! 8831: - close(s.fd); ! 8832: - } ! 8833: - exit(0); ! 8834: - } ! 8835: - if(isjukebox()){ ! 8836: - jload(vol_id, wflag); ! 8837: - exit(0); ! 8838: - } ! 8839: - { ! 8840: - for(i = 0; ; i++){ ! 8841: - sprint(buf, "%d", i); ! 8842: - dev = mapdev(buf); ! 8843: - if((s.fd = open(dev, 0)) < 0){ ! 8844: - if(errno == ENOENT) ! 8845: - break; ! 8846: - if(errno == ENXIO) ! 8847: - continue; ! 8848: - perror(dev); ! 8849: - exit(2); ! 8850: - } ! 8851: - if(e = openinode(&s, SPIN_DOWN)){ ! 8852: - fprint(2, "%s: %s\n", dev, e); ! 8853: - exit(2); ! 8854: - } ! 8855: - if(strcmp(vol_id, s.vol_id) == 0){ ! 8856: - print("%s\n", buf); ! 8857: - exit(0); ! 8858: - } ! 8859: - close(s.fd); ! 8860: - } ! 8861: - } ! 8862: - fprint(2, "worm mount: couldn't find %s\n", vol_id); ! 8863: - exit(1); ! 8864: -} ! 8865: - ! 8866: -usage() ! 8867: -{ ! 8868: - print("Usage: worm mount [-wsecs] [vol_id]\n"); ! 8869: - exit(2); ! 8870: -} ! 8871: - ! 8872: -/* ! 8873: - return zero if there isn't a jukebox ! 8874: -*/ ! 8875: -isjukebox() ! 8876: -{ ! 8877: - return(access("/dev/scsi", 6) == 0); ! 8878: -} ! 8879: - ! 8880: -/* ! 8881: - secs is the number of seconds to wait ! 8882: -*/ ! 8883: -jload(vol, secs) ! 8884: - char *vol, *secs; ! 8885: -{ ! 8886: - if(*secs) ! 8887: - execlp("/usr/lib/worm/jukebox", "jukebox", secs, "-m", vol, (char *)0); ! 8888: - else ! 8889: - execlp("/usr/lib/worm/jukebox", "jukebox", "-m", vol, (char *)0); ! 8890: - perror("execlp(/usr/lib/worm/jukebox)"); ! 8891: - exit(1); ! 8892: -} ! 8893: //GO.SYSIN DD wmount.c ! 8894: echo wmv.c 1>&2 ! 8895: sed 's/.//' >wmv.c <<'//GO.SYSIN DD wmv.c' ! 8896: -#include <libc.h> ! 8897: -#include "worm.h" ! 8898: -#include "sym.h" ! 8899: -#include <sys/types.h> ! 8900: -#include <sys/stat.h> ! 8901: -#include <pwd.h> ! 8902: -#include <grp.h> ! 8903: -#include <signal.h> ! 8904: - ! 8905: -int lflag = 0; ! 8906: -int bflag = 0; ! 8907: - ! 8908: -main(argc, argv) ! 8909: - char **argv; ! 8910: -{ ! 8911: - Superblock s; ! 8912: - register Inode *i; ! 8913: - Inode newi; ! 8914: - char *e; ! 8915: - char *dev = "/dev/worm0"; ! 8916: - int c; ! 8917: - extern char *optarg; ! 8918: - extern int optind; ! 8919: - void pr(); ! 8920: - ! 8921: - while((c = getopt(argc, argv, "lbf:")) != -1) ! 8922: - switch(c) ! 8923: - { ! 8924: - case 'f': dev = optarg; break; ! 8925: - case 'l': lflag = 1; break; ! 8926: - case 'b': bflag = 1; break; ! 8927: - case '?': usage(); ! 8928: - } ! 8929: - dev = mapdev(dev); ! 8930: - if((s.fd = open(dev, 2)) < 0){ ! 8931: - perror(dev); ! 8932: - exit(1); ! 8933: - } ! 8934: - if(e = openinode(&s, DO_INODE|SPIN_DOWN)){ ! 8935: - fprint(2, "%s: %s\n", dev, e); ! 8936: - exit(1); ! 8937: - } ! 8938: - if(optind != argc-3) ! 8939: - usage(); ! 8940: - if(strcmp(s.vol_id, argv[optind])){ ! 8941: - fprint(2, "worm mv: vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id); ! 8942: - exit(1); ! 8943: - } ! 8944: - optind++; ! 8945: - if((i = inodeof(argv[optind])) == 0){ ! 8946: - Fprint(2, "%s not found\n", argv[optind]); ! 8947: - exit(1); ! 8948: - } ! 8949: - optind++; ! 8950: - if(strlen(argv[optind]) < 1){ ! 8951: - Fprint(2, "worm mv: destination name is null\n"); ! 8952: - exit(1); ! 8953: - } ! 8954: - for(c = 1; c <= NSIG; c++) ! 8955: - signal(c, SIG_IGN); ! 8956: - ininit(); ! 8957: - newi = *i; ! 8958: - i->block = -1; ! 8959: - inadd(&s, i); ! 8960: - newi.name.n = argv[optind]; ! 8961: - inadd(&s, &newi); ! 8962: - if(inwrite(&s)) ! 8963: - exit(1); ! 8964: - exit(0); ! 8965: -} ! 8966: - ! 8967: -usage() ! 8968: -{ ! 8969: - fprint(2, "Usage: worm mv [-fdevice] vol_id from to\n"); ! 8970: - exit(2); ! 8971: -} ! 8972: - ! 8973: -static Inode *inodes; ! 8974: -static long ip; ! 8975: -static long ninodes = 0; ! 8976: -static char *nameb; ! 8977: -static long np; ! 8978: -static long nnameb = 0; ! 8979: -static long nblocks; ! 8980: -#define IINC 1024 ! 8981: -#define NINC (64*IINC) ! 8982: - ! 8983: -ininit() ! 8984: -{ ! 8985: - if(nnameb == 0){ ! 8986: - nameb = malloc((unsigned)(nnameb = NINC)); ! 8987: - if(nameb == 0){ ! 8988: - fprint(2, "wmv: malloc fail, %d bytes\n", nnameb); ! 8989: - exit(1); ! 8990: - } ! 8991: - } ! 8992: - np = 0; ! 8993: - if(ninodes == 0){ ! 8994: - inodes = (Inode *)malloc(sizeof(Inode)*(unsigned)(ninodes = IINC)); ! 8995: - if(inodes == 0){ ! 8996: - fprint(2, "wmv: malloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 8997: - exit(1); ! 8998: - } ! 8999: - } ! 9000: - ip = 0; ! 9001: -} ! 9002: - ! 9003: -inadd(s, i) ! 9004: - Superblock *s; ! 9005: - register Inode *i; ! 9006: -{ ! 9007: - register long len; ! 9008: - ! 9009: - len = strlen(i->name.n)+1; ! 9010: - if(np+len > nnameb){ ! 9011: - while(np+len > nnameb) ! 9012: - nnameb += NINC; ! 9013: - nameb = realloc(nameb, (unsigned)nnameb); ! 9014: - if(nameb == 0){ ! 9015: - fprint(2, "wmv: realloc fail, %d bytes\n", nnameb); ! 9016: - exit(1); ! 9017: - } ! 9018: - } ! 9019: - strcpy(nameb+np, i->name.n); ! 9020: - i->name.o = np; ! 9021: - np += len; ! 9022: - if(ip == ninodes){ ! 9023: - ninodes += IINC; ! 9024: - inodes = (Inode *)realloc((char *)inodes, (unsigned)ninodes*sizeof(Inode)); ! 9025: - if(inodes == 0){ ! 9026: - fprint(2, "wmv: realloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 9027: - exit(1); ! 9028: - } ! 9029: - } ! 9030: - inodes[ip++] = *i; ! 9031: -} ! 9032: - ! 9033: -inwrite(s) ! 9034: - Superblock *s; ! 9035: -{ ! 9036: - char *e; ! 9037: - ! 9038: - if(e = lkwri(s, inodes, ip, nameb, np, 0L)){ ! 9039: - fprint(2, "%s\n", e); ! 9040: - return(1); ! 9041: - } ! 9042: - return(0); ! 9043: -} ! 9044: //GO.SYSIN DD wmv.c ! 9045: echo woffline.c 1>&2 ! 9046: sed 's/.//' >woffline.c <<'//GO.SYSIN DD woffline.c' ! 9047: -#include <libc.h> ! 9048: -#include "worm.h" ! 9049: -#include <sys/types.h> ! 9050: -#include <sys/udaioc.h> ! 9051: - ! 9052: -main(argc, argv) ! 9053: - char **argv; ! 9054: -{ ! 9055: - Superblock s; ! 9056: - char *vol_id = 0; ! 9057: - char buf[1024]; ! 9058: - char *dev = "/dev/worm0"; ! 9059: - int c; ! 9060: - extern char *optarg; ! 9061: - extern int optind; ! 9062: - ! 9063: - while((c = getopt(argc, argv, "f:")) != -1) ! 9064: - switch(c) ! 9065: - { ! 9066: - case 'f': dev = optarg; break; ! 9067: - case '?': usage(); ! 9068: - } ! 9069: - if(optind != argc) ! 9070: - usage(); ! 9071: - dev = mapdev(dev); ! 9072: - if((s.fd = open(dev, 2)) < 0){ ! 9073: - if(!vol_id) ! 9074: - perror(dev); ! 9075: - exit(2); ! 9076: - } ! 9077: - /* have to read to make ioctl work */ ! 9078: - lseek(s.fd, 1024L, 0); ! 9079: - read(s.fd, buf, sizeof buf); ! 9080: - if(ioctl(s.fd, UIOSPDW) < 0){ ! 9081: - perror("ioctl"); ! 9082: - exit(2); ! 9083: - } ! 9084: - exit(0); ! 9085: -} ! 9086: - ! 9087: -usage() ! 9088: -{ ! 9089: - print("Usage: worm offline [-fdevice]\n"); ! 9090: - exit(2); ! 9091: -} ! 9092: //GO.SYSIN DD woffline.c ! 9093: echo worm.h 1>&2 ! 9094: sed 's/.//' >worm.h <<'//GO.SYSIN DD worm.h' ! 9095: -#include <errno.h> ! 9096: - ! 9097: -#define SMAGIC 0x21746967 ! 9098: -#define DMAGIC 0x3A746967 ! 9099: - ! 9100: -typedef struct Superblock ! 9101: -{ ! 9102: - long magic; /* magic number for Superblock */ ! 9103: - unsigned short blocksize; /* physical size of blocks */ ! 9104: - short version; /* type of superblock */ ! 9105: - long nblocks; /* number of blocks on device */ ! 9106: - long zero; /* first logical data block */ ! 9107: - long nfree; /* number of free blocks */ ! 9108: - long ninodes; /* number of inodes */ ! 9109: - long ninochars; /* number of bytes of inode names */ ! 9110: - long binodes; /* start of inodes */ ! 9111: - long nextffree; /* next free file block */ ! 9112: - long nextsb; /* next superblock */ ! 9113: - short fd; /* fildes for device (in core) */ ! 9114: - char vol_id[128]; /* name the disk can be mounted as */ ! 9115: - char comment[128]; /* comments */ ! 9116: - long myblock; /* where this superblock is */ ! 9117: - long nF; /* bytes for .F (VBTREE) */ ! 9118: - long nT; /* bytes for .T (VBTREE) */ ! 9119: - long ctime; /* create time for this superblock */ ! 9120: -} Superblock; ! 9121: - ! 9122: -typedef struct Inode ! 9123: -{ ! 9124: - long magic; /* magic number for Dirent */ ! 9125: - long block; /* starting block of file */ ! 9126: - long nbytes; /* bytes in file */ ! 9127: - long ctime; /* creation time */ ! 9128: - union { ! 9129: - char *n; /* core - name */ ! 9130: - long o; /* disk - offset into chars block */ ! 9131: - } name; /* filename */ ! 9132: - long pad1; /* to 32 bytes */ ! 9133: - short mode; /* a la stat */ ! 9134: - short uid; /* owner */ ! 9135: - short gid; /* owner */ ! 9136: - short pad2; /* to 32 bytes */ ! 9137: -} Inode; ! 9138: -#define IPERB (s->blocksize/sizeof(Inode)) ! 9139: - ! 9140: -extern char *openinode(), *lkwri(), *lkwsb(); ! 9141: -extern char *mapdev(); ! 9142: -extern Inode *(*inodefn)(); ! 9143: -extern void (*traversefn)(); ! 9144: -extern long numinodes; ! 9145: -extern long numnamechars; ! 9146: -extern char *timenow(); ! 9147: - ! 9148: -#define inodeof(s) (*inodefn)(s) ! 9149: -#define inodetraverse(fn) (*traversefn)(fn) ! 9150: - ! 9151: -#define VLINK 1 /* linked list version */ ! 9152: -#define VBTREE 2 /* cbt */ ! 9153: - ! 9154: -#define NBLKS(s, x) (long)(((s)->blocksize-1+(x))/(s)->blocksize) ! 9155: - ! 9156: -/* ! 9157: - flags for openinode ! 9158: -*/ ! 9159: -#define DO_INODE 1 ! 9160: -#define SPIN_DOWN 2 ! 9161: - ! 9162: -#define BIGBLOCK (60*1024L) /* max read/write */ ! 9163: - ! 9164: -/* ! 9165: - in.c declarations ! 9166: -*/ ! 9167: - ! 9168: -extern int bad; ! 9169: -extern long nbytes; ! 9170: -extern long blkdone; ! 9171: -extern long nfiles; ! 9172: -extern char *argout; ! 9173: //GO.SYSIN DD worm.h ! 9174: echo wpoke.c 1>&2 ! 9175: sed 's/.//' >wpoke.c <<'//GO.SYSIN DD wpoke.c' ! 9176: -#include <libc.h> ! 9177: -#include "worm.h" ! 9178: - ! 9179: -main(argc, argv) ! 9180: - char **argv; ! 9181: -{ ! 9182: - Superblock s; ! 9183: - char *e, *vol_id = 0; ! 9184: - char *dev = "/dev/worm0"; ! 9185: - int c; ! 9186: - long nf = 0; ! 9187: - int vflag = 0; ! 9188: - Superblock ss; ! 9189: - extern char *optarg; ! 9190: - extern int optind; ! 9191: - extern long atol(); ! 9192: - ! 9193: - while((c = getopt(argc, argv, "vF:f:")) != -1) ! 9194: - switch(c) ! 9195: - { ! 9196: - case 'f': dev = optarg; break; ! 9197: - case 'F': nf = atol(optarg); break; ! 9198: - case 'v': vflag = 1; break; ! 9199: - case '?': usage(); ! 9200: - } ! 9201: - if(optind < argc){ ! 9202: - vol_id = argv[optind++]; ! 9203: - if(optind != argc) ! 9204: - usage(); ! 9205: - } ! 9206: - dev = mapdev(dev); ! 9207: - if((s.fd = open(dev, 0)) < 0){ ! 9208: - perror(dev); ! 9209: - exit(2); ! 9210: - } ! 9211: - if(read(s.fd, &ss, sizeof ss) != sizeof ss){ ! 9212: - if(errno == ENXIO) ! 9213: - print("unwritten block zero\n"); ! 9214: - else ! 9215: - perror("block zero"); ! 9216: - } else { ! 9217: - if(ss.magic == SMAGIC){ ! 9218: - print("appears to be a good superblock at zero\n"); ! 9219: - exit(0); ! 9220: - } else if(ss.magic == 0){ ! 9221: - print("appears to be a zero'ed block at zero.\n"); ! 9222: - } else ! 9223: - print("ignoring bogus block at zero\n"); ! 9224: - } ! 9225: - vlink(s.fd, 1); ! 9226: - exit(0); ! 9227: -} ! 9228: - ! 9229: -usage() ! 9230: -{ ! 9231: - print("Usage: worm poke [-v] [-fdevice] [-Fnfree] [vol_id]\n"); ! 9232: - exit(2); ! 9233: -} ! 9234: - ! 9235: -vlink(fd, blk) ! 9236: -{ ! 9237: - Superblock s; ! 9238: - int i, n; ! 9239: - ! 9240: - while(blk < 1650000){ ! 9241: -loop: ! 9242: -print("reading sb at %d\n", blk); ! 9243: - bigseek(fd, blk, 1024, 0); ! 9244: - if(read(fd, &s, sizeof s) == sizeof s){ ! 9245: - if(s.magic == SMAGIC){ ! 9246: - blk = s.nextsb; ! 9247: - continue; ! 9248: - } ! 9249: - print("apparent garbage at supposed superblock@%ld\n", blk); ! 9250: - } else { ! 9251: - print("bad read at blk %ld, errno=%d\n", blk, errno); ! 9252: - lseek(fd, 1024, 1); ! 9253: - blk++; ! 9254: - } ! 9255: - for(i = 0; i < 50; i++){ ! 9256: - n = read(fd, &s, sizeof s); ! 9257: - if(n < 0){ ! 9258: - lseek(fd, 1024, 1); ! 9259: - continue; ! 9260: - } ! 9261: - if((n == sizeof s) && (s.magic == SMAGIC)){ ! 9262: - blk += i; ! 9263: - print("after error, skipped %d blocks to apparent superblock at %ld\n", i, blk); ! 9264: - goto loop; ! 9265: - } ! 9266: - } ! 9267: - print("after error, no superblock after %d tries\n", i); ! 9268: - blk += i; ! 9269: - } ! 9270: -} ! 9271: //GO.SYSIN DD wpoke.c ! 9272: echo wread.c 1>&2 ! 9273: sed 's/.//' >wread.c <<'//GO.SYSIN DD wread.c' ! 9274: -#include <libc.h> ! 9275: -#include <fio.h> ! 9276: -#include "sym.h" ! 9277: -#include "worm.h" ! 9278: -#include <sys/types.h> ! 9279: -#include <sys/stat.h> ! 9280: - ! 9281: -char *prefix = ""; ! 9282: -int dflag = 0; ! 9283: -int quiet = 0; ! 9284: -int mflag = 0; ! 9285: - ! 9286: -main(argc, argv) ! 9287: - char **argv; ! 9288: -{ ! 9289: - Superblock s; ! 9290: - char *e; ! 9291: - int c; ! 9292: - char *dev = "/dev/worm0"; ! 9293: - extern char *optarg; ! 9294: - extern int optind; ! 9295: - ! 9296: - while((c = getopt(argc, argv, "dmf:p:s")) != -1) ! 9297: - switch(c) ! 9298: - { ! 9299: - case 'd': dflag = 1; break; ! 9300: - case 'f': dev = optarg; break; ! 9301: - case 'm': mflag = 1; break; ! 9302: - case 'p': prefix = optarg; break; ! 9303: - case 's': quiet = 1; break; ! 9304: - case '?': usage(); ! 9305: - } ! 9306: - if(optind >= argc) ! 9307: - usage(); ! 9308: - dev = mapdev(dev); ! 9309: - if((s.fd = open(dev, 0)) < 0){ ! 9310: - perror(dev); ! 9311: - exit(1); ! 9312: - } ! 9313: - if(e = openinode(&s, DO_INODE|SPIN_DOWN)){ ! 9314: - fprint(2, "%s: %s\n", dev, e); ! 9315: - exit(1); ! 9316: - } ! 9317: - if(strcmp(s.vol_id, argv[optind])){ ! 9318: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id); ! 9319: - exit(1); ! 9320: - } ! 9321: - optind++; ! 9322: - c = 0; ! 9323: - if(optind >= argc){ ! 9324: - while(e = Frdline(0)) ! 9325: - if(pr(&s, e)) ! 9326: - c = 1; ! 9327: - } else { ! 9328: - while(optind < argc) ! 9329: - if(pr(&s, argv[optind++])) ! 9330: - c = 1; ! 9331: - } ! 9332: - exit(c); ! 9333: -} ! 9334: - ! 9335: -usage() ! 9336: -{ ! 9337: - fprint(2, "Usage: worm read [-fdevice] [-pprefix] [-dm] vol_id [files ...]\n"); ! 9338: - exit(1); ! 9339: -} ! 9340: - ! 9341: -pr(s, name) ! 9342: - Superblock *s; ! 9343: - char *name; ! 9344: -{ ! 9345: - register Inode *i; ! 9346: - char b[63*1024L]; ! 9347: - register long len, n; ! 9348: - long nb; ! 9349: - int fd; ! 9350: - char buf[4096]; ! 9351: - ! 9352: - if((i = inodeof(name)) == 0){ ! 9353: - fprint(2, "%s not found\n", name); ! 9354: - return(1); ! 9355: - } ! 9356: - sprint(buf, "%s%s", prefix, name); ! 9357: - name = buf; ! 9358: - if((fd = create(name, i->mode, i->uid, i->gid, i->ctime)) < 0){ ! 9359: - if(dflag){ ! 9360: - createdirs(name); ! 9361: - fd = create(name, i->mode, i->uid, i->gid, i->ctime); ! 9362: - } ! 9363: - if(fd < 0){ ! 9364: - perror(name); ! 9365: - return(1); ! 9366: - } ! 9367: - } ! 9368: - if(fd == 0) /* a directory */ ! 9369: - return(0); ! 9370: - nb = sizeof b / s->blocksize; ! 9371: - Seek(s, i->block); ! 9372: - for(n = i->nbytes, len = nb*s->blocksize; n > 0;){ ! 9373: - if(len > n){ ! 9374: - len = n; ! 9375: - nb = (len+s->blocksize-1)/s->blocksize; ! 9376: - } ! 9377: - if(Read(s, b, nb)){ ! 9378: - fprint(2, "while writing %s: ", name); ! 9379: - perror("read"); ! 9380: - exit(1); ! 9381: - } ! 9382: - if(write(fd, b, (int)len) != len){ ! 9383: - fprint(2, "while writing %s: ", name); ! 9384: - perror("write"); ! 9385: - exit(1); ! 9386: - } ! 9387: - n -= len; ! 9388: - } ! 9389: - close(fd); ! 9390: - if(mflag){ ! 9391: - time_t tp[2]; ! 9392: - ! 9393: - tp[0] = tp[1] = i->ctime; ! 9394: - utime(name, tp); ! 9395: - } ! 9396: - return(0); ! 9397: -} ! 9398: - ! 9399: -createdirs(s) ! 9400: - char *s; ! 9401: -{ ! 9402: - char *ls, *ss; ! 9403: - ! 9404: - for(ls = s; *ls == '/'; ls++) ! 9405: - ; ! 9406: - for(; *ls && (ss = strchr(ls, '/')); ls = ss+1){ ! 9407: - *ss = 0; ! 9408: - if(access(s, 0) < 0){ ! 9409: - if(mkdir(s, 0777) < 0){ ! 9410: - perror(s); ! 9411: - return; ! 9412: - } else if(!quiet) ! 9413: - fprint(2, "created %s\n", s); ! 9414: - } ! 9415: - *ss = '/'; ! 9416: - } ! 9417: -} ! 9418: - ! 9419: -create(name, mode, uid, gid, t) ! 9420: - char *name; ! 9421: - time_t t; ! 9422: -{ ! 9423: - time_t tp[2]; ! 9424: - ! 9425: - tp[0] = tp[1] = t; ! 9426: - if((mode&S_IFMT) == S_IFDIR){ ! 9427: - if(access(name, 0) >= 0){ ! 9428: - if(chmod(name, mode) < 0){ ! 9429: - perror(name); ! 9430: - return(-1); ! 9431: - } ! 9432: - } else { ! 9433: - if(mkdir(name, mode) < 0){ ! 9434: - perror(name); ! 9435: - return(-1); ! 9436: - } ! 9437: - } ! 9438: - chown(name, uid, gid); ! 9439: - utime(name, tp); ! 9440: - return(0); ! 9441: - } else { ! 9442: - int fd; ! 9443: - ! 9444: - if((fd = creat(name, mode)) >= 0){ ! 9445: - chown(name, uid, gid); ! 9446: - utime(name, tp); ! 9447: - } ! 9448: - return(fd); ! 9449: - } ! 9450: -} ! 9451: //GO.SYSIN DD wread.c ! 9452: echo wreset.c 1>&2 ! 9453: sed 's/.//' >wreset.c <<'//GO.SYSIN DD wreset.c' ! 9454: -#include <libc.h> ! 9455: -#include "worm.h" ! 9456: -#include <sys/types.h> ! 9457: -#include <sys/udaioc.h> ! 9458: - ! 9459: -main(argc, argv) ! 9460: - char **argv; ! 9461: -{ ! 9462: - Superblock s; ! 9463: - char *e, *vol_id = 0; ! 9464: - char buf[1024]; ! 9465: - char *dev = "/dev/worm0"; ! 9466: - int c; ! 9467: - extern char *optarg; ! 9468: - extern int optind; ! 9469: - ! 9470: - while((c = getopt(argc, argv, "f:")) != -1) ! 9471: - switch(c) ! 9472: - { ! 9473: - case 'f': dev = optarg; break; ! 9474: - case '?': usage(); ! 9475: - } ! 9476: - if(optind != argc) ! 9477: - usage(); ! 9478: - dev = mapdev(dev); ! 9479: - if((s.fd = open(dev, 2)) < 0){ ! 9480: - if(!vol_id) ! 9481: - perror(dev); ! 9482: - exit(2); ! 9483: - } ! 9484: - /* ! 9485: - normally, you have to read to bring the drive online. ! 9486: - however, when you are likely to call reset, the drive ! 9487: - is online and blocked so skip the read ! 9488: - */ ! 9489: - /*lseek(s.fd, 1024L, 0); ! 9490: - read(s.fd, buf, sizeof buf);/**/ ! 9491: - if(ioctl(s.fd, UIORST) < 0) ! 9492: - perror("reset ioctl"); ! 9493: - exit(0); ! 9494: -} ! 9495: - ! 9496: -usage() ! 9497: -{ ! 9498: - print("Usage: worm reset [-fdevice]\n"); ! 9499: - exit(2); ! 9500: -} ! 9501: //GO.SYSIN DD wreset.c ! 9502: echo wrm.c 1>&2 ! 9503: sed 's/.//' >wrm.c <<'//GO.SYSIN DD wrm.c' ! 9504: -#include <libc.h> ! 9505: -#include <fio.h> ! 9506: -#include <sys/types.h> ! 9507: -#include <sys/stat.h> ! 9508: -#include <signal.h> ! 9509: -#include "worm.h" ! 9510: - ! 9511: -static int bad = 0; ! 9512: -static long nbytes; ! 9513: -static long nfiles; ! 9514: -char *argout; ! 9515: - ! 9516: -main(argc, argv) ! 9517: - char **argv; ! 9518: -{ ! 9519: - Superblock s; ! 9520: - char *e; ! 9521: - char buf[4096]; ! 9522: - int n; ! 9523: - int c; ! 9524: - char *dev = "/dev/worm0"; ! 9525: - extern char *optarg; ! 9526: - extern int optind; ! 9527: - ! 9528: - argout = argv[0]; ! 9529: - while((c = getopt(argc, argv, "f:")) != -1) ! 9530: - switch(c) ! 9531: - { ! 9532: - case 'f': dev = optarg; break; ! 9533: - case '?': usage(); ! 9534: - } ! 9535: - ! 9536: - if(optind >= argc) ! 9537: - usage(); ! 9538: - dev = mapdev(dev); ! 9539: - if((s.fd = open(dev, 2)) < 0){ ! 9540: - perror(*argv); ! 9541: - exit(1); ! 9542: - } ! 9543: - if(e = openinode(&s, DO_INODE|SPIN_DOWN)){ ! 9544: - fprint(2, "%s: %s\n", *argv, e); ! 9545: - exit(1); ! 9546: - } ! 9547: - if(strcmp(s.vol_id, argv[optind])){ ! 9548: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id); ! 9549: - exit(1); ! 9550: - } ! 9551: - if(s.nfree == 0){ ! 9552: - fprint(2, "%s: can't write any more!\n", dev); ! 9553: - exit(1); ! 9554: - } ! 9555: - if(s.version != VLINK){ ! 9556: - fprint(2, "%s: can't write on a b-tree disk\n", s.vol_id); ! 9557: - exit(1); ! 9558: - } ! 9559: - for(n = 1; n <= NSIG; n++) ! 9560: - signal(n, SIG_IGN); ! 9561: - ininit(); ! 9562: - if(++optind < argc) ! 9563: - while(optind < argc) ! 9564: - proc(&s, argv[optind++]); ! 9565: - else ! 9566: - while(e = Frdline(0)) ! 9567: - proc(&s, e); ! 9568: - if(bad) ! 9569: - exit(1); ! 9570: - inwrite(&s); ! 9571: - if(bad) ! 9572: - exit(1); ! 9573: - exit(0); ! 9574: -} ! 9575: - ! 9576: -usage() ! 9577: -{ ! 9578: - fprint(2, "Usage: worm rm [-fdevice] vol_id [files]\n"); ! 9579: - exit(1); ! 9580: -} ! 9581: - ! 9582: -proc(s, file) ! 9583: - Superblock *s; ! 9584: - char *file; ! 9585: -{ ! 9586: - Inode i; ! 9587: - ! 9588: - if(inodeof(file) == 0){ ! 9589: - fprint(2, "%s: not on worm\n", file); ! 9590: - return; ! 9591: - } ! 9592: - i.magic = DMAGIC; ! 9593: - i.block = -1; ! 9594: - i.name.n = file; ! 9595: - if(inadd(s, &i)) ! 9596: - bad = 1; ! 9597: -} ! 9598: - ! 9599: -static Inode *inodes; ! 9600: -static long ip; ! 9601: -static long ninodes = 0; ! 9602: -static char *nameb; ! 9603: -static long np; ! 9604: -static long nnameb = 0; ! 9605: -static long nblocks; ! 9606: -#define IINC 1024 ! 9607: -#define NINC (64*IINC) ! 9608: - ! 9609: -ininit() ! 9610: -{ ! 9611: - if(nnameb == 0){ ! 9612: - nameb = malloc((unsigned)(nnameb = NINC)); ! 9613: - if(nameb == 0){ ! 9614: - fprint(2, "wrm: malloc fail, %d bytes\n", nnameb); ! 9615: - exit(1); ! 9616: - } ! 9617: - } ! 9618: - np = 0; ! 9619: - if(ninodes == 0){ ! 9620: - inodes = (Inode *)malloc(sizeof(Inode)*(unsigned)(ninodes = IINC)); ! 9621: - if(inodes == 0){ ! 9622: - fprint(2, "wrm: malloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 9623: - exit(1); ! 9624: - } ! 9625: - } ! 9626: - ip = 0; ! 9627: -} ! 9628: - ! 9629: -inadd(s, i) ! 9630: - Superblock *s; ! 9631: - register Inode *i; ! 9632: -{ ! 9633: - register long len; ! 9634: - ! 9635: - len = strlen(i->name.n)+1; ! 9636: - if(np+len > nnameb){ ! 9637: - while(np+len > nnameb) ! 9638: - nnameb += NINC; ! 9639: - nameb = realloc(nameb, (unsigned)nnameb); ! 9640: - if(nameb == 0){ ! 9641: - fprint(2, "wrm: realloc fail, %d bytes\n", nnameb); ! 9642: - exit(1); ! 9643: - } ! 9644: - } ! 9645: - strcpy(nameb+np, i->name.n); ! 9646: - i->name.o = np; ! 9647: - np += len; ! 9648: - if(ip == ninodes){ ! 9649: - ninodes += IINC; ! 9650: - inodes = (Inode *)realloc((char *)inodes, (unsigned)ninodes*sizeof(Inode)); ! 9651: - if(inodes == 0){ ! 9652: - fprint(2, "wrm: realloc fail, %d inodes %d bytes\n", ninodes, ninodes*sizeof(Inode)); ! 9653: - exit(1); ! 9654: - } ! 9655: - } ! 9656: - inodes[ip++] = *i; ! 9657: - return(0); ! 9658: -} ! 9659: - ! 9660: -inwrite(s) ! 9661: - Superblock *s; ! 9662: -{ ! 9663: - char *e; ! 9664: - ! 9665: - if(e = lkwri(s, inodes, ip, nameb, np, 0L)){ ! 9666: - fprint(2, "%s\n", e); ! 9667: - bad = 1; ! 9668: - return; ! 9669: - } ! 9670: -} ! 9671: //GO.SYSIN DD wrm.c ! 9672: echo wstat.c 1>&2 ! 9673: sed 's/.//' >wstat.c <<'//GO.SYSIN DD wstat.c' ! 9674: -#include <libc.h> ! 9675: -#include "worm.h" ! 9676: - ! 9677: -main(argc, argv) ! 9678: - char **argv; ! 9679: -{ ! 9680: - Superblock s; ! 9681: - char *e, *vol_id = 0; ! 9682: - char *dev = "/dev/worm0"; ! 9683: - int c; ! 9684: - long nf = 0; ! 9685: - int vflag = 0; ! 9686: - extern char *optarg; ! 9687: - extern int optind; ! 9688: - extern long atol(); ! 9689: - ! 9690: - while((c = getopt(argc, argv, "vF:f:")) != -1) ! 9691: - switch(c) ! 9692: - { ! 9693: - case 'f': dev = optarg; break; ! 9694: - case 'F': nf = atol(optarg); break; ! 9695: - case 'v': vflag = 1; break; ! 9696: - case '?': usage(); ! 9697: - } ! 9698: - if(optind < argc){ ! 9699: - vol_id = argv[optind++]; ! 9700: - if(optind != argc) ! 9701: - usage(); ! 9702: - } ! 9703: - dev = mapdev(dev); ! 9704: - if((s.fd = open(dev, 0)) < 0){ ! 9705: - if(!vol_id && !nf) ! 9706: - perror(dev); ! 9707: - exit(2); ! 9708: - } ! 9709: - if(e = openinode(&s, SPIN_DOWN)){ ! 9710: - if(!vol_id && !nf) ! 9711: - fprint(2, "%s: %s\n", dev, e); ! 9712: - exit(2); ! 9713: - } ! 9714: - if(nf){ ! 9715: - if(vol_id) ! 9716: - if(strcmp(vol_id, s.vol_id) != 0) ! 9717: - exit(1); ! 9718: - exit(s.nfree >= nf? 0:3); ! 9719: - } ! 9720: - if(vol_id) ! 9721: - exit(strcmp(vol_id, s.vol_id) != 0); ! 9722: - if(vflag){ ! 9723: - Fprint(1, "%s: %s, %s\t%ldx%uhd blocks, %ld (=%.1fMB) free, zero=%ld this_sb@%ld next_sb@%ld\n", ! 9724: - s.vol_id, s.comment, ctime(&s.ctime), s.nblocks, s.blocksize, ! 9725: - s.nfree, s.nfree*(double)s.blocksize*1e-6, s.zero, s.myblock, s.nextsb); ! 9726: - } else ! 9727: - Fprint(1, "%s: %.0f%% used (%.1fMB free)\n", s.vol_id, ! 9728: - s.nextffree*100.0/s.nblocks, s.nfree*(double)s.blocksize*1e-6); ! 9729: - exit(0); ! 9730: -} ! 9731: - ! 9732: -usage() ! 9733: -{ ! 9734: - print("Usage: worm stat [-v] [-fdevice] [-Fnfree] [vol_id]\n"); ! 9735: - exit(2); ! 9736: -} ! 9737: //GO.SYSIN DD wstat.c ! 9738: echo wtmpdir.c 1>&2 ! 9739: sed 's/.//' >wtmpdir.c <<'//GO.SYSIN DD wtmpdir.c' ! 9740: -#include <libc.h> ! 9741: -#include "worm.h" ! 9742: -#include "sym.h" ! 9743: -#include <sys/types.h> ! 9744: -#include <sys/stat.h> ! 9745: -#include <pwd.h> ! 9746: -#include <grp.h> ! 9747: - ! 9748: -Inode *inodebase, *inext; ! 9749: -char *namebase, *cnext; ! 9750: - ! 9751: -main(argc, argv) ! 9752: - char **argv; ! 9753: -{ ! 9754: - Superblock s; ! 9755: - char *e; ! 9756: - char *dev = "/dev/worm0"; ! 9757: - register c, j; ! 9758: - register Inode *from, *to; ! 9759: - extern char *optarg; ! 9760: - extern int optind; ! 9761: - char *vlk(); ! 9762: - int cmp(); ! 9763: - int fd; ! 9764: - int verbose = 0; ! 9765: - char buf[512]; ! 9766: - long ni, nc; ! 9767: - ! 9768: - while((c = getopt(argc, argv, "vf:")) != -1) ! 9769: - switch(c) ! 9770: - { ! 9771: - case 'v': verbose = 1; break; ! 9772: - case 'f': dev = optarg; break; ! 9773: - case '?': usage(); ! 9774: - } ! 9775: - dev = mapdev(dev); ! 9776: - if((s.fd = open(dev, 0)) < 0){ ! 9777: - perror(dev); ! 9778: - exit(1); ! 9779: - } ! 9780: - if(e = openinode(&s, SPIN_DOWN)){ ! 9781: - fprint(2, "%s: %s\n", dev, e); ! 9782: - exit(1); ! 9783: - } ! 9784: - if(s.version != VLINK){ ! 9785: - fprint(2, "%s: not a vlink disk, no action taken.\n", s.vol_id); ! 9786: - exit(1); ! 9787: - } ! 9788: - if(optind != argc-1) ! 9789: - usage(); ! 9790: - if(strcmp(argv[optind], s.vol_id)){ ! 9791: - fprint(2, "wanted volid '%s'; got '%s'\n", argv[optind], s.vol_id); ! 9792: - exit(1); ! 9793: - } ! 9794: - if(verbose) ! 9795: - print("%d inodes\n", numinodes); ! 9796: - if((inodebase = (Inode *)malloc(s.blocksize+(int)numinodes*sizeof(Inode))) == 0){ ! 9797: - fprint(2, "malloc of %ld inodes failed\n", numinodes); ! 9798: - exit(2); ! 9799: - } ! 9800: - if((namebase = malloc(s.blocksize+(int)numnamechars+(int)numinodes)) == 0){ ! 9801: - fprint(2, "malloc of %ld chars failed\n", numnamechars); ! 9802: - exit(2); ! 9803: - } ! 9804: - inext = inodebase; ! 9805: - cnext = namebase; ! 9806: - s.ninodes = 0; ! 9807: - s.nextsb = 2; ! 9808: - if(e = vlk(&s)){ ! 9809: - fprint(2, "%s: %s\n", dev, e); ! 9810: - exit(1); ! 9811: - } ! 9812: - j = inext-inodebase; ! 9813: - if(verbose) ! 9814: - print("%d in base\n", j); ! 9815: - qsort((char *)inodebase, j, sizeof(*inodebase), cmp); ! 9816: - for(to = inodebase, from = inodebase+1; from < inext; from++) ! 9817: - if(strcmp(from->name.o+namebase, from[-1].name.o+namebase)) ! 9818: - *to++ = from[-1]; ! 9819: - else { ! 9820: - while((++from < inext) && (strcmp(from->name.o+namebase, from[-1].name.o+namebase) == 0)) ! 9821: - ; ! 9822: - } ! 9823: - if(from == inext) ! 9824: - *to++ = from[-1]; ! 9825: - inext = to; ! 9826: - j = inext-inodebase; ! 9827: - sprint(buf, "/usr/worm/tmp/%s", s.vol_id); ! 9828: - if((fd = creat(buf, 0666)) < 0){ ! 9829: - perror(buf); ! 9830: - exit(1); ! 9831: - } ! 9832: - ni = j; ! 9833: - nc = cnext-namebase; ! 9834: - write(fd, (char *)&s.ctime, 4); ! 9835: - write(fd, (char *)&ni, 4); ! 9836: - write(fd, (char *)inodebase, (int)ni*sizeof(Inode)); ! 9837: - write(fd, (char *)&nc, 4); ! 9838: - write(fd, namebase, (int)nc); ! 9839: - exit(0); ! 9840: -} ! 9841: - ! 9842: -usage() ! 9843: -{ ! 9844: - fprint(2, "Usage: worm tmpdir [-fdevice] vol_id\n"); ! 9845: - exit(2); ! 9846: -} ! 9847: - ! 9848: -cmp(a, b) ! 9849: - Inode *a, *b; ! 9850: -{ ! 9851: - return(strcmp(namebase+a->name.o, namebase+b->name.o)); ! 9852: -} ! 9853: - ! 9854: -char * ! 9855: -vlk(s) ! 9856: - register Superblock *s; ! 9857: -{ ! 9858: - register Inode *i; ! 9859: - short fd = s->fd; ! 9860: - register long j; ! 9861: - long blk = -1; /* shouldn't be accessed first time through */ ! 9862: - char *b; ! 9863: - long nb; ! 9864: - Inode *iend; ! 9865: - static char buf[64]; ! 9866: - ! 9867: - if((b = malloc(s->blocksize)) == 0){ ! 9868: - sprint(buf, "couldn't malloc buffer (%d bytes)", s->blocksize); ! 9869: - return(buf); ! 9870: - } ! 9871: - for(;;){ ! 9872: - if(s->magic != SMAGIC){ ! 9873: - fprint(2, "bad Superblock at %ld\n", blk); ! 9874: - exit(1); ! 9875: - } ! 9876: - if(s->ninodes){ ! 9877: - nb = (s->ninodes+IPERB-1)/IPERB; ! 9878: - Seek(s, s->binodes); ! 9879: - if(Read(s, (char *)inext, nb)) ! 9880: - goto skip; ! 9881: - j = cnext-namebase; ! 9882: - for(i = inext, iend = i+s->ninodes; i < iend; i++) ! 9883: - i->name.o += j; ! 9884: - inext += s->ninodes; ! 9885: - nb = (s->ninochars+s->blocksize-1)/s->blocksize; ! 9886: - if(Read(s, cnext, nb)) ! 9887: - goto skip; ! 9888: - cnext += (s->ninochars+1)&~1; ! 9889: - } ! 9890: - skip: ! 9891: - blk = s->nextsb; ! 9892: - Seek(s, blk); ! 9893: - if(Read(s, b, 1L)) ! 9894: - break; ! 9895: - *s = *((Superblock *)b); ! 9896: - s->fd = fd; ! 9897: - if(s->myblock == 0) ! 9898: - s->myblock = blk; ! 9899: - } ! 9900: - free(b); ! 9901: - return((char *)0); ! 9902: -} ! 9903: //GO.SYSIN DD wtmpdir.c ! 9904: echo wwrite.c 1>&2 ! 9905: sed 's/.//' >wwrite.c <<'//GO.SYSIN DD wwrite.c' ! 9906: -#include <libc.h> ! 9907: -#include <fio.h> ! 9908: -#include <sys/types.h> ! 9909: -#include <sys/stat.h> ! 9910: -#include <signal.h> ! 9911: -#include "worm.h" ! 9912: - ! 9913: -main(argc, argv) ! 9914: - char **argv; ! 9915: -{ ! 9916: - Superblock s; ! 9917: - char *e; ! 9918: - char buf[4096]; ! 9919: - int n; ! 9920: - int c; ! 9921: - char *dev = "/dev/worm0"; ! 9922: - extern char *optarg; ! 9923: - extern int optind; ! 9924: - ! 9925: - argout = argv[0]; ! 9926: - while((c = getopt(argc, argv, "f:")) != -1) ! 9927: - switch(c) ! 9928: - { ! 9929: - case 'f': dev = optarg; break; ! 9930: - case '?': usage(); ! 9931: - } ! 9932: - ! 9933: - if(optind >= argc) ! 9934: - usage(); ! 9935: - dev = mapdev(dev); ! 9936: - if((s.fd = open(dev, 2)) < 0){ ! 9937: - perror(*argv); ! 9938: - exit(1); ! 9939: - } ! 9940: - if(e = openinode(&s, SPIN_DOWN)){ ! 9941: - fprint(2, "%s: %s\n", *argv, e); ! 9942: - exit(1); ! 9943: - } ! 9944: - if(strcmp(s.vol_id, argv[optind])){ ! 9945: - fprint(2, "vol_id mismatch: wanted %s, got %s\n", argv[optind], s.vol_id); ! 9946: - exit(1); ! 9947: - } ! 9948: - if(s.nfree == 0){ ! 9949: - fprint(2, "%s: can't write any more!\n", dev); ! 9950: - exit(1); ! 9951: - } ! 9952: - if(s.version != VLINK){ ! 9953: - fprint(2, "%s: can't write on a b-tree disk\n", s.vol_id); ! 9954: - exit(1); ! 9955: - } ! 9956: - for(n = 1; n <= NSIG; n++) ! 9957: - signal(n, SIG_IGN); ! 9958: - ininit(); ! 9959: - if(++optind < argc) ! 9960: - while(optind < argc) ! 9961: - proc(&s, argv[optind++]); ! 9962: - else ! 9963: - while(e = Frdline(0)) ! 9964: - proc(&s, e); ! 9965: - if(bad) ! 9966: - exit(1); ! 9967: - nfiles = nbytes = 0; ! 9968: - inwrite(&s, (void *)0); ! 9969: - if(bad) ! 9970: - exit(1); ! 9971: - fprint(1, "%d files, %.6fMb\n", nfiles, nbytes/1e6); ! 9972: - exit(0); ! 9973: -} ! 9974: - ! 9975: -usage() ! 9976: -{ ! 9977: - fprint(2, "Usage: worm write [-fdevice] vol_id [files]\n"); ! 9978: - exit(1); ! 9979: -} ! 9980: - ! 9981: -proc(s, file) ! 9982: - Superblock *s; ! 9983: - char *file; ! 9984: -{ ! 9985: - struct stat sbuf; ! 9986: - unsigned short mode; ! 9987: - Inode i; ! 9988: - ! 9989: - memset((char *)&i, 0, sizeof(i)); ! 9990: - if(stat(file, &sbuf) < 0){ ! 9991: - perror(file); ! 9992: - return; ! 9993: - } ! 9994: - mode = sbuf.st_mode&S_IFMT; ! 9995: - if((mode == S_IFREG) || (mode == S_IFDIR)){ ! 9996: - i.magic = DMAGIC; ! 9997: - i.block = 0; ! 9998: - i.nbytes = sbuf.st_size; ! 9999: - nbytes += i.nbytes; ! 10000: - i.ctime = sbuf.st_ctime; ! 10001: - i.name.n = file; ! 10002: - i.mode = sbuf.st_mode; ! 10003: - i.uid = sbuf.st_uid; ! 10004: - i.gid = sbuf.st_gid; ! 10005: - if(inadd(s, &i)) ! 10006: - bad = 1; ! 10007: - } else ! 10008: - fprint(2, "%s is not a file\n", file); ! 10009: -} ! 10010: - ! 10011: -writeout(s, i, blk) ! 10012: - Superblock *s; ! 10013: - Inode *i; ! 10014: - long *blk; ! 10015: -{ ! 10016: - char b[63*1024L]; ! 10017: - int fd; ! 10018: - long n, len, blen; ! 10019: - char *name; ! 10020: - ! 10021: - n = (i->nbytes+s->blocksize-1)/s->blocksize; ! 10022: - *blk += n; ! 10023: - blkdone += n; ! 10024: - blen = sizeof b/s->blocksize; ! 10025: - len = blen*s->blocksize; ! 10026: - nbytes += i->nbytes; ! 10027: - nfiles++; ! 10028: - name = i->name.n; ! 10029: - if((fd = open(name, 0)) < 0) ! 10030: - goto out; ! 10031: - for(n = i->nbytes; n > len; n -= len){ ! 10032: - if(read(fd, (char *)b, (int)len) != len){ ! 10033: - out: ! 10034: - perror(name); ! 10035: - bad = 1; ! 10036: - return; ! 10037: - } ! 10038: - if(Write(s, b, blen)){ ! 10039: -fprint(2, "nb=%d, n=%d len=%d blen=%d\n", i->nbytes, n, len, blen); ! 10040: - perror("data write"); ! 10041: - exit(1); ! 10042: - } ! 10043: - } ! 10044: - if(n){ ! 10045: - memset(b, 0, sizeof b); ! 10046: - if(read(fd, (char *)b, (int)n) != n) ! 10047: - goto out; ! 10048: - n += s->blocksize-1; ! 10049: - n /= s->blocksize; ! 10050: - if(Write(s, b, n)){ ! 10051: - perror("data write"); ! 10052: - exit(1); ! 10053: - } ! 10054: - } ! 10055: - close(fd); ! 10056: -} ! 10057: //GO.SYSIN DD wwrite.c
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.