Annotation of researchv10no/cmd/worm/oscsi/scsi.cpio, revision 1.1.1.1

1.1       root        1: 0707070035050422111006660011710000040000010273220464714144700000700000003143README    This is a simple extensible shell (scsish) for poking at scsi
                      2: devices, particularly the simpler kinds commonly called toasters.
                      3: it is supposed to be self-documenting in use; try the help command.
                      4: my use of the moran-dronek /dev/scsi library is still imperfect;
                      5: there is still some some debugging showing.
                      6: 
                      7:        To compile, you first need mk. you then have to pick a system type
                      8: to set some flags; currently we support research and sgi.
                      9: yours may differ, particularly as no one else has our ansi C compiler for the sgi.
                     10: the only problem i would expect is the normal header file crap you get
                     11: mixing ansi and non-ansi files. i recommend setting NPROC=1 while debugging hdr files.
                     12: if you change (header) files, try putting them in the directory inc
                     13: (then others may benefit). To support a new system (say sgi-gcc), just create
                     14: a new file sgi-gcc.mk and so on. you may be missing some devices in
                     15: your /dev/scsi; the script scsi/gendev may help (but check the major/minor
                     16: numbers and permissions).
                     17: 
                     18:        As for modifying/extending scsish, it has been designed to be not too hard.
                     19: Adding a new device means adding a new set of rules (like the other rules)
                     20: to mkfile and creating a new directory (say exabyte) and at least two files in it
                     21: (dev.c and fns.h). The wren directory is a small example you can clone.
                     22: Adding new functions to any device means updating a file list in mkfile,
                     23: updating dev.c and fns.h in the device directory. The argument syntax
                     24: scheme is arguably pokey, but liveable. at some future point we should probably
                     25: switch over to osterhout's tcl.
                     26: 
                     27:        as always, i invite you send extensions/fixes etc back to
                     28: [email protected]
                     29: 0707070035050453661006660011710000040000010451330457563432000000500000000565TODO      |       COPY drive NUMBER NUMBER drive NUMBER {/*:COPY sdrive sstart nblocks ddrive dstart:: */
                     30:                        s_copy($2, $3, $4, $5, $6);
                     31:                }
                     32:        |       READ drive NUMBER  {
                     33:                        struct scsi_ret output;
                     34:                        s_read($2, $3, 1, &output);
                     35:                        scsiodump(output.data, 1024);
                     36:                }
                     37:        |       WRITE drive NUMBER { s_write($2, $3, 1); }
                     38:        |       WRITE drive NUMBER NUMBER { s_write($2, $3, $4); } /*:WRITE drive start n:: */
                     39: 0707070035050450521006660011710000040000010447750457563431100001300000002057allocate.c#include        <stddef.h>
                     40: #include       <stdio.h>
                     41: #include       <string.h>
                     42: #include       "scsi.h"
                     43: #include       "juke.h"
                     44: 
                     45: allocate(char *vol_id, char *buf)
                     46: {
                     47:        int drive, sh;
                     48:        char nbuf[512];
                     49:        
                     50:        if(j_rdshelves(buf))    /* read in shelf names */
                     51:                return(-1);
                     52:        if(j_getstatus(buf))    /* get the jukebox status */
                     53:                return(-1);
                     54:        sh = j_shelfof(vol_id);
                     55:        if(sh >= 0){
                     56:                sprintf(buf, "there is an existing '%s' on shelf %d", vol_id, sh);
                     57:                return(-1);
                     58:        }
                     59:        sh = j_shelfof(UNALLOCATED);
                     60:        if(sh < 0){
                     61:                sprintf(buf, "no unallocated disks");
                     62:                return(-1);
                     63:        }
                     64:        printf("using unallocated disk from shelf %d\n", sh);
                     65:        drive = min(nlun+1, NLUN-1);
                     66:        if(j_shelf_to_drive(sh, SIDEB, drive, buf) < 0)
                     67:                return(-1);
                     68:        sprintf(nbuf, "%sb", vol_id);
                     69:        if(j_wvolid(drive, nbuf, buf))
                     70:                return(-1);
                     71:        j_wrshelf = 1;
                     72:        j_shelf[sh] = strdup(vol_id);
                     73:        if(j_drive_to_shelf(drive, sh, SIDEB, buf) < 0)
                     74:                return(-1);
                     75:        if(j_shelf_to_drive(sh, SIDEA, drive, buf) < 0)
                     76:                return(-1);
                     77:        sprintf(nbuf, "%sa", vol_id);
                     78:        if(j_wvolid(drive, nbuf, buf))
                     79:                return(-1);
                     80:        if(j_drive_to_shelf(drive, sh, SIDEA, buf) < 0)
                     81:                return(-1);
                     82:        return(0);
                     83: }
                     84: 0707070035050452321006660011710000040000010576150463130011500000700000007736cold.c#include    <stddef.h>
                     85: #include       <stdio.h>
                     86: #include       <string.h>
                     87: #include       "scsi.h"
                     88: #include       "juke.h"
                     89: 
                     90: static sort(char *buf);
                     91: 
                     92: cold_inv(char type, char *buf)
                     93: {
                     94:        Side side;
                     95:        int drive, sh, nsh;
                     96:        int n;
                     97:        char vol_id[512];
                     98:        int didit[NSHELF];
                     99: 
                    100:        if(j_getstatus(buf))    /* get the jukebox status */
                    101:                return(-1);
                    102: printf("getstatus done\n");
                    103:        /* first clear out nonexistent labels */
                    104:        n = 0;
                    105:        for(sh = 0; sh < NSHELF; sh++){
                    106:                if((j_status.shelf[sh]&0xC0) == 0xC0){
                    107:                        n++;
                    108:                        j_shelf[sh] = "there";
                    109:                } else
                    110:                        j_shelf[sh] = 0;
                    111:                didit[sh] = 0;
                    112:        }
                    113:        printf("%d disks in shelves.\n", n);
                    114:        /* second, clear the drives */
                    115:        for(sh = 0; sh < NSHELF; sh++)
                    116:                if(j_shelf[sh] == 0)
                    117:                        break;
                    118:        for(drive = 0; drive < 8; drive++){
                    119:                if(!j_status.lun[drive].diskin)
                    120:                        continue;               /* no disk in drive */
                    121: printf("clearing drive %d:\n", drive);
                    122:                if(j_status.lun[drive].diskindrive && !j_status.lun[drive].shelfvalid){
                    123:                        if(j_drive_to_shelf(drive, sh, SIDEA, buf))
                    124:                                return(-1);
                    125:                        for(sh++; sh < NSHELF; sh++)
                    126:                                if(j_shelf[sh] == 0)
                    127:                                        break;
                    128:                        n++;
                    129:                } else
                    130:                        if(j_drive_to_shelf(drive, -1, SIDEA, buf))
                    131:                                return(-1);
                    132:                printf("\n");
                    133:        }
                    134:        printf("reloading %d disks.\n", n);
                    135:        side = SIDEA;
                    136:        drive = min(nlun+1, NLUN-1);
                    137:        j_wrshelf = 1;
                    138:        for(sh = 0; sh < NSHELF; sh++){
                    139:                if(didit[sh])
                    140:                        continue;
                    141:                j_shelf[sh] = 0;
                    142:                /* the C0 means disk properly present (not temp) */
                    143:                if((j_status.shelf[sh]&0xC0) == 0xC0){
                    144:                        if(getvol(sh, drive, vol_id, &side))
                    145:                                errexit(vol_id);
                    146:                        switch(type)
                    147:                        {
                    148:                        case 'c':
                    149:                                for(nsh = 0; j_shelf[nsh]; nsh++)
                    150:                                        ;
                    151:                                break;
                    152:                        case 's':
                    153:                        case 'r':
                    154:                                while(j_shelf[nsh = nrand(NSHELF)])
                    155:                                        ;
                    156:                                break;
                    157:                        case 'u':
                    158:                        default:
                    159:                                nsh = sh;
                    160:                                break;
                    161:                        }
                    162:                        printf("%s@%d -> %d\n", vol_id, sh, nsh);
                    163:                        if(j_drive_to_shelf(drive, nsh, side, buf) < 0)
                    164:                                return(-1);
                    165:                        j_shelf[nsh] = strdup(vol_id);
                    166:                        didit[nsh] = 1;
                    167:                        sleep(2);
                    168:                }
                    169:        }
                    170:        printf("process any new disks.\n");
                    171:        if(warm_inv(buf))
                    172:                return(-1);
                    173:        if(type == 's')
                    174:                return(sort(buf));
                    175:        return(0);
                    176: } 
                    177: 
                    178: getvol(int sh, int drive, char *vol_id, int *side)
                    179: {
                    180:        int i;
                    181:        char buf[512];
                    182: 
                    183:        if(j_shelf_to_drive(sh, SIDEA, drive, vol_id) < 0)
                    184:                return(-1);
                    185:        if((i = j_rvolid(drive, buf)) < 0)
                    186:                goto softerr;
                    187:        if(i == 0)
                    188:                *side = SIDEA;
                    189:        else {
                    190:                *side = SIDEB;
                    191:                if(j_drive_to_shelf(drive, sh, SIDEA, vol_id) < 0)
                    192:                        return(-1);
                    193:                if(j_shelf_to_drive(sh, SIDEB, drive, vol_id) < 0)
                    194:                        return(-1);
                    195:                if((i = j_rvolid(drive, buf)) < 0)
                    196:                        goto softerr;
                    197:        }
                    198:        if(i > 0)
                    199:                strcpy(vol_id, UNALLOCATED);
                    200:        else {
                    201:                strcpy(vol_id, buf);
                    202:                i = strlen(vol_id)-1;
                    203:                if(i < 0){
                    204:                        sprintf(buf, "apparently good superblock but null vol_id");
                    205:                        goto softerr;
                    206:                } else if(vol_id[i] == 'a')
                    207:                        vol_id[i] = 0;
                    208:                else if(vol_id[i] == 'b'){
                    209:                        vol_id[i] = 0;
                    210:                        *side = !*side;
                    211:                } else {
                    212:                        sprintf(buf, "vol_id '%s' must end in a or b", vol_id);
                    213:                        strcpy(vol_id, buf);
                    214:                        return(-1);
                    215:                }
                    216:        }
                    217:        return(0);
                    218: softerr:
                    219:        *side = SIDEA;
                    220:        fprintf(stderr, "error in reading shelf %d: %s; proceeding\n", sh, buf);
                    221:        sprintf(vol_id, "DISK_ERROR%d", sh);
                    222:        gen_reset(0, (int *)0, 0, (char **)0, buf);
                    223:        return(0);
                    224: }
                    225: 
                    226: static int index[NSHELF];
                    227: static
                    228: cmp(int *a, int *b)
                    229: {
                    230:        char *sa = j_shelf[*a], *sb = j_shelf[*b];
                    231: 
                    232:        if((sa == 0) && (sb == 0)) return(0);
                    233:        if(sa == 0) return(-1);
                    234:        if(sb == 0) return(1);
                    235:        return(strcmp(sa, sb));
                    236: }
                    237: 
                    238: static char *disk[8];
                    239: 
                    240: static
                    241: sd(int a, int b, char *err)
                    242: {
                    243:        disk[b] = j_shelf[a];
                    244:        return(j_shelf_to_drive(a, SIDEB, b, err));
                    245: }
                    246: static
                    247: ds(int a, int b, char *err)
                    248: {
                    249:        j_shelf[b] = disk[a];
                    250:        return(j_drive_to_shelf(a, b, SIDEB, err));
                    251: }
                    252: 
                    253: static
                    254: sort(char *errbuf)
                    255: {
                    256:        int i, j, org;
                    257: 
                    258:        for(i = 0; i < NSHELF; i++)
                    259:                index[i] = i;
                    260:        qsort(index, NSHELF, sizeof index[0], cmp);
                    261:        for(i = 0; i < NSHELF; i++){
                    262:                if(index[i] < 0) continue;
                    263:                if(sd(org = i, NLUN-1, errbuf) < 0)
                    264:                        return(-1);
                    265:                j = index[i];
                    266:                index[i] = -1;
                    267:                while(j != org){
                    268:                        if(sd(j, NLUN-2, errbuf) < 0)
                    269:                                return(-1);
                    270:                        if(ds(NLUN-2, i, errbuf) < 0)
                    271:                                return(-1);
                    272:                        i = j;
                    273:                        if(index[i] < 0)
                    274:                                break;
                    275:                        j = index[i];
                    276:                        index[i] = -1;
                    277:                }
                    278:                if(ds(NLUN-1, i, errbuf) < 0)
                    279:                        return(-1);
                    280:        }
                    281:        return(0);
                    282: }
                    283: 0707070035050513661006440011710000040000010044130464677201700001000000027722dslib.c/*
                    284: || dslib.c - library routines for /dev/scsi
                    285: ||
                    286: || Copyright 1988, 1989, by
                    287: ||   Gene Dronek (Vulcan Laboratory) and
                    288: ||   Rich Morin  (Canta Forda Computer Laboratory).
                    289: || All rights reserved.
                    290: */
                    291: #ident "dslib.c: $Revision: 1.4 $"
                    292: 
                    293: #include <stdio.h>
                    294: #include <sys/types.h>
                    295: 
                    296: #include "dslib.h"
                    297: #ifdef aux
                    298: #include <sys/vio.h>
                    299: #include <sys/scsireq.h>
                    300: #endif aux
                    301: 
                    302: int dsdebug=0;
                    303: long dsreqflags;       /* flag bits always set by filldsreq */
                    304: 
                    305: #define min(i,j)  ( (i) < (j) ? (i) : (j) )
                    306: 
                    307: 
                    308: /*
                    309: || Startup/shutdown -----------------------------------------------
                    310: */
                    311: 
                    312: static struct context *dsc[FDSIZ];
                    313: 
                    314: 
                    315: /*
                    316: || dsopen - open device, set up structures
                    317: */
                    318: 
                    319: struct dsreq *
                    320: dsopen(opath, oflags)
                    321:   char *opath;
                    322:   int   oflags;
                    323: {
                    324:     
                    325:   struct dsreq *dsp;
                    326:   struct context *cp;
                    327:   int fd;
                    328:   DSDBG(fprintf(stderr,"dsopen(%s,%x) ", opath, oflags));
                    329: 
                    330:   fd = open(opath, oflags);
                    331:   if (fd < 0)                                          
                    332:     return NULL;                       /* can't open   */
                    333:   if (dsc[fd] != NULL)                 /* already in use */
                    334:     ds_zot("dsopen: fd already in use");
                    335: 
                    336:   cp = (struct context *) calloc(1, sizeof(struct context));
                    337:   if (cp == NULL)                                    /* can't allocate */
                    338:     ds_zot("dsopen: can't allocate space");
                    339:   dsc[fd] = cp;
                    340:   cp->dsc_fd = fd;
                    341:   dsp = &(cp->dsc_dsreq);
                    342: 
                    343:   dsp->ds_flags =      0;
                    344:   dsp->ds_time =       10 * 1000;      /* 10 second default timeout */
                    345:   dsp->ds_private =    (ulong) cp;     /* pointer back to context */
                    346:   dsp->ds_cmdbuf =     cp->dsc_cmd;
                    347:   dsp->ds_cmdlen =     sizeof cp->dsc_cmd;
                    348:   dsp->ds_databuf =    0;
                    349:   dsp->ds_datalen =    0;
                    350:   dsp->ds_sensebuf =   cp->dsc_sense;
                    351:   dsp->ds_senselen =   sizeof cp->dsc_sense;
                    352:   DSDBG(fprintf(stderr,"=>cp %x, dsp %x\n", cp, dsp));
                    353:   return dsp;
                    354: }
                    355: 
                    356: 
                    357: /*
                    358: || dsclose - close device, release context struct.
                    359: */
                    360: 
                    361: dsclose(dsp)
                    362:   struct dsreq *dsp;
                    363: {
                    364:   int fd;
                    365:   struct context *cp;
                    366: 
                    367:   if (dsp == NULL)
                    368:     ds_zot("dsclose: dsp is NULL");
                    369: 
                    370:   cp = (struct context *)dsp->ds_private;
                    371:   fd = getfd(dsp);
                    372:   if ( cp == NULL )
                    373:     ds_zot("dsclose: private is NULL");
                    374: 
                    375:   cfree(cp);
                    376:   dsc[fd] = (struct context *)NULL;
                    377:   return;
                    378: }
                    379: 
                    380: 
                    381: /*
                    382: || Generic SCSI CCS Command functions ------------------------------------
                    383: ||
                    384: || dsp         dsreq pointer
                    385: || data                data buffer pointer
                    386: || datalen     data buffer length
                    387: || lba         logical block address
                    388: || vu          vendor unique bits
                    389: */
                    390: 
                    391: /*
                    392: || testunitready00 - issue group 0 "Test Unit Ready" command (0x00)
                    393: */
                    394: 
                    395: testunitready00(dsp)
                    396:   struct dsreq *dsp;
                    397: {
                    398:   fillg0cmd(dsp, CMDBUF(dsp), G0_TEST, 0, 0, 0, 0, 0);
                    399:   filldsreq(dsp, 0, 0, DSRQ_READ|DSRQ_SENSE);
                    400:   return(doscsireq(getfd(dsp), dsp));
                    401: }
                    402: 
                    403: 
                    404: /*
                    405: || requestsense03 - issue group 0 "Request Sense" command (0x03)
                    406: */
                    407: 
                    408: requestsense03(dsp, data, datalen, vu)
                    409:   struct dsreq *dsp;
                    410:   caddr_t data;
                    411:   long datalen;
                    412:   char vu;
                    413: {
                    414:   fillg0cmd(dsp, CMDBUF(dsp), G0_REQU, 0, 0, 0, B1(datalen), B1(vu<<6));
                    415:   filldsreq(dsp, data, datalen, DSRQ_READ);
                    416:   return(doscsireq(getfd(dsp), dsp));
                    417: }
                    418: 
                    419: 
                    420: /*
                    421: || write0a - issue group 0 "Write" command (0x0a)
                    422: */
                    423: 
                    424: write0a(dsp, data, datalen, lba, vu)
                    425:   struct dsreq *dsp;
                    426:   caddr_t data;
                    427:   long datalen, lba;
                    428:   char vu;
                    429: {
                    430:   fillg0cmd(dsp, CMDBUF(dsp), G0_WRIT, B3(lba), B1(datalen), B1(vu<<6));
                    431:   filldsreq(dsp, data, datalen, DSRQ_READ);
                    432:   return(doscsireq(getfd(dsp), dsp));
                    433: }
                    434: 
                    435: 
                    436: /*
                    437: || inquiry12 - issue group 0 "Inquiry" command (0x12)
                    438: */
                    439: 
                    440: inquiry12(dsp, data, datalen, vu)
                    441:   struct dsreq *dsp;
                    442:   caddr_t data;
                    443:   long datalen;
                    444:   char vu;
                    445: {
                    446:   fillg0cmd(dsp, CMDBUF(dsp), G0_INQU, 0, 0, 0, B1(datalen), B1(vu<<6));
                    447:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE);
                    448:   return(doscsireq(getfd(dsp), dsp));
                    449: }
                    450: 
                    451: 
                    452: /*
                    453: || modeselect15 - issue group 0 "Mode Select" command (0x15)
                    454: ||
                    455: || save                0 - don't save saveable pages
                    456: ||             1 - save saveable pages
                    457: */
                    458: 
                    459: modeselect15(dsp, data, datalen, save, vu)
                    460:   struct dsreq *dsp;
                    461:   caddr_t data;
                    462:   long datalen;
                    463:   char save, vu;
                    464: {
                    465:   fillg0cmd(dsp, CMDBUF(dsp), G0_MSEL, save&1, 0, 0, B1(datalen), B1(vu<<6));
                    466:   filldsreq(dsp, data, datalen, DSRQ_WRITE|DSRQ_SENSE);
                    467:   return(doscsireq(getfd(dsp), dsp));
                    468: }
                    469: 
                    470: 
                    471: /*
                    472: || modesense1a - issue group 0 "Mode Sense" command (0x1a)
                    473: ||
                    474: || pagectrl    0 - current values
                    475: ||             1 - changeable values
                    476: ||             2 - default values
                    477: ||             3 - saved values
                    478: ||
                    479: || pagecode    0   - vendor unique
                    480: ||             1   - error recovery
                    481: ||             2   - disconnect/reconnect
                    482: ||             3   - direct access dev. fmt.
                    483: ||             4   - rigid disk geometry
                    484: ||             5   - flexible disk
                    485: ||             6-9 - see specific dev. types
                    486: ||             0a  - implemented options
                    487: ||             0b  - medium types supported
                    488: ||             3f  - return all pages
                    489: */
                    490: 
                    491: modesense1a(dsp, data, datalen, pagectrl, pagecode, vu)
                    492:   struct dsreq *dsp;
                    493:   caddr_t data;
                    494:   long datalen;
                    495:   char pagectrl, pagecode, vu;
                    496: {
                    497:   fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN, 0x10,
                    498:     ((pagectrl&3)<<6) | (pagecode&0x3F),
                    499:     0, B1(datalen), B1(vu<<6));
                    500:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE);
                    501:   return(doscsireq(getfd(dsp), dsp));
                    502: }
                    503: 
                    504: 
                    505: /*
                    506: || senddiagnostic1d - issue group 0 "Send Diagnostic" command (0x1d)
                    507: ||
                    508: || self                0 - run test, hold results
                    509: ||             1 - run test, return status
                    510: ||
                    511: || dofl                0 - device online
                    512: ||             1 - device offline
                    513: ||
                    514: || uofl                0 - unit online
                    515: ||             1 - unit offline
                    516: */
                    517: 
                    518: senddiagnostic1d(dsp, data, datalen, self, dofl, uofl, vu)
                    519:   struct dsreq *dsp;
                    520:   caddr_t data;
                    521:   long datalen;
                    522:   char self, dofl, uofl, vu;
                    523: {
                    524:   fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN,
                    525:     (self&1)<<2 | (dofl&1)<<1 | (uofl&1),
                    526:     0, B2(datalen), B1(vu<<6));
                    527:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE);
                    528:   return(doscsireq(getfd(dsp), dsp));
                    529: }
                    530: 
                    531: 
                    532: /*
                    533: || readcapacity25 - issue group 1 "Read Capacity" command (0x25)
                    534: ||
                    535: || pmi         0 - return last logical block, entire unit
                    536: ||             1 - return last logical block, current track
                    537: */
                    538: 
                    539: readcapacity25(dsp, data, datalen, lba, pmi, vu)
                    540:   struct dsreq *dsp;
                    541:   caddr_t data;
                    542:   long datalen, lba;
                    543:   char pmi, vu;
                    544: {
                    545:   fillg1cmd(dsp, CMDBUF(dsp), G1_RCAP, 0, B4(lba), 0, 0, pmi&1, B1(vu<<6));
                    546:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE
                    547:     /* |DSRQ_CTRL2 */ );
                    548:   /* dsp->ds_time = 100;       /* often takes a while */
                    549:   return(doscsireq(getfd(dsp), dsp));
                    550: }
                    551: 
                    552: 
                    553: /*
                    554: || readextended28 - issue group 1 "Read Extended" command (0x28)
                    555: */
                    556: 
                    557: readextended28(dsp, data, datalen, lba, vu)
                    558:   struct dsreq *dsp;
                    559:   caddr_t data;
                    560:   long datalen, lba;
                    561:   char vu;
                    562: {
                    563:   fillg1cmd(dsp, CMDBUF(dsp), G1_READ, 0, B4(lba), 0, B2(datalen), B1(vu<<6));
                    564:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE
                    565:     /* |DSRQ_CTRL2 */ );
                    566:   /* dsp->ds_time = 100;       /* often takes a while */
                    567:   return(doscsireq(getfd(dsp), dsp));
                    568: }
                    569: 
                    570: 
                    571: /*
                    572: || writeextended2a - issue group 1 "Write Extended" command (0x2a)
                    573: */
                    574: 
                    575: writeextended2a(dsp, data, datalen, lba, vu)
                    576:   struct dsreq *dsp;
                    577:   caddr_t data;
                    578:   long datalen, lba;
                    579:   char vu;
                    580: {
                    581:   fillg1cmd(dsp, CMDBUF(dsp), G1_WRIT, 0, B4(lba), 0, B2(datalen), B1(vu<<6));
                    582:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE
                    583:     /* |DSRQ_CTRL2 */ );
                    584:   /* dsp->ds_time = 100;       /* often takes a while */
                    585:   return(doscsireq(getfd(dsp), dsp));
                    586: }
                    587: 
                    588: 
                    589: /*
                    590: || Support functions ----------------------------------------------------
                    591: */
                    592: 
                    593: /*
                    594: || fillg0cmd - Fill a Group 0 command buffer
                    595: */
                    596: 
                    597: fillg0cmd(dsp, cmd, b0,b1,b2,b3,b4,b5)
                    598:   struct dsreq *dsp;
                    599:   uchar_t *cmd, b0,b1,b2,b3,b4,b5;
                    600: {
                    601:   uchar_t *c = cmd;
                    602:   DSDBG(fprintf(stderr,"fillg0cmd(%x,%x, %02x %02x %02x %02x %02x %02x)\n",
                    603:                dsp, cmd, b0,b1,b2,b3,b4,b5));
                    604:   *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5;
                    605:        
                    606:   CMDBUF(dsp) = (caddr_t) cmd;
                    607:   CMDLEN(dsp) = 6;
                    608: }
                    609: 
                    610: 
                    611: /*
                    612: || fillg1cmd - Fill a Group 1 command buffer
                    613: */
                    614: 
                    615: fillg1cmd(dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9)
                    616:   struct dsreq *dsp;
                    617:   uchar_t *cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9;
                    618: {
                    619:   uchar_t *c = cmd;
                    620:   DSDBG(fprintf(stderr,
                    621:     "fillg1cmd(%x,%x, %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x)\n",
                    622:                dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9));
                    623: 
                    624:   *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5;
                    625:   *c++ = b6, *c++ = b7, *c++ = b8, *c++ = b9;
                    626:        
                    627:   CMDBUF(dsp) = (caddr_t) cmd;
                    628:   CMDLEN(dsp) = 10;
                    629: }
                    630: 
                    631: 
                    632: /*
                    633: || filldsreq - Fill a dsreq structure
                    634: */
                    635: 
                    636: filldsreq(dsp,data,datalen,flags)
                    637:   struct dsreq         *dsp;
                    638:   uchar_t              *data;
                    639: {
                    640:   DSDBG(fprintf(stderr,"filldsreq(%x,%x,%d,%x) cmdlen %d\n",
                    641:                dsp,data,datalen,flags,CMDLEN(dsp)));
                    642:   dsp->ds_flags        = flags | dsreqflags |
                    643:          (((dsdebug&1) ? DSRQ_TRACE : 0) |
                    644:          ((dsdebug&2) ? DSRQ_PRINT : 0));
                    645:   dsp->ds_time = 10 * 1000;    /* default to 10 seconds */
                    646:   dsp->ds_link = 0;
                    647:   dsp->ds_synch        = 0;
                    648:   dsp->ds_ret          = 0;
                    649: 
                    650:   DATABUF(dsp)         = (caddr_t) data;
                    651:   DATALEN(dsp) = datalen;
                    652: }
                    653: 
                    654: 
                    655: /*
                    656: || bprint - print array of bytes, in hex.
                    657: */
                    658: 
                    659: #define hex(x) "0123456789ABCDEF" [ (x) & 0xF ]
                    660: 
                    661: bprint(s,n,nperline,space)
                    662:        char *s;
                    663: {
                    664:        int   i, x;
                    665:        char  *sp = (space) ? " ": "";
                    666: 
                    667:        for(i=0;i<n;i++)  {
                    668:                x = s[i];
                    669:                fprintf(stderr,((i%4==3)?"%c%c%s%s":"%c%c%s"),
                    670:                        hex(x>>4), hex(x), sp, sp);
                    671:                if ( i%nperline == (nperline - 1) )
                    672:                        fprintf(stderr,"\n");
                    673:        }
                    674:        if ( space )
                    675:                fprintf(stderr,"\n");
                    676: }
                    677: 
                    678: 
                    679: /*
                    680: || doscsireq - issue scsi command, return status or -1 error.
                    681: */
                    682: 
                    683: doscsireq( fd, dsp)
                    684:   int  fd;             /* ioctl file descriptor */
                    685:   struct dsreq *dsp;   /* devscsi request packet */
                    686: {
                    687:   int  cc;
                    688:   int  retries = 4;
                    689:   uchar_t      sbyte;
                    690: 
                    691:   DSDBG(fprintf(stderr,"doscsireq(%d,%x) %x ---- %s\n",fd,dsp,
                    692:     (CMDBUF(dsp))[0],
                    693:     ds_vtostr( (CMDBUF(dsp))[0], cmdnametab)));
                    694: 
                    695:   /*
                    696:    *  loop, issuing command
                    697:    *    until done, or further retry pointless
                    698:    */
                    699: 
                    700:   while ( --retries > 0 )  {
                    701: 
                    702:    caddr_t sp;
                    703: 
                    704:     sp =  SENSEBUF(dsp);
                    705:     DSDBG(fprintf(stderr,"cmdbuf   =  ");
                    706:                bprint(CMDBUF(dsp),CMDLEN(dsp),16,1));
                    707:     if ( (dsp->ds_flags & DSRQ_WRITE) )
                    708:       DSDBG(bprint( DATABUF(dsp), min(50,DATALEN(dsp)),16,1 ));
                    709:        
                    710: DSDBG(fprintf(stderr,"databuf datalen %x %d\n",DATABUF(dsp), DATALEN(dsp)));
                    711:     cc = ioctl( fd, DS_ENTER, dsp);
                    712:     if ( cc < 0)  {
                    713:       ds_panic(dsp, "cannot ioctl fd %d\n",fd);
                    714:     }
                    715:        
                    716:        DSDBG(fprintf(stderr,"cmdlen after ioctl=%d\n",CMDLEN(dsp)));
                    717:     DSDBG(fprintf(stderr,"ioctl=%d ret=%x %s",
                    718:       cc, RET(dsp), 
                    719:       RET(dsp) ? ds_vtostr(RET(dsp),dsrtnametab) : ""));
                    720:     DSDBG(if (SENSESENT(dsp)) fprintf(stderr," sensesent=%d",
                    721:       SENSESENT(dsp)));
                    722: 
                    723:     DSDBG(fprintf(stderr,
                    724:       " cmdsent=%d datasent=%d sbyte=%x %s\n",
                    725:       CMDSENT(dsp), DATASENT(dsp), STATUS(dsp),
                    726:       ds_vtostr(STATUS(dsp), cmdstatustab)));
                    727:     DSDBG(if ( FLAGS(dsp) & DSRQ_READ )
                    728:       bprint( DATABUF(dsp), min(16*16,DATASENT(dsp)), 16,1));
                    729: 
                    730: #ifdef aux
                    731:   /*
                    732:    *  check for AUX bus-error 
                    733:    *  we retry with poll-dma
                    734:    */
                    735:     if ( RET(dsp) == DSRT_AGAIN )  {
                    736:       int n = SDC_RDPOLL|SDC_WRPOLL;
                    737:       DSDBG(fprintf(stderr,"setting rd/wr-poll"));
                    738:       cc = ioctl( fd, DS_SET, n);      /* set bits */
                    739:       if ( cc != 0 )
                    740:         return -1;
                    741:     }
                    742: #endif aux
                    743: 
                    744:     if ( RET(dsp) == DSRT_NOSEL )
                    745:       continue;                /* retry noselect 3X */
                    746: 
                    747:     /* decode sense data returned */
                    748:     if ( SENSESENT(dsp) )  {
                    749:       DSDBG(
                    750:         fprintf(stderr, "sense key %x - %s\n",
                    751:           SENSEKEY(sp),
                    752:           ds_vtostr( SENSEKEY(sp), sensekeytab));
                    753:         bprint( SENSEBUF(dsp),
                    754:           min(100, SENSESENT(dsp)),
                    755:           16,1);
                    756:       );
                    757:     }
                    758:     DSDBG(fprintf(stderr, "sbyte %x\n", STATUS(dsp)));
                    759: 
                    760:     /* decode scsi command status byte */
                    761:     sbyte = STATUS(dsp);
                    762:     switch (sbyte)  {
                    763:       case 0x08:               /*  BUSY */
                    764:       case 0x18:               /*  RESERV CONFLICT */
                    765:        sleep(2);
                    766:        continue;
                    767:       case 0x00:               /*  GOOD */
                    768:       case 0x02:               /*  CHECK CONDITION */
                    769:       case 0x10:               /*  INTERM/GOOD */
                    770:       default:
                    771:        return sbyte;
                    772:     }
                    773:   }
                    774:   return -1;   /* fail retry limit */
                    775: }
                    776: 
                    777: 
                    778: /*
                    779: || opttovar - lookup option in table, return var addr (NULL if fail)
                    780: */
                    781: 
                    782: int *
                    783: opttovar( ostr, table)
                    784:   char *ostr;
                    785:   struct opttab{
                    786:     char *opt;
                    787:     int  *var;
                    788:   } *table;
                    789: {
                    790:   register struct opttab *tp;
                    791: 
                    792:   for (tp=table; (tp->var); tp++)
                    793:     if ( strncmp( ostr, tp->opt, 3) == 0 )
                    794:       break;
                    795: 
                    796:   if ( !tp->var )
                    797:     fprintf(stderr,"unknown option %s", ostr);
                    798:        
                    799:   return (tp->var);
                    800: }
                    801: 
                    802: 
                    803: /*
                    804: || ds_vtostr - lookup value in table to return string pointer
                    805: */
                    806: 
                    807: char *
                    808: ds_vtostr( v, table)
                    809:   long v;
                    810:   struct vtab *table;
                    811: {
                    812:   register struct vtab *tp;
                    813: 
                    814:   for (tp=table; (tp->string); tp++)
                    815:     if ( v == tp->val )
                    816:       break;
                    817:        
                    818:   return (tp->string) ? tp->string : "";
                    819: }
                    820: 
                    821: 
                    822: /*
                    823: || ds_panic - yelp, leave...
                    824: */
                    825: 
                    826: ds_panic( fmt, v)
                    827:   char *fmt;
                    828:   int v;
                    829: {
                    830:   extern errno;
                    831: 
                    832:   fprintf(stderr,fmt,v);
                    833:   fprintf(stderr,"\nerrno = %d\n",errno);
                    834:   exit(1);
                    835: }
                    836: 
                    837: 
                    838: /*
                    839: || ds_zot - go away, with a message.
                    840: */
                    841: 
                    842: ds_zot(message)
                    843:   char *message;
                    844: {
                    845:   fprintf(stderr, "%s\n", message);
                    846:   exit(1);
                    847: }
                    848: 0707070035050453640407770011710000040000020451370464700560700001000000000000generic0707070035050453631006660011710000040000010255410464713532400001600000002147generic/dev.c#include <stdio.h>
                    849: #include       "../scsi.h"
                    850: #include       "../scsish.h"
                    851: #include       "fns.h"
                    852: 
                    853: static int gen_id(int, int *, int, char **, char *);
                    854: 
                    855: static Function fns[] = {
                    856:        { "capacity", "capacity [lun=0]", "L?", gen_capacity },
                    857:        { "display", "display", "", gen_display },
                    858:        { "dev", "dev [type] # dev ? for list", "S?", gen_dev },
                    859:        { "help", "help [cmd]", "S?", gen_help },
                    860:        { "id", "id [target=0]", "L?", gen_id },
                    861:        { "inq", "inq [lun=0]", "L?", gen_inq },
                    862:        { "readt", "readt count [lun=0]", "IL?", gen_readt },
                    863:        { "reset", "reset", "", gen_reset },
                    864:        { "scsi", "scsi bytes... # 6 or 10", "I?I?I?I?I?I?I?I?I?I?", gen_scsi },
                    865:        { "sense", "sense [lun=0]", "L?", gen_sense },
                    866:        { "start", "start [lun=0]", "L?", gen_start },
                    867:        { "stop", "stop [lun=0]", "L?", gen_stop },
                    868:        { "testunit", "testunit [lun=0", "L?", gen_tur },
                    869:        { 0 }
                    870: };
                    871: 
                    872: Device genericdev = {
                    873:        "scsi", "generic scsi",
                    874:        gen_extsense,
                    875:        fns
                    876: };
                    877: 
                    878: static int
                    879: gen_id(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                    880: {
                    881: #pragma ref ncargs
                    882: #pragma ref cargs
                    883: #pragma ref err
                    884: 
                    885:        if(niargs == 0)
                    886:                printf("current SCSI id = %d\n", s_id);
                    887:        else
                    888:                scsi_target(iargs[0]);
                    889:        return(0);
                    890: }
                    891: 0707070035050453621006660011710000040000010255560464677353600001600000002107generic/inq.c#include     <stdio.h>
                    892: #include       "../scsi.h"
                    893: #include       "../scsish.h"
                    894: #include       "fns.h"
                    895: 
                    896: char *gen_rmb[2] = { "nonremovable", "removable" };
                    897: char *gen_devtype[256] = {
                    898:        "direct access",
                    899:        "sequential access",
                    900:        "printer",
                    901:        "processor",
                    902:        "worm",
                    903:        "cd-rom"
                    904: };
                    905: 
                    906: int
                    907: gen_inq(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                    908: {
                    909:        struct scsi_cmd cmd;
                    910:        struct scsi_return ret;
                    911:        int n, i;
                    912: 
                    913: #pragma ref ncargs
                    914: #pragma ref cargs
                    915: 
                    916:        if(niargs == 0)
                    917:                for(niargs = 0; niargs < 8; niargs++)
                    918:                        iargs[niargs] = niargs;
                    919:        for(i = 0; i < niargs; i++){
                    920:                set6(cmd, 0x12, iargs[i]<<5, 0, 0, 36, 0);
                    921:                if(n = s_io(0, &cmd, 0, &ret, -36, err))
                    922:                        return(n);
                    923:                printf("inq(%d,%d): %s %s;", s_id, iargs[i],
                    924:                        gen_rmb[ret.data[1]>>7], gen_devtype[ret.data[0]]);
                    925:                if(ret.data[4] >= 16){
                    926:                        char buf[256];
                    927: 
                    928:                        fixedstr(&ret.data[8], 8, buf);
                    929:                        printf(" %s", buf);
                    930:                        if(ret.data[4] >= 32){
                    931:                                fixedstr(&ret.data[16], 16, buf);
                    932:                                printf("/%s", buf);
                    933:                                if(ret.data[4] >= 36){
                    934:                                        fixedstr(&ret.data[32], 4, buf);
                    935:                                        printf(" rev=%s", buf);
                    936:                                }
                    937:                        }
                    938:                }
                    939:                printf(" [%d bytes]\n", ret.data[4]);
                    940:        }
                    941:        return(0);
                    942: }
                    943: 0707070035050453611006660011710000040000011500150464667004700002000000002650generic/sense.c#include   <stdio.h>
                    944: #include       "../scsi.h"
                    945: #include       "../scsish.h"
                    946: #include       "fns.h"
                    947: 
                    948: int
                    949: gen_sense(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                    950: {
                    951:        struct scsi_cmd cmd;
                    952:        struct scsi_return ret;
                    953:        int n;
                    954: 
                    955: #pragma ref ncargs
                    956: #pragma ref cargs
                    957: 
                    958:        if(niargs == 0)
                    959:                iargs[0] = 0;
                    960:        set6(cmd, 0x03, iargs[0]<<5, 0, 0, 4, 0);
                    961:        if(n = s_io(0, &cmd, 0, &ret, 4, err))
                    962:                return(n);
                    963:        printf("sense(%d,%d): ", s_id, iargs[0]);
                    964:        if((ret.data[0]&0x7F) == 0)
                    965:                printf("no error\n");
                    966:        else {
                    967:                printf("error class=0x%x, code=0x%x, sense=0x%x",
                    968:                        (ret.data[0]>>4)&7, ret.data[0]&0xF, ret.data[2]&0xF);
                    969:                if(ret.data[0]&0x80)
                    970:                        printf(", addr=0x%x", ret.data[3]+256L*ret.data[2]+256L*256*ret.data[1]);
                    971:                printf("\n");
                    972:        }
                    973:        return(0);
                    974: }
                    975: 
                    976: static char *exstab[16] =
                    977: {
                    978:        "no sense",
                    979:        "recovered error",
                    980:        "not ready",
                    981:        "medium error",
                    982:        "hardware error",
                    983:        "illegal request",
                    984:        "unit attention",
                    985:        "data protect",
                    986:        "blank check",
                    987:        "vendor specific (#9)",
                    988:        "copy aborted",
                    989:        "aborted command",
                    990:        "equal",
                    991:        "volume overflow",
                    992:        "miscompare",
                    993:        "reserved (#f)",
                    994: };
                    995: 
                    996: void
                    997: gen_extsense(uchar *data, char *dest, int ndata)
                    998: {
                    999:        int class;
                   1000: 
                   1001:        class = (data[0]>>4)&7;
                   1002:        if(class == 7){
                   1003:                if(data[0]&0x80)
                   1004:                        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]);
                   1005:                else
                   1006:                        sprintf(dest, "extended sense: %s", exstab[data[2]&0xF]);
                   1007:        } else {
                   1008:                sprintf(dest, "sense: class=#%x, code=#%x", class, data[0]&0xF);
                   1009:        }
                   1010: }
                   1011: 0707070035050453571006660011710000040000010451570457563432000002000000000613generic/start.c#include   <stdio.h>
                   1012: #include       "../scsi.h"
                   1013: #include       "../scsish.h"
                   1014: #include       "fns.h"
                   1015: 
                   1016: int
                   1017: gen_start(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1018: {
                   1019:        struct scsi_cmd cmd;
                   1020:        struct scsi_return ret;
                   1021:        int n;
                   1022: 
                   1023: #pragma ref ncargs
                   1024: #pragma ref cargs
                   1025: 
                   1026:        if(niargs == 0)
                   1027:                iargs[0] = 0;
                   1028:        set6(cmd, 0x1B, iargs[0]<<5, 0, 0, 1, 0);
                   1029:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   1030:                return(n);
                   1031:        return(0);
                   1032: }
                   1033: 0707070035050453561006660011710000040000010451730457563432000001700000000612generic/stop.c#include    <stdio.h>
                   1034: #include       "../scsi.h"
                   1035: #include       "../scsish.h"
                   1036: #include       "fns.h"
                   1037: 
                   1038: int
                   1039: gen_stop(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1040: {
                   1041:        struct scsi_cmd cmd;
                   1042:        struct scsi_return ret;
                   1043:        int n;
                   1044: 
                   1045: #pragma ref ncargs
                   1046: #pragma ref cargs
                   1047: 
                   1048:        if(niargs == 0)
                   1049:                iargs[0] = 0;
                   1050:        set6(cmd, 0x1B, iargs[0]<<5, 0, 0, 0, 0);
                   1051:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   1052:                return(n);
                   1053:        return(0);
                   1054: }
                   1055: 0707070035050453551006660011710000040000010451750457563432000002300000001115generic/capacity.c#include        <stdio.h>
                   1056: #include       "../scsi.h"
                   1057: #include       "../scsish.h"
                   1058: #include       "fns.h"
                   1059: 
                   1060: int
                   1061: gen_capacity(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1062: {
                   1063:        struct scsi_cmd cmd;
                   1064:        struct scsi_return ret;
                   1065:        int n;
                   1066:        unsigned long ns, ss;
                   1067: 
                   1068: #pragma ref ncargs
                   1069: #pragma ref cargs
                   1070: 
                   1071:        if(niargs == 0)
                   1072:                iargs[0] = 0;
                   1073:        set10(cmd, 0x25, iargs[0]<<5, 0, 0, 0, 0, 0, 0, 0, 0);
                   1074:        if(n = s_io(0, &cmd, 0, &ret, 8, err))
                   1075:                return(n);
                   1076:        ns = longat(&ret.data[0]);
                   1077:        ss = longat(&ret.data[4]);
                   1078:        printf("capacity(%d,%d): %ld blocks of %ld bytes (#%xx#%x)\n", s_id, iargs[0],
                   1079:                ns, ss, ns, ss);
                   1080:        return(0);
                   1081: }
                   1082: 0707070035050453541006660011710000040000010451770457563432000002200000002323generic/display.c#include <stdio.h>
                   1083: #include       "../scsi.h"
                   1084: #include       "../scsish.h"
                   1085: #include       "fns.h"
                   1086: 
                   1087: extern char *gen_rmb[2];
                   1088: extern char *gen_devtype[256];
                   1089: 
                   1090: int
                   1091: gen_display(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1092: {
                   1093:        struct scsi_cmd cmd;
                   1094:        struct scsi_return ret;
                   1095:        int n, i, old_id;
                   1096:        int retv = 0;
                   1097:        char rev[100], vendor[100], product[100];
                   1098: 
                   1099: #pragma ref niargs
                   1100: #pragma ref iargs
                   1101: #pragma ref ncargs
                   1102: #pragma ref cargs
                   1103: 
                   1104:        old_id = s_id;
                   1105:        for(s_id = 0; s_id < 8; s_id++){
                   1106:                printf("target %d:\n");
                   1107:                set6(cmd, 0x00, 0, 0, 0, 0, 0);
                   1108:                if(s_io(0, &cmd, 0, &ret, 0, err))
                   1109:                        continue;
                   1110:        printf("responded to test unit ready\n");
                   1111:        continue;
                   1112:                for(i = 0; i < 8; i++){
                   1113:                        set6(cmd, 0x12, i<<5, 0, 0, 36, 0);
                   1114:                        if(n = s_io(0, &cmd, 0, &ret, -36, err)){
                   1115:                                retv = n;
                   1116:                                break;
                   1117:                        }
                   1118:                        if(ret.nread >= 16)
                   1119:                                fixedstr(&ret.data[8], 8, vendor);
                   1120:                        else
                   1121:                                sprintf(vendor, "??");
                   1122:                        if(ret.nread >= 32)
                   1123:                                fixedstr(&ret.data[16], 16, product);
                   1124:                        else
                   1125:                                sprintf(product, "??");
                   1126:                        if(ret.nread >= 16)
                   1127:                                fixedstr(&ret.data[32], 4, rev);
                   1128:                        else
                   1129:                                sprintf(vendor, "??");
                   1130:                        printf("\tlun(%d): %s %s, %s/%s rev=%s\n", i,
                   1131:                                gen_rmb[ret.data[1]>>7], gen_devtype[ret.data[0]],
                   1132:                                vendor, product, rev);
                   1133:                }
                   1134:        }
                   1135:        s_id = old_id;
                   1136:        return(retv);
                   1137: }
                   1138: 0707070035050453531006660011710000040000011504230464700546400002000000000753generic/reset.c#include   <stdio.h>
                   1139: #include       "../scsi.h"
                   1140: #include       "../scsish.h"
                   1141: #include       "fns.h"
                   1142: #include       <scsi.h>
                   1143: 
                   1144: int
                   1145: gen_reset(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1146: {
                   1147:        struct scsi_cmd cmd;
                   1148:        struct scsi_return ret;
                   1149: 
                   1150: #pragma ref niargs
                   1151: #pragma ref iargs
                   1152: #pragma ref ncargs
                   1153: #pragma ref cargs
                   1154: 
                   1155:        set6(cmd, 0, 0, 0, 0, 0, 0);
                   1156:        cmd.bus_id = s_id;
                   1157:        cmd.flags |= SCSI_RESET | SCSI_BRESET;
                   1158:        /* should probably test for some kind of error... */
                   1159:        ss_io(0, &cmd, 0, &ret, 0, err);
                   1160:        return(0);
                   1161: }
                   1162: 0707070035050453521006660011710000040000010452030457563432100001600000000674generic/tur.c#include     <stdio.h>
                   1163: #include       "../scsi.h"
                   1164: #include       "../scsish.h"
                   1165: #include       "fns.h"
                   1166: 
                   1167: int
                   1168: gen_tur(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1169: {
                   1170:        struct scsi_cmd cmd;
                   1171:        struct scsi_return ret;
                   1172:        int n;
                   1173: 
                   1174: #pragma ref ncargs
                   1175: #pragma ref cargs
                   1176: 
                   1177:        if(niargs == 0)
                   1178:                iargs[0] = 0;
                   1179:        set6(cmd, 0x00, iargs[0]<<5, 0, 0, 0, 0);
                   1180:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   1181:                return(n);
                   1182:        printf("(%d,%d): good status\n", s_id, iargs[0]);
                   1183:        return(0);
                   1184: }
                   1185: 0707070035050453511006660011710000040000010452040457563432100001700000001215generic/scsi.c#include    <stdio.h>
                   1186: #include       "../scsi.h"
                   1187: #include       "../scsish.h"
                   1188: #include       "fns.h"
                   1189: 
                   1190: int
                   1191: gen_scsi(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1192: {
                   1193:        struct scsi_cmd cmd;
                   1194:        struct scsi_return ret;
                   1195:        int n;
                   1196: 
                   1197: #pragma ref ncargs
                   1198: #pragma ref cargs
                   1199: 
                   1200:        switch(niargs)
                   1201:        {
                   1202:        case 6:
                   1203:                set6(cmd, iargs[0], iargs[1], iargs[2], iargs[3], iargs[4], iargs[5]);
                   1204:                break;
                   1205:        case 10:
                   1206:                set10(cmd, iargs[0], iargs[1], iargs[2], iargs[3], iargs[4], iargs[5], iargs[6], iargs[7], iargs[8], iargs[9]);
                   1207:                break;
                   1208:        default:
                   1209:                sprintf(err, "number of bytes (%d) must be 6 or 10\n", niargs);
                   1210:                return(1);
                   1211:        }
                   1212:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   1213:                return(n);
                   1214:        return(0);
                   1215: }
                   1216: 0707070035050453501006660011710000040000010255540464677346100001600000001234generic/fns.hextern int gen_inq(int, int *, int, char **, char *);
                   1217: extern int gen_dev(int, int *, int, char **, char *);
                   1218: extern int gen_help(int, int *, int, char **, char *);
                   1219: extern int gen_sense(int, int *, int, char **, char *);
                   1220: extern int gen_start(int, int *, int, char **, char *);
                   1221: extern int gen_stop(int, int *, int, char **, char *);
                   1222: extern int gen_capacity(int, int *, int, char **, char *);
                   1223: extern int gen_display(int, int *, int, char **, char *);
                   1224: extern int gen_reset(int, int *, int, char **, char *);
                   1225: extern int gen_tur(int, int *, int, char **, char *);
                   1226: extern int gen_scsi(int, int *, int, char **, char *);
                   1227: extern int gen_readt(int, int *, int, char **, char *);
                   1228: 0707070035050513641006660011710000040000010255520464677343300002000000002007generic/readt.c#include   <stdio.h>
                   1229: #include       "../scsi.h"
                   1230: #include       "../scsish.h"
                   1231: #include       "fns.h"
                   1232: 
                   1233: int
                   1234: gen_readt(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   1235: {
                   1236:        struct scsi_cmd cmd;
                   1237:        struct scsi_return ret;
                   1238:        int n, i;
                   1239:        unsigned long ns, ss;
                   1240:        long bs, addr;
                   1241:        long t1, t2;
                   1242: 
                   1243: #pragma ref ncargs
                   1244: #pragma ref cargs
                   1245: 
                   1246:        if(niargs == 1)
                   1247:                iargs[1] = 0;
                   1248:        set10(cmd, 0x25, iargs[1]<<5, 0, 0, 0, 0, 0, 0, 0, 0);
                   1249:        if(n = s_io(0, &cmd, 0, &ret, 8, err))
                   1250:                return(n);
                   1251:        ns = longat(&ret.data[0]);
                   1252:        ss = longat(&ret.data[4]);
                   1253:        bs = ss? sizeof(ret.data)/ss : 1;
                   1254:        time(&t1);
                   1255:        srand(t1);
                   1256:        addr = nrand(ns-iargs[0])-1;
                   1257:        printf("read(%d,%d): %d blocks @%d (chunk=%dx%d),", s_id, iargs[1], iargs[0], addr, bs, ss);
                   1258:        fflush(stdout);
                   1259:        time(&t1);
                   1260:        for(i = iargs[0]; i > 0; i -= bs){
                   1261:                set10(cmd, 0x28, iargs[1]<<5, addr>>24, addr>>16, addr>>8, addr,
                   1262:                        0, 0, bs*0, 0);
                   1263:                if(n = s_io(0, &cmd, 0, &ret, bs*ss, err))
                   1264:                        return(n);
                   1265:                addr += bs;
                   1266:        }
                   1267:        time(&t2);
                   1268:        printf(" t=%ds (%.0fKB/s)\n", t2-t1, (iargs[0]*(float)ss/1024.)/((t1 == t2)? 1:t2-t1));
                   1269:        return(0);
                   1270: }
                   1271: 0707070035050450541006660011710000040000010253650464677245500001400000001727getstatus.c#include       <stddef.h>
                   1272: #include       <stdio.h>
                   1273: #include       "scsi.h"
                   1274: #include       "juke.h"
                   1275: 
                   1276: struct Jstatus j_status;
                   1277: 
                   1278: static
                   1279: dolun(struct Lunstatus *lun, uchar *u)
                   1280: {
                   1281:        lun->poweron = ((*u)&0x80) == 0;
                   1282:        lun->diskin = ((*u)&0x40) != 0;
                   1283:        lun->ready = ((*u)&0x01) != 0;
                   1284:        u++;
                   1285:        lun->diskindrive = ((*u)&0x80) != 0;
                   1286:        lun->driveshelf = (*u)&0x7F;
                   1287:        u++;
                   1288:        lun->shelfvalid = ((*u)&0x80) != 0;
                   1289:        lun->retshelf = (*u)&0x7F;
                   1290: }
                   1291: 
                   1292: j_getstatus(char *err)
                   1293: {
                   1294:        struct scsi_cmd cmd;
                   1295:        struct scsi_return ret;
                   1296:        int i;
                   1297: 
                   1298:        set6(cmd, 0x1D, 0, 0, 0, 10, 0);
                   1299:        memset(cmd.data, 0, 10);
                   1300:        cmd.data[0] = 0xE2;
                   1301:        if(s_io(1, &cmd, 10, &ret, 0, err))
                   1302:                return(-1);
                   1303:        set6(cmd, 0x1C, 0, 0, 0, 128, 0);
                   1304:        if(s_io(0, &cmd, 0, &ret, 128, err))
                   1305:                return(-1);
                   1306:        for(i = 0; i < 8; i++)
                   1307:                dolun(&j_status.lun[i], &ret.data[16+4*i]);
                   1308:        for(i = 0; i < NSHELF; i++)
                   1309:                j_status.shelf[i] = ret.data[48+i];
                   1310:        j_status.iounit = ret.data[98];
                   1311:        j_status.carrier = ret.data[99];
                   1312:        j_status.udrive = ret.data[100];
                   1313:        j_status.ldrive = ret.data[101];
                   1314:        return(0);
                   1315: }
                   1316: 0707070035050422060407770011710000040000020273120464713312700000400000000000inc0707070035050422051006660011710000040000010273140464713312700001300000000247inc/scsi.h#define SCSI_WR         0x80
                   1317: #define        SCSI_RD         0x40
                   1318: #define        SCSI_BRESET     0x20
                   1319: #define        SCSI_RESET      0x10
                   1320: #define        SCSI_SENSE      0x08
                   1321: #define        SCSI_LTMOUT     0x04
                   1322: 
                   1323: 
                   1324: #define        SCSI_CERR       0x01
                   1325: 0707070035050450411006660011710000040000010450110457563431200001200000002035iodr_sh.c#include "scsi.h"
                   1326: #include       "juke.h"
                   1327: 
                   1328: j_shelf_to_drive(int sh, Side side, int dr, char *err)
                   1329: {
                   1330:        struct scsi_cmd cmd;
                   1331:        struct scsi_return ret;
                   1332: 
                   1333:        set6(cmd, 0xD6, dr<<5, 0, (sh<<1)|side, 0, 0);
                   1334:        return(s_io(0, &cmd, 0, &ret, 0, err));
                   1335: }
                   1336: 
                   1337: j_drive_to_shelf(int dr, int sh, Side side, char *err)
                   1338: {
                   1339:        struct scsi_cmd cmd;
                   1340:        struct scsi_return ret;
                   1341: 
                   1342:        if(sh < 0)
                   1343:                set6(cmd, 0xD7, dr<<5, 0, 0, 0, 0);
                   1344:        else
                   1345:                set6(cmd, 0xD7, (dr<<5)|1, 0, (sh<<1)|side, 0, 0);
                   1346:        return(s_io(0, &cmd, 0, &ret, 0, err));
                   1347: }
                   1348: 
                   1349: int
                   1350: j_empty_drive(long tlimit, char *buf)
                   1351: {      
                   1352:        int i, tstop;
                   1353:        
                   1354:        tstop = time((long *)0) + tlimit;
                   1355:        while(time((long *)0) <= tstop){
                   1356:                setnlun();              /* in case it changes */
                   1357:                /* look for empty drives */
                   1358:                for(i = 0; i < nlun; i++)
                   1359:                        if(!j_status.lun[i].diskin)
                   1360:                                return(i);
                   1361:                /* look for spun down drives */
                   1362:                for(i = 0; i < nlun; i++){
                   1363:                        if(!j_status.lun[i].ready){
                   1364:                                if(j_drive_to_shelf(i, -1, SIDEA, buf))
                   1365:                                        return(-1);
                   1366:                                else
                   1367:                                        return(i);
                   1368:                        }
                   1369:                }
                   1370:                sleep(10);
                   1371:                if(j_getstatus(buf))    /* get the jukebox status */
                   1372:                        return(-1);
                   1373:        }
                   1374:        return(-1);
                   1375: }
                   1376: 0707070035050450401006660011710000040000010450120457563431300001400000002643ioshelves.c#include       <stddef.h>
                   1377: #include       <stdio.h>
                   1378: #include       <string.h>
                   1379: #include       "scsi.h"
                   1380: #include       "juke.h"
                   1381: 
                   1382: char *j_shelf[NSHELF];
                   1383: int j_wrshelf = 0;
                   1384: 
                   1385: j_rdshelves(char *err)
                   1386: {
                   1387:        FILE *fp;
                   1388:        static haveread = 0;
                   1389:        int shno;
                   1390:        char vname[256];
                   1391: 
                   1392:        if(haveread)
                   1393:                return(0);
                   1394:        for(shno = 0; shno < NSHELF; shno++)
                   1395:                j_shelf[shno] = 0;
                   1396:        if((fp = fopen(JUKEDIR, "r")) == NULL){
                   1397:                pperror(err, JUKEDIR);
                   1398:                return(-1);
                   1399:        }
                   1400:        while(fscanf(fp, "%d %s\n", &shno, vname) == 2){
                   1401:                if((shno < 0) || (shno >= NSHELF)){
                   1402:                fprintf(stderr, "Warning: bad shelf number in %s: %d (vol_id=%s)\n",
                   1403:                                JUKEDIR, shno, vname);
                   1404:                        continue;
                   1405:                
                   1406:                }
                   1407:                j_shelf[shno] = strdup(vname);
                   1408:        }
                   1409:        fclose(fp);
                   1410:        haveread = 1;
                   1411:        return(0);
                   1412: }
                   1413: 
                   1414: j_wrshelves(char *err)
                   1415: {
                   1416:        FILE *fp;
                   1417:        int shno;
                   1418: 
                   1419:        if((fp = fopen(JUKEDIR, "w")) == NULL){
                   1420:                pperror(err, JUKEDIR);
                   1421:                return(-1);
                   1422:        }
                   1423:        for(shno = 0; shno < NSHELF; shno++)
                   1424:                if(j_shelf[shno])
                   1425:                        fprintf(fp, "%d %s\n", shno, j_shelf[shno]);
                   1426:        fclose(fp);
                   1427:        return(0);
                   1428: }
                   1429: 
                   1430: int
                   1431: j_shelfof(char *vol_id)
                   1432: {
                   1433:        int i;
                   1434:        char buf[512];
                   1435: 
                   1436:        for(;;){
                   1437:                for(i = 0; i < NSHELF; i++)
                   1438:                        if(j_shelf[i] && (strcmp(j_shelf[i], vol_id) == 0))
                   1439:                                return(i);
                   1440:                if((i = warm_inv(buf)) <= 0)
                   1441:                        break;
                   1442:        }
                   1443:        if(i < 0)
                   1444:                fprintf(stderr, "jukebox: %s\n", buf);
                   1445:        return(-1);
                   1446: }
                   1447: 
                   1448: int
                   1449: j_driveof(char *vol_id)
                   1450: {
                   1451:        int i, sh;
                   1452: 
                   1453:        if((sh = j_shelfof(vol_id)) < 0)
                   1454:                return(-1);
                   1455:        for(i = 0; i < NLUN; i++)
                   1456:                if(j_status.lun[i].shelfvalid && (j_status.lun[i].retshelf == sh))
                   1457:                        return(i);
                   1458:        return(-1);
                   1459: }
                   1460: 0707070035050452251006660011710000040000010447370457563430700000700000004561juke.3.TH INTERNAL 3
                   1461: .CT 2 file_io
                   1462: .SH NAME
                   1463: jukebox routines
                   1464: .tr %"
                   1465: .SH SYNOPSIS
                   1466: .B "#include %hdr.h%"
                   1467: .PP
                   1468: .tr %%
                   1469: .B "int j_shelf_to_drive(int sh, Side side, int dr, char *err)"
                   1470: .PP
                   1471: .B "int j_drive_to_shelf(int dr, int sh, Side side, char *err)"
                   1472: .PP
                   1473: .B "int j_empty_drive(int tlim, char *buf)"
                   1474: .PP
                   1475: .B "void j_rdshelves(char *buf)"
                   1476: .PP
                   1477: .B "int j_getstatus(char *buf)"
                   1478: .PP
                   1479: .B "int j_scsiio(struct scsi_cmd *cmd, int ncmd,"
                   1480: .br
                   1481: .B "\ \ \ \ \ \ struct scsi_return *ret, int nret, char *err)"
                   1482: .PP
                   1483: .B "int j_shelfof(char *vol_id)"
                   1484: .PP
                   1485: .B "int j_volid(int dr, char *err)"
                   1486: .PP
                   1487: .B "extern char *j_shelf[NSHELF];"
                   1488: .PP
                   1489: .B "extern void pperror(char *buf, char *mesg);
                   1490: .SH DESCRIPTION
                   1491: .I J_shelf_to_drive
                   1492: places the disk in shelf
                   1493: .I sh
                   1494: in logical drive
                   1495: .IR dr .
                   1496: It returns 0 on success;
                   1497: otherwise an error message is placed in
                   1498: .I err .
                   1499: .PP
                   1500: .I J_drive_to_shelf
                   1501: places the disk
                   1502: in logical drive
                   1503: .IR dr
                   1504: in shelf
                   1505: .IR sh .
                   1506: If
                   1507: .I sh
                   1508: is negative,
                   1509: the disk is returned to its home shelf.
                   1510: It returns 0 on success;
                   1511: otherwise an error message is placed in
                   1512: .IR err .
                   1513: .PP
                   1514: .I J_rdshelves
                   1515: initializes each element of
                   1516: .I j_shelf
                   1517: to the volid of the disk on that shelf.
                   1518: A zero pointer means there is no disk;
                   1519: a name of
                   1520: .B UNALLOCATED
                   1521: means the disk has not been allocated a name yet.
                   1522: It returns 0 on success;
                   1523: otherwise an error message is placed in
                   1524: .IR err .
                   1525: .PP
                   1526: .I J_getstatus
                   1527: initializes
                   1528: .B j_status
                   1529: which include the following fields:
                   1530: .EX
                   1531:        struct Lunstatus lun[NLUN]; /* disk status */
                   1532:        uchar shelf[NSHELF];    /* shelf status */
                   1533:        uchar iounit;           /* I/O unit status */
                   1534:        uchar carrier;          /* carrier status */
                   1535:        uchar udrive;           /* upper drive status */
                   1536:        uchar ldrive;           /* lower drive status */
                   1537: .EE
                   1538: A return value of 0 implies success;
                   1539: otherwise \-1 is returned and an error message is placed in
                   1540: .IR err .
                   1541: .PP
                   1542: .I J_scsiio
                   1543: performs a SCSI transaction.
                   1544: It sends the command in
                   1545: .I cmd
                   1546: and
                   1547: .I ncmd
                   1548: data bytes and stores the return status in
                   1549: .IR ret .
                   1550: A return value of 0 implies success;
                   1551: otherwise \-1 is returned and an error message is placed in
                   1552: .IR err .
                   1553: .PP
                   1554: .I J_shelfof
                   1555: returns the shelf number of the disk labelled
                   1556: .IR vol_id .
                   1557: If there is no such disk,
                   1558: \-1 is returned.
                   1559: .PP
                   1560: .I J_volid
                   1561: returns the volid of the disk on drive
                   1562: .I dr
                   1563: in
                   1564: .IR err .
                   1565: A return value of 0 implies success;
                   1566: otherwise \-1 is returned and an error message is placed in
                   1567: .IR err .
                   1568: .PP
                   1569: .I Pperror 
                   1570: returns an error message that is contained in 
                   1571: .IR buf.
                   1572: .PP
                   1573: .SH "SEE ALSO"
                   1574: .SH DIAGNOSTICS
                   1575: 0707070035050453601006660011710000040000010447430457563430700000700000003362juke.h#define     NLUN    8
                   1576: #define        NSHELF  50
                   1577: extern int nlun;
                   1578: extern void setnlun(void);
                   1579: extern char *j_shelf[NSHELF];
                   1580: extern int j_wrshelf;                  /* need to write out shelves */
                   1581: extern j_rdshelves(char *err);
                   1582: extern j_wrshelves(char *err);
                   1583: extern j_inventory(char cold, int tlim, char *err);
                   1584: 
                   1585: typedef enum { SIDEA = 0, SIDEB = 1 } Side;
                   1586: 
                   1587: struct Lunstatus
                   1588: {
                   1589:        unsigned int poweron:1;         /* is power on ? */
                   1590:        unsigned int diskin:1;          /* is disk in drive? */
                   1591:        unsigned int ready:1;           /* is disk spun up or spun down? */
                   1592:        unsigned int writeprotect:1;    /* is disk write protected? */
                   1593:        unsigned int diskindrive:1;     /* is driveshelf a drive number? */
                   1594:        unsigned int shelfvalid:1;      /* is retshelf valid? */
                   1595:        uchar driveshelf;               /* drive number */
                   1596:        uchar retshelf;                 /* return shelf */
                   1597: };
                   1598: 
                   1599: struct Jstatus
                   1600: {      
                   1601:        struct Lunstatus lun[NLUN]; /* disk status */
                   1602:        uchar shelf[NSHELF];    /* shelf status */
                   1603:        uchar iounit;           /* I/O unit status */
                   1604:        uchar carrier;          /* carrier status */
                   1605:        uchar udrive;           /* upper drive status */
                   1606:        uchar ldrive;           /* lower drive status */
                   1607: };
                   1608: extern struct Jstatus j_status;
                   1609: extern int j_getstatus(char *err);
                   1610: extern int j_shelfof(char *vol_id);
                   1611: extern int j_driveof(char *vol_id);
                   1612: 
                   1613: extern char *strdup(char *);
                   1614: extern int j_shelf_to_drive(int, Side, int, char *);
                   1615: extern int j_drive_to_shelf(int, int, Side, char *);
                   1616: extern int j_empty_drive(long, char *);
                   1617: extern int j_rvolid(int, char *);
                   1618: extern int j_wvolid(int, char *, char *);
                   1619: extern void pperror(char *buf, char *mesg);
                   1620: extern int reserve_drive(int, char *);
                   1621: extern int release_drive(int, char *);
                   1622: extern int cold_inv(char, char *);
                   1623: extern int warm_inv(char *);
                   1624: extern int j_load(char *vol_id, char *buf, long tlim);
                   1625: extern int j_unload(char *vol_id, char *buf);
                   1626: 
                   1627: #define                JUKEDIR         "/usr/worm/jukedir"
                   1628: #define                UNALLOCATED     "<unallocated>"
                   1629: 0707070035050450551007770011710000040000010576210464700562400001000000215126jukebox&\H"���^Юn��P�P�Հ��P��p�P��P��[��
�P�&�t.�&�$^Ь[ЬZ�V�������������������������WЏ�B�����~��6\��W?����Z�[���2�PY�P��������YP�P�e|&�P�ah���P�U���P�w@ÏmPQ6�A�P`7&�&�&B&�&M&X&�&c&�&w&l�&V�U����&����J����&����?����&����4����&����)����&��������&��������&W�
                   1630: �����/e�&�<)�P����������@�������
e����V'����!����������������        �W�&�����Ub[��LbU�Ej�����������X�����W     �W�&�����2�X��������?�&����X��W�P�v&����@�&�&�l�&�&��=����X�h��� Џu�������~���P�0&�V2�X�������l?�&����X���P������{��������X��@�PY������Y����P��������Y���.����Y����P��������Y���.�Y�����n6�����������;����&�P�PU�Y�Y2#�I�Dc�I�;c�Y����$6�Y���zX����&���P����&�H�~�&��*��OX����&�����&�!�����X��.�&�&�*ݬ����X���-�&�&�*^����&�v�P ��������X��-�&�&�\*����&�Q�P �������QX��z-�&�&�-*�[�[�.&�K�m���U��|gUZˏ����jU�&�[�����4��cUɏ�[T�UTxjU�&UU�E�%W������4@���bUɏ�[T�UTxjU�&UU�E��V����4
���&�~4��t�&�q4ˏ����jUS��Ux��UU�E�_a.��Uˏ����UT��~x��UU�E�>a��'��)4 ��~���&��4
���&�&�4���&�&��3�[�����^Ь[����&���P �����6���V��&,�&�&�(����&�
�P �������V���+�&�&�(�Z�Z^�J�����U��|gUYˏ����iU>�[
                   1631: ˏ����iU0����~ݏ�����Z����P�����&��?V��h+�Z�Ь[�[�&�
�P�[��o&��V��:+�&�&��'ݬ�&�'�PZ�Zݬ���[��:Џ����Pj�&�Uݬ�&�^�PY�J�_�[�Y���@�Y�[�Y�~�Z����P   Џ����P!�[�Y���P Џ����P        �J�a_�Pxcan't find vol_id %s
                   1632: <unknown shelf??>unallocated shelf number %d??ab%s%c): in shelflower,%supper,%slun %d(onlineofflineUsage: jukebox [-aemprsuU] [-w secs] [vol_id
                   1633: %d: %s
                   1634: %d
                   1635: jukebox: %s
                   1636: -a needs a vol_id-e needs a vol_idaemprsuUw:^Ь[ЬZ�Z�&�>�P
Џ����P�&�Z�&�
                   1637: �P
Џ����P�s&�[�&�N�PY�Y �Y�[��&�Z��D8Џ����P�C&��&�&��PY�Y��[&�Z��8Џ����P�&�Y��&��0��&�S~��?0�PX�Z�X�&�Y����P
Џ����P���[��������7�Z����X���P
Џ����P��&�R�[�&�8�PI�-]�Z�&�Y�X����P    Џ����Pi�Z�X�~�Y��V�P     Џ����PM�[��I�����.7�Z����X���P  Џ����P�Z�~�Y�X��i�P     Џ����P�P%sa%sbusing unallocated disk from shelf %d
                   1638: no unallocated disks<unallocated>there is an existing '%s' on shelf %d��^��[ЬZ�Z�&��P
Џ����P�����&��.�V�Y�Y27��gUʏ?���U�U���VЏ�I��[�I�[�I�8��Y��V����.�Y�Y2�I�[�Y��X�X�ˏ����H�>\U��X��)��V.�H�\Uˏ����UTCʏ����U:�Z�~�Y�X���
                   1639: �P
Џ����P��&�Y�Y2�I�[�Y��V$�Z�~ݏ�����X��
                   1640: �P
Џ����P�&���&��-�X�C����V��u��-��4���&�P~��P-�PX�&��O�Y�Y2�&�I�8��&�I�Z��gUʏ?���U�U������4���8��X�Y��    &�P��8��&�����[�0���0�U�U�r7�U�s.�U�u<�U�u3��0��c&�W�G��Y�W��2�&��0�PW�@��Y��YW�W�Y��8���p���,�Z��4�~�W�X��i      �P   Џ����P`��8��&�'5�PG�Y�&G�8���&�3�Y��������&�k,�Z�&�
�P    Џ����P�[�s�Z�&�B�P�^Ь[ЬZЬY�Y�Z�~�[��x�P
Џ����P�j&����Z��:�PX�&�XԼ\�&��Y�~�[�Z���P
Џ����P�%&�Y�Z�&�[���P
Џ����P�&����Z����PX��X���Y���3�����Y���3�Y�&�'4�&PX�X�������2a�YXU�e�a�YXU�eK�YXU�e�b�YXU�eռ�&W�W�W�)�Y��@�����Q2����Y��P3Џ����PF�PBԼ����[���&���M��#�[��&�Y��
                   1641: 2����~�~�~�~���
�PмU�E�W[мU�E�WZ�[�Z�P!�[     Џ����P�Z�&P�Z�[��}2ЬUЬT�E�OWD��xݬݬ�&ݬ��ЬUЬT�E��xD�Wݬ�&ݬݬ��Ь[�Z�Z2�ZJ��x�Z���E�����2��x��P*�Z�Z2���J�x��[��ZX�Z��P����P
Џ����P��J�lxYЏ����J�_x�YXX�[��Y������P        Џ����Pb�[�Z���)����P       Џ����PH�YZ�J�x�J�xYЏ����J�x��[�Z��������P   Џ����P
                   1642: �Z�2����PDISK_ERROR%derror in reading shelf %d: %s; proceeding
                   1643: vol_id '%s' must end in a or bapparently good superblock but null vol_id<unallocated>process any new disks.
                   1644: %s@%d -> %d
                   1645: reloading %d disks.
                   1646: 
                   1647: clearing drive %d:
                   1648: %d disks in shelves.
                   1649: theregetstatus done
                   1650: Ь[ЬZ�jUʏ���U�&Y�Y�&kUˏ����YT�TUk�jUʏ����U�&Y�Y�kU�YT>D�����Tʏ����T�TUk�jUʏ����U�&Y�Y�kU�YT�D�����Tʏ����T�TUk�Z�jUʏ���U�&Y�Y�kUxYTʏ����T�TUk�jU���U�&�Z�jUʏ���U�&Y�Y� kUxYTʏ����T�TUk�jU���U�8 ^���ߐ��ߔ��ߔ��ߔ��ߐ
                   1651: ��ߔ����
                   1652: �~������L&������ݬ�~�����
                   1653: �����&���P
Џ����P����ߐ��ߔ��ߔ��ߔ��ߐ����ߔ���ݬݏ������~�����~���P   Џ����PY�[�[�K���K�T��O����[��[�[2�K�,��g�[��^��CT��_��;T��`��3T��a��+T�P&^��UH�P�ԭ�ѭ�2Э�U�E��R֭����������P[���&ݬ��
                   1654: Џ����Ps����߭����&�[��c+�PFЭ�U�U2"����ݭ���&��s&��rH��������&��-Э�U�PE�FR��[�&���&�G�P��-&��c&��3�PZ��Q&ݬ��bЏ����P7�[�[2%�K��Q�K��Q�[��&�Z���[��Z�&�x�P^Ь[�Z�Z2"�J�QU�[�U��,�P�ZP6�Z�����&���PZ��Z�����h��vG��Џ����Pݬ�&�����PZ        Џ����P6�[�[(ˏ����K��QU�K��QU�eU�UZ�[P�[�Џ����Pjukebox: %s
                   1655: wWarning: bad shelf number in %s: %d (vol_id=%s)
                   1656: %d %s
                   1657: r/usr/worm/jukedir8 ^����������x�U�U������ЬU>E�����U��T�TU���������ݬ�~�����~�����~��8 ^���լ&�������x�U�U���������������7�������x�U�&U������ЬU>E�=���U��T�TU���������ݬ�~�����~�����~��Ь[�~�&�,��PY�~�&�,�PY����Z�Z��Dˏ����J�FPU�ZPs�Z��Z�Z��D8ˏ����J�#PU%�[�~ݏ�����Z�������P       Џ����P5�ZP0�Z��
                   1658: �&�(�[�&�����P�c���Џ����PЏ����P�^Ь��ݬ߭��~߭��&���^Ь��ݬ߭��~߭��&��:�^Ь��ݬ߭��~߭��&��.�&^Ь[ЬZ�[�&�~����P
Џ����P�
                   1659: �[�&�Z����P
Џ����P��&ݬ�&�*�PXݬ������)�H����a�V-�H����b�&Vݬ���&�[��_(Џ����P�&�H��������&�2����PW�W ������&�[��((Џ����P�d&�Z�@&�X�X��H�����U��|gUY�iUˏ����UT�ʏ����U���Ux��UU�WUs��Uʏ����U�VT�UT�X�B    �XP��ˏ����iU��[�~ݏ�����X�������P
Џ����P��[�&�����PЏ����P��X�:����[�Z��.����P��խ����[��&'Џ����Pf�[ݭ��V~�W������P Џ����PHЭ�PB�
                   1660: �&�&�
                   1661: Z�[�&�����P����Џ����P�������[��&Џ����Pdisk '%s' busycan't find a free drivecan't find vol_id %svol_id '%s' must end in a or b^��]A��WA2��NA��(�����)&�~�������P��$A�/dev/worm%d^Ь[�[�&�����P
Џ����P��������&��@~���PY�[�&�Z����P
Џ����P���Z�Z2��gUʏ����U�Z��Z2���������Yݏ�������P����[��c&Џ����Pl�Z�J��J�Z��Z�����S����[����~�Z�Y������P        Џ����P+�&�@����&�7&�PJ�J�&�&�$�#����P%s -> %d
                   1662: < ^լԼ�������x�U�U���������������ݬ�~�����~�����~���P�������P�P< ^լԼ�������x�U�U���������&������ݬ�~�����~�����~��%�P�������P�P8 ^�����������������������I������U�0U���ݬ�~�����~�����~��[�P< ^�������x�U�U���������������ݬ�~�����~�����~��y&�P�������P�P�^Ь[��Џ��������f>5���q����P�N>��[ݬ��4Џ����P�&�[    Џ@ZЏ�ZЬU��T�ZT�߫ݬ��>��k&�P���[U�PU2���ݬ������=�&��Џ������=Э�P�լA�$�~ݬ��=�� �P���$�U�PUZѭ�$�&�����~ݬ��p�ì$~ݬ��h=��Y �P����Qݬ��C�g���ЬU�$���$լ��/=�&�4Џ�����=�P^Ь[ЬZ����ЬU��G��Zݬ�[ݬݬݬ��b����P���"��������P�S&�Z������"�j���횫����.&�������ЬU��U�U��������d�������Zݏ�����[�~�����~�������P�������P����Q<n��&Uʏ����U�U^����U�����UQ�������ЬU��U�U����������������Z��[�~�����~��q����P������������Pf��GЏL"�Gݏ����߫$��rG�����������Yx�����Uʏ����U�E�;Y�Y���Z��f �&P�P%s; %sreservation conflictintermediate good/metintermediate goodbusyreservedmet/goodcheck conditiongoodscsiio readscsiio write/dev/scsi< ^լԼ�������x�U�U���������������ݬ������~�����~��y����P�������P�ݼ��E����������Uʏ����U���&������Uˏ����U~����Uˏ����U~����Ux��UUˏ����U~��9������Uʏ���U+����U����TxTT�TU����TxTT�TU~���&��p���&�&�c�P�^Ь[�kUx��UUˏ����U��ѭ�d�kUʏ���U4��~��~��~��~��Uʏ����U�E��9��~ݬ��VB��Uʏ����U�E�9��Gݬ��2�kUˏ����U~ݭ���ݬ��sense: class=#%x, code=#%xextended sense: %sextended sense: %s info=#%2.2x#%2.2x#%2.2x#%2.2xreserved (#f)miscomparevolume overflowequalaborted commandcopy abortedvendor specific (#9)blank checkdata protectunit attentionillegal requesthardware errormedium errornot readyrecovered errorno sense
                   1663: , addr=0x%xerror class=0x%x, code=0x%x, sense=0x%xno error
                   1664: sense(%d,%d): ^Ь[����(���x�U�U���x��[U�U���x��[U�U���x��[U�U���[���������&������ݬݏݬ�~�����~������(^Ь[ЬZ�W�j�Z�[������P
Џ����P�r&�Z�����~�[��N����POݏ�~�������ݏ�����������P#�W�&����P7��y���&YЏ����X�W�Y��^��'7��P�Z�����Y�[�������P
                   1665: �YX�� �Y��XF�Y&�Y��W������6��
                   1666: ����Z�������[�������&P��Z�����X�[��\����P-�����[������Y�X��j��6��Џ����P>�W�X��6��a6��ݏ���&��Z���������[��K����PЬ[ЬZ���*�x�U�U�x��[U�U�x��[U�U�   x��[U�U�
                   1667: �[�����
�&���ݬ�~ݬݏ�Z�~�����X"^Ь[ЬZݬ���������&���d������  �PY�����Z���Џ����P��&�Z�[��a����P
Џ����P��&����%���x[U�U����������������������������Z��ͬ��~�����~��Q����Pͨ��ͨ�P�e&�����&��PX�XU�U���14�U���1K�X�o�@ݬ����ݏj��i&�ͬ����Xݬ����ݏP�1��I&�ͬ����8�����&�H�P��&��z4��     ݬ��������ͬ����ͬ��&�l�P �ͬ����Z��yЏ����P������&��~ݏ�Y��      �Yݏ�&������P��Y�Z��8&Џ����PC�Y�&�z�Z�ͬ������&�[������P    Џ����P�����&�!�Z�[������Pmkfs read%s: errorworm mkfs -f %s %swarning: bad capacity %d
                   1668: worm mkfs -n %d -f %s %sw+rmkfs %s
                   1669: superblock at %d
                   1670: read fail on block %d (b=%d)
                   1671: no superblocktried for superblock at blocks 1,2
                   1672: read block %d
                   1673: superblok at 0
                   1674: ���=U    �U�:��=ݬ��8ݬ���!��=U�E��ݬ��ݬ��%s: %s%s: unknown errno %dЬ[��ZxZU��T�TUZxZU��T�TUZxZU�kT�TUZ�ZP�!�\�^Ь[�Z�Y�kP�P �P �P+�P-�Y�[�[��
                   1675: ZP��Q�QP�0PZ�k0�k9��Y�ZP�ZP�P�<�&P�������P�+�+�+,,0,:,T,f,x,�,�,�,�,�,�,�,�,�,--.-=-N-b-v-�-�-�-�-�-�-�-�-..&.<.R.k..�.Error 0Not ownerNo such file or directoryNo such processInterrupted system callI/O errorNo such device or addressArg list too longExec format errorBad file numberNo childrenNo more processesNot enough memoryPermission deniedBad addressDirectory not emptyIn useFile existsCross-device linkNo such deviceNot a directoryIs a directoryInvalid argumentFile table overflowToo many open filesIllegal ioctlText file busyFile too largeNo space left on deviceIllegal seekRead-only file systemToo many linksBroken pipeArgument too largeResult too largeLink loopConcurrency violationIt's all Greg's faultSecurity label violationNo such system callOut of security labelsInadequate privilege�^���ݬ�&��^Ь[��U5��M5��O&�&�
                   1676: ������������0�Џ����P1��&��$ЫZi�[��\9����H���H���א����&X�X߭���~��3�PY�kVݏ�&���PZ�Z�������Y�YX �Z�Y�YX�Z��Y�Z��~����PYЏ�k����Z��XY� �1E�ЬP�^Ь[2�Pʏ����P�PHЫZB�Z�Y;�Z������PЏP�Pk�Y�Z��~��q�PY
� �Џ����P�P�^��e,[��&���   �[�&�t����[�[��3��^Ь[Џ����Z��&�A��<�[�&�>����PZ��~�&�����PЏ����Z��
                   1677: ݫ�&�6����ԫ���&��k�ZP�^Ь[���+X�X�;3�P1&&�X��&�瑫&+�&P�P�PY�k�w+ݏ�&ݬ����PZ�Y1��Z��Z�&������{�k�aj�Y�~�&~ݬ��H�PZ<��y63ݏ�&ݬ��r�PZ�Y�Z�Z�&�����ݬ��
                   1678: �PZ�Z'���Z���Y�~�~ݬ����PZ�Z1 ��h�Z��Y���k�r���&��XP^ЬP�����ݬ���
ݬ߬ݬ��Z�P[ЬP���QѠQݬ�&�����ݬ��
ЬP��      Џ����P�[P�^Ь[2�Y���&Y     �[�&�J����Y���Y1�ի�Ѭ�Ѭ&"Ѭkë�PѬPЬZ�Zk�Z��P1��&���~��^�PXq�kZѬ&�ZXP�P�ԬլX�YT¬Xë�P�ZP�XP�XZ�ݏݬ��/�PZ&��Z�~��~���&�[�&�� �P�Z�Zk�ӏ&&Y�kЫ�ݬݬ��~���&�P1N�Џ����P�^��0&G��0�1���0P�@�Q�a-��@�P��&���0��v0P�@���
                   1679: �P1���]0P�@��W0P�`[�[��S�[:�[ݬ��
�PZd��(0�[��50ݼ��$0��(��������
                   1680: 0��0P�@���/P�`
���/�&��/�?P1����/Џ����P1��Z�j:1��&��/P��/Q�A�P�`�&�/P��/�A�P�2O��/��/�)��x/��[��/ݼ��/���'�����1n���S/P��L/�@��1�&�@/.��8/��./P�@��(/P�`
�&�/��/��1�[P���������~����PZ�Z2<�Z7�
ZP�
P�PZP�PP�PP�@��SY�i[�&kP�[P�P�ZP
                   1681: �[�ki�[P�Z�&��^Ь[���.Z�X�j3�Z��.�ij�jY�i��[[P�PP�ZP�YP�[[P�PP�ZP�PZ1��ZY�&jZ�ZY��X�X&       ��.Z���&� �PZݏ��[~���
x
                   1682: PX�XXP�PP�ZP�PZxX~�&���PY�Y�����$�[XP�P�PX�[XP�P&���&�P19��P���xX~�Y��-&1��[[P�PP�P��-�Y��-���-�R�j��-�&��-j�Z��-   �Y��-���-�&��-Y�Y�-��ZPЬ[X�[�&kP�[P�PY�Y2:�Y5�
YP�
P�PYP�PP�PP�@�4RX�hZ�&jP�ZP�P�YP�Z��[h�[~�&��^Ь[�[�[�1-�[�&-�[�-�&k�^��     R[ԭ��Z�Z�&����֭��jk�kZ��[�[�T��Э�P�^ЬZ�ݬ��K�PP�PP�ZP�P��Э�j�Z�,W��,[��,YЭ��,�[P�ZP�ZP�&ZP�Pk���P�YP�YP�&YP�P���&�a,�\,��V,���^Ь[ݬ�&�������   �[�&������[��P�P�����~���PW�&W~�&�����PX�X[�XP�W���W���[Z�XYЊ�Э�P׭��P��X[��WWP�PP�XP�P[��WWP�PP�XP�[P�P��wP@h�ЬT4}�Q�QR+�RSя��T)���ac��T�)Tac�caP�PP�P�ЬV'}�S�TWя��V,lW���c��V�,lWVcЬP�^Ѭ�ЬPЬP��^ԭ�Э�P�@�aN
Ь@�VN�&P�!����P��p���^��#������"��
                   1683: ���"߬ݬ���P[���P���"P��"�&��������"�����"     Џ����P�[P�^Ь�SOЬ�OOŬ�P�P�~ݬ���^��-OYì���ѭ�Y1!&x&Y~ݭ���   �PY�������Э���Ь[�Y�Z+�Y��ݭ��[���ݭ��[���N�P����Ph�Y[�[���]�Z�Y��ݭ���K�Z�Y��ݭ��[����Y��Э�[/�Zݭ����N�P����P�[����Z�[��r�YZ��YZ�Z����[��>ì��Pí��Q�PQݬ�Y��~������Э��1�ݭ�ݬ�������Y���1���[�Y��ݭ��Z��2�Y��Э�Z14��^���M��Ь[ЬZ�kY�j��Y�׭���^���M��Ь[ЬZЬY�k���i��j�����׭����^�[ЏUUUUK�(�Џ����K�(��̏����K�|(�&���[�[���(��(�&[��S�PZ��(P�PQ�A�C(Q�[ R�[RQQ�Q@�1(��s(P�PQx[A�(R�R@�(��T(��[[�[ ��^��<(��5(��2(��+(��!(P��(Q�A��'@��'��(P�@�'P�PPʏ���P�^���'���'���'���'���'P���'Q�A�v'@�p'��'Pˏ�@�]'P�^��'��'��'��'��u'P��r'Q�A�"'@�'��Z'Pˏ�@� 'QnQPf�K'P�^Ǭ����PĬP�P����[��'��'��'��'��'P��&'Q�A�&@�&���&Pˏ�@�&Z�Z[�ǬZPĬP�PZP�^м[��&��[�&м[��&��[�&���[�K�Z�K�C&K��ZK�8&�[��^Ь[ЬZԭ�լ05Ь���jЪP֪�`P �Z�&��PY�Y�׭��֭�ѭ���Э�P�^Ь[ЬZԭ�լ16ЬY�j��PЪQ֪�Pa�Z��~�������Y���
                   1684: ֭�ѭ���Э�P������������%�~�&�\S�^\��������%P���%�����Ь�%�P�^߬ݬ��#���
�^߬ݬݬ���
�^Ь[��A���[���[��ԭ�֭��߬ݬ߭���
�^Ь[��A$��9$��;����&�t���ի��
                   1685: ݫ�&���������Ь���Ы��k�^ԭ�լ1�ݏ��&��P����=I�&�n�P;ݭ�����խ�����P��ݭ��&����Zݭ��&�ANԭ�խ� ѭ��í����­��¬���&����!����P��ݬ�&�������^�&��H����^��B��Ь��Џ���߭�߬ݬ��R�P[׭��PЭ�Q֭��Pa߭����z����[P�^��B��Ь��Ь��߭�߬ݬ���P[׭��PЭ�Q֭��Pa߭����-����[P}�R:���b:S���b�QR������RQT�T:STb�QP}�S�ST�P:���d)���dc�QT������TQ�Q)Qdc    �cP�aQ�QP�}�V�VS:���g(���gc�QW������WQ�Q(Qgc�VP�^ݬ�&�)�&P~�&������P���P�Pݬݭ������ЬR�RQ:���a��RQP�ЬUC}�S�TV�URЏ��Y�YUX�YU:Uf�VQU�X�YRW�YR,UfRc�WR     �XU��U�ЬP�^�� �P��1��ݬ���!���!���!���ݏ�&�&�&���9�P[�&���+�PZ߭��&�.&�P���P��   �P������ѭ�����Џ�������[�����Z����Э�Pխ��Э�P�
ЬQ�Pa�#�^լ       ��FPЬP�P[��@!�[��?�����-!�[����(!�[����!Z��a��j�z��j�[�&�3�[PЬPЬR�R&�Q{RPPR�PR�P�&P�
                   1686: ������PЬPЬR�R&�Q{RPRP�P�PR�RP�����լ�Q�������^� ��$Э�P�@�6C�@�-C���@�$C���׭�խ���&����(���&      
                   1687: 
 !"#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~���������������������������������������������������������������������������������������������������������������������������������T7��R�B�����d�ݭ��R������P���֭�������S}��T�T��P���R�P�T��S�C�����&R�Q�S��T�P�}T���P���&R�P��P�Q�R���Э�P����^Ь[Ь��Ь\ԭ�<���P�[Q}��T�QUR�PR�RP0r��Q[�&Rܕ���^U|Y|V��P�P �X�������������������������������������&����������&�����y&���������������&$
����������&�����y&��&�P�1��1�&ȏ@Z� P11��XP�&Z�&PЌR:Pb�QU�RQ1'&0123456789abcdef0123456789ABCDEF�R�S������W�R�S������W�Z������W�SV�Q�UЌP�RSPQ�Ag��VR��|V�e;0��Z1}լ�1u�S��xP�Z��XP�Pq�W�0qYʏ�Z�&lP�P
                   1688: n4
                   1689: n� 
                   1690: �
                   1691: n� &��
                   1692: n�&��
                   1693: n�W8
                   1694: n������; ��W�Z�+q�Z� q�W�&Z�&X�QUV�WV�VX&�WQ�Q�H� R�]R�RX(VaHa,a0X��W�Q�VSU�QUX�XYP �Z�ZR�WP �PX�PY0)��XYP7�XY�XP0��&R�P��R}��T�T0���R�֭�}T����YP1b�1]��0R� R�PY�Q�PW�P^,`RWn�WP�^Q0���W^ЎQЌP�P��^Q1i�ȏ�Z1L�� Z1F��Z1@��Z1:��Z�&Z�Z�&Z�IiY>I��Y       �HhX>H��X�&Z1��X�Z�&Z1��&Z
ЌY��Z�YY�ЌX��XX��&Z�X0�&���XW�WV�W�W�W�WP�PnW�#�V�WP֭��W�P&�H���W�x��WP���@���Q�WV��S�����0��0S��,a��Vc�c8Va�0��VUQ�nS�W���-��WЭ�P�0��PV�VP�PV�P��(PacЭ�P,a0Pc�XP�Z�       Z�.�έ�P�PX�XP�PX,a0Pc�XP�PV�VP�PX(Pac�XP�@� R�]R�RP�PX�PX,a0Pc�SU�DeB+��X�&Z�X0��XW�W�W�WP�PnW�֭��&WP�P&�=���W�x��WP���@��Z=��Q&�QV�&��P�Pn8n����e�VQ�Z1,�� ��1%��WV�XЭ����&��1�����P0�P�PX(�WV�PX��Q0���Z� Z�u0��e.�U�Z�1����Q0���Z��&Z�X�X�&X�Z1.�1+����p�U1�rUU����UR���R�;R���R���RƏ�R0�qPU�R�R���RR�R
                   1695: d��U�R�    R�\tPTUPU�P ��    ��t�UPU�P��XW�����юn���W�W     qU�� ������P�&���&pP�T~�MS�R�RR�R�TRdcP�S�T��RgPP�R������Q�RR�(RS�S�A�����Q�B�bT B�CG@�M �[���u��+��pPB<��Vvӈ�b��2>H�QS'���I[��������#,;
                   1696: ���:��ܒ��X���^Ь[ЬZԭ�ԭ옋Y�YP�P%U&LLLLLLLLZ&Z&LLLLLLLLLLLLLLLLLLLLLZ&LLLLe׼1S&ЬPРQ֠�aP1L&��Y�Y%�ԭ��Y*�Z����Yԭ��&���Y!%�j���Zխ��Z��Y�
                   1697: ��P�YP�0P����Y��e�խ��Zխ�Џ0u���Y�l���ԭ蘋Y�Y�h��Y�[�[�&��P[��e�Y�&��PY����YЏ����P߭�ݬݭ�ݭ��Yݭ����Pխ�֭�խ�1��խ��Э�P׼ЬPРQ֠�aP
                   1698: ݬ�&�>�P���P ��P  ��P
                   1699: ��P�����1^�ݬ�P��1O�ݬ�&��P���PY��P�����1V�ݬ�P����X^Ѭ�cѬ�s
                   1700: Ѭ�[!ݬݬݬݬլм~�~���ԭ�ԭ�ԭ�Ѭ�e
                   1701: Ѭ�f�&���
                   1702: YѬ�o�Y
Ѭ�x�Yޭ�[ԭ�ԭ�׼ЬPРQ֠�aP
                   1703: ݬ�&�/�PZ�Z ��Z   ��Z
                   1704: ��Z--֭��Z�׼ЬPРQ֠�aP
                   1705: ݬ�&���PZ׬*�Z+%׬׼ЬPРQ֠�aP
                   1706: ݬ�&���PZѬ?1B&�?�1;&��e,�Y1��Z�a  �Z�f�Z�A��Z�F�֭��Yx�����Y
                   1707: �����P�PP���Px&P��x�����Z����e�0Z�Z�a�Z�f WZ�7Z�Z��Э�Z1��Y
                   1708: 1�խ��֭�wЬPРQ֠�aPy�Z.��Z�e   �Z�Emխ�h�Y
                   1709: cխ�^խ�Y֭��Z�׼ЬPРQ֠�aP
                   1710: ݬ�&��PZ�Z+�Z-
                   1711: �Z0"�Z9�Z�׼�ݬ�&�y�PZ׬1��խ�έ����Z�����ݬ�Z���Լ�&�լ    ޭ�P�[P�P�������P�PP�PP�PPȬP�PV``&&&&&&&&&&&&&**@�&P߭��&��vPXмPPX`�߭��&��pPWмPpW`�мP���`�мPЭ�`��^Ь[ЬZԼ�[XѬ�cѬ�0u�&�ԭ�Ѭ�s�&��ЪP֪�`P�Y������j��Z�&�P&�PY����e��&��Ѭ�cԭ�8Ѭ�[.���(�[�Y�׬/�jЪP֪�`P    �Z�&���PY�Y�����
                   1712: ����e��Y�����լ�Z�Y��hԼ�&��[�[XѬ�c���&P�PЬ[�Y�k�^�Y�[�Z�Y     ��e��e�Z䘋Zˏ����ZP�P�]�[P�Y�ZP�Z��e�ZP�Z��e�Z��[���ݬ��&���ݬݬ���;������^Ь[���&��
                   1713: Џ����P1����ݏ�&������P���ի��ߘ�P�@�I5����[��\��
��
                   1714: �&�������&~Џ~ݫ��~��D����PkЫ��k!�k���������
                   1715: �&�� ��k1Q�ЫP֫�`P������Q�P���QP�%������P�^��X�������PZЬ[����[�
                   1716: �Z�������0Pk�
                   1717: �Z������PZ�[�k�X��[ЏaY�Y�z        ���P%�YP�Y�Pk�ݬ�������P��X�ЬPЬPЭ`Э��PЬP�&PЬQ�aP�&��P����Q�
                   1718: ���Q��a�(Џ�U����7����^�С��ݏOV���:���longjmp botch
                   1719: �0�����&Џ��X}�V�VQ:Xa��QS:Xg
(Xgc�QW������WQ�Q(Qgc�VP�^Ь[�[�A�[�Z� [�[P�^Ь[Ѭ�����  Џ����P)�ѫ�ѫ���k�֫�k׫���ЬPP�&ЬX�&�X�SЬR�U��T� T��T�T
�+T�-T�&S��T|P�T04�T9/�Q����y&PVyPP�VP�WQ�0T�TP�Q�U�S�U��TǑT.�S��V�T�e�T�E[��T�T+�T-�S��T�T0�T9�V������FfV>F��V��&S�VV�VU�U�����Џ����U�U�dЏdU�X�R�Rh}PP1��R�U#�Q���� y��PP�R�yPV�VP�WQ�R�U�=;�Q
yPP�Ry&PP�R�Q��QV�W{VQW�PV�W{
                   1720: VPV�PP�V�P�R�U��Qy��PP�Ry&PP���PPnPVnQPd�~���P`VP�SrPP�RpP~��p�P�PR��R�R�&
                   1721: �RP|Pp��
P��rPP�"����&����&!� � � � � � � � � � � � � � � $$$�#�#�#�#�#�#�#�#~#x#h#]#O#�g�g&& d*&&&&--%s%s%c
                   1722: : illegal option -- %s%s%c
                   1723: : option requires an argument -- �d�d�d�d�dP�K��S���g�;���vf�py6��>�1<�7{i�V�g9��"���$h�JG�y��Fr\��K��� PH�/bin/shsh-caaa/tmp/XXXXXX/tmp/&&&/         (((((                  H����������������&&&&&&&&&&&&&&&&&&&&������ ��������&<d<$�&E�Έ&($<- D2�7@<��A@�
                   1724: DE�MDMD�FID��&#&D#&D&&D,&D1&D7&D<&DB&DG&DM&DR&DX&D]&Dc&Dh&Dn&Dq&Dw&D�&D�&D�&�&�&D �&D!�&D"�&D#�&D$�&D%�&D&D'        �&D(�D)I7D*$�*D,*D-;�&AD/A�&GD0GD1PD2YD3��&�D5��&�D6���D7�M%D8���D:�D;��&�D=��&�D>�D?�D@�DA�QDBDCDD/U�&>DF>DGDDHK�&QDIQDJ`DKbDKdDLiDMrYDK��&�DO�DP�DQ�DR�DT�DU�DV�]@     _�b�f@"m@s@y��������������DW��W���W��$Y�� DDZ���D[���D\���D]��]���]��$_�� D��"D`���Da�Db�Dc�c��c�&�\�\������$e� DDf!�!Dl!�&0Dm0DnG�&PDpP�&_Dq_Drv�&DtDt��&�Du�Dv�Dw�Dx���Dy�Dz�&�D{�D|&�D~!
&�D.&�D�;�ED�ED�W&�&�D��!&���D��&&pD��+&n�&�Dt�0&@2&@(
                   1725: 4&�>&�b���D�����E&���N&$��U& D\&�b&@D����D���&�D��D���&�D���&D�D��&'D�'D�)�&.D�.D�>D�HD�JD�XD�q�&�D��h&@
                   1726: j&@(    l&�v&�b���D�����}&����&$���& D�&�"�&�"�&@"D����D���&�D��D���&�D��D���&�D���&XD���&�D��D���&&D�&D��&D�D�D�+D�4D�CD�LD�S�&@
                   1727: �&@    �U��U�&��V�&\�&`h�&���&`l �2�&`R�&`S�&`T�&`U�&^X�&\&p.     p.&p.p.#p./p.:`&E`N^X\
                   1728: Z```&f^
                   1729: h\t`w`�`�`�`�`
�`

                   1730: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   1731: �`l��^�\�`�`,�`,``^��V�T*dT5�&EV�&9$TB DK�"R@"Y�"]@"
                   1732: D]�eDeD
rDD�D�D��&�D�aa
                   1733: D��&�D�dS
                   1734: D��&�D�h>
                   1735: D��&�D�l
                   1736: D    D     D/     D<     p
                   1737: DO    D b     D!o     D"v     D#�     D$�     D%�     D&�     D'�     t
                   1738: D(�    D)�     D*�     D+&
                   1739: D,
                   1740: 
                   1741: x@     {@��b��
                   1742: �-
                   1743: ��-
                   1744: �\�`h����`l �2�`R�`S�`T�`U�^X�\�p.�p.&�p.�p.�p.p.`&`'^1\
                   1745: 3`9`&?^
                   1746: &A\M`P`Z`c`i`n`
s`

                   1747: x`l�~`b"��`l$��`$�^(�\�`�`�`�`l�
                   1748: �`l��^�\�`�`,�`,�`�`�^��-
                   1749: �-�
                   1750: d�
                   1751: �&EV�&$   �
                   1752:  D�"@'�"+@"
                   1753: D
                   1754: �
                   1755: ��
                   1756: D�
                   1757: D�
                   1758: D�
                   1759: /�D�
                   1760: D�
                   1761: D�
                   1762: �&�
                   1763: D�
                   1764: ��
                   1765: D�
                   1766: D�
                   1767: 2���
                   1768: D�
                   1769: D�
                   1770: �&�
                   1771: D�
                   1772: D6�D D D!D"D"D !D#%D#'�&2D$2D%AD&G:xD'V�qD(qD)�D*�D*�D+�D,�D,�D*�D-���D/�D0�D1�>v�&�D#�D3�BaD4�D5�D6D7D7�&D8D9&D:,D<3�PD=PD>gD?r��DB�DB�DC�DB�DD�DG�DH�DI�DL�DM���DO�FTDP�DQ&
DR
                   1773: 
DS
DT#
�,
�&,
D7,
DW4
J<DXA
DYN
DZW
D[]
N�D\h
T@        W@]@a�d��2g�b��n@p�
                   1774: �u��j
�]j
w�]k
�$_l
� D���@���@
                   1775: ��"�@"        ��$D`u
��
Dd�
De�
Df�
Dg�
Dh�
Di�
�&�
Dk�
Dl�
Dm�
Dn�
Do�
DpDq�&DsDt"�.�&7Dv7DwDDxQ�UDyU�Dzf�hD{hD|rD}z��D~�D�����D����D��D�����&�D��D��D����D����D��D� �@��b��������$���2D��$��$D��D�D�D�&D�.D�2D�6D�?D�CD�H�@"�@"
                   1776: �S��S���T�$�T�T�2D�����"D�V�VD�Vh�D�k�}��}
                   1777: ��~
$�~~2D���"D����D��D����������"$��'2D,�"3@"D����D��D��D��:��D��D��D��D���&�D��D��D��D�D�D�D�)�.D�.D�?D�HD�YD�bD�eD�nD�nD�pD�x��D��D���&�D��D��A@
                   1778: C@    E@�����I���N(�h��S(d���2Y\a`he��o`l �2u`R|`S�`T�`U�^X�\�p.�p.&�p.�p.�p.�p.�`&�`�^�\
                   1779: �``&  ^
                   1780: &\``$`-`3`8`
=`

                   1781: B`l�H`b"�L`l$�Q`$W^(c\l`o`v`|`l�
                   1782: �`l��^�\�`�`,�`,�`�`�^��������d���&EX�&�$����2D��(���@(�
                   1783: �,@,
                   1784: D
                   1785: ���D�D�D
D?DADgDpDrD���D�����$�  D,�"D���D�D�D�D�D �D!D"&D#FD$OD$QD%VD$iD&mD&oD'tD&~D(�D)�D*�D+�D,�0@2�(6�B�8 F����-�O�-�[ d�l\t`hx���`l �2�`R�`S�`T�`U�^X�\�p.�p.&�p.�p.�p.�p.�`&�` ^     \
                   1786:  `     `&     ^
                   1787: & \*     `-     `7     `@     `F     `K     `
P     `

                   1788: U   `l�[ `b"�_ `l$�d `$j     ^(v     \     `�     `�     `�     `l�
                   1789: �   `l�� ^�     \�     `�     `,�     `,�     `�     `�     ^�     �-��     -��     d��     �&EY�&�      �     &\
                   1790: \     
                   1791: $
                   1792: �
                   1793:  D!
                   1794: �"D���D�D�D�D�D�D�D�%
                   1795: �)
                   1796: ��&�D�D�&D-
                   1797: ��&*D*�5D51
                   1798: �DU�WD W�&nD"pD#yD$�5
                   1799: �:
                   1800: �b&�&@
                   1801: @(C
                   1802: ����%�J
                   1803: �%�V
                   1804: $'�b
                   1805:  Dn
                   1806: �"D(���D,�r
                   1807: ��&�D-�D.��&�D0�D0�D1�D2�D0�D3�D4�v
                   1808: @{
                   1809: @(
                   1810: ~
                   1811: ����5��
                   1812: �5��
                   1813: $7��
                   1814:  D�
                   1815: �"�
                   1816: @"D9���D=�D=��&�D>�D>�D?D@D>"DA&DB6DB6�&6D=6DD6DE:�
                   1817: �DFQ�
                   1818: @
                   1819: �
                   1820: �b��X�GX�
                   1821: �GY�
                   1822: $IZ�
                   1823:  D�
                   1824: �"DK\�\DN\DOkDPtDPvDQ{DR�DP�DS��
                   1825: @�
                   1826: @
                   1827: ���T��
                   1828: �T��
                   1829:  ��2�
                   1830: \&`h��`l �2`R`S$`T+`U2^X:\Dp.Lp.&Sp.Yp.fp.rp.}`&�`�^�\
                   1831: �`�`&�^
                   1832: &�\�`�`�`�`�`�`
�`

                   1833: �`l��`b"��`l$��`$�^(\````l�
                   1834:  `l�%^.\5`:`,?`,E`K`Q^X�T�dTndx�&EZ�&|$� D����
                   1835: ������"D�D        D
                   1836: L������8 ���d�d��e�$
f� D��
�
�
                   1837: 
                   1838: 
�
�"Do�tDtDyD�D�
�
�
�8 !
�����-
��>
$�L
 DZ
�a
�"e
@"D���D�D�&D D"D"!D#*D$9D">D&BD&D�MD'M�\D(\D)sD+|����D&�D.�D/�D0��&�D2�i
@
                   1839: k
@    ���3�q
�3�
\�
`h�
���
`l �2�
`R�
`S�
`T�
`U�
^X�
\�
p.�
p.&�
p.�
p.�
p.�
p.`&`^!\
                   1840: #`)`&/^
                   1841: &1\=`@`J`S`Y`^`
c`

                   1842: h`l�n`b"�r`l$�w`$}^(�\�`�`�`�`l�
                   1843: �`l��^��3��3��d���&E[�&�$�� D����"D���D�D
���d�&����&��������$� D�
                   1844: �"D���D�D��d�&���&������!$�) D1�4�"D���D�D�8�d�&>���&�� D� L\N`"S`"[`0&d`(h�j^l\n`"s`"x`"~`$&�^�\�`�`�`�`�`�`
�`

                   1845: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   1846: �`l��^\
``,`,`#`)^0� 6 =dD�&E]�&H$O DV�"]�"a@"e�l@
                   1847: D�%D%D2D?DLDYDfDtD}D�D��&�D�s�D��&�D�D�D ��&�D!�wsD"��&�D$��&�D%�D%���D&�D'�<D(<D)XD*aD+kD,qD-�D.�D/�D0�D0�����D%�D4�D5���D6�{[D7���D9�D:�D;&D=D>D?D@&�&/DB/LDCB�@(    ���@�@�@
                   1848: ������b&�&�I�DI��DJ�\�`h����`l �2�`R�`S�`T�`U�^X�\�p.p.&p.p.p.+p.6`&A`J^T\
                   1849: V`\`&b^
                   1850: &d\p`s`}`�`�`�`
�`

                   1851: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   1852: �`l��^�\�`�`,�`,�``
                   1853: ^�DJD�d�&�&E]�&* /$�7 PD  ���D�D��&�D
�?�D�D��&�D�B�b���D���F��N\V`hZ��d`l �2j`Rq`Sy`T�`U�^X�\�p.�p.&�p.�p.�p.�p.�`&�`�^�\
                   1854: �`�`&�^
                   1855: &\```"`(`-`
2`

                   1856: 7`l�=`b"�A`l$�F`$L^(X\a`d`k`q`l�
                   1857: u`l�z^�\�`�`,�`,�`�`�^�����d��&E^�&�$� D��"�@"D    �
D

DD'D+D?D?�&?D?DLDYD[D`DpDpDrDvD{D{D���D�D���D�D�D�D�D�� D�D �D!�D"�D#
�&DD%�@
                   1858: ��b���
                   1859: ���@      ��&��&\`h��`l �2 `R'`S/`T6`U=^XE\Op.Wp.&^p.dp.qp.}p.�`&�`�^�\
                   1860: �`�`&�^
                   1861: &�\�`�`�`�`�`�`
�`

                   1862: �`l��`b"��`l$��`$^(\``!`'`l�
                   1863: +`l�0^9\@`E`,J`,P`V`\^c�&j&,td,{�&Ea�&$,� D����$�������"D5�5D5D:D=D`DD���������< ����������\�`"�`"�`0&�`(���^�\�`"�`"`"    `$&^\``'`0`6`;`
@`

                   1864: E`l�K`b"�O`l$�T`$Z^(f\o`r`y``l�
                   1865: �`l��^�\�`�`,�`,�`�`�^������d���&Eb�&�$�� D����$��&���"D���D�D�D�D�D�D�����< �����*��4\6`";`"C`0&L`(P�R^T\V`"[`"``"f`$&i^k\w`z`�`�`�`�`
�`

                   1866: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   1867: �`l��^�\�`�`,�`,``^�� �+d�3�&Ef�&7$�A DK�R�$X�_��e�"D  ���D�DDD%D=i�m�v�8 z��?�?��@�\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&�^�\�`�`�`�`�`�`
�`

                   1868: �`l�`b"�`l$�
`$^(\(`+`2`8`l�
                   1869: <`l�A^J\Q`V`,[`,a`g`m^t�@|@�d@��&En�&�$@� D����$�������"DI�IDIDmD�D���������< ����������\�`"�`"`0&        `(
�^\`"`"`"#`$&&^(\4`7`A`J`P`U`
Z`

                   1870: _`l�e`b"�i`l$�n`$t^(�\�`�`�`�`l�
                   1871: �`l��^�\�`�`,�`,�`�`�^������d���&E��&�&\�\� $
� D��(�"�'@,�(0�<�A�"D���D�D�D��&�D�E-!��D�D����&�D�D
                   1872: �&*D*H !D:DGD R�&\D"\�&aD#a��D$�D%�D'�L!D(����&��&�D+���D,�D-���D/��&�D1��&�D2�D3��&�D5�P�R����6�W�6�]&� \b \�h!l� p� t� x� |� �� �� �$@�� D����(������(���@(������"�@"
                   1873: DA�DGDIDK�&=DL=DMCDNNDO[�&]DQ_DRc�&qDSqDT�DU�DV���DW���DX���DY�DZ D[4 D\; �; �; �; D`; DaC DbN Dcb �� Dd� �&� Df� ��������b�����b���� �g� 
                   1874: �g�   0& \"`"'`"/`0&8`(<�>^@\B`"G`"L`"R`$&U^W\c`f`p`y``�`
�`

                   1875: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   1876: �`l��^�\�`�`,�`,�`�`�^�g� g8!d8!�&E��&"$8!, D6�=�$C�J��P�"DA!�A!DA!DF!DI!Dm!D�!D�!Tg$D�!D�!W]$�&�!D�![5$D"D"_)$D<"c'$�&I"DI"g�k�t�8 x���< �K"� K"�� L"�&�`\�`\��$�$�$��#��#��#��#��#��#��#��#�~#�x#�h#�]#�O#�$6L"� P��,�@,�"�D8Q"�U"D;U"D<f"�&l"D=l"D>x"#D@�"#�&�"�&�"DB�"�"�&�"���"DD�"�D�" �D�"-\/`"4`"<`0&E`(I�K^M\O`"T`"Y`"_`$&b^d\p`s`}`�`�`�`
�`

                   1877: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   1878: �`l��^�\�`�`,�`,�``
                   1879: ^�D�"Dx$#dx$+�&E���&/$x$6x$>2DE�K�Q@W�([�g�"D�$��$D�$D�$k�o���$�
�$x�
�$$�$� D���@��"�@"
                   1880: D�$��$D�$D�$D�$D%D%�&.%D.%DA%�Z%DZ%Dd%�*Dw%�}%�&}%D!}%D!�%�&�%D#�%D$�%��)D%�%D&�%D&�%D'�%D(�%�&�%D!�%D*�%�&�%D+�%��%D,�%D-�%��%D/�%D0�%��)D1�%��)D2�%D3&�&&D5&�& &D6 &D7-&��)D8D&�&M&D:M&D;Q&��)D=f&D>y&D?|&D@�&�@        ��(���@�@��b(���&�A�&��A�&�$C�&��&�2D& � �
 @ �( �  @(
                   1881: $ �- �(1 �= �"DE�&��&DF�&DG�&��&�H�&A �H�&I $J�&R  D[ �a @g �"n �"r @"
                   1882: DK�&��&DS�&v �)DU
'DV'z �)�&.'DW.'DX;'�&H'DZH'D[W'D\d'D]�'D^�'D_�'�&�'Db�'~ i)Dc(De
(Df+(Dh-(� O)DiM(� <)Dje(�&e(Dle(�&t(Dmt(� 2)Dn�(�&�(Dp�(Dq�(Dr�(�&�(Ds�(� ()Dt�(�&�(Dv�(Dw�(Dx)Dy)Dz)D{")� �� �� �b,�� @(        � �� �T � �� �bT"�� �X"�$)�|$)� �|%)� \� `h� ��� `l �2� `R� `S� `T!`U !^X!\!p.#!p.&*!p.0!p.=!p.I!p.T!`&_!`h!^r!\
                   1883: t!`z!`&�!^
                   1884: &�!\�!`�!`�!`�!`�!`�!`
�!`

                   1885: �!`l��!`b"��!`l$��!`$�!^(�!\�!`�!`�!`�!`l�
                   1886: �!`l��!^"\"`"`,"`,"`""`("^/"�|%)7"|*C"d*M"�&E���&Q"$*Y" Pa"�"e"�"D*�*D
                   1887: *D$*j"k*D
?*m"d*�`*D`*�`*p"�a*x"\�"`�"`�"`�"`�"`�"`
�"`

                   1888: �"`l��"`b"��"`l$��"`$�"^(�"\�"`�"`�"`�"`l�
                   1889: �"`l��"^�"�a*#�*#d�*#�&E���&#$�*$# N+#�,/#@,D�*��*D�*D      �*D
                   1890: �*D�*D�*3#@
                   1891: ��*�
�*5#�
�*<#\H#`K#`U#`^#`d#`i#`
n#`

                   1892: s#`l�y#`b"�}#`l$��#`$�#^(�#\�#`�#`�#`�#`l�
                   1893: �#`l��#^�#�
�*�#
�*�#�*�#t+�#�$+�#4+�#�4+�#��.$��.    $y�0$��1$L`2#$�&x3,$�,54$<5=$��8F$�$9O$X9U$�p9^$��9e$�9n$L(:v$��;}$(h>�$f?�$ ?�$�l?�$�?�$y,@�$�A�$��A�$
                   1894: �A�$B�$!<B�$!tB�$$�B�$��B�$��C�$��C%xD%�8D%HD%�pD#%�D+%�D6%-�D>%��DF%��DN%�DW%f`M`%nTh%�Tp%�(Ty%4T�%�U�%U�%�,U�%<U�%��U�%�`V�%pV�%��V�%H�V�%AW�%x�X�%��X�%��.�%�%~<�%r\&.�\&��?&�x3&  ��f &t�*&&C�-&     ��f3&��<&0dD&l�L&!BT&�[&,@b&Z�
                   1895: l&ETv&~&��&��1�&���&�9�&��&���& X�f�&^\�&�&��&���&c��&     c&|g�&[f
                   1896: 'h&�'FA'Z)'��2'�D'�\J'�X9O',�&Y'&<Ba'�l
i'��=p'�z'�&�$�'$tB�'m��'�A�'`(:�'$9�'���'t�0�'�*�'x�?�'&d0�'���'��C�'(��'�,�'N@
                   1897: (��*()�(!\"(��9((��D/(;$+6(�?<(        y�gI(;L"W(u8!b(��8j(��Bs(a�C{(\�*�(��B�(v8D�(e`2�(Nh>�(     ��g�(�$d�(�4+�(+�( ��g�(     
                   1898: �w�(� d�(��D�(��D�(�(d�(f�.)�00)�p9)�<5$)L�/,)y�62).�D9)�,5@)~zFI)�HDN)�&4TW),d_)      :܇g)
                   1899: �Ao)�Dt)� ?z)+�7�)788�)��8�)  -��)(�;�)��<�)��<�)X@=�)(>�)[�>�)     �H��)�U?�)�l?�):`M�)�?�)��D�)��U�)�`V*pU
                   1900: *�,U*��D*��U *�PA**�U0*zT7*�pD=*��CD*�pVL*x<UT*�e\*��ed*�Sm*H�Vv*�TO~*A�V�*��R�*n(W�*�T�*�(T�*?U�*�!U�*N W�*|�X�*crt0.oexitjukebox.ojukebox.crccmainmainargcargcargvargv_6_30_45_54_57_70cerrbufvol_idUflagaflageflagmflagpflagrflaguflagsflagsecsmainusageusage_81usageerrexiterrexiterrbuferrexitspin_86_87_88prstatusprstatus_99_102_105_106_107_113_112_114_115_116clLunstatuserrbufprstatusunloadunloadforceforceclLunstatuserrbufunloadejectejectvol_iderrbuferrbuf_140shdrejectJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufjukebox.callocate.oallocate.crccallocateallocatevol_idvol_idbufbuf_9_10_13_14_17_24shdrivenbufallocateJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufallocate.ccold.ocold.crcccold_invcold_invtypetypebufbuf_5_12_13_26_39_40_64_67_sortshdrivenshdiditvol_idnside1cold_invgetvolgetvolshshdrivedrivevol_idvol_idside_89_92_100_101_102ibufgetvolcmp_cmpcmpabsasbcmpsd_sdsdaberr_disksdds_dsdsaberrdssortsorterrbuferrbuf_indexijorgsortdiskindexJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufcold.cgetstatus.ogetstatus.crccdolun_dolundolunlunLunstatuslunLunstatusuudolunj_getstatusj_getstatuserriretscsi_returncmdscsi_cmdj_getstatusj_statusJstatusJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufgetstatus.cioshelves.oioshelves.crccj_wrshelfhaveread_3j_rdshelvesj_rdshelveserr_13_12_17_21shnovnamefp_iobufj_rdshelvesj_wrshelvesj_wrshelveserr_26shnofp_iobufj_wrshelvesj_shelfofj_shelfofvol_idvol_id_49ibufj_shelfofj_driveofj_driveofvol_idishj_driveofj_shelfJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufioshelves.ciodr_sh.oiodr_sh.crccj_shelf_to_drivej_shelf_to_driveshside1drerrcmdscsi_cmdretscsi_returnj_shelf_to_drivej_drive_to_shelfj_drive_to_shelfdrshside1errcmdscsi_cmdretscsi_returnj_drive_to_shelfj_empty_drivej_empty_drivetlimitbufbufitstopj_empty_driveJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmdiodr_sh.clib.olib.crccs_starts_startdrerriargscargss_starts_stops_stopdrerriargscargss_stops_ejects_ejectdrerriargscargss_eject2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobuflib.cload.oload.crccj_loadj_loadvol_idbufbuftlimittlimit_11_14_35_40lLunstatusnshside1drdisk_to_loadj_loadJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufload.cnlun.onlun.crccnlunsetnlunsetnlun_7bufsetnlunJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufnlun.cwarm.owarm.crccwarm_invwarm_invbufbuf_25shvol_idside1drivewarm_invJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufwarm.cge_stop.ostop.crccgen_stopgen_stopniargsiargsncargscargserrcmdscsi_cmdnretscsi_returngen_stop2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufstop.cge_start.ostart.crccgen_startgen_startniargsiargsncargscargserrcmdscsi_cmdnretscsi_returngen_start2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufstart.cge_reset.oreset.crccgen_resetgen_resetniargsiargsncargscargserrcmdscsi_cmdretscsi_returngen_reset2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufreset.cso_eject.oeject.crccsony_ejectsony_ejectniargsiargsncargscargserrcmdscsi_cmdnretscsi_returnsony_eject2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufeject.cs_h_io.oh_io.crccfd_fds_ignuass_ioss_iopreservecmdscsi_cmdncmdncmdretscsi_returnnreterr_8_14_22nretvss_iosmsg_smsg_28_29_30_31_32_33_34_35s_ios_iopreservecmdscsi_cmdncmdretscsi_returnretscsi_returnnreterrerr_56mycmdscsi_cmdnioerrstatusbufignoreduas_ios_idss_extsense2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufh_io.cge_sense.osense.crccgen_sensegen_senseniargsiargsncargscargserr_8_11_12_15_16cmdscsi_cmdretscsi_returnngen_senseexstab_exstab_18_19_20_21_22_23_24_25_26_27_28_29_30_31_32_33gen_extsensegen_extsensedatadatadestndata_39_40_41classgen_extsense2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufsense.cs_volid.ovolid.crccmyread_myreadmyreaddriveblockblockretscsi_returnerrcmdscsi_cmdmyreadj_rvolidj_rvoliddrivedriveerrerr_13_22_31_32_35_38bretscsi_returnlastbdebugbufj_rvolidmywrite_mywritemywritedriveblockblockcmdscsi_cmdcmdscsi_cmdretscsi_returnerrmywritej_wvolidj_wvoliddrivedrivevol_iderrerr_43_46_55_57_58_61_64cmdscsi_cmdtmpfilefp_iobufretscsi_returnbufnj_wvolidJstatuslunLunstatusshelfiounitcarrierudriveldriveJstatusLunstatuspowerondiskinreadywriteprotectdiskindriveshelfvaliddriveshelfretshelfLunstatus1SIDEASIDEB1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufvolid.cs_pperror.opperror.crccpperrorpperrorbufmesg_5_6pperrorscsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmdpperror.cs_longat.olongat.crcclongatlongatsrcsrcnlongatscsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmdlongat.caccess.oatol.ocerror.oclose.odata.oerrlst.oexit.oflsbuf.ofopen.ofprintf.ofseek.ogetopt.olseek.omalloc.omemcmp.omemset.omin.oonexit.oopen.oprintf.oqsort.orand.ordwr.oread.osbrk.oscanf.osetbuf.osleep.osprintf.ostrchr.ostrcmp.ostrcpy.ostrdup.ostrlen.ostrncpy.osystem.otime.otmpnam.oudiv.ounlink.ourem.owait.owrite.o_cleanup.o_exit.oalarm.ocreat.odoprnt.odoscan.oexecl.oexecv.oexecve.ofilbuf.ofork.ogetpid.okill.omktemp.osetjmp.osignal.ostrcat.otolower.oungetc.oatof.octype.oldexp.o_exitstart_main_environ__iob_setbuf_getopt_optarg_atol_usage_s_id_setnlun_optind_unload_strcpy_eject_sleep_cold_inv_allocate_j_load_s_start_fprintf_s_stop_printf_prstatus_j_rdshelves_j_shelf_j_wrshelf_j_wrshelves_errexit_j_getstatus_j_status_j_drive_to_shelf_j_shelfof_sprintf_j_driveof_s_eject_j_shelf_to_drive_nlun_min_j_wvolid_strdup_getvol_nrand_warm_inv_j_rvolid_strlen_gen_reset_strcmp_qsort_memset_s_io_fopen_pperror_fscanf_fclose_j_empty_drive_time_gen_start_gen_stop_sony_eject_access_ss_io_s_ignua_open_write_close_read_ss_extsense_gen_extsense_gen_sense_memcmp_strncpy_tmpnam_longat_system_unlink_fseek_fread_errno_sys_nerr_sys_errlistcerror__sibuf__sobuf__lastbuf__cleanup__exit__setcleanup__flsbuf__stdioclean_onexit_malloc_fflush_free_creat_lseek__doprnturem__filbuf_opterr_optopt_strchrudiv_sbrk_ialloc_realloc_mstats__onexitfns_srand_rand_lrand_frand_Srand_fwrite_end_brk_scanf__doscan_sscanf_alarm_setjmp_signal_getpid_kill_pause_longjmp_snprintf_fork_execl_wait_ftime_strcat_mktemp__sctab__ctype__getccl_tolower__innum_ungetc__instr_atof_execv_execve_vfork_getppid_strtod_ldexp0707070035050452421006660011710000040000010632770461717160700001200000007445jukebox.c#include        <stdio.h>
                   1901: #include       <limits.h>
                   1902: #include       "scsi.h"
                   1903: #include       "juke.h"
                   1904: 
                   1905: main(int argc, char *argv[])
                   1906: {
                   1907:        int c;
                   1908:        int aflag = 0, eflag = 0, mflag = 0, pflag = 0;
                   1909:        int rflag = 0, sflag = 0, uflag = 0, Uflag = 0;
                   1910:        long secs = 3600L*24*183;       /* half a year is enough */
                   1911:        char *vol_id;
                   1912:        char errbuf[1024];
                   1913:        extern int optind;
                   1914:        extern char *optarg;
                   1915: 
                   1916:        setbuf(stdout, (char *)0);      /* turn off buffering */
                   1917:        while((c = getopt(argc, argv, "aemprsuUw:")) != -1)
                   1918:                switch (c)
                   1919:                {
                   1920:                case 'a':       aflag = 1; break;
                   1921:                case 'e':       eflag = 1; break;
                   1922:                case 'm':       mflag = 1; break;
                   1923:                case 'p':       pflag = 1; break;
                   1924:                case 'r':       rflag = 1; break;
                   1925:                case 's':       sflag = 1; break;
                   1926:                case 'u':       uflag = 1; break;
                   1927:                case 'U':       Uflag = 1; break;
                   1928:                case 'w':       secs = atol(optarg); break;
                   1929:                default:        usage(); break;
                   1930:                }
                   1931:        s_id = 2;
                   1932:        setnlun();
                   1933:        if(!aflag&&!eflag&&!mflag&&!pflag&&!rflag&&!uflag&&!Uflag)
                   1934:                sflag = 1;
                   1935:        vol_id = (optind < argc)? argv[optind] : 0;
                   1936:        if(uflag || Uflag)
                   1937:                unload(Uflag);
                   1938:        if(eflag){
                   1939:                if(vol_id == 0){
                   1940:                        strcpy(errbuf, "-e needs a vol_id");
                   1941:                        goto scram;
                   1942:                }
                   1943:                if(eject(vol_id, errbuf))
                   1944:                        goto scram;
                   1945:        }
                   1946:        if(rflag){
                   1947:                unload(1);
                   1948:                sleep(1);
                   1949:                if(cold_inv(vol_id? *vol_id : 'u', errbuf) < 0)
                   1950:                        goto scram;
                   1951:        }
                   1952:        if(aflag){
                   1953:                if(vol_id == 0){
                   1954:                        strcpy(errbuf, "-a needs a vol_id");
                   1955:                        goto scram;
                   1956:                }
                   1957:                if(allocate(vol_id, errbuf))
                   1958:                        goto scram;
                   1959:        }
                   1960:        if(mflag){
                   1961:                if((c = j_load(vol_id, errbuf, secs)) < 0)
                   1962:                        goto scram;
                   1963:                if(s_start(c, errbuf) < 0)
                   1964:                        fprintf(stderr, "jukebox: %s\n", errbuf);
                   1965:                if(s_stop(c, errbuf) < 0)
                   1966:                        fprintf(stderr, "jukebox: %s\n", errbuf);
                   1967:                printf("%d\n", c);
                   1968:        }
                   1969:        if(sflag)
                   1970:                prstatus();
                   1971:        if(pflag){
                   1972:                if(j_rdshelves(errbuf) < 0)
                   1973:                        goto scram;
                   1974:                for(c = 0; c < NSHELF; c++)
                   1975:                        if(j_shelf[c])
                   1976:                                printf("%d: %s\n", c, j_shelf[c]);
                   1977:        }
                   1978:        if(j_wrshelf)
                   1979:                if(j_wrshelves(errbuf))
                   1980:                        errexit(errbuf);
                   1981:        exit(0);
                   1982: scram:
                   1983:        if(j_wrshelf)
                   1984:                j_wrshelves(errbuf);
                   1985:        errexit(errbuf);
                   1986: }
                   1987: 
                   1988: usage()
                   1989: {
                   1990:        fprintf(stderr, "Usage: jukebox [-aemprsuU] [-w secs] [vol_id\n");
                   1991:        exit(1);
                   1992: }
                   1993: 
                   1994: errexit(char *errbuf)
                   1995: {
                   1996:        fprintf(stderr, "jukebox: %s\n", errbuf);
                   1997:        exit(1);
                   1998: }
                   1999: 
                   2000: prstatus()
                   2001: {
                   2002:        struct Lunstatus *l;
                   2003:        int c;
                   2004:        char errbuf[1024];
                   2005:        static char *spin[2] = { "offline", "online" };
                   2006: 
                   2007:        if(j_getstatus(errbuf)){
                   2008:                fprintf(stderr, "jukebox: %s\n", errbuf);
                   2009:                exit(1);
                   2010:        }
                   2011:        if(j_rdshelves(errbuf)){
                   2012:                fprintf(stderr, "jukebox: %s\n", errbuf);
                   2013:                exit(1);
                   2014:        }
                   2015:        for(c = 0; c < 8; c++){
                   2016:                l = &j_status.lun[c];
                   2017:                if(!l->diskin)
                   2018:                        continue;
                   2019:                printf("lun %d(", c);
                   2020:                if(j_status.udrive == (0x80|c))
                   2021:                        printf("upper,%s", spin[l->ready]);
                   2022:                else if(j_status.ldrive == (0x80|c))
                   2023:                        printf("lower,%s", spin[l->ready]);
                   2024:                else
                   2025:                        printf("in shelf");
                   2026:                printf("): ");
                   2027:                if(l->shelfvalid){
                   2028:                        if(j_shelf[l->retshelf>>1])
                   2029:                                printf("%s%c", j_shelf[l->retshelf>>1], "ab"[l->retshelf&1]);
                   2030:                        else
                   2031:                                printf("unallocated shelf number %d??", l->retshelf);
                   2032:                } else
                   2033:                        printf("<unknown shelf??>");
                   2034:                printf("\n");
                   2035:        }
                   2036: }
                   2037: 
                   2038: unload(int force)
                   2039: {
                   2040:        struct Lunstatus *l;
                   2041:        int c;
                   2042:        char errbuf[1024];
                   2043: 
                   2044:        if(j_getstatus(errbuf)){
                   2045:                fprintf(stderr, "jukebox: %s\n", errbuf);
                   2046:                exit(1);
                   2047:        }
                   2048:        if(j_rdshelves(errbuf)){
                   2049:                fprintf(stderr, "jukebox: %s\n", errbuf);
                   2050:                exit(1);
                   2051:        }
                   2052:        for(c = 0; c < 8; c++){
                   2053:                l = &j_status.lun[c];
                   2054:                if(!l->diskin)
                   2055:                        continue;
                   2056:                if(force || !l->ready)
                   2057:                        if(j_drive_to_shelf(c, -1, SIDEA, errbuf))
                   2058:                                fprintf(stderr, "jukebox: %s\n", errbuf);
                   2059:        }
                   2060: }
                   2061: 
                   2062: eject(char *vol_id, char *errbuf)
                   2063: {
                   2064:        int sh;
                   2065:        int dr;
                   2066: 
                   2067:        if(j_rdshelves(errbuf)){
                   2068:                fprintf(stderr, "jukebox: %s\n", errbuf);
                   2069:                exit(1);
                   2070:        }
                   2071:        sh = j_shelfof(vol_id);
                   2072:        if(sh < 0){
                   2073:                sprintf(errbuf, "xcan't find vol_id %s", vol_id);
                   2074:                return(-1);
                   2075:        }
                   2076:        j_wrshelf = 1;
                   2077:        if((dr = j_driveof(vol_id)) >= 0){
                   2078:                j_shelf[sh] = 0;
                   2079:                return(s_eject(dr, errbuf));
                   2080:        }
                   2081:        dr = NLUN-1;
                   2082:        if(j_shelf_to_drive(sh, SIDEA, dr, errbuf) < 0)
                   2083:                return(-1);
                   2084:        if(s_eject(dr, errbuf))
                   2085:                return(-1);
                   2086:        j_shelf[sh] = 0;
                   2087:        return(0);
                   2088: }
                   2089: 0707070035050453221006660011710000040000010452360457563432300000600000000741lib.c#include     <stdio.h>
                   2090: #include       "scsi.h"
                   2091: #include       "scsish.h"
                   2092: #include       "generic/fns.h"
                   2093: #include       "sony/fns.h"
                   2094: 
                   2095: s_start(int dr, char *err)
                   2096: {
                   2097:        int iargs[1];
                   2098:        char *cargs[1];
                   2099: 
                   2100:        iargs[0] = dr;
                   2101:        return(gen_start(1, iargs, 0, cargs, err));
                   2102: }
                   2103: 
                   2104: s_stop(int dr, char *err)
                   2105: {
                   2106:        int iargs[1];
                   2107:        char *cargs[1];
                   2108: 
                   2109:        iargs[0] = dr;
                   2110:        return(gen_stop(1, iargs, 0, cargs, err));
                   2111: }
                   2112: 
                   2113: s_eject(int dr, char *err)
                   2114: {
                   2115:        int iargs[1];
                   2116:        char *cargs[1];
                   2117: 
                   2118:        iargs[0] = dr;
                   2119:        return(sony_eject(1, iargs, 0, cargs, err));
                   2120: }
                   2121: 0707070035050453771006660011710000040000010450320457563431500000700000003012load.c#include    <stdio.h>
                   2122: #include       <stddef.h>
                   2123: #include       <string.h>
                   2124: #include       "scsi.h"
                   2125: #include       "juke.h"
                   2126: 
                   2127: j_load(char *vol_id, char *buf, long tlimit)
                   2128: {
                   2129:        Side side;
                   2130:        int n, sh, dr;
                   2131:        char disk_to_load[256];
                   2132:        struct Lunstatus *l;
                   2133: 
                   2134:        if(j_rdshelves(buf))    /* read in shelf names */
                   2135:                return(-1);
                   2136:        if(j_getstatus(buf))    /* get the jukebox status */
                   2137:                return(-1);
                   2138:        /* now check which side we want */
                   2139:        n = strlen(vol_id);
                   2140:        strcpy(disk_to_load, vol_id);
                   2141:        if(disk_to_load[n-1] == 'a')
                   2142:                side = SIDEA;
                   2143:        else if(disk_to_load[n-1] == 'b')
                   2144:                side = SIDEB;
                   2145:        else {
                   2146:                sprintf(buf, "vol_id '%s' must end in a or b", vol_id);
                   2147:                return(-1);
                   2148:        }
                   2149:        disk_to_load[n-1] = 0;
                   2150:        /* which shelf is that? */
                   2151:        sh = j_shelfof(disk_to_load);
                   2152:        if(sh < 0){
                   2153:                sprintf(buf, "can't find vol_id %s", disk_to_load);
                   2154:                return(-1);
                   2155:        }
                   2156:        while(tlimit >= 0){
                   2157:                for(n = 0; n < NLUN; n++){
                   2158:                        l = &j_status.lun[n];
                   2159:                        if(l->diskin && l->shelfvalid && (sh == (l->retshelf>>1))){
                   2160:                                if(((l->retshelf&1) == side) && (n < nlun))
                   2161:                                        return(n);
                   2162:                                if(l->ready)
                   2163:                                        goto await;
                   2164:                                if(j_drive_to_shelf(n, -1, 0, buf))
                   2165:                                        return(-1);
                   2166:                                if(j_getstatus(buf))    /* get the jukebox status */
                   2167:                                        return(-1);
                   2168:                                break;
                   2169:                        }
                   2170:                }
                   2171:                /* disk is available */
                   2172:                dr = j_empty_drive(tlimit, buf);
                   2173:                if(dr < 0){
                   2174:                        sprintf(buf, "can't find a free drive");
                   2175:                        return(-1);
                   2176:                }
                   2177:                if(j_shelf_to_drive(sh, side, dr, buf) < 0)
                   2178:                        return(-1);
                   2179:                return(dr);
                   2180: await:
                   2181:                sleep(10);
                   2182:                tlimit -= 10;
                   2183:                if(j_getstatus(buf))    /* get the jukebox status */
                   2184:                        return(-1);
                   2185:        }
                   2186:        sprintf(buf, "disk '%s' busy", disk_to_load);
                   2187:        return(-1);
                   2188: }
                   2189: 0707070035050453761006660011710000040000010450340457563431500000700000002411main.c#include    <stdio.h>
                   2190: #include       "jukebox.h"
                   2191: #include       "hdr.h"
                   2192: 
                   2193: main(int argc, char *argv[])
                   2194: {
                   2195:        int c;
                   2196:        int err = 0, cold = 0, warm = 0;
                   2197:        char *toload = 0, *uload = 0;
                   2198:        char *drive = 0;
                   2199:        char buf[256];
                   2200:        extern int optind;
                   2201:        extern char *optarg; 
                   2202: 
                   2203:        setbuf(stdout, (char *)0);      /* turn off buffering */
                   2204:        /* gather options */
                   2205:        while ((c = getopt(argc,argv,"cn:l:wu:")) != -1)
                   2206:                switch (c)
                   2207:                {
                   2208:                case 'l':       toload = optarg; break;
                   2209:                case 'c':       cold = 1; break;
                   2210:                case 'w':       warm = 1; break;
                   2211:                case 'u':       uload = optarg ; break;
                   2212:                case 'n':       drive = optarg ; break;
                   2213:                default:        err = 1; break;
                   2214:                }
                   2215:        if(err)
                   2216:                exit(1);
                   2217:        /* now actually do some work */
                   2218:        if (toload){
                   2219:                if (j_load(toload, buf, 30))
                   2220:                        printf("load %s failed: %s\n", toload, buf);
                   2221:                else
                   2222:                        printf("loaded %s on %s\n", toload, buf);
                   2223:        }
                   2224:        if(drive){
                   2225:                if(j_volid(atoi(drive), buf))
                   2226:                        printf("j_volid(%s) failed: %s\n", drive, buf);
                   2227:                else
                   2228:                        printf("%s is mounted on drive %d\n", buf, atoi(drive));
                   2229:        }
                   2230:        if(cold){
                   2231:                printf("invent cold: %d\n", cold);
                   2232:                cold_inventory(30, buf);
                   2233:                
                   2234:        }
                   2235:        if (warm) {
                   2236:                printf("invent warm: %d\n", warm);
                   2237:                warm_inventory(buf);
                   2238:                
                   2239:        }
                   2240: 
                   2241: 
                   2242:        if (uload){
                   2243:                if (j_unload(uload, buf)) 
                   2244:                        printf("unload %s failed: %s\n", uload, buf);
                   2245:                else
                   2246:                        printf("unloaded %s from %s\n", uload, buf);
                   2247:                
                   2248: 
                   2249:        }
                   2250:        exit(0);
                   2251: }
                   2252: 0707070035050375071006660011710000040000010576310464713705700000700000004763mkfileSYS=research
                   2253: < $SYS.mk
                   2254: JL=juke.a
                   2255: X=allocate cold getstatus ioshelves iodr_sh lib load nlun warm
                   2256: JLIB=${X:%=$JL(%.o)}
                   2257: JSRC=${X:%=%.c}
                   2258: 
                   2259: SL=scsi.a
                   2260: X=s_$IO ge_sense s_volid s_pperror s_fixedstr s_longat s_xd
                   2261: SLIB=${X:%=$SL(%.o)}
                   2262: 
                   2263: SHL=scsish.a
                   2264: GENERIC=ge_dev ge_inq ge_stop ge_start ge_capacity ge_display\
                   2265:        ge_reset ge_tur ge_scsi ge_readt # ge_sense in $SL
                   2266: SONY=so_dev so_inq so_alt so_config so_status so_eject so_rel so_set\
                   2267:        so_shelfside so_diskid so_internal so_media so_readid so_copy\
                   2268:        so_i0.tab so_i1.tab so_scsi.tab so_sense so_nesd.tab
                   2269: WREN=wr_dev wr_inq wr_mode wr_diag
                   2270: X=$GENERIC $SONY $WREN
                   2271: SHLIB=${X:%=$SHL(%.o)}
                   2272: 
                   2273: all:V: jukebox scsish
                   2274: 
                   2275: both:V:        ../jukebox ../scsish
                   2276: 
                   2277: ../%:  %
                   2278:        cp $prereq $target
                   2279: 
                   2280: jukebox:       jukebox.o $JL $SHL $SL
                   2281:        $CC $CFLAGS -o $target $prereq $LDFLAGS
                   2282: 
                   2283: scsish:        scsish.o $SHL $SL
                   2284:        $CC $CFLAGS -o $target $prereq $LDFLAGS
                   2285: 
                   2286: jpp:V:
                   2287:        pr mkfile juke.h scsi.h jukebox.c $JSRC | lp -ddp -n2
                   2288: 
                   2289: poot:V:        scsish
                   2290:        echo 'dev scsi
                   2291:        id 6
                   2292:        readt 50000' | scsish
                   2293: 
                   2294: scsi.cpio:V:   inc/scsi.h
                   2295:        find * -print | sed -e '/\.[oa]$/d' -e '/\.cpio$/d' | cpio -oc > $target
                   2296: inc/scsi.h:Pcmp -s:    /usr/include/scsi.h
                   2297:        cp $prereq $target
                   2298: 
                   2299: 
                   2300: # below is just magic; believe it.
                   2301: 
                   2302: $JL(%.o):N:    %.o
                   2303: $JL:Q: $JLIB
                   2304:        names=`membername $newprereq`
                   2305:        ar rv $JL $names && rm $names
                   2306:        $RANLIB $JL
                   2307: 
                   2308: $SL(%.o):N:    %.o
                   2309: $SL:Q: $SLIB
                   2310:        names=`membername $newprereq`
                   2311:        ar rv $SL $names && rm $names
                   2312:        $RANLIB $SL
                   2313: 
                   2314: $SHL(%.o):N:   %.o
                   2315: $SHL:Q:        $SHLIB
                   2316:        names=`membername $newprereq`
                   2317:        ar rv $SHL $names && rm $names
                   2318:        $RANLIB $SHL
                   2319: 
                   2320: s_%.o: scsi/%.c
                   2321:        cd scsi; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target
                   2322: so_%.o:        sony/%.c
                   2323:        cd sony; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target
                   2324: so_%.o:        sony/fns.h
                   2325: ge_%.o:        generic/%.c
                   2326:        cd generic; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target
                   2327: ge_%.o:        generic/fns.h
                   2328: wr_%.o:        wren/%.c
                   2329:        cd wren; $CC $CFLAGS -c $stem.c && mv $stem.o ../$target
                   2330: wr_%.o:        wren/fns.h
                   2331: so_%.o wr_%.o ge_%.o:  scsish.h scsi.h
                   2332: 
                   2333: so_%.tab.o:Q:  sony/%.tab
                   2334:        cd sony
                   2335:        echo generating $target
                   2336:        p=$stem.tab
                   2337:        awk -F' ' '
                   2338:        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;
                   2339:                h["8"]=8;h["9"]=9;h["a"]=10;h["b"]=11;h["c"]=12;h["d"]=13;h["e"]=14;h["f"]=15;
                   2340:                }
                   2341:        function done(  i){
                   2342:                for(i = 0; i < 256; i++) if(x[i]){
                   2343:                                print "\t\"" x[i] "\","
                   2344:                                x[i] = ""
                   2345:                        } else printf "\t\"<#%x>\",\n", i
                   2346:                print "};"
                   2347:        }
                   2348:        function hex(n, i){
                   2349:                return(h[substr(n, 1, 1)]*16+h[substr(n, 2, 1)]);
                   2350:        }
                   2351:        NF == 1 { if(NR > 1) done(); print "char *" $1 "[] = {" }
                   2352:        NF > 1  { x[hex($1)] = $2; }
                   2353:        END     { done(); }' < $p > $p.c && $CC $CFLAGS -c $p.c && mv $p.o ../$target
                   2354:        rm $p.c
                   2355: 0707070035050450531006660011710000040000010447730457563431100000700000000340nlun.c#include    <stdio.h>
                   2356: #include       "scsi.h"
                   2357: #include       "juke.h"
                   2358: 
                   2359: int nlun = 1;
                   2360: 
                   2361: void
                   2362: setnlun(void)
                   2363: {
                   2364:        char buf[512];
                   2365: 
                   2366:        for(nlun = 0; nlun < NLUN; nlun++){
                   2367:                sprintf(buf, "/dev/worm%d", nlun);
                   2368:                if(access(buf, 0) < 0)
                   2369:                        return;
                   2370:        }
                   2371: }
                   2372: 0707070035050453131006660011710000040000010000000457563432400001200000000000nohup.out0707070035050446240407770011710000040000020447210457563430600001000000000000osanity0707070035050452261006660011710000040000010447230457563430600002200000001051osanity/tstfill.cshort pat[][8] =
                   2373: {
                   2374:        0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
                   2375:        0xb6db, 0xeb6d, 0xb6db, 0xeb6d, 0xb6db, 0xeb6d, 0xb6db, 0xeb6d,
                   2376:        0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
                   2377:        0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 0xAAAA, 
                   2378:        0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 0x5555, 
                   2379: };
                   2380: 
                   2381: fillbuf(buf, n)
                   2382:        char *buf;
                   2383: {
                   2384:        int i = 0;
                   2385:        register j;
                   2386: 
                   2387:        while(n > 0){
                   2388:                if(i >= sizeof(pat)/sizeof(pat[0]))
                   2389:                        i = 0;
                   2390:                for(j = 0; j < 64; j++, buf += 16)
                   2391:                        memcpy(buf, pat[i], 16);
                   2392:                n--;
                   2393:                i++;
                   2394:        }
                   2395: }
                   2396: 0707070035050446231006660011710000040000010447250457563430600002000000002004osanity/tstrd.cmain(argc, argv)
                   2397:        char **argv;
                   2398: {
                   2399:        long first, last, t;
                   2400:        char buf[32768], buf1[32768], *bufp;
                   2401:        int fd, n;
                   2402:        char *worm = "/dev/worm0";
                   2403: 
                   2404:        if((argc < 3) || (argc > 4)){
                   2405:                print("Usage: tstrd [device] firstblock firstnonblock\n");
                   2406:                exit(1);
                   2407:        }
                   2408:        if(argc > 3)
                   2409:                worm = *++argv;
                   2410:        if((fd = open(worm, 0)) < 0){
                   2411:                perror(worm);
                   2412:                exit(1);
                   2413:        }
                   2414:        first = atol(argv[1]);
                   2415:        last = atol(argv[2]);
                   2416:        if((first < 0) || (last <= first)){
                   2417:                print("bad first=%ld last=%ld\n", first, last);
                   2418:                exit(1);
                   2419:        }
                   2420:        print("reading blocks %ld - %ld inclusive on %s\n", first, last-1, worm);
                   2421:        fillbuf(buf, 32);
                   2422:        bufp = &buf[1024*(first%5)];
                   2423:        lseek(fd, first*1024, 0);
                   2424:        while(first < last){
                   2425:                n = last-first;
                   2426:                if(n > 25) n = 25;
                   2427:                if(read(fd, buf1, n*1024) != n*1024){
                   2428:                        print("block %ld: ", first);
                   2429:                        perror("read");
                   2430:                        exit(1);
                   2431:                }
                   2432:                if(memcmp(bufp, buf1, n*1024)){
                   2433:                        print("block %ld: bytes differ\n", first);
                   2434:                        exit(1);
                   2435:                }
                   2436:                if((first%5000) == 0){
                   2437:                        t = time((long *)0);
                   2438:                        print("done block %ld: %s", first, ctime(&t));
                   2439:                }
                   2440:                first += n;
                   2441:        }
                   2442:        exit(0);
                   2443: }
                   2444: 0707070035050452331006660011710000040000010447270457563430600002000000002730osanity/tstsk.cmain(argc, argv)
                   2445:        char **argv;
                   2446: {
                   2447:        long first, last, t;
                   2448:        char buf[32768], buf1[32768], *bufp;
                   2449:        int fd, n, i;
                   2450:        char *worm = "/dev/worm0";
                   2451:        long bands[50][2];
                   2452:        int nbands;
                   2453:        long loop;
                   2454:        double tseek, tbl;
                   2455:        float floop;
                   2456: 
                   2457:        if(argc < 3){
                   2458:                print("Usage: tstsk [device] firstblock firstnonblock ...\n");
                   2459:                exit(1);
                   2460:        }
                   2461:        if((argc&1) == 0)
                   2462:                worm = *++argv;
                   2463:        if((fd = open(worm, 0)) < 0){
                   2464:                perror(worm);
                   2465:                exit(1);
                   2466:        }
                   2467:        nbands = 0;
                   2468:        while(*++argv){
                   2469:                first = atol(*argv);
                   2470:                last = atol(*++argv);
                   2471:                if((first < 0) || (last <= first)){
                   2472:                        print("bad first=%ld last=%ld\n", first, last);
                   2473:                        exit(1);
                   2474:                }
                   2475:                bands[nbands][0] = first;
                   2476:                bands[nbands][1] = last;
                   2477:                nbands++;
                   2478:        }
                   2479:        tseek = tbl = 0;
                   2480:        last = 0;
                   2481:        fillbuf(buf, 32);
                   2482:        for(loop = 0;; loop++){
                   2483:                i = nrand(nbands);
                   2484:                first = bands[i][0] + lrand()%(bands[i][1]-bands[i][0]);
                   2485:                n = 20;
                   2486:                if(first+n > bands[i][1])
                   2487:                        first = bands[i][1]-n;
                   2488:                if(first < bands[i][0])
                   2489:                        first = bands[i][0], n = bands[i][1]-first;
                   2490:                tbl += n;
                   2491:                lseek(fd, first*1024, 0);
                   2492:                last -= first;
                   2493:                if(last < 0) last = -last;
                   2494:                tseek += last;
                   2495:                bufp = &buf[1024*(first%5)];
                   2496:                if(read(fd, buf1, n*1024) != n*1024){
                   2497:                        print("block %ld: ", first);
                   2498:                        perror("read");
                   2499:                        exit(1);
                   2500:                }
                   2501:                if(memcmp(bufp, buf1, n*1024)){
                   2502:                        print("block %ld: bytes differ\n", first);
                   2503:                        exit(1);
                   2504:                }
                   2505:                if(loop && ((loop%100) == 0)){
                   2506:                        t = time((long *)0);
                   2507:                        floop = loop+1;
                   2508:                        print("loop %ld: ave blocks=%.1f, ave seek=%.1fk at %s",
                   2509:                                loop, tbl/floop, tseek/floop, ctime(&t));
                   2510:                }
                   2511:                last = first+n;
                   2512:        }
                   2513: }
                   2514: 0707070035050446221006660011710000040000010447310457563430600002000000001646osanity/tstwr.cmain(argc, argv)
                   2515:        char **argv;
                   2516: {
                   2517:        long first, last, t;
                   2518:        char buf[32768], buf1[32768], *bufp;
                   2519:        int fd, n;
                   2520:        char *worm = "/dev/worm0";
                   2521: 
                   2522:        if((argc < 3) || (argc > 4)){
                   2523:                print("Usage: tstwr [device] firstblock firstnonblock\n");
                   2524:                exit(1);
                   2525:        }
                   2526:        if(argc > 3)
                   2527:                worm = *++argv;
                   2528:        if((fd = open(worm, 1)) < 0){
                   2529:                perror(worm);
                   2530:                exit(1);
                   2531:        }
                   2532:        first = atol(argv[1]);
                   2533:        last = atol(argv[2]);
                   2534:        if((first < 0) || (last <= first)){
                   2535:                print("bad first=%ld last=%ld\n", first, last);
                   2536:                exit(1);
                   2537:        }
                   2538:        print("writing blocks %ld - %ld inclusive on %s\n", first, last-1, worm);
                   2539:        fillbuf(buf, 32);
                   2540:        bufp = &buf[1024*(first%5)];
                   2541:        lseek(fd, first*1024, 0);
                   2542:        while(first < last){
                   2543:                n = last-first;
                   2544:                if(n > 25) n = 25;
                   2545:                if(write(fd, bufp, n*1024) != n*1024){
                   2546:                        print("block %ld: ", first);
                   2547:                        perror("write");
                   2548:                        exit(1);
                   2549:                }
                   2550:                if((first%5000) == 0){
                   2551:                        t = time((long *)0);
                   2552:                        print("done block %ld: %s", first, ctime(&t));
                   2553:                }
                   2554:                first += n;
                   2555:        }
                   2556:        exit(0);
                   2557: }
                   2558: 0707070035050452241006660011710000040000010447330457563430600001700000000214osanity/mkfileCFLAGS=-g
                   2559: NPROC=2
                   2560: ALL=tstwr tstrd tstsk
                   2561: 
                   2562: all:V: $ALL
                   2563: 
                   2564: tst%:  tst%.o tstfill.o
                   2565:        $CC $CFLAGS -o $target $prereq
                   2566: 
                   2567: clean:V:
                   2568:        rm -f *.o $ALL core
                   2569: 0707070035050446211007770011710000040000010447350457563430600001500000000113osanity/seektstsk 5 100000 400000 500000 800000 900000 1200000 1300000 1500000 1600000
                   2570: 0707070035050422101006660011710000040000010273160464713414700001400000000126research.mk# config stuff: research unix
                   2571: CC=lcc
                   2572: CFLAGS=-g
                   2573: RANLIB=ranlib
                   2574: LDFLAGS=
                   2575: IO=h_io
                   2576: NPROC=2
                   2577: 0707070035050450510407770011710000040000020447760464700560600000500000000000scsi0707070035050517151006440011710000040000010255620464677426000001500000027722scsi/dslib.c/*
                   2578: || dslib.c - library routines for /dev/scsi
                   2579: ||
                   2580: || Copyright 1988, 1989, by
                   2581: ||   Gene Dronek (Vulcan Laboratory) and
                   2582: ||   Rich Morin  (Canta Forda Computer Laboratory).
                   2583: || All rights reserved.
                   2584: */
                   2585: #ident "dslib.c: $Revision: 1.4 $"
                   2586: 
                   2587: #include <stdio.h>
                   2588: #include <sys/types.h>
                   2589: 
                   2590: #include "dslib.h"
                   2591: #ifdef aux
                   2592: #include <sys/vio.h>
                   2593: #include <sys/scsireq.h>
                   2594: #endif aux
                   2595: 
                   2596: int dsdebug=0;
                   2597: long dsreqflags;       /* flag bits always set by filldsreq */
                   2598: 
                   2599: #define min(i,j)  ( (i) < (j) ? (i) : (j) )
                   2600: 
                   2601: 
                   2602: /*
                   2603: || Startup/shutdown -----------------------------------------------
                   2604: */
                   2605: 
                   2606: static struct context *dsc[FDSIZ];
                   2607: 
                   2608: 
                   2609: /*
                   2610: || dsopen - open device, set up structures
                   2611: */
                   2612: 
                   2613: struct dsreq *
                   2614: dsopen(opath, oflags)
                   2615:   char *opath;
                   2616:   int   oflags;
                   2617: {
                   2618:     
                   2619:   struct dsreq *dsp;
                   2620:   struct context *cp;
                   2621:   int fd;
                   2622:   DSDBG(fprintf(stderr,"dsopen(%s,%x) ", opath, oflags));
                   2623: 
                   2624:   fd = open(opath, oflags);
                   2625:   if (fd < 0)                                          
                   2626:     return NULL;                       /* can't open   */
                   2627:   if (dsc[fd] != NULL)                 /* already in use */
                   2628:     ds_zot("dsopen: fd already in use");
                   2629: 
                   2630:   cp = (struct context *) calloc(1, sizeof(struct context));
                   2631:   if (cp == NULL)                                    /* can't allocate */
                   2632:     ds_zot("dsopen: can't allocate space");
                   2633:   dsc[fd] = cp;
                   2634:   cp->dsc_fd = fd;
                   2635:   dsp = &(cp->dsc_dsreq);
                   2636: 
                   2637:   dsp->ds_flags =      0;
                   2638:   dsp->ds_time =       10 * 1000;      /* 10 second default timeout */
                   2639:   dsp->ds_private =    (ulong) cp;     /* pointer back to context */
                   2640:   dsp->ds_cmdbuf =     cp->dsc_cmd;
                   2641:   dsp->ds_cmdlen =     sizeof cp->dsc_cmd;
                   2642:   dsp->ds_databuf =    0;
                   2643:   dsp->ds_datalen =    0;
                   2644:   dsp->ds_sensebuf =   cp->dsc_sense;
                   2645:   dsp->ds_senselen =   sizeof cp->dsc_sense;
                   2646:   DSDBG(fprintf(stderr,"=>cp %x, dsp %x\n", cp, dsp));
                   2647:   return dsp;
                   2648: }
                   2649: 
                   2650: 
                   2651: /*
                   2652: || dsclose - close device, release context struct.
                   2653: */
                   2654: 
                   2655: dsclose(dsp)
                   2656:   struct dsreq *dsp;
                   2657: {
                   2658:   int fd;
                   2659:   struct context *cp;
                   2660: 
                   2661:   if (dsp == NULL)
                   2662:     ds_zot("dsclose: dsp is NULL");
                   2663: 
                   2664:   cp = (struct context *)dsp->ds_private;
                   2665:   fd = getfd(dsp);
                   2666:   if ( cp == NULL )
                   2667:     ds_zot("dsclose: private is NULL");
                   2668: 
                   2669:   cfree(cp);
                   2670:   dsc[fd] = (struct context *)NULL;
                   2671:   return;
                   2672: }
                   2673: 
                   2674: 
                   2675: /*
                   2676: || Generic SCSI CCS Command functions ------------------------------------
                   2677: ||
                   2678: || dsp         dsreq pointer
                   2679: || data                data buffer pointer
                   2680: || datalen     data buffer length
                   2681: || lba         logical block address
                   2682: || vu          vendor unique bits
                   2683: */
                   2684: 
                   2685: /*
                   2686: || testunitready00 - issue group 0 "Test Unit Ready" command (0x00)
                   2687: */
                   2688: 
                   2689: testunitready00(dsp)
                   2690:   struct dsreq *dsp;
                   2691: {
                   2692:   fillg0cmd(dsp, CMDBUF(dsp), G0_TEST, 0, 0, 0, 0, 0);
                   2693:   filldsreq(dsp, 0, 0, DSRQ_READ|DSRQ_SENSE);
                   2694:   return(doscsireq(getfd(dsp), dsp));
                   2695: }
                   2696: 
                   2697: 
                   2698: /*
                   2699: || requestsense03 - issue group 0 "Request Sense" command (0x03)
                   2700: */
                   2701: 
                   2702: requestsense03(dsp, data, datalen, vu)
                   2703:   struct dsreq *dsp;
                   2704:   caddr_t data;
                   2705:   long datalen;
                   2706:   char vu;
                   2707: {
                   2708:   fillg0cmd(dsp, CMDBUF(dsp), G0_REQU, 0, 0, 0, B1(datalen), B1(vu<<6));
                   2709:   filldsreq(dsp, data, datalen, DSRQ_READ);
                   2710:   return(doscsireq(getfd(dsp), dsp));
                   2711: }
                   2712: 
                   2713: 
                   2714: /*
                   2715: || write0a - issue group 0 "Write" command (0x0a)
                   2716: */
                   2717: 
                   2718: write0a(dsp, data, datalen, lba, vu)
                   2719:   struct dsreq *dsp;
                   2720:   caddr_t data;
                   2721:   long datalen, lba;
                   2722:   char vu;
                   2723: {
                   2724:   fillg0cmd(dsp, CMDBUF(dsp), G0_WRIT, B3(lba), B1(datalen), B1(vu<<6));
                   2725:   filldsreq(dsp, data, datalen, DSRQ_READ);
                   2726:   return(doscsireq(getfd(dsp), dsp));
                   2727: }
                   2728: 
                   2729: 
                   2730: /*
                   2731: || inquiry12 - issue group 0 "Inquiry" command (0x12)
                   2732: */
                   2733: 
                   2734: inquiry12(dsp, data, datalen, vu)
                   2735:   struct dsreq *dsp;
                   2736:   caddr_t data;
                   2737:   long datalen;
                   2738:   char vu;
                   2739: {
                   2740:   fillg0cmd(dsp, CMDBUF(dsp), G0_INQU, 0, 0, 0, B1(datalen), B1(vu<<6));
                   2741:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE);
                   2742:   return(doscsireq(getfd(dsp), dsp));
                   2743: }
                   2744: 
                   2745: 
                   2746: /*
                   2747: || modeselect15 - issue group 0 "Mode Select" command (0x15)
                   2748: ||
                   2749: || save                0 - don't save saveable pages
                   2750: ||             1 - save saveable pages
                   2751: */
                   2752: 
                   2753: modeselect15(dsp, data, datalen, save, vu)
                   2754:   struct dsreq *dsp;
                   2755:   caddr_t data;
                   2756:   long datalen;
                   2757:   char save, vu;
                   2758: {
                   2759:   fillg0cmd(dsp, CMDBUF(dsp), G0_MSEL, save&1, 0, 0, B1(datalen), B1(vu<<6));
                   2760:   filldsreq(dsp, data, datalen, DSRQ_WRITE|DSRQ_SENSE);
                   2761:   return(doscsireq(getfd(dsp), dsp));
                   2762: }
                   2763: 
                   2764: 
                   2765: /*
                   2766: || modesense1a - issue group 0 "Mode Sense" command (0x1a)
                   2767: ||
                   2768: || pagectrl    0 - current values
                   2769: ||             1 - changeable values
                   2770: ||             2 - default values
                   2771: ||             3 - saved values
                   2772: ||
                   2773: || pagecode    0   - vendor unique
                   2774: ||             1   - error recovery
                   2775: ||             2   - disconnect/reconnect
                   2776: ||             3   - direct access dev. fmt.
                   2777: ||             4   - rigid disk geometry
                   2778: ||             5   - flexible disk
                   2779: ||             6-9 - see specific dev. types
                   2780: ||             0a  - implemented options
                   2781: ||             0b  - medium types supported
                   2782: ||             3f  - return all pages
                   2783: */
                   2784: 
                   2785: modesense1a(dsp, data, datalen, pagectrl, pagecode, vu)
                   2786:   struct dsreq *dsp;
                   2787:   caddr_t data;
                   2788:   long datalen;
                   2789:   char pagectrl, pagecode, vu;
                   2790: {
                   2791:   fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN, 0x10,
                   2792:     ((pagectrl&3)<<6) | (pagecode&0x3F),
                   2793:     0, B1(datalen), B1(vu<<6));
                   2794:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE);
                   2795:   return(doscsireq(getfd(dsp), dsp));
                   2796: }
                   2797: 
                   2798: 
                   2799: /*
                   2800: || senddiagnostic1d - issue group 0 "Send Diagnostic" command (0x1d)
                   2801: ||
                   2802: || self                0 - run test, hold results
                   2803: ||             1 - run test, return status
                   2804: ||
                   2805: || dofl                0 - device online
                   2806: ||             1 - device offline
                   2807: ||
                   2808: || uofl                0 - unit online
                   2809: ||             1 - unit offline
                   2810: */
                   2811: 
                   2812: senddiagnostic1d(dsp, data, datalen, self, dofl, uofl, vu)
                   2813:   struct dsreq *dsp;
                   2814:   caddr_t data;
                   2815:   long datalen;
                   2816:   char self, dofl, uofl, vu;
                   2817: {
                   2818:   fillg0cmd(dsp, CMDBUF(dsp), G0_MSEN,
                   2819:     (self&1)<<2 | (dofl&1)<<1 | (uofl&1),
                   2820:     0, B2(datalen), B1(vu<<6));
                   2821:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE);
                   2822:   return(doscsireq(getfd(dsp), dsp));
                   2823: }
                   2824: 
                   2825: 
                   2826: /*
                   2827: || readcapacity25 - issue group 1 "Read Capacity" command (0x25)
                   2828: ||
                   2829: || pmi         0 - return last logical block, entire unit
                   2830: ||             1 - return last logical block, current track
                   2831: */
                   2832: 
                   2833: readcapacity25(dsp, data, datalen, lba, pmi, vu)
                   2834:   struct dsreq *dsp;
                   2835:   caddr_t data;
                   2836:   long datalen, lba;
                   2837:   char pmi, vu;
                   2838: {
                   2839:   fillg1cmd(dsp, CMDBUF(dsp), G1_RCAP, 0, B4(lba), 0, 0, pmi&1, B1(vu<<6));
                   2840:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE
                   2841:     /* |DSRQ_CTRL2 */ );
                   2842:   /* dsp->ds_time = 100;       /* often takes a while */
                   2843:   return(doscsireq(getfd(dsp), dsp));
                   2844: }
                   2845: 
                   2846: 
                   2847: /*
                   2848: || readextended28 - issue group 1 "Read Extended" command (0x28)
                   2849: */
                   2850: 
                   2851: readextended28(dsp, data, datalen, lba, vu)
                   2852:   struct dsreq *dsp;
                   2853:   caddr_t data;
                   2854:   long datalen, lba;
                   2855:   char vu;
                   2856: {
                   2857:   fillg1cmd(dsp, CMDBUF(dsp), G1_READ, 0, B4(lba), 0, B2(datalen), B1(vu<<6));
                   2858:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE
                   2859:     /* |DSRQ_CTRL2 */ );
                   2860:   /* dsp->ds_time = 100;       /* often takes a while */
                   2861:   return(doscsireq(getfd(dsp), dsp));
                   2862: }
                   2863: 
                   2864: 
                   2865: /*
                   2866: || writeextended2a - issue group 1 "Write Extended" command (0x2a)
                   2867: */
                   2868: 
                   2869: writeextended2a(dsp, data, datalen, lba, vu)
                   2870:   struct dsreq *dsp;
                   2871:   caddr_t data;
                   2872:   long datalen, lba;
                   2873:   char vu;
                   2874: {
                   2875:   fillg1cmd(dsp, CMDBUF(dsp), G1_WRIT, 0, B4(lba), 0, B2(datalen), B1(vu<<6));
                   2876:   filldsreq(dsp, data, datalen, DSRQ_READ|DSRQ_SENSE
                   2877:     /* |DSRQ_CTRL2 */ );
                   2878:   /* dsp->ds_time = 100;       /* often takes a while */
                   2879:   return(doscsireq(getfd(dsp), dsp));
                   2880: }
                   2881: 
                   2882: 
                   2883: /*
                   2884: || Support functions ----------------------------------------------------
                   2885: */
                   2886: 
                   2887: /*
                   2888: || fillg0cmd - Fill a Group 0 command buffer
                   2889: */
                   2890: 
                   2891: fillg0cmd(dsp, cmd, b0,b1,b2,b3,b4,b5)
                   2892:   struct dsreq *dsp;
                   2893:   uchar_t *cmd, b0,b1,b2,b3,b4,b5;
                   2894: {
                   2895:   uchar_t *c = cmd;
                   2896:   DSDBG(fprintf(stderr,"fillg0cmd(%x,%x, %02x %02x %02x %02x %02x %02x)\n",
                   2897:                dsp, cmd, b0,b1,b2,b3,b4,b5));
                   2898:   *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5;
                   2899:        
                   2900:   CMDBUF(dsp) = (caddr_t) cmd;
                   2901:   CMDLEN(dsp) = 6;
                   2902: }
                   2903: 
                   2904: 
                   2905: /*
                   2906: || fillg1cmd - Fill a Group 1 command buffer
                   2907: */
                   2908: 
                   2909: fillg1cmd(dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9)
                   2910:   struct dsreq *dsp;
                   2911:   uchar_t *cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9;
                   2912: {
                   2913:   uchar_t *c = cmd;
                   2914:   DSDBG(fprintf(stderr,
                   2915:     "fillg1cmd(%x,%x, %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x)\n",
                   2916:                dsp, cmd, b0,b1,b2,b3,b4,b5,b6,b7,b8,b9));
                   2917: 
                   2918:   *c++ = b0, *c++ = b1, *c++ = b2, *c++ = b3, *c++ = b4, *c++ = b5;
                   2919:   *c++ = b6, *c++ = b7, *c++ = b8, *c++ = b9;
                   2920:        
                   2921:   CMDBUF(dsp) = (caddr_t) cmd;
                   2922:   CMDLEN(dsp) = 10;
                   2923: }
                   2924: 
                   2925: 
                   2926: /*
                   2927: || filldsreq - Fill a dsreq structure
                   2928: */
                   2929: 
                   2930: filldsreq(dsp,data,datalen,flags)
                   2931:   struct dsreq         *dsp;
                   2932:   uchar_t              *data;
                   2933: {
                   2934:   DSDBG(fprintf(stderr,"filldsreq(%x,%x,%d,%x) cmdlen %d\n",
                   2935:                dsp,data,datalen,flags,CMDLEN(dsp)));
                   2936:   dsp->ds_flags        = flags | dsreqflags |
                   2937:          (((dsdebug&1) ? DSRQ_TRACE : 0) |
                   2938:          ((dsdebug&2) ? DSRQ_PRINT : 0));
                   2939:   dsp->ds_time = 10 * 1000;    /* default to 10 seconds */
                   2940:   dsp->ds_link = 0;
                   2941:   dsp->ds_synch        = 0;
                   2942:   dsp->ds_ret          = 0;
                   2943: 
                   2944:   DATABUF(dsp)         = (caddr_t) data;
                   2945:   DATALEN(dsp) = datalen;
                   2946: }
                   2947: 
                   2948: 
                   2949: /*
                   2950: || bprint - print array of bytes, in hex.
                   2951: */
                   2952: 
                   2953: #define hex(x) "0123456789ABCDEF" [ (x) & 0xF ]
                   2954: 
                   2955: bprint(s,n,nperline,space)
                   2956:        char *s;
                   2957: {
                   2958:        int   i, x;
                   2959:        char  *sp = (space) ? " ": "";
                   2960: 
                   2961:        for(i=0;i<n;i++)  {
                   2962:                x = s[i];
                   2963:                fprintf(stderr,((i%4==3)?"%c%c%s%s":"%c%c%s"),
                   2964:                        hex(x>>4), hex(x), sp, sp);
                   2965:                if ( i%nperline == (nperline - 1) )
                   2966:                        fprintf(stderr,"\n");
                   2967:        }
                   2968:        if ( space )
                   2969:                fprintf(stderr,"\n");
                   2970: }
                   2971: 
                   2972: 
                   2973: /*
                   2974: || doscsireq - issue scsi command, return status or -1 error.
                   2975: */
                   2976: 
                   2977: doscsireq( fd, dsp)
                   2978:   int  fd;             /* ioctl file descriptor */
                   2979:   struct dsreq *dsp;   /* devscsi request packet */
                   2980: {
                   2981:   int  cc;
                   2982:   int  retries = 4;
                   2983:   uchar_t      sbyte;
                   2984: 
                   2985:   DSDBG(fprintf(stderr,"doscsireq(%d,%x) %x ---- %s\n",fd,dsp,
                   2986:     (CMDBUF(dsp))[0],
                   2987:     ds_vtostr( (CMDBUF(dsp))[0], cmdnametab)));
                   2988: 
                   2989:   /*
                   2990:    *  loop, issuing command
                   2991:    *    until done, or further retry pointless
                   2992:    */
                   2993: 
                   2994:   while ( --retries > 0 )  {
                   2995: 
                   2996:    caddr_t sp;
                   2997: 
                   2998:     sp =  SENSEBUF(dsp);
                   2999:     DSDBG(fprintf(stderr,"cmdbuf   =  ");
                   3000:                bprint(CMDBUF(dsp),CMDLEN(dsp),16,1));
                   3001:     if ( (dsp->ds_flags & DSRQ_WRITE) )
                   3002:       DSDBG(bprint( DATABUF(dsp), min(50,DATALEN(dsp)),16,1 ));
                   3003:        
                   3004: DSDBG(fprintf(stderr,"databuf datalen %x %d\n",DATABUF(dsp), DATALEN(dsp)));
                   3005:     cc = ioctl( fd, DS_ENTER, dsp);
                   3006:     if ( cc < 0)  {
                   3007:       ds_panic(dsp, "cannot ioctl fd %d\n",fd);
                   3008:     }
                   3009:        
                   3010:        DSDBG(fprintf(stderr,"cmdlen after ioctl=%d\n",CMDLEN(dsp)));
                   3011:     DSDBG(fprintf(stderr,"ioctl=%d ret=%x %s",
                   3012:       cc, RET(dsp), 
                   3013:       RET(dsp) ? ds_vtostr(RET(dsp),dsrtnametab) : ""));
                   3014:     DSDBG(if (SENSESENT(dsp)) fprintf(stderr," sensesent=%d",
                   3015:       SENSESENT(dsp)));
                   3016: 
                   3017:     DSDBG(fprintf(stderr,
                   3018:       " cmdsent=%d datasent=%d sbyte=%x %s\n",
                   3019:       CMDSENT(dsp), DATASENT(dsp), STATUS(dsp),
                   3020:       ds_vtostr(STATUS(dsp), cmdstatustab)));
                   3021:     DSDBG(if ( FLAGS(dsp) & DSRQ_READ )
                   3022:       bprint( DATABUF(dsp), min(16*16,DATASENT(dsp)), 16,1));
                   3023: 
                   3024: #ifdef aux
                   3025:   /*
                   3026:    *  check for AUX bus-error 
                   3027:    *  we retry with poll-dma
                   3028:    */
                   3029:     if ( RET(dsp) == DSRT_AGAIN )  {
                   3030:       int n = SDC_RDPOLL|SDC_WRPOLL;
                   3031:       DSDBG(fprintf(stderr,"setting rd/wr-poll"));
                   3032:       cc = ioctl( fd, DS_SET, n);      /* set bits */
                   3033:       if ( cc != 0 )
                   3034:         return -1;
                   3035:     }
                   3036: #endif aux
                   3037: 
                   3038:     if ( RET(dsp) == DSRT_NOSEL )
                   3039:       continue;                /* retry noselect 3X */
                   3040: 
                   3041:     /* decode sense data returned */
                   3042:     if ( SENSESENT(dsp) )  {
                   3043:       DSDBG(
                   3044:         fprintf(stderr, "sense key %x - %s\n",
                   3045:           SENSEKEY(sp),
                   3046:           ds_vtostr( SENSEKEY(sp), sensekeytab));
                   3047:         bprint( SENSEBUF(dsp),
                   3048:           min(100, SENSESENT(dsp)),
                   3049:           16,1);
                   3050:       );
                   3051:     }
                   3052:     DSDBG(fprintf(stderr, "sbyte %x\n", STATUS(dsp)));
                   3053: 
                   3054:     /* decode scsi command status byte */
                   3055:     sbyte = STATUS(dsp);
                   3056:     switch (sbyte)  {
                   3057:       case 0x08:               /*  BUSY */
                   3058:       case 0x18:               /*  RESERV CONFLICT */
                   3059:        sleep(2);
                   3060:        continue;
                   3061:       case 0x00:               /*  GOOD */
                   3062:       case 0x02:               /*  CHECK CONDITION */
                   3063:       case 0x10:               /*  INTERM/GOOD */
                   3064:       default:
                   3065:        return sbyte;
                   3066:     }
                   3067:   }
                   3068:   return -1;   /* fail retry limit */
                   3069: }
                   3070: 
                   3071: 
                   3072: /*
                   3073: || opttovar - lookup option in table, return var addr (NULL if fail)
                   3074: */
                   3075: 
                   3076: int *
                   3077: opttovar( ostr, table)
                   3078:   char *ostr;
                   3079:   struct opttab{
                   3080:     char *opt;
                   3081:     int  *var;
                   3082:   } *table;
                   3083: {
                   3084:   register struct opttab *tp;
                   3085: 
                   3086:   for (tp=table; (tp->var); tp++)
                   3087:     if ( strncmp( ostr, tp->opt, 3) == 0 )
                   3088:       break;
                   3089: 
                   3090:   if ( !tp->var )
                   3091:     fprintf(stderr,"unknown option %s", ostr);
                   3092:        
                   3093:   return (tp->var);
                   3094: }
                   3095: 
                   3096: 
                   3097: /*
                   3098: || ds_vtostr - lookup value in table to return string pointer
                   3099: */
                   3100: 
                   3101: char *
                   3102: ds_vtostr( v, table)
                   3103:   long v;
                   3104:   struct vtab *table;
                   3105: {
                   3106:   register struct vtab *tp;
                   3107: 
                   3108:   for (tp=table; (tp->string); tp++)
                   3109:     if ( v == tp->val )
                   3110:       break;
                   3111:        
                   3112:   return (tp->string) ? tp->string : "";
                   3113: }
                   3114: 
                   3115: 
                   3116: /*
                   3117: || ds_panic - yelp, leave...
                   3118: */
                   3119: 
                   3120: ds_panic( fmt, v)
                   3121:   char *fmt;
                   3122:   int v;
                   3123: {
                   3124:   extern errno;
                   3125: 
                   3126:   fprintf(stderr,fmt,v);
                   3127:   fprintf(stderr,"\nerrno = %d\n",errno);
                   3128:   exit(1);
                   3129: }
                   3130: 
                   3131: 
                   3132: /*
                   3133: || ds_zot - go away, with a message.
                   3134: */
                   3135: 
                   3136: ds_zot(message)
                   3137:   char *message;
                   3138: {
                   3139:   fprintf(stderr, "%s\n", message);
                   3140:   exit(1);
                   3141: }
                   3142: 0707070035050450471006660011710000040000011476170464014756600001500000005504scsi/volid.c#include      <stddef.h>
                   3143: #include       <stdio.h>
                   3144: #include       "../scsi.h"
                   3145: #include       "../juke.h"
                   3146: 
                   3147: static
                   3148: myread(int drive, long block, struct scsi_return *ret, char *err)
                   3149: {
                   3150:        struct scsi_cmd cmd;
                   3151: 
                   3152:        set10(cmd, 0x28, drive<<5, block>>24, block>>16, block>>8, block, 0, 0, 1, 0);
                   3153:        return(s_io(0, &cmd, 0, ret, 1024, err));
                   3154: }
                   3155: 
                   3156: j_rvolid(int drive, char *err)
                   3157: {
                   3158:        struct scsi_return ret;
                   3159:        long b, lastb;
                   3160:        char buf[1024];
                   3161:        int debug = 0;
                   3162: 
                   3163:        err[0] = 0;
                   3164:        if(s_start(drive, err) < 0)
                   3165:                return(-1);
                   3166:        if(myread(drive, 0L, &ret, err) == 0){
                   3167:                memset(buf, 0, 1024);
                   3168:                if(memcmp(buf, ret.data, 1024)){
                   3169:                        if(debug)
                   3170:                                fprintf(stderr, "superblok at 0\n");
                   3171:                        goto done;      /* found a superblock at 0 */
                   3172:                }
                   3173:        }
                   3174:        for(b = 1, lastb = -1;;){
                   3175: hack:
                   3176:                if(debug)
                   3177:                        fprintf(stderr, "read block %d\n", b);
                   3178:                if(myread(drive, b, &ret, err))
                   3179:                        break;
                   3180:                lastb = b;
                   3181:                b = ((long *)ret.data)[9];
                   3182:        }
                   3183:        if(lastb < 0){
                   3184:                if(b == 1){     /* for disks with a bad block 1 */
                   3185:                        b = 2;
                   3186:                        goto hack;
                   3187:                }
                   3188:                if(debug)
                   3189:                        fprintf(stderr, "tried for superblock at blocks 1,2\n");
                   3190:                sprintf(err, "no superblock");
                   3191:                s_stop(drive, buf);
                   3192:                return(1);
                   3193:        }
                   3194:        if(myread(drive, lastb, &ret, err) < 0){
                   3195:                s_stop(drive, buf);
                   3196:                fprintf(stderr, "read fail on block %d (b=%d)\n", lastb, b);/**/
                   3197:                return(-1);
                   3198:        }
                   3199:        if(debug)
                   3200:                fprintf(stderr, "superblock at %d\n", lastb);
                   3201: done:
                   3202:        strncpy(err, (char *)&ret.data[42], 128);
                   3203:        err[127] = 0;
                   3204:        s_stop(drive, buf);
                   3205:        return(0);
                   3206: }
                   3207: 
                   3208: static
                   3209: mywrite(int drive, long block, struct scsi_cmd *cmd, struct scsi_return *ret, char *err)
                   3210: {
                   3211:        set10((*cmd), 0x2A, drive<<5, block>>24, block>>16, block>>8, block, 0, 0, 1, 0);
                   3212:        return(s_io(0, cmd, 1024, ret, 0, err));
                   3213: }
                   3214: 
                   3215: j_wvolid(int drive, char *vol_id, char *err)
                   3216: {
                   3217:        char tmpfile[L_tmpnam];
                   3218:        char buf[512];
                   3219:        struct scsi_return ret;
                   3220:        struct scsi_cmd cmd;
                   3221:        FILE *fp;
                   3222:        int n;
                   3223: 
                   3224:        printf("mkfs %s\n", vol_id);
                   3225:        /* first get the capacity/size for mkfs to make a valid superblock */
                   3226:        tmpnam(tmpfile);
                   3227:        if((fp = fopen(tmpfile, "w+r")) == NULL){
                   3228:                pperror(err, tmpfile);
                   3229:                return(-1);
                   3230:        }
                   3231:        if(s_start(drive, err) < 0)
                   3232:                return(-1);
                   3233:        set10(cmd, 0x25, drive<<5, 0, 0, 0, 0, 0, 0, 0, 0);
                   3234:        if(n = s_io(0, &cmd, 0, &ret, 8, err))
                   3235:                return(n);
                   3236:        switch(longat(&ret.data[0]))
                   3237:        {
                   3238:        case 1637999:           /* sony 12in clv single density */
                   3239:                sprintf(buf, "worm mkfs -n %d -f %s %s", 1600000, tmpfile, vol_id);
                   3240:                break;
                   3241:        case 3275999:           /* sony 12in clv double density */
                   3242:                sprintf(buf, "worm mkfs -n %d -f %s %s", 3250000, tmpfile, vol_id);
                   3243:                break;
                   3244:        default:
                   3245:                fprintf(stderr, "warning: bad capacity %d\n", longat(&ret.data[0]));
                   3246:                sprintf(buf, "worm mkfs -f %s %s", tmpfile, vol_id);
                   3247:                break;
                   3248:        }
                   3249:        if(system(buf)){
                   3250:                sprintf(err, "%s: error", buf);
                   3251:                return(-1);
                   3252:        }
                   3253:        unlink(tmpfile);
                   3254:        fseek(fp, 1024L, 0);
                   3255:        if(fread(cmd.data, 1, 1024, fp) == 0){
                   3256:                pperror(err, "mkfs read");
                   3257:                return(-1);
                   3258:        }
                   3259:        fclose(fp);
                   3260:        if(mywrite(drive, 1L, &cmd, &ret, err))
                   3261:                return(-1);
                   3262:        unlink(tmpfile);
                   3263:        s_stop(drive, err);
                   3264:        return(0);
                   3265: }
                   3266: 0707070035050450461006660011710000040000010450010457563431200001700000000434scsi/pperror.c#include    "../scsi.h"
                   3267: 
                   3268: void
                   3269: pperror(char *buf, char *mesg)
                   3270: {
                   3271:        extern int sys_nerr;
                   3272:        extern char *sys_errlist[];
                   3273:        extern int errno;
                   3274: 
                   3275:        if((errno < 0) || (errno >= sys_nerr))
                   3276:                sprintf(buf, "%s: unknown errno %d", mesg, errno);
                   3277:        else
                   3278:                sprintf(buf, "%s: %s", mesg, sys_errlist[errno]);
                   3279: }
                   3280: 0707070035050450451006660011710000040000010450030457563431200002000000000400scsi/fixedstr.c#include   "../scsi.h"
                   3281: 
                   3282: void
                   3283: fixedstr(uchar *src, int len, char *dest)
                   3284: {
                   3285:        uchar *s;
                   3286: 
                   3287:        while((*src == ' ') && (len > 0))
                   3288:                src++, len--;
                   3289:        for(s = src+len-1; s >= src; s--)
                   3290:                if(*s != ' ')
                   3291:                        break;
                   3292:        memcpy(dest, (char *)src, len = s-src+1);
                   3293:        dest[len] = 0;
                   3294: }
                   3295: 0707070035050450441006660011710000040000010450040457563431200001600000000247scsi/longat.c#include     "../scsi.h"
                   3296: 
                   3297: unsigned long
                   3298: longat(uchar *src)
                   3299: {
                   3300:        unsigned long n;
                   3301: 
                   3302:        n = *src++;
                   3303:        n = (n<<8) | *src++;
                   3304:        n = (n<<8) | *src++;
                   3305:        n = (n<<8) | *src;
                   3306:        return(n);
                   3307: }
                   3308: 0707070035050450431006660011710000040000010450050457563431200001200000001642scsi/xd.c#include <stdio.h>
                   3309: #include       "../scsi.h"
                   3310: #include       "../scsish.h"
                   3311: 
                   3312: #define        WIDTH   32
                   3313: 
                   3314: void
                   3315: xd(uchar *p, int n, FILE *fp)
                   3316: {
                   3317:        register i, nd, l;
                   3318:        unsigned char buf[WIDTH];
                   3319:        int didstar;
                   3320:        unsigned char *s;
                   3321: 
                   3322:        for(nd = 0; n > 0; n -= l, nd += l){
                   3323:                l = min(WIDTH, n);
                   3324:                if(nd && (l == WIDTH) && (memcmp(buf, p, l) == 0)){
                   3325:                        p += WIDTH;
                   3326:                        if(didstar++ == 0)
                   3327:                                fprintf(fp, "*\n");
                   3328:                        continue;
                   3329:                }
                   3330:                memcpy(buf, p, l);
                   3331:                didstar = 0;
                   3332:                fprintf(fp, "%5.5d", nd);
                   3333:                s = p;
                   3334:                for(i = 0; i < l; i++){
                   3335:                        if((i%4) == 0) putc(' ', fp);
                   3336:                        fprintf(fp, "%2.2x", *p++);
                   3337:                }
                   3338:                putc('\n', fp);
                   3339:                fprintf(fp, "     ");
                   3340:                for(i = 0; i < l; i++){
                   3341:                        if((i%4) == 0) putc(' ', fp);
                   3342:                        if((*s >= ' ') && (*s < 0177))
                   3343:                                fprintf(fp, " %c", *s++);
                   3344:                        else switch(*s++)
                   3345:                        {
                   3346:                        case '\n':      fprintf(fp, "\\n"); break;
                   3347:                        case '\t':      fprintf(fp, "\\t"); break;
                   3348:                        default:        fprintf(fp, ".."); break;
                   3349:                        }
                   3350:                }
                   3351:                putc('\n', fp);
                   3352:        }
                   3353:        fprintf(fp, "%5.5d\n", nd);
                   3354: }
                   3355: 0707070035050513571006660011710000040000011505520464714335200001500000005050scsi/md_io.c#include      <stdio.h>
                   3356: #include       "../scsi.h"
                   3357: #include       "../scsish.h"
                   3358: #include       <sys/types.h>
                   3359: #include       <sys/dsreq.h>
                   3360: 
                   3361: #define        DEV(buf, target, lun)   sprintf(buf, "/dev/scsi/sc0d%dl%d", target, lun)
                   3362: 
                   3363: static fd = -1;
                   3364: int s_id;
                   3365: void (*ss_extsense)(uchar *, char *, int);
                   3366: 
                   3367: ss_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err)
                   3368: {
                   3369:        int retv;
                   3370:        dsreq_t ds;
                   3371:        char dev[512];
                   3372: 
                   3373:        err[0] = 0;
                   3374:        retv = -1;
                   3375:        if(ncmd && nret){
                   3376:                sprintf(err, "both input (%d bytes) and output (%d bytes) expected", ncmd, nret);
                   3377:                return(retv);
                   3378:        }
                   3379:        if(cmd->bus_id & 0x8000){
                   3380:                sprintf(err, "reset not supported");
                   3381:                return(retv);
                   3382:        }
                   3383:        if(fd < 0){
                   3384:                DEV(dev, cmd->bus_id, ((cmd->cmd[1]>>5)&7));
                   3385:                if((fd = open(dev, 2)) < 0){
                   3386:                        pperror(err, dev);
                   3387:                        return(-1);
                   3388:                }
                   3389:        }
                   3390:        ds.ds_flags = DSRQ_SENSE;
                   3391:        ds.ds_time = 30000;
                   3392:        ds.ds_cmdbuf = (char *)cmd->cmd;
                   3393:        ds.ds_cmdlen = 10;
                   3394:        if(ncmd){
                   3395:                ds.ds_databuf = (char *)cmd->data;
                   3396:                ds.ds_datalen = ncmd;
                   3397:                ds.ds_flags |= DSRQ_WRITE;
                   3398:        } else {
                   3399:                ds.ds_databuf = (char *)ret->data;
                   3400:                ds.ds_datalen = nret;
                   3401:                ds.ds_flags |= DSRQ_READ;
                   3402:        }
                   3403:        ds.ds_sensebuf = (char *)ret->sense;
                   3404:        ds.ds_senselen = sizeof ret->sense;
                   3405:        ds.ds_iovbuf = 0;
                   3406:        ds.ds_link = 0;
                   3407:        if(ioctl(fd, DS_ENTER, &ds) < 0){
                   3408:                pperror(err, "DS_ENTER ioctl");
                   3409: err_ret:
                   3410:                close(fd);
                   3411:                fd = -1;
                   3412:                return(retv);
                   3413:        }
                   3414:        if(ds.ds_ret
                   3415:                && (ds.ds_ret != DSRT_SHORT)
                   3416:                && (ds.ds_ret != DSRT_OK)
                   3417:        )       /* an error */
                   3418:                fprintf(stderr, "ds_ret = #%x\n", ds.ds_ret);
                   3419:        ret->type = 3;
                   3420:        ret->scsi_stat = ds.ds_status;
                   3421:        ret->scsi_msg = ds.ds_msg;
                   3422:        ret->reg1 = ret->reg2 = 0;
                   3423:        if(nret >= 0){
                   3424:                if(ds.ds_datasent != nret){
                   3425:                        if(ds.ds_datasent == 0)
                   3426:                                retv = 1;
                   3427:                        else
                   3428:                                sprintf(err, "data transfer error; wanted %d, got %d", nret, ds.ds_datasent);
                   3429:                        goto err_ret;
                   3430:                }
                   3431:        } else {
                   3432:                ret->nread = ds.ds_datasent;
                   3433:        }
                   3434:        if(!preserve){
                   3435:                close(fd);
                   3436:                fd = -1;
                   3437:        }
                   3438:        return(0);
                   3439: }
                   3440: 
                   3441: static char *smsg[16] =
                   3442: {
                   3443:        "good", "check condition", "met/good", "reserved",
                   3444:        "busy", "reserved", "reserved", "reserved",
                   3445:        "intermediate good", "reserved", "intermediate good/met", "reserved",
                   3446:        "reservation conflict", "reserved", "reserved", "reserved",
                   3447: };
                   3448: 
                   3449: s_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err)
                   3450: {
                   3451:        int n;
                   3452:        int status;
                   3453:        char buf[512];
                   3454:        char ioerr[512];
                   3455: 
                   3456:        cmd->bus_id = s_id;
                   3457:        if(n = ss_io(preserve, cmd, ncmd, ret, nret, err)){
                   3458:                if(n < 0)
                   3459:                        return(n);
                   3460:                strcpy(ioerr, err);
                   3461:                err[0] = 0;
                   3462:        } else
                   3463:                ioerr[0] = 0;
                   3464:        if(status = ret->scsi_stat){
                   3465:                (*ss_extsense)(ret->data, buf, sizeof buf);
                   3466:                sprintf(err, "%s; %s", ioerr[0]? ioerr : smsg[(status>>1)&0xF], buf);
                   3467:                return(1);
                   3468:        }
                   3469:        return(0);
                   3470: }
                   3471: 0707070035050450501006660011710000040000010576220464700551700001400000004236scsi/h_io.c#include       <stdio.h>
                   3472: #include       "../scsi.h"
                   3473: #include       "../scsish.h"
                   3474: #include       <scsi.h>
                   3475: 
                   3476: #define                DEV             "/dev/scsi"
                   3477: 
                   3478: static fd = -1;
                   3479: int s_id;
                   3480: int s_ignua = 1;
                   3481: void (*ss_extsense)(uchar *, char *, int);
                   3482: 
                   3483: ss_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err)
                   3484: {
                   3485:        int n;
                   3486:        int retv;
                   3487: 
                   3488:        err[0] = 0;
                   3489:        retv = -1;
                   3490:        if(fd < 0){
                   3491:                if((fd = open(DEV, 2)) < 0){
                   3492:                        pperror(err, DEV);
                   3493:                        return(-1);
                   3494:                }
                   3495:        }
                   3496:        cmd->flags |= (ncmd == 0)? SCSI_RD:SCSI_WR;
                   3497:        if((n = write(fd, cmd, 16+ncmd)) != 16+ncmd){
                   3498:                pperror(err, "scsiio write");
                   3499: err_ret:
                   3500:                close(fd);
                   3501:                fd = -1;
                   3502:                return(retv);
                   3503:        }
                   3504:        if(nret >= 0){
                   3505:                if((n = read(fd, ret, 36+nret)) != 36+nret){
                   3506:                        if(n == 36)
                   3507:                                retv = 1;
                   3508:                        else
                   3509:                                pperror(err, "scsiio read");
                   3510:                        goto err_ret;
                   3511:                }
                   3512:        } else {
                   3513:                if((n = read(fd, ret, 36-nret)) < 0){
                   3514:                        pperror(err, "scsiio read");
                   3515:                        goto err_ret;
                   3516:                }
                   3517:                ret->nread = n-36;
                   3518:        }
                   3519:        if(!preserve){
                   3520:                close(fd);
                   3521:                fd = -1;
                   3522:        }
                   3523:        return(0);
                   3524: }
                   3525: 
                   3526: static char *smsg[16] =
                   3527: {
                   3528:        "good", "check condition", "met/good", "reserved",
                   3529:        "busy", "reserved", "reserved", "reserved",
                   3530:        "intermediate good", "reserved", "intermediate good/met", "reserved",
                   3531:        "reservation conflict", "reserved", "reserved", "reserved",
                   3532: };
                   3533: 
                   3534: s_io(int preserve, struct scsi_cmd *cmd, int ncmd, struct scsi_return *ret, int nret, char *err)
                   3535: {
                   3536:        int n;
                   3537:        int status;
                   3538:        char buf[512];
                   3539:        char ioerr[512];
                   3540:        struct scsi_cmd mycmd;
                   3541:        int ignoredua = 0;
                   3542: 
                   3543:        cmd->bus_id = s_id;
                   3544: again:
                   3545:        if(n = ss_io(preserve, cmd, ncmd, ret, nret, err)){
                   3546:                if(n < 0)
                   3547:                        return(n);
                   3548:                strcpy(ioerr, err);
                   3549:                err[0] = 0;
                   3550:        } else
                   3551:                ioerr[0] = 0;
                   3552:        if(status = ret->scsi_stat){
                   3553:                set6(mycmd, 0x03, cmd->cmd[1]&0xE0, 0, 0, 100, 0);
                   3554:                if(n = ss_io(0, &mycmd, 0, ret, -100, err))
                   3555:                        return(n);
                   3556:                if(s_ignua){    /* ignore unit attention ?? */
                   3557:                        if((ret->data[2]&0xF) == 6){    /* it is */
                   3558:                                if(ignoredua++ == 0){   /* but only ignore once */
                   3559:                                        set6(mycmd, 0x12, cmd->cmd[1]&0xE0, 0, 0, 5, 0);
                   3560:                                        if(n = ss_io(0, &mycmd, 0, ret, 5, err))
                   3561:                                                return(n);
                   3562:                                        goto again;
                   3563:                                }
                   3564:                        }
                   3565:                }
                   3566:                if(ss_extsense == 0)
                   3567:                        ss_extsense = gen_extsense;
                   3568:                (*ss_extsense)(ret->data, buf, sizeof buf);
                   3569:                sprintf(err, "%s; %s", ioerr[0]? ioerr : smsg[(status>>1)&0xF], buf);
                   3570:                return(1);
                   3571:        }
                   3572:        return(0);
                   3573: }
                   3574: 0707070035050517141007550011710000040000010255710464677445500001400000000251scsi/gendevawk 'END { for(t = 1; t < 8; t++) for(l=0; l < 8; l++){
                   3575:                printf "/etc/mknod sc0d%dl%d c 43 %d\n", t, l, l*8+t
                   3576:                }
                   3577:                print "chmod 600 *; chown andrew *"
                   3578:        }' < /dev/null
                   3579: 0707070035050446171006660011710000040000011470230464700536700000700000003041scsi.htypedef unsigned char uchar;
                   3580: 
                   3581: struct scsi_cmd
                   3582: {
                   3583:        unsigned long id;
                   3584:        uchar bus_id;           /* SCSI id of destination device */
                   3585:        uchar flags;
                   3586:        uchar cmd[10];          /* SCSI command */
                   3587:        uchar data[4096];       /* optional data */
                   3588: };
                   3589: 
                   3590: struct scsi_return
                   3591: {
                   3592:        unsigned long id;
                   3593:        uchar scsi_stat;        /* scsi status byte */
                   3594:        uchar scsi_msg;         /* scsi message byte */
                   3595:        uchar flags;
                   3596:        uchar type;             /* 1=td 2=us */
                   3597:        unsigned short reg1;    /* td=sa, us=per */
                   3598:        unsigned short reg2;    /* td=mscp, us=per */
                   3599:        unsigned char sense[22];
                   3600:        char pad[2];
                   3601:        uchar data[4096];       /* any data */
                   3602:        uchar nread;            /* chars read(-8) if ret count was -ve */
                   3603: };
                   3604: 
                   3605: #define        set6(x,a,b,c,d,e,f)     (x).flags=0,(x).cmd[0]=(a),(x).cmd[1]=(b),(x).cmd[2]=(c),\
                   3606:        (x).cmd[3]=(d),(x).cmd[4]=(e),(x).cmd[5]=(f)
                   3607: #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),\
                   3608:        (x).cmd[3]=(d),(x).cmd[4]=(e),(x).cmd[5]=(f),(x).cmd[6]=(g),(x).cmd[7]=(h),\
                   3609:        (x).cmd[8]=(i),(x).cmd[9]=(j)
                   3610: #define        setdiag(x,lun,n)        (x).flags=0,(x).cmd[0]=0x1C,(x).cmd[1]=(lun)<<5,(x).cmd[2] = 0,\
                   3611:        (x).cmd[3]=(n)>>8,(x).cmd[4]=(n),(x).cmd[5]=0
                   3612: 
                   3613: extern s_io(int, struct scsi_cmd *, int, struct scsi_return *, int, char *);/* return 0 on no error, does sense on error */
                   3614: extern ss_io(int, struct scsi_cmd *, int, struct scsi_return *, int, char *);/* return 0 on no error */
                   3615: extern int s_ignua;    /* should s_io ignore unit attentions? */
                   3616: extern void (*ss_extsense)(uchar *, char *, int);
                   3617: extern int s_start(int, char *);
                   3618: extern int s_stop(int, char *);
                   3619: extern int s_eject(int, char *);
                   3620: extern int s_id;
                   3621: extern unsigned long longat(uchar *);
                   3622: 0707070035050454001007770011710000040000011461060464700562400000700000435026scsish&�0�+T&�^Юn��P�P�Հ��P��p�P��P�؟��
�P�&�&�~�����o���&������M��  ����[��~�[�[�����ڋ��(��&��~�&� ��@^Ь[���&廓����&�7��[ݏ�� ������P�&�
                   3623: �� ���͐�PZ�jݏd��p��� ���Q��PX�X&�������p���&�PV��p����������e�������WЦZ�&Y�YX���P�P�I�P�L"�P�S[k�I�p��&�Hu��U�PE� �T�I�p��&�1u��U�PE� ��G���G��0�G����p���V�����M����U����I�p�E���j?�Z�Y�Y����j��&U
                   3624: �U?�Z��YX�&�������j�&��������������1�Z�X�Y��p������ݦ�����������D���������������� ��W���P�����f��G��A������Ь[ЬZի$�k�&�֏�P�Z�k����P�[P�[��P�^ԭ����U"ХUݬ�U������P��
                   3625: �����ݬ���������P��Џ���Э�PЬ�Ȝ��œUХ�i��Ь[ЬZЬY�YթЩV�V�VW�ZHݫ�k��K����ЫX,�h(�W�h�W��   ����Pݨ���ﳈ�X��P9ЫX/�h+�Z�h��!��Pݨ�k���&����&P �X��P���&�~լ�[м[�[�����0����P�P$��ڛլ�[м[�[�﹜������PЬ[լ-�者      ����Y�Y�Y��=&������(&�k��_��P2��&&�&�‡Џ�Z�j`�jUݥ�e�����Z�Џ�Z�jݺ�k����P�Z��j�j�&�<����k��~��������PЬ[�[�[�[��>�������[�s��^Џ`��߭��&߭��~������sony%d is an invalid target
                   3626: device '%s' unknown
                   3627:       %s(%s)
                   3628: available devices:
                   3629: ?dev=%s
                   3630: (%s) %s
                   3631:       %s
                   3632: device %s(%s):
                   3633: error in '%s': %s
                   3634: device %s: %s
                   3635: param mismatch: %s: i=%d/n=%d param='%s'
                   3636: %s: lun %d out of range
                   3637: can't find cmd '%s'
                   3638: > dev=%s, target=%d:
                   3639: լ��7�����ޅ
                   3640: ݼ�&�~����Pcurrent SCSI id = %d
                   3641: generic scsitestunit [lun=0testunitstop [lun=0]stopstart [lun=0]startsense [lun=0]senseI?I?I?I?I?I?I?I?I?I?scsi bytes... # 6 or 10scsiresetIL?readt count [lun=0]readtinq [lun=0]inqid [target=0]idhelp [cmd]helpS?dev [type]devdisplayL?capacity [lun=0]capacity�8!^Ь[ЬZЬY�[�[�[�[Kj�[��X�X[�&�������xHjU�U���������$�������Yݏ���������~�����~���e�PW    �WP������U�Eﲘ����Ux��UU�E�Hj��8������߃����U�Uz�����������xk�������ﳃ����U�U N�����������Lk������g�����U�U$"���������� k������3��[�����~����I��X������P [%d bytes]
                   3642:  rev=%s/%s %sinq(%d,%d): %s %s;cd-romwormprocessorprintersequential accessdirect accessremovablenonremovable< ^լԼ�������x�U�U���������������ݬ�~�����~�����~��2d�P�������P�P< ^լԼ�������x�U�U���������&������ݬ�~�����~�����~���c�P�������P�P< ^լԼ����%���x�U�U���������������������������ݬ������~�����~��bc�P�������P<�����&�i�P[�����&�i�PZ�Z�[�Z�[ݼ�������P��Pcapacity(%d,%d): %ld blocks of %ld bytes (#%xx#%x)
                   3643: h!^Ь[�X��O�͘���F���@��&���&�&�ހ�����������������������[�~�����~�����~��ub�P�6&��m&�&�#&�Z�Z�&�������xZU�U���������$�������[ݏ���������~�����~��
b�PY     �YX������U�U��d���������g�����d������U�U ����������g�������Y�����U�U�͜�������rg����d���+��͜������dߚ���U�E�?�����Ux��UU�E�&��Z��*��s�Z���������e����͘����XP  lun(%d): %s %s, %s/%s rev=%s
                   3644: ??responded to test unit ready
                   3645: target %d:
                   3646: 8 ^�����������������������%�������U�0U���ݬ�~�����~�����~��_�P< ^լԼ�������x�U�U���������������ݬ�~�����~�����~��/`�P�������Pݼ�������A~�P(%d,%d): good status
                   3647: < ^ЬU�U
                   3648: U�U
                   3649: �Ѭ�������ЬU�����ЬU�����ЬU�����ЬU�����ЬU�����~������ЬU�����ЬU�����ЬU�����ЬU�����ЬU�����ЬU�����ЬU�����ЬU�� ���ЬU��$���ݬ��:ݬ��ā�&P(ݬ�~�����~�����~���^�P�������P�Pnumber of bytes (%d) must be 6 or 10
                   3650: �X ^Ь[ЬZѬ&ԫ����%���x�U�U����������������������������Z������~�����~��R^�PV    �VP�&�����&�d�P͸������&�od�P�����������ݏ��C��Pʹ��&ʹ��ʹ�X�����&�������&�|�k͸�~�&�?~�&PY�����X�Y�kݫ��D���5&���{��I��&�zs�����&ᅡ�kW�Wu����(���x�U�U���x��YU�U���x��YU�U���x��YU�U���Y���������X�������Z����X~�����~�����~��3]�PV�VP}�XY�XW��ͼ��&�8�����UnUͬ�
nUTa�]Tͬ�����ͼ��&ͨ�
                   3651: ����ͼ�ͨ�NkUvͬ�TDTUVUTf�#Tnͨ�RgRT~����ͼ�~�����z�P�E�P t=%ds (%.0fKB/s)
                   3652: read(%d,%d): %d blocks @%d (chunk=%dx%d),Sony WDA-3000sonystatusSLset shelfside lunsetsense [lun=0]senseLS?rel lun [shelfside]relLI?readid lun [start]readidLIIS?media lun start count [file]mediaII?internal test [drive]  # internal -1 for listinternalinq [lun]inqLeject lunejectdiskid [lun]diskidLIILIcopy srclun start n destlun destcopyconfigL?alternate [lun]alternate�D ^Ь[ЬZЬY�[�[�[�[Kj�[��X�X[�o&�������xHjU�U����������������Y������~�����~��~Z�PW �WP�(&�Hj�����&��x����Uʏ���U ����Uˏ���U~��V&��hx������Uʏ����U ����Uˏ���U~��&��:x�����Uˏ���U~����Uʏ����U   Џ�VЏ�V�V����Uʏ����UЏ����      Џ������ߚ���Uʏ����UЏ���   Џ������ߚ���Uʏ����UЏͼ�   Џͼ��ͼ���T��w�X�����Pnot readyreadydrive errorno alternatewritablewrite protect%s,%s,%s,%s (0x%x)
                   3653: empty (0x%x)
                   3654: power off (0x%x)
                   3655: inq(%d,%d): Ь[��Y�Yݬݬ��,��� &���v�[�Z�ZYH�
                   3656: Z~�
                   3657: nÎZU�U        �
                   3658: X� X�X�kU��&TxTT�TU��TxTT�TU~�����v�[�Z��
                   3659: Z~�
                   3660: nÎZU-�Y)��ί��ʯU��ï�
                   3661: e�ﴯ�
                   3662: ���l< ^Ь[լ�k���ߐ�����xkU�U��ߔ��ߔ��ߔ��ߔ���ݬݏ�����~�����~��W�P�������P"�Z�Zx
                   3663: ZU�E���ߪ&�k�������Z��P%ld%c(%d,%d): alternate table %d (%d entries)
                   3664: <"^���ߐ��ߔ��ߔ��ߔ��ߐ,��ߔ���ݬ�,�����~�����~��W�P�������P�/&���!�~���t�P[�����������\>KﳎU�e1       Џ�ZЏ�Z�Z>KU�e~>KU�e1       Џ�YЏ�Y�Y>K�i�U�e~���ݚ���U�U      Џ�XЏ�X�X�~������&�       �t����U�E�0������{t���&�nt��"�U�U����"�~����Nt��$�U�U����$�~��O��.t��'�~��&�~�� �~��
��t�P IF-129=0x%x, SY-46=0x%x, SS-30=0x%x
                   3665:  lower controller=0x%x, upper controller=0x%x,      ROMS:  Unibus-SCSI controller=%s
                   3666: sUnknownWORMconfig(%d,%d): %s device, '%s', %c controller%s, %c drive%s
                   3667: U.S. Design 1158T.D. Systems Vikingno doardЬ[��q�&�sˏ���[Uxˏ����[U  Џ�ZЏ�Z�Z��:���rˏ����[U
���&�rˏ����[U
����&�rˏ����[U$ˏ����[~����r
���&�vr��u�&�ir^����������������
                   3668: ���������&����������������        �ݬ�~ݬ�
                   3669: �����~���S�P[�[PF����������������������ݬݏ�ݬ�~�����~��S�P[�[P�P�,^ݬ������/����P�������P�m���[�Z�Z�&�kUʏ���U  Џ1XЏ.X�X�kUʏ����U   Џ>WЏ5W�W�kUʏ����U   Џ>VЏ9V�V�Z�����
                   3670: q�kUʏ����U���&Uʏ���US��&Uˏ����U~�����p��Uʏ���UV��Uˏ����UT��~ʏ����U�U~��F��p)��&Uˏ����UT�Tʏ����Uߥa�T~����op��n�&�bp�Z�[������Z�Z2_�ZY�&ZU�UZ�U2�[ZU�eU�[YT�dT�UT��&YU�ZU�Y��&��p�&Z~�Y��&��&p�[YU�e~�&�������2[��_&�&��o�k~�&�����[��<&�&��o�kUˏ����UZ�kUʏ���U �Zˏ����ZUߥa�Z~�����o
����&�o�[�kUʏ���U�kUˏ����U~����^o
��s�&�Oo�[�kUʏ���U�kUˏ����U~��2��)o
��
�&�o�Plower drive: no disk
                   3671: lower drive: disk, LUN=%d
                   3672: upper drive: no disk
                   3673: upper drive: disk, LUN=%d
                   3674: no disk
                   3675: disk shelf=%d%c (%d)
                   3676: carrier: I/O shelf%d-%d%ddisk in shelf %d%c (%d)ab, return shelf %d%cdisk in drive %donoffno not drive %d: %sready,%sdisk in LUN,power %s,
                   3677: no diskuse shelf instead of drive for LUN %dwait ejection,wait loading,temporarydisk%s,: < ^�������x�U�U���������������ݬ�~�����~�����~��O�P�������P�PD ^լ
                   3678: ���������&���ݬݼ����P����&PR�������x�U����U������������������ݬ�~�ͼ��~�����~��N�P�������P�P@ ^ݬݼ��^�P����&PO�������x�U�U������������������ݬ�~�����~�����~��N�P�������P�P�^Ь[�[���kU�U0�U9ݭ���]ݬ��pЏ����PH�Z�kU�U0�U9�Z
                   3679: U��T�TU�0UZ�>J����Z�k�a   �k�b��&Z�&[U�U[�e��ZPshelfside '%s' must be numa or numb< ^լԼ�������x�U�U���������������ݬݏ�����~�����~��M�P�������P/ݼ���"��'k�ݏ������PS�P(%d,%d) disk id block:
                   3680: ^Ь[ЬZ���������������
                   3681: ������[��x���U�U�&����������������  �ݬ�~ݬ�
                   3682: �����~��FL�P[�[PG�������������x��ZU�U���Z������ݬ�Zݬ�~�����~��&L�P[�[P�PL ^мY�Y�������Y��I�Ue�"�"J#�#�$E%�'��       �&��i�Z�J�z��`�J�k��Z�����i�Z�ݬ����ݏ&�~ݏ�������P     �&P�мU�E�$�����ci��F�&�Vi�Z����[�Z����~��~��&U�E�i��k~����!i�Z�[�ݬ����ݏ&�~ݏ���
                   3683: ����P �&P�мU�E�����h��Q�&��h�Z����[�Z�\��U�E����~��U�E�؆��&U�E�͒�kU�E�Î�����~h�Z�[�мU�E� �����_h�。�&��_�����&�3oݬ������~ݏ���;����P  �&P���ͼ��&�o����[�kU��M�&�h��~��&~�k~�����g����ͼ�~������g�mмU�E�t�����g����&�B_�����&�nݬ������~ݏ�������P     �&P��ͼ��&�Wn����[�kU���&�Tg��~��&~�k~��d��:g����ͼ�~��@��%g��Ѭ&ЬUԥЬUХ���ݬ����������P        �&P���`�Uʏ���U��`�Uʏ����U����UЏ&͸�L��a�Uʏ���U��a�Uʏ����U����UЏ͸� ������v������B`�&P�мU�E���͸ߏ  Џ7*YЏ3*Y�Y��������<f��&��]�����&�mݬ����ݏ&�͸��������P        �&P��ͼ��&��l����[��&Uʏ���U����&��e��&Uʏ����U��k�&�e���&Uʏ����U
��9�&�e��&Uʏ����U
���&�ye��&Uʏ����U
����&�_e��~����Ne��&Uʏ����U�E�
                   3684: ����-e����ͼ�~��3��e�Z�Z
                   3685: 7~J����U����U�U�[U�eU�E�,��J��~�Z��!���d�Z����&�&��d��h[�Z�Z%�kU��&TxTT�TU~�Z��&��d�Z�[���&�&�d�)&���ߐ����ߔ��ߔ��ߔ��ߔ��ߔ��ߔ��ߔ��ߔ��ߔ���ݬ������~�����~��F�Pʹ��ʹ�P��мU�E��}��&��d����[� ��U��TxTT�TU~��~��~���������c� ��     U��TxTT�TU~��
                   3686: ~��~������c� ��
U��TxTT�TU~��~��~��U��s��c��U��TxTT�TU~��U��TxTT�TU~��
��^c�Pbackup mem(0/%d/%d)
                   3687: sys controllower driveupper drive%s(%d/%d/%d)%c%s: component(fatal err/err/cmds)
                   3688: 
                   3689:  %d:%ddiagnostic count (drive:avail):test %d[%s]: %s
                   3690: diagnostic not performed: %s (last error code 0x%2.2ux) disk-fault drive-fault controller-fault no faultsdiagnostic result:upplowdrive %d[%ser]: %s
                   3691: drive %d not occupied
                   3692: internal 3 (%s):
                   3693:  (time: %lds)
                   3694:       failed, error codes=#%x, #%x, #%x      ended normallyinternal 2 (%s):
                   3695: %s[%s]: %s[#%x] (%s)
                   3696: Diagnostic #E4: last 16 errors; initiator[identify] error[sense] (cmd)
                   3697: internal 1 (%s):
                   3698: [%d] %s (%d,%d)
                   3699: Diagnostic #E5: last 16 internal tasks (drive,shelf)
                   3700: internal 0 (%s):
                   3701:       internal %d: %s
                   3702: available internal commands:
                   3703: read data compareECC margin checkwritesearch writable areawritten sector searchblank sector searchseekmoveread disk iddrive on/offurk 15urk 14urk 13urk 12urk 11urk 10urk 9urk 8urk 7urk 6urk 5urk 4diagnostic aborted: write area fulldiagnostic aborted: write-protectdrive connected but no diskdrive not connected or powered offjukebox statusdrive controller diagnosticsscsi control board diagnosticsarm controller diagnosticserror information tableinternal command table^Ь[ЬZ�������x[U�U���������
                   3704: ������
                   3705: ��լ�X�&X�X�&�����[��Z��x��ZU�U��x��ZU�U�����      �ݬ�~ݬ�
                   3706: �����~���?�PY�YPJ�������x[U�U������&���������ݬݏ&ݬ�~�����~��?�PY�YP�P�P^Ь[ЬZ�k���Ыͼ�Ы͸������XѬ&E��Kݼ��c�P�&���*��.ݼ��       V�PXݼ�Z��D�&P�~�Z�����������P   �&P�d��`�Uʏ���U��`�Uʏ����U����U����D��a�Uʏ���U��a�Uʏ����U����U�&���������v�Z��Sa�&P�������������Џ�5ʹ�  Џ�5ʹ��ʹ��ͼ�U�͸�T�TUS�&S~�U�T�����\�Xݼ����k\��ɕ��ŕU�ユ�
                   3707: e�ﯕ�
                   3708: ���R�����W�W�&*�W��Q������`�����&�b�PG���W�Џ�5�ԿЏu5���Џ[5���ЏA5��Џ'5��Џ5��Џ5��Џ�4��Џ�4��Џ�4�}�Џ�4�v�Џ&VЏ������������W�W�&�G�@��W��ͼ�W�͸��������&�&�Z���������W����������P   �&P�J����Y����U�YU���X"�hШU֨�ie�X�i~��~Q��iU�UV��YWU����T�TUͰ�����d����^����U�U�F�UͰ�~�����Z�&���U�U����U-����������ܓU��Փ�
                   3709: e��Ɠ�
                   3710: ���P�iV�Ͱ���U�E�%��)���&�����&W����������&�Z���������W������^����P  �&P�(����Y�������X"�hШU֨�ie�X�i~��`P��iU�UV��YWU����T�TUͰ�����d����^����U�U�F�k��UͰ�~��&��xY�&���U�U����U-������’�メU�﷒�
                   3711: e�晴�
                   3712: ���O�iV�Ͱ���U�E�������)����X$�hШU֨�e�Xݏ&��O��V�&��YWU����T�TUͰ�����d����^����U�U�F�UͰ�~�����X�&���U�U����U-�����������U����
                   3713: e��ڑ�
                   3714: ��OЏ&V�Ͱ��������)�﷑�ﳑU�﬑�
                   3715: e��
                   3716: ���N��d�&�#X��������&4����U�E�� ����U�E�ڻ�E�ӿ�����W�������
                   3717: �&��W�P
                   3718: %d %s,       %d %s@%d, uncorrectable (alternated)>96% burst (alternated)50-96% burst (alternated)<50% burstread error 3 (alternated)unwrittenread error 1 (alternated)seek error 3 (alternated)seek error 2 (alternated)seek error 1 (alternated)goodrare error 0x%x stored in '%s'upperlowermedia margin check for %d blocks [%d-%d] on %s drive (%d,%d):drive %d not occupied and ready
                   3719: w-v^Ь[��y�������(���x�U�U���x��[U�U���x��[U�U���x��[U�U���[���������&������ݬݏݬ�~�����~��,6�P�������P��^Ь[мX�W��X�ѬЬUХZ"�ZZ�&W�[�����~�X��<����Pp�&ZЏ����Y�W�Z����YU�[�����Z�X������P
                   3720: �ZY�� �Z��Y�Z��k��%U�&PN�[�����Y�X�������P�&P4ݏ���&���X���[������X��X��-������T�P(%d,%d): '%s'
                   3721: read(blk=%d) failed
                   3722: %d: �T^Ь[ЬZ�k��ЫYЫ��Ы��Ы����—���ﺗ��Э�Ͱ�Э�UЭ�T�TUS�&S~�Uݭ�ݭ��TYU�&U~�Yݭ�ݭ���U� �1T�Z�ʹ�������P   �&P�P��<�Uʏ���U��<�Uʏ����Uѭ�Uԭ�A��=�Uʏ���U��=�Uʏ����Uѭ�U�&��ݭ�����Z��:X�&P��&�&�
��&���&����&�u��ͬ��&�vZЏ������խ��E&ݭ�ݏ&��S�PVy�Z�&�V�Yݭ�ݭ���s�PX�X[�XY�X���X���XVIǏ'YU�U���Ǐ'Y��߭��&��Y߭��&��=�Pŭ��'~������R�r���ݭ�ݏ&��R�PV�L����Z�~�V�Yݭ�ݭ����&�PW�W�*����Zݭ�ݭ�ݭ��W�Yݭ�ݭ�����P�����WY�W���W��Ǐ'YU�U���Ǐ'Y��߭��&�FY߭��&�,=�Pŭ��'~��.��8R�I���߭��&�Y�ͬ��խ��&��ݭ����&��     Rխ�ݭ�ݭ��Y��&���Q�&P#�Ͱ�UNUTN��SFSTVT~�U��t&���Q�P8 ^Ь[ЬZЬY�������x�U�U������������������&�����x�U��U��x�U��U������x��ZU�U��x��ZU�U�      �x��ZU�U�
                   3723: �Z��x��[U�U��x��[U�U�
�x��[U�U��[��x��YU�U��x��YU�U��x��YU�U��Y��ݬ �~����������~��2(^Ь[��Z�[�Pc�[�&Џ&[ݬ����ݬݬݬ�������P       Џ����P/����Y�[U�[�U�iU��D�U�ZT�UT�Y�����U�UYP%d blocks at %.1fKB/s
                   3724: copy buggered up: sbase=%d nblks=%d dbase=%d
                   3725: %ds:         doing block %ld at %sdrive %d not occupied
                   3726: copying drive (%d,%d)[%d-%d] to drive (%d,%d)[%d-%d]
                   3727: <#ff><#fe><#fd><#fc><#fb><#fa><#f9><#f8><#f7><#f6><#f5><#f4><#f3><#f2><#f1><#f0><#ef><#ee><#ed><#ec><#eb><#ea><#e9><#e8><#e7><#e6><#e5><#e4><#e3><#e2><#e1><#e0><#df><#de><#dd><#dc><#db><#da><#d9><#d8><#d7><#d6><#d5><#d4><#d3><#d2><#d1><#d0><#cf><#ce><#cd><#cc><#cb><#ca><#c9><#c8><#c7><#c6><#c5><#c4><#c3><#c2><#c1><#c0><#bf><#be><#bd><#bc><#bb><#ba><#b9><#b8><#b7><#b6><#b5><#b4>disk rotatedisk releasedisk set<#b0><#af><#ae><#ad><#ac><#ab><#aa><#a9><#a8><#a7><#a6><#a5><#a4><#a3>carrier movedisk check<#a0><#9f><#9e><#9d><#9c><#9b><#9a><#99><#98><#97><#96><#95><#94><#93><#92><#91><#90><#8f><#8e><#8d><#8c><#8b><#8a><#89><#88><#87><#86><#85><#84><#83><#82><#81><#80><#7f><#7e><#7d><#7c><#7b><#7a><#79><#78><#77><#76><#75><#74><#73><#72><#71><#70><#6f><#6e><#6d><#6c><#6b><#6a><#69><#68><#67><#66><#65><#64><#63><#62><#61><#60><#5f><#5e><#5d><#5c><#5b><#5a><#59><#58><#57><#56><#55><#54><#53><#52><#51><#50><#4f><#4e><#4d><#4c><#4b><#4a><#49><#48><#47><#46><#45><#44><#43><#42><#41><#40><#3f><#3e><#3d><#3c><#3b><#3a><#39><#38><#37><#36><#35><#34><#33>readmoveseek<#2f><#2e><#2d><#2c><#2b><#2a><#29><#28><#27><#26><#25>disk outdrive offdrive onrecalibratesense drive status<#1f><#1e><#1d><#1c><#1b><#1a><#19>diagnostics<#17><#16><#15><#14><#13><#12><#11><#10><#f><#e><#d><#c><#b>error margin check<#9>sense alternate information<#7><#6><#5>recover disk warning<#3>version checksense resultnop<#ff><#fe><#fd><#fc><#fb><#fa><#f9><#f8><#f7><#f6><#f5><#f4><#f3><#f2><#f1><#f0><#ef><#ee><#ed><#ec><#eb><#ea><#e9><#e8><#e7><#e6><#e5><#e4><#e3><#e2><#e1><#e0><#df><#de><#dd><#dc><#db><#da><#d9><#d8><#d7><#d6><#d5><#d4><#d3><#d2><#d1><#d0><#cf><#ce><#cd><#cc><#cb><#ca><#c9><#c8><#c7><#c6><#c5><#c4><#c3><#c2><#c1><#c0><#bf><#be><#bd><#bc><#bb><#ba><#b9><#b8><#b7><#b6><#b5><#b4><#b3><#b2><#b1><#b0><#af><#ae><#ad>no disk in LUNreservedmedium removal preventeddrive not readyunit attentionunacceptable diagnostics parameterillegal parameterillegal parameter lengthillegal shelf numberillegal logical addressreserved bit nonzeroinvalid LUNinvalid command<#9f><#9e><#9d><#9c><#9b><#9a><#99><#98><#97><#96><#95>drive error (SONY)<#93><#92><#91><#90><#8f><#8e><#8d><#8c><#8b><#8a><#89><#88><#87><#86><#85><#84><#83><#82><#81><#80><#7f><#7e><#7d><#7c><#7b><#7a><#79><#78><#77><#76><#75><#74><#73><#72><#71><#70><#6f><#6e><#6d><#6c><#6b><#6a><#69><#68><#67><#66><#65><#64><#63><#62><#61><#60><#5f><#5e><#5d><#5c><#5b><#5a><#59><#58><#57><#56><#55><#54><#53><#52><#51><#50><#4f><#4e><#4d><#4c><#4b><#4a><#49><#48><#47><#46><#45><#44><#43><#42><#41><#40><#3f><#3e><#3d><#3c><#3b><#3a><#39><#38><#37><#36><#35><#34><#33><#32><#31><#30><#2f><#2e><#2d><#2c><#2b><#2a><#29><#28><#27><#26><#25><#24><#23><#22><#21><#20><#1f><#1e><#1d><#1c><#1b><#1a><#19><#18><#17><#16><#15><#14><#13><#12><#11><#10><#f><#e><#d><#c><#b><#a><#9><#8><#7><#6><#5><#4><#3><#2><#1><#0>not connected or power offdrive not ready (no disk)diagnostic could not be donetest not donegooddis/reconnect-LUN 7dis/reconnect-LUN 6dis/reconnect-LUN 5dis/reconnect-LUN 4dis/reconnect-LUN 3dis/reconnect-LUN 2dis/reconnect-LUN 1dis/reconnect-LUN 0no dis/reconnect-LUN 7no dis/reconnect-LUN 6no dis/reconnect-LUN 5no dis/reconnect-LUN 4no dis/reconnect-LUN 3no dis/reconnect-LUN 2no dis/reconnect-LUN 1no dis/reconnect-LUN 0<#d7><#d6><#d3><#c4><#c3><#c2><#c0>7<#2d><#2c><#2a><#28><#25><#1e><#1d><#1c><#1b><#1a><#18><#17><#16><#15><#12><#c><#b><#a><#8><#3>1<#1><#0><#ff><#fe><#fd><#fc><#fb><#fa><#f9><#f8><#f7><#f6><#f5><#f4><#f3><#f2><#f1><#f0><#ef><#ee><#ed><#ec><#eb><#ea><#e9><#e8><#e7><#e6><#e5><#e4><#e3><#e2><#e1><#e0><#df><#de><#dd><#dc><#db><#da><#d9><#d8>disk releasedisk set<#d5><#d4>request recovered status<#d2><#d1><#d0><#cf><#ce><#cd><#cc><#cb><#ca><#c9><#c8><#c7><#c6><#c5>recover disk warningsense alternate informationread disk id<#c1>disk eject<#bf><#be><#bd><#bc><#bb><#ba><#b9><#b8><#b7><#b6><#b5><#b4><#b3><#b2><#b1><#b0><#af><#ae><#ad><#ac><#ab><#aa><#a9><#a8><#a7><#a6><#a5><#a4><#a3><#a2><#a1><#a0><#9f><#9e><#9d><#9c><#9b><#9a><#99><#98><#97><#96><#95><#94><#93><#92><#91><#90><#8f><#8e><#8d><#8c><#8b><#8a><#89><#88><#87><#86><#85><#84><#83><#82><#81><#80><#7f><#7e><#7d><#7c><#7b><#7a><#79><#78><#77><#76><#75><#74><#73><#72><#71><#70><#6f><#6e><#6d><#6c><#6b><#6a><#69><#68><#67><#66><#65><#64><#63><#62><#61><#60><#5f><#5e><#5d><#5c><#5b><#5a><#59><#58><#57><#56><#55><#54><#53><#52><#51><#50><#4f><#4e><#4d><#4c><#4b><#4a><#49><#48><#47><#46><#45><#44><#43><#42><#41><#40><#3f><#3e><#3d><#3c><#3b><#3a><#39><#38><#37><#36><#35><#34><#33><#32><#31><#30><#2f><#2e>written sector searchblank sector search<#2b><#29><#27><#26>read capacity<#24><#23><#22><#21><#20><#1f>prevent/allow medium removalsend diagnosticsreceive diagnosticsstart/stop unitmode sense<#19>copyreleasereservemode select<#14><#13>inquiry<#11><#10><#f><#e><#d>moveseekwrite<#9>read<#7><#6><#5><#4>request sense<#2>rezero unittest unit ready<0^լԼ�������x�U�U��������� ������ݬݏ���������~�����~����P�������P>ݼ��H|������8ݏ��������������������8�P^��ЬU��[�[�[&!�[I�[
                   3728: .B���&ݬ��=�X&��^ݬ���<�B&��Hݬ���<�,&ЬU��U�UЬU��~��F&�U��<ЬU��Uʏ����U�E�j��&�����<���ݬ��#=ЬU��Uʏ���U>ЬU��T��
                   3729: SxSS�ST��     UxUU�UT~�������B<���ݬ���<ЬU��U�E��i��}�����<���ݬ��<��Uʏ���UIЬU��T��SxSS�ST��SxSS�ST��UxUU�UT~�������;���ݬ��P< info=#%x, ext sense: %s at addr #%xsense: %swarning: extra data is %d, not 4! no errorkey #fmiscomparevolume overflowkey #caborted commandcopy abortedkey #9blank checkdata protectunit attentionillegal requesthardware errormedium errornot readyrecovered errorno sense%s
                   3730: sense(%d,%d): <#ff><#fe><#fd><#fc><#fb><#fa><#f9><#f8><#f7><#f6><#f5><#f4><#f3><#f2><#f1><#f0><#ef><#ee><#ed><#ec><#eb><#ea><#e9><#e8><#e7><#e6><#e5><#e4><#e3><#e2><#e1><#e0><#df><#de><#dd><#dc><#db><#da><#d9><#d8><#d7><#d6><#d5><#d4><#d3><#d2><#d1><#d0><#cf><#ce><#cd><#cc><#cb><#ca><#c9><#c8><#c7><#c6><#c5><#c4><#c3><#c2><#c1><#c0><#bf><#be><#bd><#bc><#bb><#ba><#b9><#b8><#b7><#b6><#b5><#b4><#b3><#b2><#b1><#b0><#af><#ae><#ad><#ac><#ab><#aa><#a9><#a8><#a7><#a6><#a5><#a4><#a3><#a2><#a1><#a0><#9f><#9e><#9d><#9c><#9b><#9a><#99><#98><#97><#96><#95><#94><#93><#92><#91><#90><#8f><#8e><#8d><#8c><#8b><#8a><#89><#88><#87><#86><#85><#84><#83><#82><#81><#80><#7f><#7e><#7d><#7c><#7b><#7a><#79><#78><#77><#76><#75><#74><#73><#72><#71><#70>carrier errorshelf errordrive 1 errordrive 0 errori/o shelf errorhook servo errorroter servo errorz-axis servo error<#67><#66><#65><#64><#63><#62><#61>no data in specified address<#5f><#5e><#5d><#5c><#5b><#5a><#59><#58><#57><#56>tracking erroruncorrectable read errordata could not be readall address could not be readaddress block not foundspecified address not found<#4f><#4e><#4d><#4c><#4b><#4a><#49><#48>alternation troubledisk warningwrite protect error 2write protect error 1cannot read disk iddisk errorwrite errorwrite warning<#3f><#3e><#3d><#3c><#3b>disk already exists in shelfdisk already exists in drive<#37><#36><#35><#34><#33>drive not readyno disk in drivedrive power offdrive error<#2e><#2d><#2c>over laser powerunder laser powerwrite modulation troublehead lead outskew troubleslide trouiblespindle troubletracking troublefocus troubleloading troubledrive interface parity errorcommand not terminated<#1f><#1e><#1d><#1c><#1b><#1a><#19><#18><#17><#16><#15>scsi hardware/firmware errorSONY I/F II hardware/firmware errorcontroller errortime out errorecc trouible occurred<#f><#e><#d><#c><#b>copy aborted<#9>message reject errorparity errorunit attention<#5><#4>illegal requestrecovered errorinvalid commandno senseWren VIwrenIIIIImodeselect er-param er-retries read-recon write-recon cache-enablemodeselectmodesenseextinqdiag\ ^���������������`������ݬݏ`�����~�����~��j�Pͤ��ͤ�Pf�ͼ��������5�ͨ��������$�������ͨ��ͼߚ���U�E�A����Ux��UU�E��@�~��o��
�   �.,�Pinq(%d,%d): %s %s, %s/%s rev=%0.4s serial=%0.8s
                   3731: 8 ^���ߐ��ߔ���x�U�&U��ߔ��ߐ��ߔ���ݬ������~�����~��x
�P[�[Ph��
                   3732: �&�+�[�[;�K�ab��
                   3733: �Ux[&T�TT�TU  Џ>kZЏ<kZ�Z��;
                   3734: ��Y+�[����~���~���     ��>+�P< ^����������x�U�U������������ݬ������~�����~���P�������P3��    �&��*����~��X       ���*����~��-       ��*�P8 ^���ߐ��ߔ���x�U�U��ߔ��ߐ$��ߔ���ݬ�$�����~�����~��6�P[  �[P�(&���&�Q*���UxUU���T�TU~���UxUU���T�TU~���UxUU���T�TU~���UxUU���T�TU~���UxUU���T�TU~������)���UxUU���T�TU~��
                   3735: �UxUU���T�TU~���UxUU���T�TU~���UxUU��
�T�TU~��[��)��A�&�)�[�[;�K�q`���Ux[&T�TT�TU   Џ>kZЏ<kZ�Z��+��I)�[�����&�8)�P< ^����������x�U�U������ ������ݬ� �����~�����~��
                   3736: �P�������P2����~����UxUU����TxTT����S�ST�TU~��C��(�P8 ^���ߐ��ߔ���x�U�8U��ߔ��ߐ��ߔ���ݬ������~�����~��0
                   3737: �P[ �[P����&�K(�[�[;�K�T_��
                   3738: �Ux[&T�TT�TU  Џ>kZЏ<kZ�Z�����(�[���
                   3739: �Uˏ����U~��J���'���~���~��
�~���~���~������'�PЬ[��k�����'�[�~������PZ�ZPV�[�~��Q����PZ�ZPA�[�~�������PZ�ZP,�[�~��-����PZ�ZP�[�~������PZ�ZP�P8 ^Ь[ЬZ��/�&� '�kU�U�&�U�kU�U�U������&ЫU�U�&�Uݫ������&ЫU�U�&�Uݫ����&ЫU�U�&�Uݫ��[��&ЫU�U�&(�U$ի      Џ
iXЏ     iX�X����d&����&�W&��_�&���
                   3740: �&��)�kU�U�&�UЫU�U�&���U������������&�������������Z������~�����~���PY �YP�L����������%���U�U���kU�U�&        �U�k��ЫU�U�&
                   3741: �U��������������������������Z�~����������~���PY   �YP��&ЫU�U�&�UЫU�U�&���U�������������������������Z������~�����~���PY       �YP�N&����������  $ЫU�U�&
                   3742: �U����ЫU�U�&
                   3743: �U��������������������������Z�~����������~��'�PY   �YP��ЫU�U�&��U�����������8�������������Z������~�����~����PY�YPn����������)#���U�U��ի���U�U������������������������Z�~����������~��Z�PY�YP�P
                   3744: sleep(10); kill me if you disagree
                   3745: disencache %sable, write-recon=%d/256, read-recon=%d/256, er-retries=%d, er-param=%d(=#%x), changing modes to mode sense(%d,0):
                   3746:       prefetch: thr=%d max=%dx%d min=%dx%d
                   3747: , cache size=%d
                   3748: cache control:
                   3749:        WIERSVDCacheEnabledrive geometry:
                   3750:        %d cyls, %d heads
                   3751: 
                   3752:       drive type:    %d alt sec/%d alt trk per zone(=%d trks), %d alt trks per vol
                   3753:       sec=%dB, trk=%d secs, interleave=%d trk skew=%d cyl skew=%d
                   3754: format parameters:
                   3755: SoftSecHardSecRemoveSURFINS write reconnect=%d/256
                   3756:       read reconnect=%d/256,disconnect/reconnect:
                   3757: 
                   3758:        %d retries, max ecc span=%d
                   3759: ~ %s%serror recovery:
                   3760:        AWREARRETBRCEECPERDTEDCR8 ^�~�&��'�P[����������������������ݬ�~�����~�����~��k�PZ       �ZP�����������������������ݬ������~�����~��'�PZ�ZPf�~�&�6'�[P[�[����7 ����U����U��^�&� +����~����~����~����~����~����~��
                   3761: ����P  error==#%x,#%x FRU=(#%x,#%x,#%x,#%x)
                   3762:       no errors
                   3763: selftest diagnostic (%ds)
                   3764: �^Ь[��Џ��������V5���q��a�P�V��[ݬ��Џ����P�&�[        Џ@ZЏ�ZЬU��T�ZT�߫ݬ��VV��?&�P���[U�PU2���ݬ��>��,V�&� Џ�����VЭ�P�լA�$�~ݬ���U��!�P���$�U�PUZѭ�$�&�����~ݬ����ì$~ݬ��U��y!�P����Qݬ���g���ЬU�$���$լ��U�&�        Џ�����qU�P^Ь[ЬZ����ЬU��ca��Zݬ�[ݬݬݬ��b����P���"��������P�S&�Z������#�j���횫����.&�������ЬU��U�U��������d�������Zݏ�����[�~�����~�������P�������P����Tn��&Uʏ����U�U^����U�����UQ�������ЬU��U�U����������������Z��[�~�����~��q����P������������Pf��C`Џ|q�6`ݏ����߫$��"`�����������Yx�����Uʏ����U�E��SY�Y���Z��!�&P�P%s; %sreservation conflictintermediate good/metintermediate goodbusyreservedmet/goodcheck conditiongoodscsiio readscsiio write/dev/scsi< ^լԼ�������x�U�U���������������ݬ������~�����~��y����P�������P�ݼ���^���������Uʏ����U���&�l����Uˏ����U~����Uˏ����U~����Ux��UUˏ����U~��9��1����Uʏ���U+����U����TxTT�TU����TxTT�TU~���&������&�&���P�^Ь[�kUx��UUˏ����U��ѭ�d�kUʏ���U4��~��~��~��~��Uʏ����U�E�R��~ݬ��
                   3765: B��Uʏ����U�E��Q��Gݬ����kUˏ����U~ݭ���ݬ���sense: class=#%x, code=#%xextended sense: %sextended sense: %s info=#%2.2x#%2.2x#%2.2x#%2.2xreserved (#f)miscomparevolume overflowequalaborted commandcopy abortedvendor specific (#9)blank checkdata protectunit attentionillegal requesthardware errormedium errornot readyrecovered errorno sense
                   3766: , addr=0x%xerror class=0x%x, code=0x%x, sense=0x%xno error
                   3767: sense(%d,%d): ��\U   �U�Y���[ݬ��8ݬ��!���[U�E�c
                   3768: ݬ��ݬ���%s: %s%s: unknown errno %dЬ[ЬZ�kU�U 
                   3769: �Z�[�Z��[ZU������UY�Y[�iU�U �Y��[YU�U�UZ�U�[ݬ��B��ZU�eЬ[��ZxZU��T�TUZxZU��T�TUZxZU�kT�TUZ�ZP�� ^�Zլ��&ݬ� ��N�PY�Z=�Y 8�Yݬ߭����P%� ���U�&���&ݬ��(�&�Yݬ߭����W�Z��&ݬ���ЬX�[�[YO�[~�nÎ[U$ЬU�eЬUХT֥� dݬ� ��
ЬU֬�e~��Q&ݬ���[�ЬU�eЬUХT֥�
                   3770: dݬ�
                   3771: ��U
��&ݬ��q�[�[Y��[~�nÎ[U$ЬU�eЬUХT֥� dݬ� ��
�hU�U �U���~��ݬ��C��V�V       �V
                   3772: $��ݬ���"��tݬ�����_ݬ����[�S���ЬU�eЬUХT֥�
                   3773: dݬ�
                   3774: ��r�Y��YZ�����Z��
ݬ��%5.5d
                   3775: ..\t\n %c     %2.2x%5.5d*
                   3776: �^Ь[�Z�Y�kP�P �P �P+�P-�Y�[�[��
                   3777: ZP��Q�QP�0PZ�k0�k9��Y�ZP�ZP���P�^ݬ�&�
�P�&����^߭��&��2��P�<P�P���߭��&�v&�PZ����ZP1&Ъ[Џ�Y�YXЏVԭ�Э�������Wx�WWP�PP�PP��b�P�P�_�WWP�PP�PP��c�PѪPH�WWP�PP�PP2�f�Y�WWP�PP�PP2�h�X�WWP�PP�PP��d����WWP�PP�PP��e����W�W�'�1|��YX�Y���XYЭ�X�V���VV�Y�Z��R���PY�X�Z��B���PX�[Y�[Y1
                   3778: �Ѫ��[X�[X�Ѫ&��V��߭��&�T�PZ֪ 1���^Ь[ЬZ�Z:ݫ�&�lm&P�PZëZP��P���P�PQ�Q�QPQ�QZP�^Ǐ�Q&�Pď�Q&P�P���Ǐ�Q&���խ����Q&��׭����Y�<��P�<P�P����<��Z�<ZP�<P�PZ��<Z�Z���p��P�PQ�Q�QP�[�խ�DЏFZ�:�����&Zѭ���:��Z�&�&�P���Z�Z�&�&ѭ�P�:ЏFZ���:���&Zѭ��O�����&Z~�&�Q&�P���Zխ���Z��Э�[�[���Z�&�+&�P�n&��J�Z
                   3779: �J��I[�Z�[J��I����I�&[��Z�����cP�^���~[���IZ����ЬP��Q�A��IZ���~[����������[��Y�iP�@��IZ����������y�[���P[�Y��di~�[���P[�Y��di~�[��~�P[�Y��di~�[��g�P[ЬPѠ�d�2�&�0��[ЬP��d�~�[��5�P[��~P�^��PxPP�P�PЏn&PЏm&P��^Ь[�[Ѭ
                   3780: �
                   3781: �P�
                   3782: PQ�
                   3783: Q�QPQ�0Q�� ��
                   3784: �P�
                   3785: P�P�P�0P��[P^��#~P��~�P=����H���P��(�[����ݭ���i&�P����[�m}ݭ��&�5����[[P�PP�PP�@�U}�������P��[�[
                   3786: ���^Ь[ЬZ߭��[���P[�P1�����l�j����k���j��l��j߭��[���P[ʱ���l��&����k����&��l���&�Z~�[��L�P[�߭��[��;�P[������Z~�[��$�P[1j�߭��[���P[쐭���&P�^Ь[ЬZ�[�kP����kP����P%�Y�
                   3787: YP��Q�QP�0PY�kP����Yj�[P�^��|
��{|�z|0ݏݬݬ����P���P1�Ь�N|�����H|��>|[�[�[�6|�k
                   3788: ��[�(|
                   3789: ��|�����|Z�[�|�ZPo���{ZЬ[����Z��{�ì[P�P�~�[ݬ��W�P��1m��[P��{�[�[�{�k
                   3790: ��[�{�[���[�{ЬP�~�~,DNhz����������#�2�B�Q�b�v���������΀ۀ����0�:�P�f������Error 0Not ownerNo such file or directoryNo such processInterrupted system callI/O errorNo such device or addressArg list too longExec format errorBad file numberNo childrenNo more processesNot enough memoryPermission deniedBad addressDirectory not emptyIn useFile existsCross-device linkNo such deviceNot a directoryIs a directoryInvalid argumentFile table overflowToo many open filesIllegal ioctlText file busyFile too largeNo space left on deviceIllegal seekRead-only file systemToo many linksBroken pipeArgument too largeResult too largeLink loopConcurrency violationIt's all Greg's faultSecurity label violationNo such system callOut of security labelsInadequate privilege�^���ݬ�&��Ь[�ZЬYЫP֫�`P�Z��Z
                   3791: ׬�k��[�&��PZ��Z   �Y��P��ЬP�^Ь[���&��
                   3792: Џ����P1����ݏ�&�h�P���ի��ߘ�P�@�iw����[�����AC
��.C�&�_&���&~Џ~ݫ��~���PkЫ��k!�k���������
                   3793: �&�� ��k1Q�ЫP֫�`P�^Ь[��5J��-J��O&�&�        ������������0�Џ����P1��&��$ЫZi�[���9����Z\���R\���א����&X�X߭���~����PY�kVݏ�&�#�PZ�Z�������Y�YX �Z�Y�YX�Z��Y�Z��~���PYЏ�k����Z��XY� �1E�ЬP�^Ь[2�Pʏ����P�PHЫZB�Z�Y;�Z������PЏP�Pk�Y�Z��~��=�PY
� �Џ����P�P�^��EA[��&���    �[�&�t����[�[�H��^Ь[Џ����Z��&�A��<�[�&�>����PZ��~�&�`����PЏ����Z��
                   3794: ݫ�&�����ԫ���&��k�ZP�^Ь[��@X�X�H�P1&&�X��&�瑫&+�&P�P�PY�k�w+ݏ�&ݬ���PZ�Y1��Z��Z�&������{�k�aj�Y�~�&~ݬ����PZ<��!J3ݏ�&ݬ��J�PZ�Y�Z�Z�&�r����ݬ���PZ�Z'���Z���&�Y�~�~ݬ��_�PZ�Z1 ��h�Z��Y���k�r���&��XP^ЬP�����ݬ��t  ݬ߬ݬ��2�P[ЬP���QѠQݬ�&�����ݬ��< ЬP��      Џ����P�[P�^�&Z��s[
��D��Z��Z�Z�&�kݏ&���uF��ݏ&�&��`G���Ь[�kP�&�D���P��D��k��6G��HsP�^Ь[ЬZ�[���Y��D���Y���׬�լ�j�[�[��YkìZP�P�^Ь[ЬZլ�P<��Y��D���Y�����Y��D���Y
                   3795: �[�[�׬�լ�jìZP�P��(���~���PZ�Z2<�Z7�
ZP�
P�PZP�PP�PP�@�gsY�i[�&kP�[P�P�ZP
                   3796: �[�ki�[P�Z�&��^Ь[��GZ�X�j3�Z�G�ij�jY�i��[[P�PP�ZP�YP�[[P�PP�ZP�PZ1��ZY�&jZ�ZY��X�X&       ���FZ���&���PZݏ��[~��
                   3797: x
                   3798: PX�XXP�PP�ZP�PZxX~�&��PY�Y�����$�[XP�P�PX�[XP�P&���&�P19��P���xX~�Y��-&1��[[P�PP�P�4F�Y�-F��%F�,r�j�F�&�Fj�Z�F   �Y��E���E�&��EY�Y��E��ZPЬ[X�[�&kP�[P�PY�Y2:�Y5�
YP�
P�PYP�PP�PP�@�qX�hZ�&jP�ZP�P�YP�Z��[h�[~�&��^Ь[�[�[�iE�[�^E�[�UE�&k�^��q[ԭ��Z�Z�&����֭��jk�kZ��[�[�`��Э�P�^ЬZ�ݬ��      �PP�PP�ZP�P��Э�j�Z��DW���D[���DYЭ���D�[P�ZP�ZP�&ZP�Pk���P�YP�YP�&YP�P���&��D�D���D���^Ь[ݬ�&�������  �[�&������[��P�P�����~��i�PW�&W~�&�����PX�X[�XP�W���W���[Z�XYЊ�Э�P׭��P��X[��WWP�PP�XP�P[��WWP�PP�XP�[P�P���o@h�ЬT4}�Q�QR+�RSя��T)���ac��T�)Tac�caP�PP�P@ЬV#}�S�TQя��V(���ac��V�(VacЬP�ЬV'}�S�TWя��V,lW���c��V�,lWVcЬP�^Ѭ�ЬPЬP��^ԭ�Э�P�@�c
Ь@�zc�&P�!����P��^��`9�����I9��6��<9߬ݬ����P[���P��)9P��9�&�I������       9�����9       Џ����P�[P�^�[ЏUUUUK�eB�Џ����K�UB��̏����K�DB�&���[�[���tB��qB�&[��S�PZ��ZBP�PQ�A�BQ�[ R�[RQQ�Q@��A��;BP�PQx[A��AR�R@��A��B��[[�[ ��^��B���A���A���A���AP���AQ�A�A@�A���AP�@�AP�PPʏ���P�^��A��A��A��A��AP��AQ�A�>A@�8A��vAPˏ�@�%AP�^��XA��QA��NA��GA��=AP��:AQ�A��@@��@��"APˏ�@��@QnQPf�AP�^Ǭ����PĬP�P����[���@���@���@���@���@P���@Q�A�y@@�s@��@Pˏ�@�`@Z�Z[�ǬZPĬP�PZP�^м[��}@��[�t@м[��n@��[�e@���[�K�Z�K�@K��ZK�@�[���|������,@�~�&�\S�^\��S��@P���@��7Ь��?�P�^Ь[��u=��m=������&�H���ի��
                   3799: ݫ�&�|�������Ь���Ы��k�^ԭ�լ1�ݏ��&��P����]k�&�R�P;ݭ�����խ�����P��ݭ��&����Zݭ��&�aNԭ�խ� ѭ��í����­��¬���&����!���t�P��ݬ�&�����^�&��j����^��B��Ь��Џ���߭�߬ݬ��~�P[׭��PЭ�Q֭��Pa߭���������[P�^��B��Ь��Ь��߭�߬ݬ��1�P[׭��PЭ�Q֭��Pa߭��������[P�&Џ��X}�V�VQ:Xa��QS:Xg
(Xgc�QW������WQ�Q(Qgc�VP}�R:���b:S���b�QR������RQT�T:STb�QP}�S�ST�P:���d)���dc�QT������TQ�Q)Qdc        �cP�aQ�QP�}�V�VS:���g(���gc�QW������WQ�Q(Qgc�VP�^ݬ�&�)�&P~�&�N����P���P�Pݬݭ������ЬR�RQ:���a��RQPЬT�PЬQЬS�QS�Ï��TUЏ��T�QR:Ta�U�RQT�T�RQ)Tac�caP�PP�UT��ЬUC}�S�TV�URЏ��Y�YUX�YU:Uf�VQU�X�YRW�YR,UfRc�WR �XU��U�ЬP�
ЬQ�Pa�#ЬPЬR�R&�Q{RPPR�PR�P�&P��P�^� ��$Э�P�@�\�@�\���@��[���׭�խ���&���P��;�&P������&     
                   3800: 
 !"#$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~���������������������������������������������������������������������������������������������������������������������������������T7��R�B�����d�ݭ��R�������P���֭�������S}��T�T��P���R�P�T��S�C�����&R�Q�S��T�P�}T���P���&R�P��P�Q�R���Э�P����^Ь[Ь��Ь\ԭ�<���P�[Q}��T�QUR�PR�RP0r��Q[�&Rܕ���^U|Y|V��P�P �X�������������������������������������&����������&�����y&���������������&$
����������&�����y&��&�P�1��1�&ȏ@Z� P11��XP�&Z�&PЌR:Pb�QU�RQ1'&0123456789abcdef0123456789ABCDEF�R�S������W�R�S������W�Z������W�SV�Q�UЌP�RSPQ�Ag��VR��|V�e;0��Z1}լ�1u�S��xP�Z��XP�Pq�W�0qYʏ�Z�&lP�P
                   3801: n4
                   3802: n� 
                   3803: �
                   3804: n� &��
                   3805: n�&��
                   3806: n�W8
                   3807: n������; ��W�Z�+q�Z� q�W�&Z�&X�QUV�WV�VX&�WQ�Q�H� R�]R�RX(VaHa,a0X��W�Q�VSU�QUX�XYP �Z�ZR�WP �PX�PY0)��XYP7�XY�XP0��&R�P��R}��T�T0���R�֭�}T����YP1b�1]��0R� R�PY�Q�PW�P^,`RWn�WP�^Q0���W^ЎQЌP�P��^Q1i�ȏ�Z1L�� Z1F��Z1@��Z1:��Z�&Z�Z�&Z�IiY>I��Y       �HhX>H��X�&Z1��X�Z�&Z1��&Z
ЌY��Z�YY�ЌX��XX��&Z�X0�&���XW�WV�W�W�W�WP�PnW�#�V�WP֭��W�P&�H���W�x��WP���@���Q�WV��S�����0��0S��,a��Vc�c8Va�0��VUQ�nS�W���-��WЭ�P�0��PV�VP�PV�P��(PacЭ�P,a0Pc�XP�Z�       Z�.�έ�P�PX�XP�PX,a0Pc�XP�PV�VP�PX(Pac�XP�@� R�]R�RP�PX�PX,a0Pc�SU�DeB+��X�&Z�X0��XW�W�W�WP�PnW�֭��&WP�P&�=���W�x��WP���@��Z=��Q&�QV�&��P�Pn8n����e�VQ�Z1,�� ��1%��WV�XЭ����&��1�����P0�P�PX(�WV�PX��Q0���Z� Z�u0��e.�U�Z�1����Q0���Z��&Z�X�X�&X�Z1.�1+����p�U1�rUU����UR���R�;R���R���RƏ�R0�qPU�R�R���RR�R
                   3808: d��U�R�    R�\tPTUPU�P ��    ��t�UPU�P��XW�����юn���W�W     qU�� ������P�&���&pP�T~�MS�R�RR�R�TRdcP�S�T��RgPP�R������Q�RR�(RS�S�A�����Q�B�bT B�CG@�M �[���u��+��pPB<��Vvӈ�b��2>H�QS'���I[��������#,;
                   3809: ���:��ܒ��X�����QP�%�\����PЬPЭ`Э��PЬP�&PЬQ�aP�&��P����Q�
                   3810: ���Q��a�(Џ������7����^�С��ݏ����v���longjmp botch
                   3811: �0�������,����p
                   3812: ���L���J�����t�lpd��^JFx@@�`
;#@��hp���
                   3813: ����        ����
;�|q��     �     �     v     n     d     _     X     4$!����7��!� ������!@��~:"x[U�.N;7�63$!S���������S�00111222??C/�-�-o-P-3-$-&-�,�,�,�,�,�,�,�,{,t,m,f,_,X,Q,D,7,2,-,,,�+�+�+�+%CC
                   3814: CC�B�B�B�B�B�B�B�B�B�B�B�B�B�B�B|BvBpBjBdBXBRBLBFB@B:B4B.BBBB�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A�A~AxArAlAfA`AZATANAHABA<A6A0A*A$AAAAAAA�@�@�@�@�@�@�@�@�@�@�@�@�@�@�@�@�@�@�@�@�@|@v@p@j@d@^@X@R@L@F@@@:@4@.@(@"@@@@
                   3815: @@�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?�?z?t?n?h?b?\?V?P?J?D?>?8?2?,?&? ?????�>�>�>�>�>�>�>�>�>�>�>�>�>�>�>�>�>�>z>t>n>h>b>\>V>P>J>D>>>8>2>,>&> >>>>>>�=�=�=�=�=�=�=�=�=�=�=�=�=�=�=�=�=�=�=�=�=~=x=r=l=f=`=Z=T=N=H=B=<=6=0=*=$=======�<�<�<�<�<�<�<�<�<�<�<�<�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I�I{IuIoIiIcI]IWIQIKIEI?I9I3I-I'I!IIII        II�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�H�HHyHsHmHgHaH[HUHOHIHCH=H7H1H+H%HHHH
HH&H�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G�G}GwGqGkGeG_GYGSGMGGGAG;G5G/G)G#GGGGGG�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F�F{FuFoF\FVFPFJFDF>F8F2F,F&F FF
                   3816: F�E�E�E�E�E�EnE_EOE6E-EEEEEEE�D�D�D�D�D�D�D�D�D�D�D�D�D�D�D�D�D�D�D�D�D|DvDpDjDdD^DXDRDLDFD@D:D4D.D(D"DDDD
                   3817: DD�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�C�CzCtCnChCbC\CVCPCJCDC>C8C2C,C�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R�R~RxRrRfR^RVRQRKR@R0RRR�Q�Q�Q�Q�Q�Q�Q�Q�Q�Q�R�Q�R�Q�QzQtQnQhQbQ\QVQPQJQDQ>Q8Q2Q,Q&Q QQQQQQ�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P~PxPrPlPfP`PZPTPNPHPBP<P6P0P*P$PPPPPPP�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O|OvOpOjOdO^OXOROLOFO@O:O4O.O(O"OOOO
                   3818: OO�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�NzNtNnNhNbN\NVNPNJNDN>N8N2N,N&N NNNNN�M�M�M�M�M�M�M�M�M�M�M�M�M�M}MwMqMkMRMLMFM=M0M*M$MMMMMMM�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L|LvLpLjLdL^LXLRLLLFL@L;L6L4L/L�R�R�R�R*L�R%L LL�R�R�R�R�RLxRrRL    LL�KKR�K�K�K�K�K�Q�Q�Q�Q�Q�Q�K�Q�Q�K�Q�K�Q�K�KtQnQhQbQ\QVQPQJQDQ>Q8Q2Q,Q&Q QQQQQQ�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P~PxPrPlPfP`PZPTPNPHPBP<P6P0P*P$PPPPPPP�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�K�O|OvOpOjOdO^OXOROLOFO@O:O4O.O(O"OOOO
                   3819: OO�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�NzNtNnNhNbN\NVNPNJNDN>N8N2N,N&N NNNN�K�M�K�K�K�M�M�M�M�M�M�M�M�M�M}MwMqMkM�KLMFM�K�K*M$MMMMMMM�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L|LvLpLjLdL^LXLRLLLFL@L;L6L�R/L�R�R�R�R*L�R%L LL�R�R�R�R�RLxRrRL    LL�KKR�K�K�K�K�K�Q�Q�Q�Q�Q�Q�K�Q�Q�K�Q�K�Q�K�KtQnQhQbQ\QVQPQJQDQ>Q8Q2Q,Q&Q QQQQQQ�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P~PxPrPlPfP`PZPTPNPHPBP<P6P0P*P$PPPPPPP�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O~KgKPK9K"KK�J�JXOROLOFO@O:O4O.O(O"OOOO
                   3820: OO�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�NzNtNnNhNbN\NVNPNJNDN>N8N2N,N&N NNNN�J�J�J�JyJeJQJ=J�M�M�M�M�M�M�M}MwMqMkM�KLMFM�K�K*M$MMMMMMM�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L�L|LvLpLjLdL^LXLRLLLFL@L8J6L�R/L�R�R�R�R*L�R%L LL�R�R�R�R�RLxRrRL    LL�KKR�K�K�K�K�K�Q�Q�Q�Q�Q�Q�K�Q�Q�K�Q�K�Q�K�KtQnQhQbQ\QVQPQJQDQ>Q8Q2Q,Q&Q QQQQQQ�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P�P~PxPrPlPfP`PZPTPNPHPBP<P6P0P*P$PPPPPPP�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O�O|OvOpOjOdO^OXOROLOFO@O:O4O.O(O"OOOO
                   3821: OO�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�N�NzNtNnNhNbN\NVNPNJNDN>N8N2N,N&N NNNN�K�M�K�K�K�M�M�M�M�M�M�M�M�M�M}MwMqMkM�KLMFM�K�K*M$MMMMMMM*J�L�L�L�L�L�L�L�L�L�L�L�L�L
J�L�L�L�L�L�L|LvLpLjLdL^LXLRLLL�I�IPV@V6V)VV
                   3822: V�U�U�U�U�U�U�U�U�U�U�^�^�^�^�^�^�^�^�^�^�^}^x^s^n^i^S^D^3^^�]�]�]�]�]�]�]�]�]�]�]�]�]|]l]^]M]=].]!]]�\�\�\�\�\�\�\�\�\�\�\|\v\p\j\M\�\0\*\$\\\\\�[�[�[�[�[�[�[�[�[z[t[n[h[b[\[@[([
                   3823: [�Z�Z�Z�Z�Z�Z�Z�Z�Z�Z�Z�Z�ZrZlZfZ`ZZZTZNZHZ5Z#ZZZ�Y�Y�Y�Y�Y�Y�Y�Y�Y�Y�Y�Y�Y�Y�Y�Y~YxYrYlYfY`YZYTYNYHYBY<Y6Y0Y*Y$YYYYYYY�X�X�X�X�X�X�X�X�X�X�X�X�X�X�X�X�X�X�X�X�X|XvXpXjXdX^XXXRXLXFX@X:X4X.X(X"XXXX
                   3824: XX�W�W�W�W�W�W�W�W�W�W�W�W�W�W�W�W�W�W�W�W�W�WzWtWnWhWbW\WVWPWJWDW>W8W2W,W&W WWWWWW�V�V�V�V�V�V�V�V�V�V�V�V�V�V�V�V�V�V�V�V�V~VxVrVlV{_{_z_xks_s_z_�_i_i_z_�d^___&e__|q��skokkkgkdkak\kWk>k>k>k�j�j�j�j�j>k>k>k>k�i�i�i�i����&?p/p&pppppppp�op�opppNs>s4s'sss�r�r�r�r�r�r�r�r�rrDay Mon 00 00:00:00 1900
                   3825: SunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDec/lib/dst         (((((                  H����������������&&&&&&&&&&&&&&&&&&&&������ ����&&8�*&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&E�D�D�D�D�P�K��S���g�;���vf�py6��>�1<�7{i�V�g9��"���$h�JG�y��Fr\��K��� P���&<d<"�&E�Έ&&&(�*�/�1$<6 DD
>�>D>DMDVD];UD�>�D���D���E��J$�P2PV�(Y�`@(c�D���D#�D#��&�D$�jRD%�D&�D'�D'�D(�D)�D*�D+&D,&D-&n��-&D.-&x=D/D&�J&D1J&D2P&D3T&D3W&�b&D4b&��&D7�&D8�&D:�&D;�&��&D<�&|$D=�&��&D?�&DA�&DB�&DD�&��&DF�&DG�&��&D3�&DI�&DJ
DK�:DL:��DNQ��DOe�kDQkDR����&�D#��@"
                   3826: �@    �@����&�d�@��d�&���b���@(��������4���(8����b8���DT��T���T��$V����2�����(���@(����"�@"
                   3827: DX���DY�DY�DZ�D[�DY�D\����]���]��$_�&2�        &�&�"&��&�Da���Dd�DeDfDg%Dh-&�(&��1�i1&�i2&&$k20& P:&�(<&�Dm4�4Dn4Do<�KDpK�pK>&�pLH&$rLM&LS&2DX&�(Z&�\&@(^&�`&�"d&@"
                   3828: h&�(m&�o&@(    t&�DtN�ZDxZDyn�&rDzrv&�D{�D|���D}�D~�z&�D���D���&��&�D��D��D����D��~&�D����D��D���&��&@(�&��&@(�&���D������&����&$���& D�&��&�$�&��&��D����D��D��D� D�$D�F�H��H�&��I�&&���&��&���&$�J�& D�&��&�$�&��&���&@�D�L�PD�PD�U�D�� ��&�D���D��D��D���D���&��&�D��D��D��D��D��D��D��D��D��~�&
D�
@�
                   3829: ����!��)$�5 PA�C@D��D�D�EeD�6�=D�=��=J��>V$�>_ DD�C�CD�Ch`D�Km���&s�d�&�\D�\��\y��]�\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&�^�\�`�`�`�`�`�`
�`

                   3830: �`l��`b"��`l$��`$^(\``$`*`l�
                   3831: .`l�3^<\C`H`,M`,S`Y`_^f��]o�lxdl~�&E_�&�&h�����������������������������t�l�p�d�^�J�F�@�;�#���������������� 
��$l2D!�(�$.�5��;�"D!n�nD&nD's?�D)�D*����+�C�+�J\L`"Q`"Y`0&b`(f�h^j\l`"q`"v`"|`$&^�\�`�`�`�`�`�`
�`

                   3832: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   3833: �`l��^\``,`,`!`'^.�+�4+�=d�C�&E`�&G ��O�   R�     U ��&a�     dv     gn     jd     m_     pX     t$�| D���@��$�@$
                   3834: �������"�@"        D���D�D�D�D�D�D�D��&DD)D ID!R�E    D#���D&�D'��A     D(���D)�D*��=     D+���D,�D-��5     �              �              ��b8!�&�              D1              �(     �&     D     D3#     ������8 ���@�@�%     �4%     ��4&     �\�`"�`"`0&`(�^\`"`" `"&`$&)^+\7`:`D`M`S`X`
]`

                   3835: b`l�h`b"�l`l$�q`$w^(�\�`�`�`�`l�
                   3836: �`l��^�\�`�`,�`,�`�`�^��4&   �4�     �d�     ��&Ea�&�$� � D��$����"D�     ��     D�     D�     D�     D�     D
                   3837: D
                   3838: 
                   3839: #�'�0�2�< 6��
                   3840: �
                   3841: B�
                   3842: K\M`"R`"Z`0&c`(g�i^k\m`"r`"w`"}`$&�^�\�`�`�`�`�`�`
�`

                   3843: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   3844: �`l��^\``,`,`"`(^/�
                   3845: 6
                   3846: Ad
                   3847: I�&Eb�&M$
                   3848: W Da�h�$n�u��{�"D
                   3849: �
                   3850: D
                   3851: D
                   3852: D!
                   3853: DE
                   3854: Dd
                   3855: Dk
                   3856: �������< ���m
                   3857: �m
                   3858: ��n
                   3859: �\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&�^�\�`�`�`&        `     `     `
     `

                   3860:    `l� `b"�  `l$�% `$+     ^(7     \@     `C     `J     `P     `l�
                   3861: T   `l�Y ^b     \i     `n     `,s     `,y     `     `�     ^�     �n
                   3862: �    p
                   3863: �    dp
                   3864: �    �&Ec�&�     $p
                   3865: �     D�     ��     �$�     ��     ���     �"Dy
                   3866: �y
                   3867: Dy
                   3868: D~
                   3869: D�
                   3870: D�
                   3871: D�
                   3872: D�
                   3873: D�
                   3874: D�
                   3875: �    D� ��     ��     �8 �     �      
                   3876: @
                   3877: @
                   3878: 
                   3879: �< ��
                   3880: �
                   3881: \ 
                   3882: `"%
                   3883: `"-
                   3884: `0&6
                   3885: `(:
                   3886: �<
                   3887: ^>
                   3888: \@
                   3889: `"E
                   3890: `"J
                   3891: `"P
                   3892: `$&S
                   3893: ^U
                   3894: \a
                   3895: `d
                   3896: `n
                   3897: `w
                   3898: `}
                   3899: `�
                   3900: `
�
                   3901: `

                   3902: �
                   3903: `l��
                   3904: `b"��
                   3905: `l$��
                   3906: `$�
                   3907: ^(�
                   3908: \�
                   3909: `�
                   3910: `�
                   3911: `�
                   3912: `l�
                   3913: �
                   3914: `l��
                   3915: ^�
                   3916: \�
                   3917: `�
                   3918: `,�
                   3919: `,�
                   3920: `�
                   3921: `�
                   3922: ^�
LdL$�&Ed�&($       L4 D@�G�$M�T��Z�"^@"DU�YDYD[DdDj�&yDybT
D�D�D�D�e6
D�D�D���D �D!�&D"&D#)D#)�/D%/D&9D(Li3
D)]D*gD,zD-�D.�D0�D1�m
��D��&�D�D6
D7
q�u�~�8 ���@
                   3923: ��b� �d��b!�d�@    ��bd!�d�@��h!�
�8
��8
�\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&�^�\``
```!`
&`

                   3924: +`l�1`b"�5`l$�:`$@^(L\U`X`_`e`l�
                   3925: i`l�n^w\~`�`,�`,�`�`�^��8
�8`
�d`
��&Ef�&�$`
� D����$�������"D  i
�i
Di
D�
D�
D�
D�
����&
�8 
���
��

��

\
`""
`"*
`0&3
`(7
�9
^;
\=
`"B
`"G
`"M
`$&P
^R
\^
`a
`k
`t
`z
`
`
�
`

                   3926: �
`l��
`b"��
`l$��
`$�
^(�
\�
`�
`�
`�
`l�
                   3927: �
`l��
^�
\�
`�
`,�
`,�
`�
`�
^�
��
�
d�
�&Ef�&$�
" D*�1�$7�>��D�"D�
��
D�
D�
D�
D�
DD
H(D#K�O�X�Z�< ^��%�%j�&r\t`"y`"�`0&�`(���^�\�`"�`"�`"�`$&�^�\�`�`�`�`�`�`
�`

                   3928: �`l��`b"��`l$��`$�^(&\
                   3929: `
```l�
                   3930: `l�#^,\3`8`,=`,C`I`O^V�&\@fd@m�&Eh�&q$@z D����$�������"DI�IDI�&iDiD�D�DD
�PD �&%D%DDDK��������< ���M�M��N�\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&&^\```%`+`0`
5`

                   3931: :`l�@`b"�D`l$�I`$O^([\d`g`n`t`l�
                   3932: x`l�}^�\�`�`,�`,�`�`�^��N�x�dx��&Eh�&�$x� D����$�@$������"@"
                   3933: D���D�D�D�D�D�D�D�D
                   3934: D2D=DHDY
                   3935: �DyD �D!�D!��&�D"�D$�D%D&�&D!D(
D)���D*���'@        ,@/@1@3�6�< :�F�@ I�D L�H ���+�O�+�Y\[`"``"h`0&q`(u�w^y\{`"�`"�`"�`$&�^�\�`�`�`�`�`�`
�`

                   3936: �`l��`b"��`l$��`$�^(�\�`�`�`&`l�
                   3937: `l�
                   3938: ^\``,$`,*`0`6^=�+�E+�Nd�T�&Ej�&X&h�\�a��c4f$i!loru�x�|������������������~�x�[�U�N�;�7�3������������ �������\�`"�`"&`0&
                   3939: `(�^\`"`"`"$`$&'^)\5`8`B`K`Q`V`
[`

                   3940: ``l�f`b"�j`l$�o`$u^(�\�`�`�`�`l�
                   3941: �`l��^�\�`�`,�`,�`�`�^����@�d@��&Ej�&�$@� D&�@�$@$
                   3942: �"��(�",@"        DI�UDUDYD[D`DdDhDj�&uDuD�D�D�0]D�D�4KDD8=D0<�@�D�HLPTX)�&�D�D$�\�`�i�8 m�y@{@���%�}�%��\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&�^�\�`�`�`�`�`�`
�`

                   3943: �`l��`b"��`l$�`$        ^(\`!`(`.`l�
                   3944: 2`l�7^@\G`L`,Q`,W`]`c^j�%�p%lydl�&Ek�&�$l�l�2D������,�@,Dn�rDrDv��D
�D
�D���D
�D�D��@
                   3945: �@    �D����$� D����$�@$�������"D'�+D+D0D 2D!UD"xD#D#�D$�D#�D%��@
                   3946: ��(���8 ��< ���&��&�\`"!`")`0&2`(6�8^:\<`"A`"F`"L`$&O^Q\]```j`s`y`~`
�`

                   3947: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   3948: �`l��^�\�`�`,�`,�`�`�^��&�&�d��&El�&&�&�"���(&��0��9C</?B$�L DV�]�$c�j��p�"D���D�D�DD%D6D Gt�x�|�����D$���D%���D&�D'��D(D)$�~D*6�XD,R��(����8 ���@��b8"���<"�T�-T��-U�\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&�^&\
```#`)`.`
3`

                   3949: 8`l�>`b"�B`l$�G`$M^(Y\b`e`l`r`l�
                   3950: v`l�{^�\�`�`,�`,�`�`�^��-U�-L�dL��&Em�&�$L�L�2D���@DN�RDR��D  _�&iD
                   3951: i������D�D���D�D���D
�D
��s�&�D��kD�i��D�����
$� D'�(+�7�"D�DD#D)D-D1D5D9D =D!AD"ED#ID$MD%iD&nD'�D(�D)�;�?�H@���*�J�*�W$,�c Do�v�$|������"D.���D8�D9�D:�D;�D;��&�D<��1�.�>�5�9�?D?Z�lD@l�yDAy�DB�DC���  ��DE�����DG��&D;DI
DI�&DJDJDK#DL6DL6DJ6DM6DN?��DPP��DQc�&qDIqDSsDTv��DU�DV�DW���DX�DY�DZ���D\���D]�D^�D_���Da��DbDcDd#�fDf=�PDgJ�@,�@
                   3952: �@    ��(����,�L�hL��hM\`"`"`0&`(!�#^%\'`",`"1`"7`$&:^<\H`K`U`^`d`i`
n`

                   3953: s`l�y`b"�}`l$��`$�^(�\�`�`�`�`l�
                   3954: �`l��^�\�`�`,�`,�`�`�^��hM�h��d��&En�&    $� D�&�$,�3��9�"D���D�D�DD=�A�J�L�< P��!�!\�"g\i`"n`"v`0&`(���^�\�`"�`"�`"�`$&�^�\�`�`�`�`�`�`
�`

                   3955: �`l��`b"��`l$��`$�^(�\�``        ``l�
                   3956: `l�^!\(`-`,2`,8`>`D^K�"S$\d$b�&Eo�&f$$o Dx��$�������"D-�-D-�&2D2D6�&:�&<D<DADU�&ZDZD�D�D�������������D ����������\�`"�`"�`0&�`(���^�\�`"�`"�`"�`$&�^�\````!`&`
+`

                   3957: 0`l�6`b"�:`l$�?`$E^(Q\Z`]`d`j`l�
                   3958: n`l�s^|\�`�`,�`,�`�`�^������d���&Ep�&�$�� D����$�������"D���D�D�D�D�D D ���������@ ��! �! �" \`" `"(`0&1`(5�7^9\;`"@`"E`"K`$&N^P\\`_`i`r`x`}`
�`

                   3959: �`l��`b"��`l$��`$�^(�\�`�`�`�`l�
                   3960: �`l��^�\�`�`,�`,�`�`�^��" $ d$ �&Er�&"$$ , D6�":@">�"D) �- D  - D1 �&> D> B� DQ �&Z DZ D\ Di Dy D� D� D� D� D� D� D� D� E@
                   3961: K�"�� �� P�� Z\\`"a`"i`0&r`(v�x^z\|`"�`"�`"�`$&�^�\�`�`�`�`�`�`
�`

                   3962: �`l��`b"��`l$��`$�^(�\�`�`�` `l�
                   3963:  `l� ^ \ `  `,% `,+ `1 `7 ^> �� J � V d� _ �&Er�&c $� o  D{ �� �$� �� ��� �"D� �� D� D� D� D� D !D'!� X!D=!DT!� �� �� �8 � �� �< �V!�V!� �W!� \� `"� `"� `0&� `(� �� ^� \� `"� `"� `"� `$&� ^� \
                   3964: !`
!`!` !`&!`+!`
0!`

                   3965: 5!`l�;!`b"�?!`l$�D!`$J!^(V!\_!`b!`i!`o!`l�
                   3966: s!`l�x!^�!\�!`�!`,�!`,�!`�!`�!^�!�W!�!p!�!dp!�!�&Es�&�!$p!�!p!�!2D�!��!@�!��!��!@
                   3967: �!�(�!�
                   3968: "�"Dy!��!D�!D�!D
�!D�!D�!D�!D�!D�!D�!D�!D�!D�!D�!D�!D"D2"D7""�"��9"�9""�:"$"&��)"��/"�-2"�-6"o-:"P->"3-B"$-F"&�4�K"4��Q"&-U"�,Y"�,]"�,a"�,e"�,i"�,m"�,q"�,u"{,y"t,}"m,�"f,�"_,�"X,�"Q,�"&�t��"t��
                   3969: �"D,�"7,�"2,�"-,�",�",�"�+�"�+�"�+�"�+�"$@:"�" D�"��"�$�"��"���"�"DBC"�C"DOC"#l"�&�"DR�"#�+DS�"DS�"DT�"        #�+DS�"DU�"DW�"DX�"DY�"
#�+DZ&##M+D[#D[#� #D\ ##<+�C#D[C#D_J#DaJ#Dbj#Dcs##*+Dd�##�*De�#De�#��#Df�#!#�*��#De�#Di�#Dk�#%#�*Dl$Dm$Dn$Do9$DpB$DqM$DrR$DsW$)#�*Duf$-#�*Dw~$1#x*Dx�$Dz�$5#f*D{�$D|�$D}�$D~�$D�$D��$D��$D�%D�%D�*%D�?%D�E%D�K%D�R%D�\%D�n%D�w%D��%D��%D��%��%D��%9#O*D��%��%D��%=#7*A#3*E#;*D�(&D�5&D�@&D�^&D�g&D�r&D�w&��&D��&I# *D��&D��&N#*��&D��&D��&S#*D��&D��&X#�)D��&D��&]#�)D�'b#�)�'�'D�'g#�)D�7'D�L'D�N'D�S'l#�)D��'D��'q#�)D��'D��'D��'v#y)D��'D��'{#w)D��'D��'D�(D�*(D�5(�#T)D�M(D�R(�#9)�#E)D�(�#-)D��(�#!)D��(�#)D�)�&)D�)�#@,�#@
                   3970: �#�(�#��#�,�#�< �#��#�@ �#�D �#�H �#�L �)��)�#��        )�#\�#`"�#`"�#`0&�#`(�#��#^&$\$`"$`"
$`"$`$&$^$\$$`'$`1$`:$`@$`E$`
J$`

                   3971: O$`l�U$`b"�Y$`l$�^$`$d$^(p$\y$`|$`�$`�$`l�
                   3972: �$`l��$^�$\�$`�$`,�$`,�$`�$`�$^�$��    )�$��-�$d�-�$�&Et�&�$$
                   3973: �-�$ D�$�%@%�%@
                   3974: %�%�(%�)%�"D�-��-D�-D�-D�-D.D.D.D.D.D#.D-.D1.D5.DQ.DV.Dy.D�.D�.-%�1%�:%@        ��.� �.<%� �.H%$"�.S% D^%�e%�$k%@$q%�x%��~%�"�%@"
                   3975: D$�.��.D,�.D-�.D.�.D0�.D1�.D5�.�&�.D6�.�%!6D7�.D8�.�%6�/D9/D:/�/�&/D=/D>&/D?//D@P/DAV/DBw/�&~/DD~/�%�5DE�/�&�/DG�/�%�5�%�5�%�5DI�/DJ�/�%�5DK�/DL"0�%D��&00DM00DM20�;0DN;0�%�5DON0�a0DMa0DQe0�%�5DRp0�%u5DS{0�%[5DT�0�%A5DU�0�%'5DV�0�%5DW�0�%5DX�0�%�4DY�0�%�4DZ�0�%�4D[�0�%�4�&�0Df�0Dg�0Dh�0Di�0Di�0Dj�0�%D�Di1Dk1Dk1�&%1Dl%1Dm@1DnI1DnN1�^1Do^1Dob1Do�1��1Do�1Do�1��1Do�1�%�4Do�1��1Do�1Do�1�2�2Do2Do2�%�P�2Do2Dp2�2Dn2�&%2Dk%2Ds;2�&G2DtG2Dub2Dvk2Dvp2�|2Dw|2Dw�2Dw�2��2Dw�2Dw�2��2Dw�2Dw�2��2Dw�2Dw3�)3�)3Dw)3Dw,3�%�P�33Dw33Dx33�=3Dv=3�&G3D{G3D{K3D{o3�&~3D{~3D{�3��3D{�3D{�3��3D{�3D{�3��3��3D{�3D{�3�%�P�&4D{4D|4D}4D~44�%�4DA4DE4D�P4D�^4�%�4D~4D��4�%�4D��4&@,        &@(&�&�(&�&@&@#&�,(&�0*&�42&�88&�<>&�@D&�b@�&H&�DL&�H��4���4R&���4]&(�D��&b&(dD��&g&\i&`"n&`"v&`0&&`(�&��&^�&\�&`"�&`"�&`"�&`$&�&^�&\�&`�&`�&`�&`�&`�&`
�&`

                   3976: �&`l��&`b"��&`l$��&`$�&^(�&\�&`'`        '`'`l�
                   3977: '`l�'^!'\('`-'`,2'`,8'`>'`D'^K'���4S'�$6_'d$6h'�&Ew�&l'$$6t'$6}'2D�'��'��'@�'�(�'��'�"D-6�16D16D
:6D�6D�6�'��'��'���6��6�'��6�'$�6�' D�'��'�$�'��'���'�"�'@"D�6��6D�6D�6D�6D�6�&�6D �6��6D!�6D"�6��6�&�6�&�6D%�6D&�6D'�6�&�6D)�6D)�6�&�6D*�6��6D+�6�'�7�7D-7D. 7D. 7D/"7D0%7�&*7D)*7D2,7�&07D307�'�7D4?7�&D7D6D7D7Y7D9^7D:s7D;w7�'�7D<�7(@
                   3978: (�(
                   3979: (�(@    (@"(@%(�b�����7�=�7)(�=�75(\7(`"<(`"D(`0&M(`(Q(�S(^U(\W(`"\(`"a(`"g(`$&j(^l(\x(`{(`�(`�(`�(`�(`
�(`

                   3980: �(`l��(`b"��(`l$��(`$�(^(�(\�(`�(`�(`�(`l�
                   3981: �(`l��(^�(\�(`�(`,)`,)`)`)^)�=�7")=�7,)d�73)�&Ew�&7)$�7A) DK)�R)�$X)@$^)�e)��k)�"o)@"
                   3982: D�7��7D�7D�7D�7D�7D�7D�7D�7D�7D*�7s)�<D-38D.D8D/M8D0m8D1r8D2�8�&�8D4�8v)j<D5�8�&�8D7�8z)D�D8�8D9�8D:�8�&�8D<�8�9D=9�)�;D>9D?9D?9D@ 9DA#9DB'9DC+9DD09DD09DE29�@9DE@9DEI9DES9�)S<�u9�u9DH{9��9DI�9DJ�9DK�9DK�9DM�9�)�:DN�9DN�9DO�9DP�9DQ�9DR�9��9DR�9DR:DR
                   3983: :�,:�,:�&2:DU2:DV<:DWB:DWG:DXK:�)M<DY[:�&`:DZ`:�)<D\u:�&z:D^z:�)<D_�:�)@    �)@�)@�)@�)��)��)��)��)��)��)��)� �)�$�)�L�)��)�P�)�T��:�`�:�)�`�:*$b�:*2D*�*�*�*@*�*@
                   3984: *�!*�$*�'*@        **�" Dd�:��:Dh�:Di�:Dj�:Dk�:Dl�:Dm�:Dn�:Do;Dp;Dq;Dr;Ds;Dt&;Du+;Dv5;Dw?;DxI;DyN;DzX;D{b;D|l;D}q;.*�2*�;*�8 ?*���;�~�;K*�~�;Q*$��;X*2D_*�b*�h*�n*�p*@r*�t*@
                   3985: 
                   3986: v*�x*�"D��;��;D��;D��;D��;D��;D��;D��;D��;D��;D��;D��;D��;D��;D��;|*@,        *�(�*��<��<�*��<�*(bD��&�*\
                   3987: �*`�*`&�*^
                   3988: &�*\�*`"�*`"�*`0&�*`(�*��*^�*\�*`"�*`"�*`"�*`$&�*^�*\�*`�*`�*`&+`+`+`
+`

                   3989: +`l�+`b"� +`l$�%+`$++^(7+\@+`C+`J+`P+`l�
                   3990: T+`l�Y+^b+\i+`n+`,s+`,y+`+`�+^�+��<�+��<�+d�<�+�&Ez�&�+ ���+%C�+C�+
                   3991: C�+C�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+�B�+|B�+vB�+pB&,jB,dB        ,XB
,RB,LB,FB,@B,:B!,4B%,.B),B-,B1,B5,�A9,�A=,�AA,�AE,�AI,�AM,�AQ,�AU,�AY,�A],�Aa,�Ae,�Ai,�Am,�Aq,�Au,�Ay,�A},�A�,�A�,�A�,~A�,xA�,rA�,lA�,fA�,`A�,ZA�,TA�,NA�,HA�,BA�,<A�,6A�,0A�,*A�,$A�,A�,A�,A�,A�,A�,A�,�@�,�@�,�@�,�@�,�@�,�@�,�@�,�@&-�@-�@ -�@
-�@-�@-�@-�@-�@!-�@%-�@)-�@--�@1-�@5-|@:-v@?-p@D-j@I-d@N-^@S-X@X-R@]-L@b-F@g-@@l-:@q-4@v-.@{-(@�-"@�-@�-@�-@�-
                   3992: @�-@�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?�-�?.�?.�?.z?.t?.n?.h? .b?%.\?*.V?/.P?4.J?9.D?>.>?C.8?H.2?M.,?R.&?W. ?\.?a.?f.?k.?p.�>u.�>z.�>.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.�>�.z>�.t>�.n>�.h>�.b>�.\>�.V>�.P>�.J>�.D>�.>>&/8>/2>/,>/&>/ >/>/>$/>)/>./>3/�=8/�==/�=B/�=G/�=L/�=Q/�=V/�=[/�=`/�=e/�=j/�=o/�=t/�=y/�=~/�=�/�=�/�=�/�=�/�=�/�=�/~=�/x=�/r=�/l=�/f=�/`=�/Z=�/T=�/N=�/H=�/B=�/<=�/6=�/0=�/*=�/$=�/=�/=�/=�/=0=0=
                   3993: 0�<0�<0�<0�<0�<#0�<(0�<-0�<20�<70�<<0�<A0�<F0�&�<O0&,C[0d,Cd0�&E{�&h0 ��n0�Iq0�It0�Iw0�Iz0�I}0�I�0�I�0�I�0�I�0�I�0�I�0�I�0�I�0�I�0�I�0�I�0�I�0{I�0uI�0oI�0iI�0cI�0]I�0WI�0QI�0KI�0EI�0?I�09I�03I�0-I�0'I�0!I�0I�0I�0I�0        I�0I�0�H&1�H1�H     1�H
1�H1�H1�H1�H1�H!1�H%1�H)1�H-1�H11�H51�H91�H=1�HA1�HE1�HI1�HM1�HQ1HU1yHY1sH]1mHa1gHe1aHi1[Hm1UHq1OHu1IHy1CH}1=H�17H�11H�1+H�1%H�1H�1H�1H�1
H�1H�1&H�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G�1�G2}G2wG
                   3994: 2qG2kG2eG2_G2YG#2SG(2MG-2GG22AG72;G<25GA2/GF2)GK2#GP2GU2GZ2G_2Gd2Gi2�Fn2�Fs2�Fx2�F}2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2�F�2{F�2uF�2oF�2\F�2VF�2PF�2JF�2DF�2>F38F    32F3,F3&F3 F3F"3
                   3995: F'3�E,3�E13�E63�E;3�E@3�EE3nEJ3_EO3OET36EY3-E^3Ec3Eh3Em3Er3Ew3E|3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3�D�3|D�3vD�3pD�3jD�3dD�3^D4XD4RD
4LD4FD4@D4:D!44D&4.D+4(D04"D54D:4D?4DD4
                   3996: DI4DN4�CS4�CX4�C]4�Cb4�Cg4�Cl4�Cq4�Cv4�C{4�C�4�C�4�C�4�C�4�C�4�C�4�C�4�C�4�C�4�C�4�C�4�C�4�C�4zC�4tC�4nC�4hC�4bC�4\C�4VC�4PC�4JC�4DC�4>C�48C�42C�4,C5�&,C5&�I5d�I$5�&E�&(5 ��05�R35�R65�R95�R<5�R?5�RB5�RE5�RH5�RK5�RO5�RS5�RW5�R[5�R_5�Rc5�Rg5�Rk5�Ro5~Rs5xRw5rR{5fR5^R�5VR�5QR�5KR�5@R�50R�5R�5R�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5�Q�5zQ�5tQ�5nQ�5hQ�5bQ�5\Q�5VQ�5PQ�5JQ�5DQ�5>Q�58Q62Q6,Q6&Q6 Q6Q6Q6Q6Q#6Q'6�P+6�P/6�P36�P76�P;6�P?6�PC6�PG6�PK6�PO6�PS6�PW6�P[6�P_6�Pc6�Pg6�Pk6�Po6�Ps6�Pw6�P{6~P6xP�6rP�6lP�6fP�6`P�6ZP�6TP�6NP�6HP�6BP�6<P�66P�60P�6*P�6$P�6P�6P�6P�6P�6P�6P�6�O�6�O�6�O�6�O�6�O�6�O�6�O�6�O7�O7�O
7�O7�O7�O7�O!7�O&7�O+7�O07�O57�O:7�O?7�OD7|OI7vON7pOS7jOX7dO]7^Ob7XOg7ROl7LOq7FOv7@O{7:O�74O�7.O�7(O�7"O�7O�7O�7O�7
                   3997: O�7O�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N�7�N8�N8�N8�N8�N8�N8zN 8tN%8nN*8hN/8bN48\N98VN>8PNC8JNH8DNM8>NR88NW82N\8,Na8&Nf8 Nk8Np8Nu8Nz8N8�M�8�M�8�M�8�M�8�M�8�M�8�M�8�M�8�M�8�M�8�M�8�M�8�M�8�M�8}M�8wM�8qM�8kM�8RM�8LM�8FM�8=M�80M�8*M�8$M�8M&9M9M9M9M9M9�L9�L$9�L)9�L.9�L39�L89�L=9�LB9�LG9�LL9�LQ9�LV9�L[9�L`9�Le9�Lj9�Lo9�Lt9�Ly9�L~9�L�9|L�9vL�9pL�9jL�9dL�9^L�9XL�9RL�9LL�9FL�9@L�9 ���9;L�96L�94L�9/L�9*L�9%L�9 L�9L�9L�9L�9    L�9L�9�K&:�K:�K:�K:�K:�K:�K:�K$:�K):�K.:�K3:�K8:�K=:�KB:�KG:�KL:�KQ:�KV:�K[: ��e:~Kj:gKo:PKt:9Ky:"K~:K�:�J�:�J�:�J�:�J�:�J�:�J�:yJ�:eJ�:QJ�:=J�: ���:8J�:*J�:
J�:�I�:�I�:��I�:S�:dS�:�&E}�&�:$S&; D;�;�$;� ;��&;�"D     S�     SD     SDSDSD5SDXSD_S*;]VDuSD�S-;YVD�S0;�4;�=;�b �A;�80E;�Q;�<0��S��SS;��S^;&���e;���m;PVq;@Vu;6Vy;)V};V�;
                   3998: V�;�U�;�U�;�U�;�U�;�U�;�U�;�U�;�U�;�U�;�U�;$0�S�; P�;�,�;�"�;�D2�S��SD6�SD7�S�&�SD:�S�;�UD;�SD=�SD>�SD@�SDATDCTDDT�;iUDE,T�;_UDFSTDGaT�rTDHrT�;RUDI�T��TDK�T�;BUDL�TDM�T��TDN�T�;8UDO&U�4UDQ4U�&4U�;�b��4UDS4U�S4U�;�S5U<\<`"
                   3999: <`"<`0&<`(<�!<^#<\%<`"*<`"/<`"5<`$&8<^:<\F<`I<`S<`\<`b<`g<`
l<`

                   4000: q<`l�w<`b"�{<`l$��<`$�<^(�<\�<`�<`�<`�<`l�
                   4001: �<`l��<^�<\�<`�<`,�<`,�<`�<`�<^�<�S5U�<SlV�<dlV=�&E�&= ��=�^=�^=�^=�^=�^ =�^#=�^&=�^)=�^,=�^0=�^4=}^8=x^<=s^@=n^D=i^H=S^L=D^P=3^T=^X=�]\=�]`=�]d=�]h=�]l=�]p=�]t=�]x=�]|=�]�=�]�=�]�=�]�=|]�=l]�=^]�=M]�==]�=.]�=!]�=]�=�\�=�\�=�\�=�\�=�\�=�\�=�\�=�\�=�\�=�\�=�\�=|\�=v\�=p\�=j\�=M\�=0\�=*\�=$\�=\�=\>\>\>�[>�[>�[>�[>�[>�[ >�[$>�[(>�[,>z[0>t[4>n[8>h[<>b[@>\[D>@[H>([L>
                   4002: [P>�ZT>�ZX>�Z\>�Z`>�Zd>�Zh>�Zl>�Zp>�Zt>�Zx>�Z|>�Z�>�Z�>rZ�>lZ�>fZ�>`Z�>ZZ�>TZ�>NZ�>HZ�>5Z�>#Z�>Z�>Z�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y�>�Y?�Y?�Y?~Y?xY?rY?lY ?fY%?`Y*?ZY/?TY4?NY9?HY>?BYC?<YH?6YM?0YR?*YW?$Y\?Ya?Yf?Yk?Yp?Yu?Yz?�X?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?�X�?|X�?vX�?pX�?jX�?dX�?^X&@XX@RX@LX@FX@@X@:X@4X$@.X)@(X.@"X3@X8@X=@XB@
                   4003: XG@XL@�WQ@�WV@�W[@�W`@�We@�Wj@�Wo@�Wt@�Wy@�W~@�W�@�W�@�W�@�W�@�W�@�W�@�W�@�W�@�W�@�W�@�W�@�W�@zW�@tW�@nW�@hW�@bW�@\W�@VW�@PW�@JW�@DW�@>W�@8W�@2W�@,WA&WA W
                   4004: AWAWAWAWAW#A�V(A�V-A�V2A�V7A�V<A�VAA�VFA�VKA�VPA�VUA�VZA�V_A�VdA�ViA�VnA�VsA�VxA�V}A�V�A�V�A�V�A~V�AxV�ArV�AlV�A�&lV�A&_�Ad_�A�&E��&�A&h���A���A���A{_�Az_�As_�Ai_�A^_�A_�A_�A �A��A_�A_�A\�A`"�A`"�A`0&B`(B�B^B\B`"B`"B`""B`$&%B^'B\3B`6B`@B`IB`OB`TB`
YB`

                   4005: ^B`l�dB`b"�hB`l$�mB`$sB^(B\�B`�B`�B`�B`l�
                   4006: �B`l��B^�B\�B`�B`,�B`,�B`�B`�B^�B�_�B�_�Bd�_�B�&E��&�B$      �_�B D&C�C�$C�C��C�"D�_��_D�_D�_D�_D�_D�_D�_C<`D6`"C�&C�/C�8 3C�?C�bD �       FC�bX �NC�\ �8`�8`PC�9`ZC\\C`"aC`"iC`0&rC`(vC�xC^zC\|C`"�C`"�C`"�C`$&�C^�C\�C`�C`�C`�C`�C`�C`
�C`

                   4007: �C`l��C`b"��C`l$��C`$�C^(�C\�C`�C`�C`D`l�
                   4008: D`l�D^D\D` D`,%D`,+D`1D`7D^>D�9`DDp`NDdp`UD�&E��&YD&�<�]D<��`DskcDokfDkkiDgklDdkoDaksD\kwDWk{D$p`~Dp`�D2D�D��D�"D
                   4009: y`�y`Dy`D�`D�`D�`�DEkD�`D�`D�`�D>k�D<k�D?kDaDa�DkD&a�D@�D�(�D��D�8 �D��(a�(a�D�)a�D$*a�D*a�D2D�D��D�"D3a�3aD!3aD"XaD#waD$~a�DkD%�a�D�jD&�a�D�jD'�a�D��D��D�8 �D��D�< ��a�(�aE�(�aE&�\�E\��E�jE�jE�jE�jE�jE$*�a"E�a&E2D)E�-E�"D,�a��aD2�aD3�aD4�aD5b1E�jD6b5EcjD8zb9E#jD:�b=EjD;�bD;�bD<�bD;cD=cAEjD>,cEE@GE�(KE�WE�8 [E��.c�?.cdE�?/cgE$A0clE0crE2DwE�{E�"DC9c�9cDH9cDI^cDJ}cDK�cE�iDM�c�E��E��E�8 �E��E�< ��c�N�c�E�N�c�E&�|��E|���E�i�E�i�E�i�E$P�c�E�c�E2D�E��E�"DR�c��cDX�cDY�cDZdD[d�E�iD\dD\dD]!dD\XdD^\d�E�iD_vd�E�iDa�d�E@�E�(�E��E�8 �E���d�b�d�E�b�d�E$d�dF DF�F�$"F�)F��/F�"3F@"Df�d��dDp�d7FiDq�dDr�dDs�dDt�dDu�dDv�dDw�dDxeDy
eDzeD{"e;F@
                   4010: �$e�|$e=F�|%eJF$~&eXF DfF�mF�$sF@$yF��F���F�"�F@"
                   4011: D�/e�7eD�7e�FliD�DeD�Te�FXiD�heD�ye�FHiD��eD��e�F4iD��eD��e�FiD��eD��e�F
i�F        i�FiD�f�F�hD�
fD�fD�#f�&PfD�PfD�ofD��fD��fD��fD��fD��fD��fD��fD��fD��fD�g�& gD� g�&NgD�NgD�mgD��gD��gD��gD��gD��gD��gD��gD��gD�h�&hD�h�&2hD�2hD�QhD�mhD�rhD��hD��hD��hD��hD��hD��h�&�hD��h�F��F��F�8 �F��F@     ��h���h�F���h�F\�F`"�F`"�F`0&�F`(G�G^G\G`"
G`"G`"G`$&G^G\)G`,G`6G`?G`EG`JG`
OG`

                   4012: TG`l�ZG`b"�^G`l$�cG`$iG^(uG\~G`�G`�G`�G`l�
                   4013: �G`l��G^�G\�G`�G`,�G`,�G`�G`�G^�G���h�G�xk�Gdxk�G�&E��&�G$xk�G D�G��G�$H�
                   4014: H��H�"D�k��kD�kD�kD�kD�kD�kD�kDlDlDlH�lD-lD;lH�lDJlHxlD"ulH�#H�,H�8 0H�<H@>H@
                   4015: �wl�#wl@H�#xlHH\JH`"OH`"WH`0&`H`(dH�fH^hH\jH`"oH`"tH`"zH`$&}H^H\�H`�H`�H`�H`�H`�H`
�H`

                   4016: �H`l��H`b"��H`l$��H`$�H^(�H\�H`�H`�H`�H`l�
                   4017: �H`l��H^I\    I`I`,I`,I`I`%I^,I�#xl3I#�l<Id�lCI�&E��&GI&��JI��NI VI$
�l\I DbI�kI�(oI�xI�}I@�I�(�I��I��I�"D�l��lD�lD�lD�l�&�lD�l�I]p��lD�lDm�m�&mDmD:m�&ZmDZm�IPpDjmDwmD �m�&�mD"�m�&�mD#�m��mD$�mD%�mD'�m�IDpD(�m��m�&�m�&�mD+�m��mD,�mD-�m�nD/n�&nD1n�&nD2nD3 n�&+nD5+n�I��I��-n�6-n�I�6.n�I&����I����I?p�I/p�I&p�Ip�Ip�Ip�I�o�I�o�I$@.n�I D�I��I�(�I��I�J�(J�J@(J�#J�(J�",J@"
                   4018: DA7n�?nDG?nDICnDKOn�&mnDLmnDMsnDN~nDO�n�&�nDQ�nDR�n�&�nDS�nDT�nDU�nDV�n��nDW�n�
oDX
o�oDYoDZBoD[doD\ko�ko�ko�koD`koDasoDb~oDc�o0J�oDd�o�&�oDf�o4J�:J�CJ�EJ�b�KJ�RJ�b�VJ���o�g�o`J�g�oeJ jJ 0&vJ\xJ`"}J`"�J`0&�J`(�J��J^�J\�J`"�J`"�J`"�J`$&�J^�J\�J`�J`�J`�J`�J`�J`
�J`

                   4019: �J`l��J`b"��J`l$��J`$�J^(K\K`K`K`K`l�
                   4020: "K`l�'K^0K\7K`<K`,AK`,GK`MK`SK^ZK�g�oaKghplKdhptK�&E��&xK$hp�K D�K��K�$�K��K���K�"Dqp�qpDqpDvpDypD�pD�pD�p�K�sD�pD�p�K�s�&�pD�p�KesD3qDAq�KYsDlq�KWs�&yqDyq�K��K��K�8 �K��K�< �{q� {q�K� |q�K&����K����KNs�K>s�K4s&L'sLs        Ls
L�rL�rL�rL�rL�r!L�r%L�r)L�r-L�r1Lr5L$6|qBL POL�,TL@,YL�"^L�D8�q��qD;�qD<�q�&�qD=�qD>�qdLNrD@�qhL;r�&�q�&rDBrlL r�&rpL��rDDr�DrvL�Dr�L\�L`"�L`"�L`0&�L`(�L��L^�L\�L`"�L`"�L`"�L`$&�L^�L\�L`�L`�L`�L`�L`�L`
�L`

                   4021: �L`l��L`b"��L`l$�M`$M^(M\M`M`%M`+M`l�
                   4022: /M`l�4M^=M\DM`IM`,NM`,TM`ZM``M^gM�DroMD�s{Md�s�M�&E���&�M$�s�M P�M�"�M�"D�s��sD
                   4023: �sD�s�MtD
�s�M�s��sD�s��s�M��s�M\�M`�M`�M`�M`�M`�M`
�M`

                   4024: �M`l��M`b"��M`l$��M`$�M^(N\N`N`N`!N`l�
                   4025: %N`l�*N^3N��s=NtJNdtUN�&E���&YN$tbN PkN�,oN@,sN�wN@
                   4026: {N�"Dt�"tD"tD      .tD
                   4027: 4tD
                   4028: @tDEtDMtDMtD
                   4029: OtD
StDjt�N@,  �qtDqt�qt�N�rt�N\�N`�N`�N`�N`�N`�N`
�N`

                   4030: �N`l��N`b"��N`l$��N`$�N^(�N\�N`�N`�N`�N`l�
                   4031: O`l�O^O�rtOtt$Odtt-O�&E���&1O$tt8O N?O�,CO@,Dvt�ztDztD      }tD
                   4032: �tD�tD�tGO@
                   4033: ��t�
�tIO�
�tPO\\O`_O`iO`rO`xO`}O`
�O`

                   4034: �O`l��O`b"��O`l$��O`$�O^(�O\�O`�O`�O`�O`l�
                   4035: �O`l��O^�O�
�t�O
�t�Od�t�O�&E���&�O$�t�O P�O�,�O��O�(�O�D  �t��tD�tD�t�&�tD�tD�t��tD�tD�tD�tP�vDu�uDuDuDuP�vD)uD-uD/u�4uD4uDAuDeuP�v�uDuD�uD �uP�vD!�uD!�u��uD"�uD"�uD#�uD$vP�vD%v�*vD'*vP�vD':vD(<vP�vD(LvD)NvP�vD)^v�^v�^vD!^vD,fv�&�vD�vD.�v P�v$P@&P@
                   4036: )P@    +P@,-P�l � 1P@��vD/�v�/�v9P�/�v<P\>P`"CP`"KP`0&TP`(XP�ZP^\P\^P`"cP`"hP`"nP`$&qP^sP\P`�P`�P`�P`�P`�P`
�P`

                   4037: �P`l��P`b"��P`l$��P`$�P^(�P\�P`�P`�P`�P`l�
                   4038: �P`l��P^�P\�P`Q`,Q`,
Q`Q`Q^ Q�/�v%Q/�v,Qq0w4Q@w<Q�H~DQ�H~KQ�H~TQ���[Q�؁cQ�&(�lQ���uQy�}Q�(��QL���Q����Qć�Q�l��Q����Q�܋�Q��Q�(��Q�T��Qd��QL���Q(`��Qp��Q����Qy�R��R���R��� R
                   4039: �)R,�2R!\�;R!��DR$��NR��XR�P�_R�d�fR���nR��yR-ԓ�R�ܓ�R���R����R��Rfp��R����R���R�(��R����R�R~<�Rr��R.���R����R��R�>S      ���S0&��Sd�SL�'S+؁.S
                   4040: ��6S�`�BS�(�KSq�vQS$��YS���bS�2mS      y��zS��S���S0��S�,��S�J�Skp
                   4041: �SIL�S���S"x�Sl`
�SO@�Suhp�S(
                   4042: &T��    T�
T;|q"T��+TW�8T�.n>T�&tHT\ttPTF�YT)�l`T�d�eT�P�kT(��rT���yT��T�&��T�&�7�TJ� �TN��T�@�Tm:"�T��.�T�6�T�$�T;S�T��U��U��S Uf��)U��.UY�<U�$ GU��tKU���RU��[U���bU���mUn��tU��{Ug�-�Ut��U��s�U&\��U���UW@w�U�ܾ�U����U�xk�U��_�U?�d�U&e�U��U����U!��V�T�
V���V;0wV�`�!V!,�)V  ���0V�<�:V�H~GV�l�OV�VV@\waV       TzjV�^�qV��xyVO8{�V����V       ����V     
                   4043: ���V�8��V����V�ԓ�V�&(��V�ć�V�@��V�h��V�(��V&���Vyp��V.���V���W~��W���W܋W&�*W�p�0W+8�8W7��AW�h�IW      -��UW���[W��bWX8�iW(�pW     ���uW���zW�ܓ�W����W�(��Wpp��W����W���W����W�4��W�u��Wcrt0.oexitscsish.oscsish.crccdev_dev2mainmain_4_parsemainparseparsefp_iobuffp_iobuf_14_function_23_35_50_51_54paraminptrsniiargsbuffn1nccargsthatdev2errparseflook_flookflook1f1f1namenameflookfunctionfunction1namedevptr2f1functionsetdevicesetdeviced2setdevicehelp_helphelpd2d2cmdcmdprec2prec2_78_87_95f1base1helpgen_helpgen_helpniargsiargsncargscargsgen_helpdevs_devs2gen_devgen_devniargsiargsncargscargscargs_112_118_119_124_133d2gen_devscsi_targetscsi_targetnn_139scsi_targetset_sonyset_sony_142cargsiargsset_sony2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufscsish.cge_dev.odev.crccfns_fns1_3_4_5_6_7_8_9_10_11_12_13_14_gen_id_15_16_17_18_19_20_21_22_23_24_25_26_27_28_29_30_31genericdev2_32gen_idgen_idniargsiargsncargscargserr_36gen_id2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufdev.cge_inq.oinq.crccgen_rmb_3_4gen_devtype_5_6_7_8_9_10gen_inqgen_inqniargsniargsiargsiargsncargscargserrerr_24_27_30_33buf_34cmdscsi_cmdretscsi_returningen_inq2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufinq.cge_stop.ostop.crccgen_stopgen_stopniargsiargsncargscargserrcmdscsi_cmdnretscsi_returngen_stop2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufstop.cge_start.ostart.crccgen_startgen_startniargsiargsncargscargserrcmdscsi_cmdnretscsi_returngen_start2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufstart.cge_capacity.ocapacity.crccgen_capacitygen_capacityniargsiargsncargscargserr_8cmdscsi_cmdretscsi_returnnsssngen_capacity2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufcapacity.cge_display.odisplay.crccgen_displaygen_displayniargsiargsncargscargserrerr_8_11_20_25cmdscsi_cmdretscsi_returnivendorproductnrevretvold_idgen_display2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufdisplay.cge_reset.oreset.crccgen_resetgen_resetniargsiargsncargscargserrcmdscsi_cmdretscsi_returngen_reset2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufreset.cge_tur.otur.crccgen_turgen_turniargsiargsncargscargserr_8cmdscsi_cmdnretscsi_returngen_tur2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobuftur.cge_scsi.oscsi.crccgen_scsigen_scsiniargsiargsncargscargserr_8cmdscsi_cmdnretscsi_returngen_scsi2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufscsi.cge_readt.oreadt.crccgen_readtgen_readtniargsiargsiargsncargscargserrerr_11_23_24_18cmdscsi_cmdaddrbsinssretscsi_returnt1t2nsgen_readt2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufreadt.cso_dev.odev.crccfns_fns1_3_4_5_6_7_8_9_10_11_12_13_14_15_16_17_18_19_20_21_22_23_24_25_26_27_28_29_30_31_32_33_34_35sonydev2_36_372nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufdev.cso_inq.oinq.crccsony_inqsony_inqniargsniargsiargsiargsncargscargserrerr_16_19_22_32_33_30_28_27_24_25_23cmdscsi_cmdretscsi_returninsony_inq2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufinq.cso_alt.oalt.crcctable_tabletabledrivetabdatadata_4_9intablesony_altsony_altniargsiargsiargsncargscargserriretscsi_returncmdscsi_cmdnsony_alt2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufalt.cso_config.oconfig.crccmtab_mtabbrdname_brdname_3_4_5sony_confsony_confniargsiargsncargscargserr_13_14_10_11_9_23_24_27_30_31retscsi_returncmdscsi_cmdibufnsony_conf2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufconfig.cso_status.ostatus.crccshelf_shelfshelfii_4_8_9_7_15_18_21_22_23shelfsony_istatussony_istatusretscsi_returnerrcmdscsi_cmdnsony_istatussony_statussony_statusniargsiargsncargscargserr_44_45_39_42_40_38_57_61_60_62_75_76_77_78_81_82_85_86_89_90distartretscsi_returnnsony_status2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufstatus.cso_eject.oeject.crccsony_ejectsony_ejectniargsiargsncargscargserrcmdscsi_cmdnretscsi_returnsony_eject2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufeject.cso_rel.orel.crccsony_relsony_relniargsiargsncargscargserrcmdscsi_cmdijnretscsi_returnsony_rel2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufrel.cso_set.oset.crccsony_setsony_setniargsiargsncargscargserrcmdscsi_cmdinretscsi_returnsony_set2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufset.cso_shelfside.oshelfside.crccshelfsideshelfsideargargerr_8shelfoargshelfside2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufshelfside.cso_diskid.odiskid.crccsony_diskidsony_diskidniargsiargsncargscargserr_8cmdscsi_cmdretscsi_returnnsony_diskid2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufdiskid.cso_internal.ointernal.crccinternal_internalinternalnnb1nbnbretscsi_returnerrcmdscsi_cmdinternalcmds_cmds_9_10_11_12_13_14msg1_msg1_15_16_17_18_19_20_21_22_23_24_25_26_27_28_29_30testn_testn_31_32_33_34_35_36_37_38_39_40sony_internalsony_internalniargsiargsncargscargserr_144_46_51_55_56_61_65_66_71_73_78_79_80_82_96_98_99_97_107_110_113_116_119_120_121_126_127_132_133_137_139_138_140_141_142diretscsi_returndrivecmdscsi_cmdt1t2lowernsony_internal2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufinternal.cso_media.omedia.crccsony_media1sony_media1drivedrivelbnlbnlowerretscsi_returnerrcmdscsi_cmdnsony_media1sony_mediasony_medianiargsiargsiargsncargscargserrerr_17_20_27_29_30_28_36_cmsg_46_47_48_49_50_51_52_53_54_55_56_57_cnts_81newbnewbnewb_128_135_136dfp_iobufretscsi_returnbncurcurbcverbosenlinedrivelowerbuflbncountsony_mediacmsgcnts2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufmedia.cso_readid.oreadid.crccmy_read_my_readmy_readlunblkblkretscsi_returnerrcmdscsi_cmdnmy_readsony_readidsony_readidniargsiargsncargscargserrerr_19_24_27blkretscsi_returnlastbdriveprbufsony_readid2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufreadid.cso_copy.ocopy.crccsony_copysony_copyniargsiargsiargsncargscargserrerr_5_12_good_search_25_copy1_37_40_41sbasewrunwrnnblocksgoosdrdbaset2lowerddrstargetdtargetretscsi_returnnbt1sony_copycopy1copy1stsdsbsbnndtdddbdberrcmdscsi_cmdretscsi_returncopy1searchsearchdrlowersbasennss3errcpretscsi_returnsearchgood3BADGOOD32nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufcopy.cso_i0.tab.oi0.tab.crcci0com_1_2_3_4_5_6_7_8_9_10_11_12_13_14_15_16_17_18_19_20_21_22_23_24_25_26_27_28_29_30_31_32_33_34_35_36_37_38_39_40_41_42_43_44_45_46_47_48_49_50_51_52_53_54_55_56_57_58_59_60_61_62_63_64_65_66_67_68_69_70_71_72_73_74_75_76_77_78_79_80_81_82_83_84_85_86_87_88_89_90_91_92_93_94_95_96_97_98_99_100_101_102_103_104_105_106_107_108_109_110_111_112_113_114_115_116_117_118_119_120_121_122_123_124_125_126_127_128_129_130_131_132_133_134_135_136_137_138_139_140_141_142_143_144_145_146_147_148_149_150_151_152_153_154_155_156_157_158_159_160_161_162_163_164_165_166_167_168_169_170_171_172_173_174_175_176_177_178_179_180_181_182_183_184_185_186_187_188_189_190_191_192_193_194_195_196_197_198_199_200_201_202_203_204_205_206_207_208_209_210_211_212_213_214_215_216_217_218_219_220_221_222_223_224_225_226_227_228_229_230_231_232_233_234_235_236_237_238_239_240_241_242_243_244_245_246_247_248_249_250_251_252_253_254_255_256i0.tab.cso_i1.tab.oi1.tab.crcci1err_1_2_3_4_5_6_7_8_9_10_11_12_13_14_15_16_17_18_19_20_21_22_23_24_25_26_27_28_29_30_31_32_33_34_35_36_37_38_39_40_41_42_43_44_45_46_47_48_49_50_51_52_53_54_55_56_57_58_59_60_61_62_63_64_65_66_67_68_69_70_71_72_73_74_75_76_77_78_79_80_81_82_83_84_85_86_87_88_89_90_91_92_93_94_95_96_97_98_99_100_101_102_103_104_105_106_107_108_109_110_111_112_113_114_115_116_117_118_119_120_121_122_123_124_125_126_127_128_129_130_131_132_133_134_135_136_137_138_139_140_141_142_143_144_145_146_147_148_149_150_151_152_153_154_155_156_157_158_159_160_161_162_163_164_165_166_167_168_169_170_171_172_173_174_175_176_177_178_179_180_181_182_183_184_185_186_187_188_189_190_191_192_193_194_195_196_197_198_199_200_201_202_203_204_205_206_207_208_209_210_211_212_213_214_215_216_217_218_219_220_221_222_223_224_225_226_227_228_229_230_231_232_233_234_235_236_237_238_239_240_241_242_243_244_245_246_247_248_249_250_251_252_253_254_255_256i1.tab.cso_scsi.tab.oscsi.tab.crccscsicmd_1_2_3_4_5_6_7_8_9_10_11_12_13_14_15_16_17_18_19_20_21_22_23_24_25_26_27_28_29_30_31_32_33_34_35_36_37_38_39_40_41_42_43_44_45_46_47_48_49_50_51_52_53_54_55_56_57_58_59_60_61_62_63_64_65_66_67_68_69_70_71_72_73_74_75_76_77_78_79_80_81_82_83_84_85_86_87_88_89_90_91_92_93_94_95_96_97_98_99_100_101_102_103_104_105_106_107_108_109_110_111_112_113_114_115_116_117_118_119_120_121_122_123_124_125_126_127_128_129_130_131_132_133_134_135_136_137_138_139_140_141_142_143_144_145_146_147_148_149_150_151_152_153_154_155_156_157_158_159_160_161_162_163_164_165_166_167_168_169_170_171_172_173_174_175_176_177_178_179_180_181_182_183_184_185_186_187_188_189_190_191_192_193_194_195_196_197_198_199_200_201_202_203_204_205_206_207_208_209_210_211_212_213_214_215_216_217_218_219_220_221_222_223_224_225_226_227_228_229_230_231_232_233_234_235_236_237_238_239_240_241_242_243_244_245_246_247_248_249_250_251_252_253_254busid_255_256_257_258_259_260_261_262_263_264_265_266_267_268_269_270_271_272_273_274_275_276_277_278_279_280_281_282_283_284_285scsiident_286_287_288_289_290_291_292_293_294_295_296_297_298_299_300_301cmesg_302_303_304_305_306scsi.tab.cso_sense.osense.crccsony_sensesony_senseniargsiargsncargscargserr_8_9cmdscsi_cmdbufretscsi_returnnsony_senseexstab_exstab_11_12_13_14_15_16_17_18_19_20_21_22_23_24_25_26sony_extsensesony_extsensedatadestndata_32_37_38_41_42_45bufsony_extsense2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufsense.cso_nesd.tab.onesd.tab.crccnesd_1_2_3_4_5_6_7_8_9_10_11_12_13_14_15_16_17_18_19_20_21_22_23_24_25_26_27_28_29_30_31_32_33_34_35_36_37_38_39_40_41_42_43_44_45_46_47_48_49_50_51_52_53_54_55_56_57_58_59_60_61_62_63_64_65_66_67_68_69_70_71_72_73_74_75_76_77_78_79_80_81_82_83_84_85_86_87_88_89_90_91_92_93_94_95_96_97_98_99_100_101_102_103_104_105_106_107_108_109_110_111_112_113_114_115_116_117_118_119_120_121_122_123_124_125_126_127_128_129_130_131_132_133_134_135_136_137_138_139_140_141_142_143_144_145_146_147_148_149_150_151_152_153_154_155_156_157_158_159_160_161_162_163_164_165_166_167_168_169_170_171_172_173_174_175_176_177_178_179_180_181_182_183_184_185_186_187_188_189_190_191_192_193_194_195_196_197_198_199_200_201_202_203_204_205_206_207_208_209_210_211_212_213_214_215_216_217_218_219_220_221_222_223_224_225_226_227_228_229_230_231_232_233_234_235_236_237_238_239_240_241_242_243_244_245_246_247_248_249_250_251_252_253_254_255nesd.tab.cwr_dev.odev.crccfns_fns1_3_4_5_6_7_8_9wrendev2_10_112nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufdev.cwr_inq.oinq.crccwr_extinqwr_extinqniargsiargsncargscargserr_6cmdscsi_cmdretscsi_returnvendorproductnwr_extinq2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufinq.cwr_mode.omode.crccbit_4_5_6_7_8_9_10_11_12er_ererpcferr_15_21_22_20_26nretscsi_returncmdscsi_cmderdr_drdrpcferr_31_32_33cmdscsi_cmdretscsi_returnndrbit_36_37_38_39_40_41fp_fpfppcferr_44_45_46_47_55nretscsi_returncmdscsi_cmdfpgeom_geomgeompcferr_60cmdscsi_cmdretscsi_returnngeombit_63_64_65_66cc_ccccpcferr_69_77_78nretscsi_returncmdscsi_cmdccwr_modesensewr_modesenseniargsiargsncargscargserrerr_81nwr_modesensewr_modeselectwr_modeselectniargsiargsiargsncargscargserrerr_94_97_100_103_106_110_111_109_115cmdscsi_cmdretscsi_returnnwr_modeselect2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufmode.cwr_diag.odiag.crccwr_diagwr_diagniargsiargsncargscargserr_8_11_12cmdscsi_cmdretscsi_returntnwr_diag2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufdiag.cs_h_io.oh_io.crccfd_fds_ignuass_ioss_iopreservecmdscsi_cmdncmdncmdretscsi_returnnreterr_8_14_22nretvss_iosmsg_smsg_28_29_30_31_32_33_34_35s_ios_iopreservecmdscsi_cmdncmdretscsi_returnretscsi_returnnreterrerr_56mycmdscsi_cmdnioerrstatusbufignoreduas_ios_idss_extsense2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufh_io.cge_sense.osense.crccgen_sensegen_senseniargsiargsncargscargserr_8_11_12_15_16cmdscsi_cmdretscsi_returnngen_senseexstab_exstab_18_19_20_21_22_23_24_25_26_27_28_29_30_31_32_33gen_extsensegen_extsensedatadatadestndata_39_40_41classgen_extsense2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufsense.cs_pperror.opperror.crccpperrorpperrorbufmesg_5_6pperrorscsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmdpperror.cs_fixedstr.ofixedstr.crccfixedstrfixedstrsrcsrclenlendestsfixedstrscsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmdfixedstr.cs_longat.olongat.crcclongatlongatsrcsrcnlongatscsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmdlongat.cs_xd.oxd.crccxdxdpnfp_iobuf_12_13_23_27_39_44_46_47_51indlsbufdidstarxd2nameverboseextsensefns121namehelpparamfn1scsi_returnidscsi_statscsi_msgflagstypereg1reg2sensepaddatanreadscsi_returnscsi_cmdidbus_idflagscmddatascsi_cmd_iobuf_cnt_ptr_base_flag_file_iobufxd.catoi.oclose.octime.octype.odata.oerrlst.oexit.ofgets.ofilbuf.oflsbuf.ofopen.ofprintf.ogetfields.olseek.omalloc.omemcmp.omemcpy.omemset.omin.oonexit.oopen.oprintf.orand.oread.osbrk.osetbuf.osleep.osprintf.ostrcat.ostrchr.ostrcmp.ostrcpy.ostrdup.ostrlen.ostrncmp.ostrncpy.otime.oudiv.owrite.o_cleanup.o_exit.oalarm.ocerror.ocreat.odoprnt.ogetpid.okill.osetjmp.osignal.o_exitstart_main_environ__iob_setbuf_scsi_target_set_sony_s_id_genericdev_printf_fflush_fgets_strchr_getmfields_fprintf_atoi_strlen_strncmp_setdevice_ss_extsense_strcmp_gen_help_sonydev_wrendev_gen_dev_gen_capacity_gen_display_gen_inq_gen_readt_gen_reset_gen_scsi_gen_sense_gen_start_gen_stop_gen_tur_gen_extsense_gen_rmb_gen_devtype_s_io_fixedstr_longat_sprintf_ss_ioudiv_time_srand_nrand_sony_alt_sony_conf_sony_copy_sony_diskid_sony_eject_sony_inq_sony_internal_sony_media_sony_readid_sony_rel_sony_sense_sony_set_sony_status_sony_extsense__flsbuf_min_sony_istatus_shelfside_xd_i0com_scsicmd_i1err_scsiident_busid_cmesg_sony_media1_fopen_pperror_strdup_strncpy_ctime_nesd_strcat_wr_diag_wr_extinq_wr_modesense_wr_modeselect_sleep_memcpy_s_ignua_open_write_close_read_strcpy_errno_sys_nerr_sys_errlist_memcmpcerror_localtime_asctime_ftime_gmtime_dysize__ctype__sibuf__sobuf__lastbuf__cleanup__exit__filbuf_malloc__setcleanup__stdioclean_onexit_fclose_free_creat_lseek__doprnt_setfields_memset_getfields_sbrk_ialloc_realloc_mstats__onexitfns_rand_lrand_frand_Srand_end_brk_alarm_setjmp_signal_getpid_kill_pause_longjmp_snprintf_getppid0707070035050454011006660011710000040000011505010464020224300001100000007344scsish.c#include  <stddef.h>
                   4044: #include       <stdio.h>
                   4045: #include       <string.h>
                   4046: #include       "scsi.h"
                   4047: #include       "scsish.h"
                   4048: 
                   4049: extern Device genericdev;
                   4050: static Device *dev = 0;
                   4051: static Function *function(char *, Device **);
                   4052: static void parse(FILE *);
                   4053: 
                   4054: main()
                   4055: {
                   4056:        setbuf(stdout, (char *)0);
                   4057:        scsi_target(2);
                   4058:        set_sony();
                   4059:        printf("dev=%s, target=%d:\n", dev? dev->name:genericdev.name, s_id);
                   4060:        parse(stdin);
                   4061:        exit(0);
                   4062: }
                   4063: 
                   4064: static void
                   4065: parse(FILE *fp)
                   4066: {
                   4067:        int i, n;
                   4068:        char *param;
                   4069:        char buf[4096];
                   4070:        char *ptrs[100], *cargs[20];
                   4071:        int iargs[20];
                   4072:        int nc, ni;
                   4073:        Function *fn;
                   4074:        Device *thatdev;
                   4075:        char err[512];
                   4076: 
                   4077:        for(;;){
                   4078:                printf("> ");
                   4079:                fflush(stdout);
                   4080:                if(fgets(buf, sizeof buf, fp) == NULL)
                   4081:                        break;
                   4082:                if(param = strchr(buf, '\n'))
                   4083:                        *param = 0;
                   4084:                n = getmfields(buf, ptrs, sizeof ptrs/sizeof ptrs[0]);
                   4085:                if(n < 1)
                   4086:                        continue;
                   4087:                if((fn = function(ptrs[0], &thatdev)) == 0){
                   4088:                        fprintf(stderr, "can't find cmd '%s'\n", ptrs[0]);
                   4089:                        continue;
                   4090:                }
                   4091:                ni = nc = 0;
                   4092:                param = fn->param;
                   4093:                for(i = 1; i < n; i++){
                   4094:                        switch(*param++)
                   4095:                        {
                   4096:                        case 'I':
                   4097:                                iargs[ni++] = atoi(ptrs[i]);
                   4098:                                break;
                   4099:                        case 'L':
                   4100:                                iargs[ni++] = atoi(ptrs[i]);
                   4101:                                if((iargs[ni-1] < 0) || (iargs[ni-1] > 7)){
                   4102:                                        fprintf(stderr, "%s: lun %d out of range\n", ptrs[0], iargs[ni-1]);
                   4103:                                        continue;
                   4104:                                }
                   4105:                                break;
                   4106:                        case 'S':
                   4107:                                cargs[nc++] = ptrs[i];
                   4108:                                break;
                   4109:                        default:
                   4110:                                break;
                   4111:                        }
                   4112:                        if(*param == '?')
                   4113:                                param++;
                   4114:                }
                   4115:                while(param[0] && param[1] && (param[1] == '?'))
                   4116:                        param += 2;
                   4117:                if((i == n) != (*param == 0)){
                   4118:                        printf("param mismatch: %s: i=%d/n=%d param='%s'\n",
                   4119:                                ptrs[0], i, n, param);
                   4120:                        printf("device %s: %s\n", thatdev->name, fn->help);
                   4121:                        continue;
                   4122:                }
                   4123:                if((*fn->fn)(ni, iargs, nc, cargs, err))
                   4124:                        fprintf(stderr, "error in '%s': %s\n", fn->name, err);
                   4125:        }
                   4126: }
                   4127: 
                   4128: static Function *
                   4129: flook(Function *f, char *name)
                   4130: {
                   4131:        for(; f->help; f++)
                   4132:                if(strncmp(f->name, name, strlen(f->name)) == 0)
                   4133:                        return(f);
                   4134:        return(0);
                   4135: }
                   4136: 
                   4137: static Function *
                   4138: function(char *name, Device **devptr)
                   4139: {
                   4140:        Function *f = 0;
                   4141: 
                   4142:        if(dev && dev->fns && (f = flook(dev->fns, name)))
                   4143:                *devptr = dev;
                   4144:        else if(f = flook(genericdev.fns, name))
                   4145:                *devptr = &genericdev;
                   4146:        return(f);
                   4147: }
                   4148: 
                   4149: void
                   4150: setdevice(Device *d)
                   4151: {
                   4152:        dev = d;
                   4153:        ss_extsense = dev->extsense;
                   4154: }
                   4155: 
                   4156: static
                   4157: help(Device *d, char *cmd, Device *prec)
                   4158: {
                   4159:        Function *f;
                   4160:        Function *base;
                   4161: 
                   4162:        base = (prec && prec->fns)? prec->fns:0;
                   4163:        if(cmd == 0){
                   4164:                printf("device %s(%s):\n", d->name, d->verbose);
                   4165:                if(f = d->fns)
                   4166:                        while(f->name){
                   4167:                                if((base == 0) || (flook(base, f->name) == 0))
                   4168:                                        printf("\t%s\n", f->help);
                   4169:                                f++;
                   4170:                        }
                   4171:                return(0);
                   4172:        } else {
                   4173:                if(f = d->fns)
                   4174:                        while(f->name)
                   4175:                                if(strcmp(f->name, cmd) == 0){
                   4176:                                        printf("(%s) %s\n", d->name, f->help);
                   4177:                                        return(1);
                   4178:                                } else
                   4179:                                        f++;
                   4180:                return(0);
                   4181:        }
                   4182: }
                   4183: 
                   4184: int
                   4185: gen_help(int niargs, int *iargs, int ncargs, char **cargs)
                   4186: {
                   4187: #pragma ref niargs
                   4188: #pragma ref iargs
                   4189: 
                   4190:        if(dev)
                   4191:                if(help(dev, ncargs == 0? 0:cargs[0], (Device *)0))
                   4192:                        return(0);
                   4193:        help(&genericdev, ncargs == 0? 0:cargs[0], dev);
                   4194:        return(0);
                   4195: }
                   4196: 
                   4197: extern Device sonydev;
                   4198: extern Device wrendev;
                   4199: static Device *devs[] = {
                   4200:        &genericdev,
                   4201:        &sonydev,
                   4202:        &wrendev,
                   4203:        0
                   4204: };
                   4205: 
                   4206: int
                   4207: gen_dev(int niargs, int *iargs, int ncargs, char **cargs)
                   4208: {
                   4209:        Device **d;
                   4210: 
                   4211: #pragma ref niargs
                   4212: #pragma ref iargs
                   4213: 
                   4214:        if(ncargs == 0)
                   4215:                printf("dev=%s\n", dev? dev->name : genericdev.name);
                   4216:        else if(strcmp(cargs[0], "?") == 0){
                   4217:                printf("available devices:\n");
                   4218:                for(d = devs; *d; d++)
                   4219:                        printf("\t%s(%s)\n", (*d)->name, (*d)->verbose);
                   4220:        } else {
                   4221:                for(d = devs; *d; d++)
                   4222:                        if(strcmp(cargs[0], (*d)->name) == 0)
                   4223:                                break;
                   4224:                if(*d)
                   4225:                        setdevice(*d);
                   4226:                else
                   4227:                        fprintf(stderr, "device '%s' unknown\n", cargs[0]);
                   4228:        }
                   4229:        return(0);
                   4230: }
                   4231: 
                   4232: void
                   4233: scsi_target(int n)
                   4234: {
                   4235:        if((n < 0) || (n >= 8))
                   4236:                fprintf(stderr, "%d is an invalid target\n", n);
                   4237:        else
                   4238:                s_id = n;
                   4239: }
                   4240: 
                   4241: set_sony()
                   4242: {
                   4243:        int iargs[1];
                   4244:        char *cargs[1];
                   4245: 
                   4246:        cargs[0] = "sony";
                   4247:        gen_dev(0, iargs, 1, cargs);
                   4248: }
                   4249: 0707070035050453651006660011710000040000010451350457563432000001100000001004scsish.htypedef int (*Functionfn)(int, int *, int, char **, char *);
                   4250: 
                   4251: typedef struct
                   4252: {
                   4253:        char *name;
                   4254:        char *help;
                   4255:        char *param;
                   4256:        Functionfn fn;
                   4257: } Function;
                   4258: 
                   4259: typedef struct
                   4260: {
                   4261:        char *name;
                   4262:        char *verbose;
                   4263:        void (*extsense)(uchar *, char *, int);
                   4264:        Function *fns;
                   4265: } Device;
                   4266: extern void setdevice(Device *);
                   4267: 
                   4268: extern void scsi_target(int);
                   4269: extern void fixedstr(uchar *src, int len, char *dest);
                   4270: extern void gen_extsense(uchar *, char *, int);
                   4271: extern int shelfside(char *arg, char *err);
                   4272: extern void xd(uchar *base, int, FILE *fp);
                   4273: 0707070035050422071006660011710000040000010273200464713423200000700000000215sgi.mk# config stuff: sgi; system v with moran/droneck /dev/scsi
                   4274: CC=pcc         # must be ansi
                   4275: RANLIB=:
                   4276: LDFLAGS= -lds
                   4277: IO=md_io
                   4278: CFLAGS=-g -I../inc
                   4279: NPROC=4
                   4280: 0707070035050453470407770011710000040000020452060464700560100000500000000000sony0707070035050453461006660011710000040000010031700463122750000001300000001570sony/dev.c#include       <stdio.h>
                   4281: #include       "../scsi.h"
                   4282: #include       "../scsish.h"
                   4283: #include       "fns.h"
                   4284: 
                   4285: static Function fns[] = {
                   4286:        { "alternate", "alternate [lun]", "L?", sony_alt },
                   4287:        { "config", "config", "", sony_conf },
                   4288:        { "copy", "copy srclun start n destlun dest", "LIILI", sony_copy },
                   4289:        { "diskid", "diskid [lun]", "L?", sony_diskid },
                   4290:        { "eject", "eject lun", "L", sony_eject },
                   4291:        { "inq", "inq [lun]", "L?", sony_inq },
                   4292:        { "internal", "internal test [drive]  # internal -1 for list", "II?", sony_internal },
                   4293:        { "media", "media lun start count [file]", "LIIS?", sony_media },
                   4294:        { "readid", "readid lun [start]", "LI?", sony_readid },
                   4295:        { "rel", "rel lun [shelfside]", "LS?", sony_rel },
                   4296:        { "sense", "sense [lun=0]", "L?", sony_sense },
                   4297:        { "set", "set shelfside lun", "SL", sony_set },
                   4298:        { "status", "status", "", sony_status },
                   4299:        { 0 }
                   4300: };
                   4301: 
                   4302: Device sonydev = {
                   4303:        "sony", "Sony WDA-3000",
                   4304:        sony_extsense,
                   4305:        fns
                   4306: };
                   4307: 0707070035050453451006660011710000040000010452100457563432100001300000001625sony/inq.c#include        <stdio.h>
                   4308: #include       "../scsi.h"
                   4309: #include       "../scsish.h"
                   4310: #include       "fns.h"
                   4311: 
                   4312: int
                   4313: sony_inq(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4314: {
                   4315:        struct scsi_cmd cmd;
                   4316:        struct scsi_return ret;
                   4317:        int n, i;
                   4318: 
                   4319: #pragma ref ncargs
                   4320: #pragma ref cargs
                   4321: 
                   4322:        if(niargs == 0)
                   4323:                for(niargs = 0; niargs < 8; niargs++)
                   4324:                        iargs[niargs] = niargs;
                   4325:        for(i = 0; i < niargs; i++){
                   4326:                set6(cmd, 0x12, iargs[i]<<5, 0, 0, 6, 0);
                   4327:                if(n = s_io(0, &cmd, 0, &ret, 6, err))
                   4328:                        return(n);
                   4329:                printf("inq(%d,%d): ", s_id, iargs[i]);
                   4330:                if(ret.data[5]&0x80)
                   4331:                        printf("power off (0x%x)\n", ret.data[5]&0xFF);
                   4332:                else if(ret.data[5]&0x40)
                   4333:                        printf("empty (0x%x)\n", ret.data[5]&0xFF);
                   4334:                else
                   4335:                        printf("%s,%s,%s,%s (0x%x)\n",
                   4336:                                (ret.data[5]&0x08)?"write protect":"writable",
                   4337:                                (ret.data[5]&0x04)?"no alternate":"",
                   4338:                                (ret.data[5]&0x02)?"drive error":"",
                   4339:                                (ret.data[5]&0x01)?"ready":"not ready",
                   4340:                                ret.data[5]&0xFF);
                   4341:        }
                   4342:        return(0);
                   4343: }
                   4344: 0707070035050453441006660011710000040000010452120457563432100001300000001423sony/alt.c#include        <stdio.h>
                   4345: #include       "../scsi.h"
                   4346: #include       "../scsish.h"
                   4347: #include       "fns.h"
                   4348: 
                   4349: static
                   4350: table(int drive, int tab, uchar *data)
                   4351: {
                   4352:        int n, i;
                   4353: 
                   4354:        n = data[6];
                   4355:        printf("(%d,%d): alternate table %d (%d entries)\n", s_id, drive, tab, n);
                   4356:        for(data += 0x18, i = 0; i < n; data += 4, i++)
                   4357:                printf("%ld%c", data[0]+256L*data[1]+256L*256*data[2],
                   4358:                        (i%10 == 9)? '\n':' ');
                   4359:        if((i%10) && n)
                   4360:                putchar('\n');
                   4361: }
                   4362: 
                   4363: int
                   4364: sony_alt(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4365: {
                   4366:        struct scsi_cmd cmd;
                   4367:        struct scsi_return ret;
                   4368:        int n, i;
                   4369: 
                   4370: #pragma ref ncargs
                   4371: #pragma ref cargs
                   4372: 
                   4373:        if(niargs == 0)
                   4374:                iargs[0] = 0;
                   4375:        set6(cmd, 0xC3, iargs[0]<<5, 0, 0, 0, 0);
                   4376:        if(n = s_io(0, &cmd, 0, &ret, 4096, err))
                   4377:                return(n);
                   4378:        for(i = 0; i < 4; i++)
                   4379:                table(iargs[0], i+1, &ret.data[1024*i]);
                   4380:        return(0);
                   4381: }
                   4382: 0707070035050453431006660011710000040000011505140464060013200001600000002236sony/config.c#include     <stdio.h>
                   4383: #include       "../scsi.h"
                   4384: #include       "../scsish.h"
                   4385: #include       "fns.h"
                   4386: 
                   4387: static char mtab[5][2] =
                   4388: {
                   4389:        '0', '0', '1', '1', '1', '2', '2', '2', '?', '?'
                   4390: };
                   4391: static char *brdname[] = {
                   4392:        "no doard", "T.D. Systems Viking", "U.S. Design 1158"
                   4393: };
                   4394: 
                   4395: int
                   4396: sony_conf(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4397: {
                   4398:        struct scsi_cmd cmd;
                   4399:        struct scsi_return ret;
                   4400:        int n, i;
                   4401:        char buf[512];
                   4402: 
                   4403: #pragma ref niargs
                   4404: #pragma ref iargs
                   4405: #pragma ref ncargs
                   4406: #pragma ref cargs
                   4407: 
                   4408:        set6(cmd, 0x12, 0, 0, 0, 44, 0);
                   4409:        if(n = s_io(0, &cmd, 0, &ret, 44, err))
                   4410:                return(n);
                   4411:        i = min(ret.data[37], 4);
                   4412:        fixedstr(&ret.data[8], 28, buf);
                   4413:        printf("config(%d,%d): %s device, '%s', %c controller%s, %c drive%s\n",
                   4414:                s_id, 0, (ret.data[0] == 0x4)? "WORM":"Unknown",
                   4415:                buf, mtab[i][0], (mtab[i][0] == '1')?"":"s",
                   4416:                mtab[i][1], (mtab[i][1] == '1')?"":"s");
                   4417:        printf("\tUnibus-SCSI controller=%s\n", brdname[ret.type]);
                   4418:        printf("\tROMS:");
                   4419:        if(ret.data[38] != 0xFF)
                   4420:                printf(" upper controller=0x%x,", ret.data[38]);
                   4421:        if(ret.data[40] != 0xFF)
                   4422:                printf(" lower controller=0x%x,", ret.data[40]);
                   4423:        printf( " IF-129=0x%x, SY-46=0x%x, SS-30=0x%x\n", ret.data[36],
                   4424:                ret.data[42], ret.data[43]);
                   4425:        return(0);
                   4426: }
                   4427: 0707070035050453421006660011710000040000011504400463127760200001600000004127sony/status.c#include     <stdio.h>
                   4428: #include       "../scsi.h"
                   4429: #include       "../scsish.h"
                   4430: 
                   4431: static
                   4432: shelf(int i)
                   4433: {
                   4434:        printf(": ");
                   4435:        if(i&0x80){
                   4436:                printf("%s,", (i&0x40)? "disk":"temporary");
                   4437:                if(i&0x10) printf("wait loading,");
                   4438:                if(i&0x08) printf("wait ejection,");
                   4439:                if(i&0x20) printf("use shelf instead of drive for LUN %d", i&7);
                   4440:        } else
                   4441:                printf("no disk");
                   4442:        printf("\n");
                   4443: }
                   4444: 
                   4445: int
                   4446: sony_istatus(struct scsi_return *ret, char *err)
                   4447: {
                   4448:        struct scsi_cmd cmd;
                   4449:        int n;
                   4450: 
                   4451:        set6(cmd, 0x1D, 0, 0, 0, 10, 0);
                   4452:        cmd.data[0] = 0xE2;     /* internal status */
                   4453:        cmd.data[1] = 0;
                   4454:        cmd.data[2] = 0;
                   4455:        cmd.data[3] = 0;
                   4456:        cmd.data[4] = 0;
                   4457:        cmd.data[5] = 0;
                   4458:        cmd.data[6] = 0;
                   4459:        cmd.data[7] = 0;
                   4460:        cmd.data[8] = 0;
                   4461:        cmd.data[9] = 0;
                   4462:        if(n = s_io(0, &cmd, 10, ret, 0, err))
                   4463:                return(n);
                   4464:        setdiag(cmd, 0, 128);
                   4465:        if(n = s_io(0, &cmd, 0, ret, 128, err))
                   4466:                return(n);
                   4467:        return(0);
                   4468: }
                   4469: 
                   4470: int
                   4471: sony_status(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4472: {
                   4473:        struct scsi_return ret;
                   4474:        int n, i, start;
                   4475:        uchar *d;
                   4476: 
                   4477: #pragma ref niargs
                   4478: #pragma ref iargs
                   4479: #pragma ref ncargs
                   4480: #pragma ref cargs
                   4481: 
                   4482:        if(n = sony_istatus(&ret, err))
                   4483:                return(n);
                   4484:        d = &ret.data[16];
                   4485:        for(i = 0; i < 8; i++, d += 4){
                   4486:                printf("drive %d: %sready,%sdisk in LUN,power %s,", i,
                   4487:                        (d[0]&1)?"":"not ", (d[0]&0x40)?"":"no ",
                   4488:                        (d[0]&0x80)?"off":"on");
                   4489:                if(d[0]&0x40){
                   4490:                        if(d[1]&0x80){
                   4491:                                printf("disk in drive %d", d[1]&0x7f);
                   4492:                                if(d[2]&0x80)
                   4493:                                        printf(", return shelf %d%c", (d[2]&0x7F)/2, "ab"[d[2]&1]);
                   4494:                        } else
                   4495:                                printf("disk in shelf %d%c (%d)", (d[1]&0x7f)/2, (d[1]&1)+'a', d[1]&0x7f);
                   4496:                }
                   4497:                printf("\n");
                   4498:        }
                   4499:        for(i = 0; i < 50;){
                   4500:                for(start = i; ++i < 50;)
                   4501:                        if(d[i] != d[start])
                   4502:                                break;
                   4503:                if(i == start+1)
                   4504:                        printf("%d", start);
                   4505:                else
                   4506:                        printf("%d-%d", start, i-1);
                   4507:                shelf(d[start]);
                   4508:        }
                   4509:        d += 50;
                   4510:        printf("I/O shelf");
                   4511:        shelf(*d);
                   4512:        d++;
                   4513:        printf("carrier: ");
                   4514:        i = *d&0x7F;
                   4515:        if(*d&0x80)
                   4516:                printf("disk shelf=%d%c (%d)\n", i/2, 'a'+(i&1), i);
                   4517:        else
                   4518:                printf("no disk\n");
                   4519:        d++;
                   4520:        if(*d&0x80)
                   4521:                printf("upper drive: disk, LUN=%d\n", *d&7);
                   4522:        else
                   4523:                printf("upper drive: no disk\n");
                   4524:        d++;
                   4525:        if(*d&0x80)
                   4526:                printf("lower drive: disk, LUN=%d\n", *d&7);
                   4527:        else
                   4528:                printf("lower drive: no disk\n");
                   4529:        return(0);
                   4530: }
                   4531: 0707070035050453411006660011710000040000010452160457563432200001300000000754sony/rel.c#include        <stdio.h>
                   4532: #include       "../scsi.h"
                   4533: #include       "../scsish.h"
                   4534: #include       "fns.h"
                   4535: 
                   4536: int
                   4537: sony_rel(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4538: {
                   4539:        struct scsi_cmd cmd;
                   4540:        struct scsi_return ret;
                   4541:        int n, i, j;
                   4542: 
                   4543: #pragma ref niargs
                   4544: 
                   4545:        if(ncargs == 0){
                   4546:                i = 0;
                   4547:                j = 0;          /* its ignored anyway */
                   4548:        } else {
                   4549:                i = 1;
                   4550:                if((j = shelfside(cargs[0], err)) < 0)
                   4551:                        return(1);
                   4552:        }
                   4553:        set6(cmd, 0xD7, (iargs[0]<<5)|i, 0, j, 0, 0);
                   4554:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   4555:                return(n);
                   4556:        return(0);
                   4557: }
                   4558: 0707070035050453401006660011710000040000010452170457563432200001300000000642sony/set.c#include        <stdio.h>
                   4559: #include       "../scsi.h"
                   4560: #include       "../scsish.h"
                   4561: #include       "fns.h"
                   4562: 
                   4563: int
                   4564: sony_set(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4565: {
                   4566:        struct scsi_cmd cmd;
                   4567:        struct scsi_return ret;
                   4568:        int n, i;
                   4569: 
                   4570: #pragma ref niargs
                   4571: #pragma ref ncargs
                   4572: 
                   4573:        if((i = shelfside(cargs[0], err)) < 0)
                   4574:                return(1);
                   4575:        set6(cmd, 0xD6, iargs[0]<<5, 0, i, 0, 0);
                   4576:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   4577:                return(n);
                   4578:        return(0);
                   4579: }
                   4580: 0707070035050453371006660011710000040000010452200457563432200001500000000576sony/eject.c#include      <stdio.h>
                   4581: #include       "../scsi.h"
                   4582: #include       "../scsish.h"
                   4583: #include       "fns.h"
                   4584: 
                   4585: int
                   4586: sony_eject(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4587: {
                   4588:        struct scsi_cmd cmd;
                   4589:        struct scsi_return ret;
                   4590:        int n;
                   4591: 
                   4592: #pragma ref niargs
                   4593: #pragma ref ncargs
                   4594: #pragma ref cargs
                   4595: 
                   4596:        set6(cmd, 0xC0, iargs[0]<<5, 0, 0, 0, 0);
                   4597:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   4598:                return(n);
                   4599:        return(0);
                   4600: }
                   4601: 0707070035050453361006660011710000040000010452210457563432200002100000000754sony/shelfside.c#include  <stdio.h>
                   4602: #include       "../scsi.h"
                   4603: #include       "../scsish.h"
                   4604: #include       "fns.h"
                   4605: 
                   4606: int
                   4607: shelfside(char *arg, char *err)
                   4608: {
                   4609:        char *oarg = arg;
                   4610:        int shelf;
                   4611: 
                   4612:        if((*arg < '0') || (*arg > '9')){
                   4613: usage:
                   4614:                sprintf(err, "shelfside '%s' must be numa or numb", oarg);
                   4615:                return(-1);
                   4616:        }
                   4617:        shelf = 0;
                   4618:        while((*arg >= '0') && (*arg <= '9'))
                   4619:                shelf = 10*shelf + *arg++ - '0';
                   4620:        shelf <<= 1;
                   4621:        if(*arg == 'a')
                   4622:                ;
                   4623:        else if(*arg == 'b')
                   4624:                shelf |= 1;
                   4625:        else
                   4626:                goto usage;
                   4627:        if(*++arg)
                   4628:                goto usage;
                   4629:        return(shelf);
                   4630: }
                   4631: 0707070035050453351006660011710000040000010452220457563432200001600000000742sony/diskid.c#include     <stdio.h>
                   4632: #include       "../scsi.h"
                   4633: #include       "../scsish.h"
                   4634: #include       "fns.h"
                   4635: 
                   4636: int
                   4637: sony_diskid(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4638: {
                   4639:        struct scsi_cmd cmd;
                   4640:        struct scsi_return ret;
                   4641:        int n;
                   4642: 
                   4643: #pragma ref ncargs
                   4644: #pragma ref cargs
                   4645: 
                   4646:        if(niargs == 0)
                   4647:                iargs[0] = 0;
                   4648:        set6(cmd, 0xC2, iargs[0]<<5, 0, 0, 0, 0);
                   4649:        if(n = s_io(0, &cmd, 0, &ret, 1024, err))
                   4650:                return(n);
                   4651:        printf("(%d,%d) disk id block:\n", s_id, iargs[0]);
                   4652:        xd(ret.data, 1024, stdout);
                   4653:        return(0);
                   4654: }
                   4655: 0707070035050453341006660011710000040000010332450463123222500002000000011302sony/internal.c#include   <stdio.h>
                   4656: #include       "../scsi.h"
                   4657: #include       "../scsish.h"
                   4658: #include       "fns.h"
                   4659: 
                   4660: static
                   4661: internal(int n, int b1, int nb, struct scsi_return *ret, char *err)
                   4662: {
                   4663:        struct scsi_cmd cmd;
                   4664: 
                   4665:        set6(cmd, 0x1D, b1, 0, 0, 10, 0);
                   4666:        cmd.data[0] = n;
                   4667:        cmd.data[1] = b1>>8;
                   4668:        cmd.data[2] = 0;
                   4669:        cmd.data[3] = 0;
                   4670:        cmd.data[4] = 0;
                   4671:        cmd.data[5] = 0;
                   4672:        cmd.data[6] = 0;
                   4673:        cmd.data[7] = 0;
                   4674:        cmd.data[8] = 0;
                   4675:        cmd.data[9] = 0;
                   4676:        if(n = s_io(0, &cmd, 10, ret, 0, err))
                   4677:                return(n);
                   4678:        setdiag(cmd, 0, nb);
                   4679:        if(n = s_io(0, &cmd, 0, ret, nb, err))
                   4680:                return(n);
                   4681:        return(0);
                   4682: }
                   4683: 
                   4684: static char *cmds[] = {
                   4685:        "internal command table",
                   4686:        "error information table",
                   4687:        "arm controller diagnostics",
                   4688:        "scsi control board diagnostics",
                   4689:        "drive controller diagnostics",
                   4690:        "jukebox status",
                   4691:        0
                   4692: };
                   4693: 
                   4694: static char *msg1[16] =
                   4695: {
                   4696:        "drive not connected or powered off",
                   4697:        "drive connected but no disk",
                   4698:        "diagnostic aborted: write-protect",
                   4699:        "diagnostic aborted: write area full",
                   4700:        "urk 4", "urk 5", "urk 6", "urk 7", "urk 8", "urk 9", "urk 10",
                   4701:        "urk 11", "urk 12", "urk 13", "urk 14", "urk 15"
                   4702: };
                   4703: 
                   4704: static char *testn[10] =
                   4705: {
                   4706:        "drive on/off",
                   4707:        "read disk id",
                   4708:        "move",
                   4709:        "seek",
                   4710:        "blank sector search",
                   4711:        "written sector search",
                   4712:        "search writable area",
                   4713:        "write",
                   4714:        "ECC margin check",
                   4715:        "read data compare"
                   4716: };
                   4717: 
                   4718: int
                   4719: sony_internal(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4720: {
                   4721:        struct scsi_cmd cmd;
                   4722:        struct scsi_return ret;
                   4723:        int n;
                   4724:        register unsigned char *d;
                   4725:        int i, drive, lower;
                   4726:        long t1, t2;
                   4727:        extern char *cmesg[];
                   4728:        extern char *i0com[], *i1err[], *scsicmd[], *busid[], *scsiident[];
                   4729: 
                   4730: #pragma ref ncargs
                   4731: #pragma ref cargs
                   4732: 
                   4733:        switch(iargs[0])
                   4734:        {
                   4735:        case -1:
                   4736:                printf("available internal commands:\n");
                   4737:                for(i = 0; cmds[i]; i++)
                   4738:                        printf("\tinternal %d: %s\n", i, cmds[i]);
                   4739:                break;
                   4740:        case 0:
                   4741:                if(internal(0xE5, 0, 256, &ret, err))
                   4742:                        return(1);
                   4743:                printf("internal 0 (%s):\n", cmds[iargs[0]]);
                   4744:                printf("Diagnostic #E5: last 16 internal tasks (drive,shelf)\n");
                   4745:                for(i = 0, d = ret.data; i < 16; i++, d += 16){
                   4746:                        printf("[%d] %s (%d,%d)\n",
                   4747:                                d[0], i0com[d[1]], d[2], d[3]);
                   4748:                }
                   4749:                break;
                   4750:        case 1:
                   4751:                if(internal(0xE4, 0, 256, &ret, err))
                   4752:                        return(1);
                   4753:                printf("internal 1 (%s):\n", cmds[iargs[0]]);
                   4754:                printf("Diagnostic #E4: last 16 errors; initiator[identify] error[sense] (cmd)\n");
                   4755:                for(i = 0, d = ret.data; i < 16; i++, d += 16){
                   4756:                        printf("%s[%s]: %s[#%x] (%s)\n",
                   4757:                                busid[d[0]], scsiident[d[1]], i1err[d[14]], d[15], scsicmd[d[4]]);
                   4758:                }
                   4759:                break;
                   4760:        case 2:
                   4761:                printf("internal 2 (%s):\n", cmds[iargs[0]]);
                   4762:                fflush(stdout);
                   4763:                time(&t1);
                   4764:                if(internal(0x90, 0, 8, &ret, err))
                   4765:                        return(1);
                   4766:                time(&t2);
                   4767:                d = ret.data;
                   4768:                if(d[0] == 0)
                   4769:                        printf("\tended normally");
                   4770:                else
                   4771:                        printf("\tfailed, error codes=#%x, #%x, #%x",
                   4772:                                d[0], d[1], d[2]);
                   4773:                printf(" (time: %lds)\n", t2-t1);
                   4774:                break;
                   4775:        case 3:
                   4776:                printf("internal 3 (%s):\n", cmds[iargs[0]]);
                   4777:                fflush(stdout);
                   4778:                time(&t1);
                   4779:                if(internal(0xe0, 0, 8, &ret, err))
                   4780:                        return(1);
                   4781:                time(&t2);
                   4782:                d = ret.data;
                   4783:                if(d[0] == 0)
                   4784:                        printf("\tended normally");
                   4785:                else
                   4786:                        printf("\tfailed, error codes=#%x, #%x, #%x",
                   4787:                                d[0], d[1], d[2]);
                   4788:                printf(" (time: %lds)\n", t2-t1);
                   4789:                break;
                   4790:        case 4:
                   4791:                if(niargs == 1)
                   4792:                        iargs[1] = 0;           /* zero default */
                   4793:                drive = iargs[1];
                   4794:                if(sony_istatus(&ret, err))
                   4795:                        return(1);
                   4796:                if((ret.data[100]&0x80) && (drive == (ret.data[100]&7)))
                   4797:                        lower = 0x100;
                   4798:                else if((ret.data[101]&0x80) && (drive == (ret.data[101]&7)))
                   4799:                        lower = 0x200;
                   4800:                else {
                   4801:                        fprintf(stderr, "drive %d not occupied\n", drive);
                   4802:                        return(1);
                   4803:                }
                   4804:                printf("drive %d[%ser]: %s\n", drive, (lower == 0x200)?"low":"upp", cmds[iargs[0]]);
                   4805:                fflush(stdout);
                   4806:                time(&t1);
                   4807:                if(internal(0x18, lower, 256, &ret, err))
                   4808:                        return(1);
                   4809:                time(&t2);
                   4810:                d = ret.data;
                   4811:                if(d[1]&0x80){
                   4812:                        printf("diagnostic result:");
                   4813:                        if((d[1]&0x70) == 0)
                   4814:                                printf(" no faults");
                   4815:                        else {
                   4816:                                if(d[1]&0x10)
                   4817:                                        printf(" controller-fault");
                   4818:                                if(d[1]&0x20)
                   4819:                                        printf(" drive-fault");
                   4820:                                if(d[1]&0x10)
                   4821:                                        printf(" disk-fault");
                   4822:                                printf(" (last error code 0x%2.2ux)", d[4]);
                   4823:                        }
                   4824:                } else
                   4825:                        printf("diagnostic not performed: %s", msg1[d[1]&0xF]);
                   4826:                printf(" (time: %lds)\n", t2-t1);
                   4827:                for(i = 0; i < 10; i++)
                   4828:                        printf("test %d[%s]: %s\n", i, testn[i], cmesg[d[i*8+drive+8]]);
                   4829:                printf("diagnostic count (drive:avail):");
                   4830:                for(d += 104, i = 0; i < 8; i++, d += 2)
                   4831:                        printf(" %d:%d", i, d[0]+d[1]*256);
                   4832:                printf("\n");
                   4833:                break;
                   4834:        case 5:
                   4835:                set10(cmd,  0xD3, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                   4836:                if(n = s_io(0, &cmd, 0, &ret, 20, err))
                   4837:                        return(n);
                   4838:                printf("%s: component(fatal err/err/cmds)\n", cmds[iargs[0]]);
                   4839:                d = ret.data;
                   4840: #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)
                   4841:        
                   4842:                ONE("upper drive", 4, ' ');
                   4843:                ONE("lower drive", 8, ' ');
                   4844:                ONE("sys control", 12, ' ');
                   4845:                printf("backup mem(0/%d/%d)\n", d[19]+256*d[18], d[17]+256*d[16]);
                   4846:                break;
                   4847:        }
                   4848:        return(0);
                   4849: }
                   4850: 0707070035050453331006660011710000040000010452240457563432200001400000000465sony/i0.tabi0com
                   4851: 00     nop
                   4852: 01     sense result
                   4853: 02     version check
                   4854: 04     recover disk warning
                   4855: 08     sense alternate information
                   4856: 0a     error margin check
                   4857: 18     diagnostics
                   4858: 20     sense drive status
                   4859: 21     recalibrate
                   4860: 22     drive on
                   4861: 23     drive off
                   4862: 24     disk out
                   4863: 30     seek
                   4864: 31     move
                   4865: 32     read
                   4866: a1     disk check
                   4867: a2     carrier move
                   4868: b1     disk set
                   4869: b2     disk release
                   4870: b3     disk rotate
                   4871: 0707070035050453321006660011710000040000010452260457563432200001400000000477sony/i1.tabi1err
                   4872: 94     drive error (SONY)
                   4873: a0     invalid command
                   4874: a1     invalid LUN
                   4875: a2     reserved bit nonzero
                   4876: a3     illegal logical address
                   4877: a4     illegal shelf number
                   4878: a5     illegal parameter length
                   4879: a6     illegal parameter
                   4880: a7     unacceptable diagnostics parameter
                   4881: a8     unit attention
                   4882: a9     drive not ready
                   4883: aa     medium removal prevented
                   4884: ab     reserved
                   4885: ac     no disk in LUN
                   4886: 0707070035050453311006660011710000040000010452270457563432200001600000001777sony/scsi.tabscsicmd
                   4887: 00     test unit ready
                   4888: 01     rezero unit
                   4889: 03     request sense
                   4890: 08     read
                   4891: 0a     write
                   4892: 0b     seek
                   4893: 0c     move
                   4894: 12     inquiry
                   4895: 15     mode select
                   4896: 16     reserve
                   4897: 17     release
                   4898: 18     copy
                   4899: 1a     mode sense
                   4900: 1b     start/stop unit
                   4901: 1c     receive diagnostics
                   4902: 1d     send diagnostics
                   4903: 1e     prevent/allow medium removal
                   4904: 25     read capacity
                   4905: 28     read
                   4906: 2a     write
                   4907: 2c     blank sector search
                   4908: 2d     written sector search
                   4909: c0     disk eject
                   4910: c2     read disk id
                   4911: c3     sense alternate information
                   4912: c4     recover disk warning
                   4913: d3     request recovered status
                   4914: d6     disk set
                   4915: d7     disk release
                   4916: busid
                   4917: 01     0
                   4918: 02     1
                   4919: 80     7
                   4920: scsiident
                   4921: 80     no dis/reconnect-LUN 0
                   4922: 81     no dis/reconnect-LUN 1
                   4923: 82     no dis/reconnect-LUN 2
                   4924: 83     no dis/reconnect-LUN 3
                   4925: 84     no dis/reconnect-LUN 4
                   4926: 85     no dis/reconnect-LUN 5
                   4927: 86     no dis/reconnect-LUN 6
                   4928: 87     no dis/reconnect-LUN 7
                   4929: c0     dis/reconnect-LUN 0
                   4930: c1     dis/reconnect-LUN 1
                   4931: c2     dis/reconnect-LUN 2
                   4932: c3     dis/reconnect-LUN 3
                   4933: c4     dis/reconnect-LUN 4
                   4934: c5     dis/reconnect-LUN 5
                   4935: c6     dis/reconnect-LUN 6
                   4936: c7     dis/reconnect-LUN 7
                   4937: cmesg
                   4938: 0      good
                   4939: e0     test not done
                   4940: ee     diagnostic could not be done
                   4941: fe     drive not ready (no disk)
                   4942: ff     not connected or power off
                   4943: 0707070035050453301006660011710000040000011504740464014764400001500000005757sony/media.c#include      <stdio.h>
                   4944: #include       <stddef.h>
                   4945: #include       "../scsi.h"
                   4946: #include       "../scsish.h"
                   4947: #include       "fns.h"
                   4948: 
                   4949: static int cnts[256];
                   4950: static char *cmsg[256];
                   4951: 
                   4952: sony_media1(int drive, long lbn, int lower, struct scsi_return *ret, char *err)
                   4953: {
                   4954:        struct scsi_cmd cmd;
                   4955:        int n;
                   4956: 
                   4957:        set6(cmd, 0x1D, drive<<5, 0, 0, 10, 0);
                   4958:        cmd.data[0] = 0x0A;     /* error margin check */
                   4959:        cmd.data[1] = lower? 2:1;
                   4960:        cmd.data[2] = 0;
                   4961:        cmd.data[3] = 0;
                   4962:        cmd.data[4] = drive;
                   4963:        cmd.data[5] = lbn;
                   4964:        cmd.data[6] = lbn>>8;
                   4965:        cmd.data[7] = lbn>>16;
                   4966:        cmd.data[8] = 0;
                   4967:        cmd.data[9] = 0;
                   4968:        if(n = s_io(0, &cmd, 10, ret, 0, err))
                   4969:                return(n);
                   4970:        setdiag(cmd, drive, 256);
                   4971:        if(n = s_io(0, &cmd, 0, ret, 256, err))
                   4972:                return(n);
                   4973:        return(0);
                   4974: }
                   4975: 
                   4976: int
                   4977: sony_media(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   4978: {
                   4979:        struct scsi_return ret;
                   4980:        uchar *d;
                   4981:        int bn, c;
                   4982:        char buf[256];
                   4983:        int lower;
                   4984:        int nline;
                   4985:        int cur, curb;
                   4986:        int drive = iargs[0];
                   4987:        long lbn = iargs[1];
                   4988:        int count = iargs[2];
                   4989:        extern char *strdup(char *);
                   4990:        int verbose = 0;
                   4991:        FILE *fp = 0;
                   4992: 
                   4993: #pragma ref niargs
                   4994: 
                   4995:        if(ncargs == 1){
                   4996:                if(strcmp(cargs[0], "-v") == 0)
                   4997:                        verbose = 1;
                   4998:                else if((fp = fopen(cargs[0], "w")) == NULL){
                   4999:                        pperror(err, cargs[0]);
                   5000:                        return(1);
                   5001:                }
                   5002:        }
                   5003:        if(sony_istatus(&ret, err))
                   5004:                return(1);
                   5005:        if((ret.data[100]&0x80) && (drive == (ret.data[100]&7)))
                   5006:                lower = 0;
                   5007:        else if((ret.data[101]&0x80) && (drive == (ret.data[101]&7)))
                   5008:                lower = 1;
                   5009:        else {
                   5010:                sprintf(err, "drive %d not occupied and ready\n", drive);
                   5011:                return(1);
                   5012:        }
                   5013:        printf("media margin check for %d blocks [%d-%d] on %s drive (%d,%d):",
                   5014:                count, lbn, lbn+count-1, lower? "lower":"upper", s_id, drive);
                   5015:        if(fp)
                   5016:                printf(" stored in '%s'", cargs[0]);
                   5017:        putchar('\n');
                   5018:        if(cmsg[0] == 0){
                   5019:                for(bn = 0; bn < 256; bn++){
                   5020:                        sprintf(buf, "rare error 0x%x", bn);
                   5021:                        cmsg[bn] = strdup(buf);
                   5022:                }
                   5023:                cmsg[0] = "good";
                   5024:                cmsg[0x40] = "seek error 1 (alternated)";
                   5025:                cmsg[0x41] = "seek error 2 (alternated)";
                   5026:                cmsg[0x42] = "seek error 3 (alternated)";
                   5027:                cmsg[0x44] = "read error 1 (alternated)";
                   5028:                cmsg[0x45] = "unwritten";
                   5029:                cmsg[0x46] = "read error 3 (alternated)";
                   5030:                cmsg[0x81] = "<50% burst";
                   5031:                cmsg[0x82] = "50-96% burst (alternated)";
                   5032:                cmsg[0x83] = ">96% burst (alternated)";
                   5033:                cmsg[0x84] = "uncorrectable (alternated)";
                   5034:        }
                   5035: #define        DO(ch,cp) if(fp) putc(ch,fp); else if(ch != cur){\
                   5036:                        int newb = bn+cp-ret.data;\
                   5037:                        if(verbose && (curb>=0)){\
                   5038:                                printf("%d %s@%d, ", newb-curb, cmsg[cur], curb);\
                   5039:                                if(++nline == 5){nline = 0; putchar('\n');}\
                   5040:                        }\
                   5041:                        cur = ch;\
                   5042:                        curb = newb;\
                   5043:                }
                   5044:        cur = 256;
                   5045:        curb = -1;
                   5046:        nline = 0;
                   5047:        for(bn = 0; bn < 256; bn++)
                   5048:                cnts[bn] = 0;
                   5049:        for(bn = lbn, c = count; c >= 256; c -= 256, bn += 256){
                   5050:                if(sony_media1(drive, bn, lower, &ret, err))
                   5051:                        return(1);
                   5052:                for(d = ret.data; d < &ret.data[256];){
                   5053:                        DO(*d, d);
                   5054:                        cnts[*d++]++;
                   5055:                }
                   5056:        }
                   5057:        if(c){
                   5058:                if(sony_media1(drive, bn, lower, &ret, err))
                   5059:                        return(1);
                   5060:                for(d = ret.data; c; c--){
                   5061:                        DO(*d, d);
                   5062:                        cnts[*d++]++;
                   5063:                }
                   5064:        }
                   5065:        DO(256, d);
                   5066:        if(nline)
                   5067:                putchar('\n');
                   5068:        printf("\t");
                   5069:        for(c = 0; c < 256; c++)
                   5070:                if(cnts[c])
                   5071:                        printf("%d %s, ", cnts[c], cmsg[c]);
                   5072:        printf("\n");
                   5073:        return(0);
                   5074: }
                   5075: 0707070035050453271006660011710000040000011504660464215423500001600000002140sony/readid.c#include     <stdio.h>
                   5076: #include       "../scsi.h"
                   5077: #include       "../scsish.h"
                   5078: #include       "fns.h"
                   5079: 
                   5080: static int
                   5081: my_read(int lun, long blk, struct scsi_return *ret, char *err)
                   5082: {
                   5083:        struct scsi_cmd cmd;
                   5084:        int n;
                   5085: 
                   5086:        cmd.bus_id = s_id;
                   5087:        set10(cmd, 0x28, lun<<5, blk>>24, blk>>16, blk>>8, blk, 0, 0, 1, 0);
                   5088:        n = ss_io(0, &cmd, 0, ret, 1024, err);
                   5089:        return(n);
                   5090: }
                   5091: 
                   5092: int
                   5093: sony_readid(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   5094: {
                   5095:        struct scsi_return ret;
                   5096:        char buf[128];
                   5097:        int drive = iargs[0];
                   5098:        long blk, lastb;
                   5099:        int pr = 0;
                   5100: 
                   5101: #pragma ref ncargs
                   5102: #pragma ref cargs
                   5103: 
                   5104:        buf[0] = 0;
                   5105:        if(niargs == 2){
                   5106:                if((blk = iargs[1]) < 0){
                   5107:                        blk = -blk;
                   5108:                        pr = 1;
                   5109:                }
                   5110:        } else {
                   5111:                if(my_read(drive, 0L, &ret, err) == 0)
                   5112:                        goto done;
                   5113:                blk = 1;
                   5114:        }
                   5115:        for(lastb = -1;;){
                   5116:                if(pr){
                   5117:                        printf("%d: ", blk);
                   5118:                }
                   5119:                if(my_read(drive, blk, &ret, err))
                   5120:                        break;
                   5121:                lastb = blk;
                   5122:                blk = ((long *)ret.data)[9];
                   5123:        }
                   5124:        if(lastb < 0){
                   5125:                printf("read(blk=%d) failed\n", blk);
                   5126:                return(1);
                   5127:        }
                   5128:        if(my_read(drive, lastb, &ret, err) != 0)
                   5129:                return(1);
                   5130: done:
                   5131:        strncpy(buf, (char *)&ret.data[42], 128);
                   5132:        buf[127] = 0;
                   5133:        printf("(%d,%d): '%s'\n", s_id, drive, buf);
                   5134:        return(0);
                   5135: }
                   5136: 0707070035050453261006660011710000040000011504720464014762400001400000006207sony/copy.c#include       <stdio.h>
                   5137: #include       "../scsi.h"
                   5138: #include       "../scsish.h"
                   5139: #include       "fns.h"
                   5140: 
                   5141: #define        PROGRESS        \
                   5142:                if(sbase/TALK != goo){\
                   5143:                        goo = sbase/TALK;\
                   5144:                        time(&t2);\
                   5145:                        printf("\tdoing block %ld at %s", goo*TALK, ctime(&t2));\
                   5146:                }
                   5147: 
                   5148: static char good[256]; /* by default, all BAD */
                   5149: typedef enum { BAD = 0, GOOD } Searchtype;
                   5150: static int copy1(int, int, int, int, int, int, int, char *);
                   5151: static int search(int, int, int, int, Searchtype, char *);
                   5152: 
                   5153: int
                   5154: sony_copy(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   5155: {
                   5156:        int n;
                   5157:        int sdr = iargs[0];
                   5158:        int sbase = iargs[1];
                   5159:        int nblocks = iargs[2];
                   5160:        int ddr = iargs[3];
                   5161:        int dbase = iargs[4];
                   5162:        int starget = s_id;
                   5163:        int dtarget = s_id;
                   5164:        int wr, unwr;
                   5165:        long nb = nblocks;
                   5166:        long t1, t2;
                   5167:        long goo;
                   5168:        int lower;
                   5169:        struct scsi_return ret;
                   5170: #define                TALK            10000
                   5171:        extern char *ctime();
                   5172: 
                   5173: #pragma ref niargs
                   5174: #pragma ref ncargs
                   5175: #pragma ref cargs
                   5176: 
                   5177:        printf("copying drive (%d,%d)[%d-%d] to drive (%d,%d)[%d-%d]\n",
                   5178:                starget, sdr, sbase, sbase+nblocks-1,
                   5179:                dtarget, ddr, dbase, dbase+nblocks-1);
                   5180:        if(sony_istatus(&ret, err))
                   5181:                return(1);
                   5182:        if((ret.data[100]&0x80) && (sdr == (ret.data[100]&7)))
                   5183:                lower = 0;
                   5184:        else if((ret.data[101]&0x80) && (sdr == (ret.data[101]&7)))
                   5185:                lower = 1;
                   5186:        else {
                   5187:                sprintf(err, "drive %d not occupied\n", sdr);
                   5188:                return(1);
                   5189:        }
                   5190:        good[0] = good[0x81] = good[0x82] = good[0x83] = GOOD;
                   5191:        time(&t1);
                   5192:        goo = -1;
                   5193:        while(nblocks > 0){
                   5194:                /* search for a block to copy */
                   5195:                while(n = min(256, nblocks)){
                   5196:                        wr = search(sdr, lower, sbase, n, GOOD, err);
                   5197:                        if(wr < 0)
                   5198:                                break;
                   5199:                        sbase += wr;
                   5200:                        dbase += wr;
                   5201:                        nblocks -= wr;
                   5202:                        if(wr < n)
                   5203:                                break;
                   5204:                        PROGRESS
                   5205:                }
                   5206:                /* now copy until the first bad block */
                   5207:                while(n = min(256, nblocks)){
                   5208:                        unwr = search(sdr, lower, sbase, n, BAD, err);
                   5209:                        if(unwr < 0)
                   5210:                                break;
                   5211:                        /*printf("writing %d-%d\n", sbase, sbase+unwr-1);/**/
                   5212:                        if(copy1(starget, sdr, sbase, unwr, dtarget, ddr, dbase, err))
                   5213:                                break;
                   5214:                        sbase += unwr;
                   5215:                        dbase += unwr;
                   5216:                        nblocks -= unwr;
                   5217:                        PROGRESS
                   5218:                }
                   5219:        }
                   5220:        time(&t2);
                   5221:        t2 -= t1;
                   5222:        if(t2 == 0) t2 = 1;
                   5223:        printf("%ds: ", t2);
                   5224:        if(nblocks){
                   5225:                printf("copy buggered up: sbase=%d nblks=%d dbase=%d\n",
                   5226:                        sbase, nblocks, dbase);
                   5227:                return(1);
                   5228:        }
                   5229:        printf("%d blocks at %.1fKB/s\n", nb, nb/(float)t2);
                   5230:        return(0);
                   5231: }
                   5232: 
                   5233: static int
                   5234: copy1(int st, int sd, int sb, int n, int dt, int dd, int db, char *err)
                   5235: {
                   5236:        struct scsi_cmd cmd;
                   5237:        struct scsi_return ret;
                   5238: 
                   5239:        set6(cmd, 0x18, sd<<5, 0, 0, 20, 0);
                   5240:        cmd.data[0] = 0x10;     /* copy */
                   5241:        cmd.data[1] = 0;
                   5242:        cmd.data[2] = 0;
                   5243:        cmd.data[3] = 0;
                   5244:        cmd.data[4] = (st<<5)|sd;
                   5245:        cmd.data[5] = (dt<<5)|dd;
                   5246:        cmd.data[6] = 0;
                   5247:        cmd.data[7] = 0;
                   5248:        cmd.data[8] = n>>24;
                   5249:        cmd.data[9] = n>>16;
                   5250:        cmd.data[10] = n>>8;
                   5251:        cmd.data[11] = n;
                   5252:        cmd.data[12] = sb>>24;
                   5253:        cmd.data[13] = sb>>16;
                   5254:        cmd.data[14] = sb>>8;
                   5255:        cmd.data[15] = sb;
                   5256:        cmd.data[16] = db>>24;
                   5257:        cmd.data[17] = db>>16;
                   5258:        cmd.data[18] = db>>8;
                   5259:        cmd.data[19] = db;
                   5260:        return(s_io(0, &cmd, 20, &ret, 0, err));
                   5261: }
                   5262: 
                   5263: static int
                   5264: search(int dr, int lower, int sbase, int n, Searchtype s, char *err)
                   5265: {
                   5266:        uchar *cp;
                   5267:        struct scsi_return ret;
                   5268: 
                   5269:        if(n <= 0)
                   5270:                return(0);
                   5271:        if(n > 256)
                   5272:                n = 256;
                   5273:        if(sony_media1(dr, sbase, lower, &ret, err))
                   5274:                return(-1);
                   5275:        for(cp = ret.data; n-- > 0; cp++)
                   5276:                if(good[*cp] != s)
                   5277:                        break;
                   5278:        return(cp-ret.data);
                   5279: }
                   5280: 0707070035050453251006660011710000040000010452330457563432300001300000001477sony/fns.hextern int sony_inq(int, int *, int, char **, char *);
                   5281: extern int sony_alt(int, int *, int, char **, char *);
                   5282: extern int sony_conf(int, int *, int, char **, char *);
                   5283: extern int sony_status(int, int *, int, char **, char *);
                   5284: extern int sony_set(int, int *, int, char **, char *);
                   5285: extern int sony_rel(int, int *, int, char **, char *);
                   5286: extern int sony_eject(int, int *, int, char **, char *);
                   5287: extern int sony_diskid(int, int *, int, char **, char *);
                   5288: extern int sony_internal(int, int *, int, char **, char *);
                   5289: extern int sony_media(int, int *, int, char **, char *);
                   5290: extern int sony_readid(int, int *, int, char **, char *);
                   5291: extern int sony_copy(int, int *, int, char **, char *);
                   5292: extern int sony_sense(int, int *, int, char **, char *);
                   5293: extern void sony_extsense(uchar *, char *, int);
                   5294: 
                   5295: extern int shelfside(char *arg, char *err);
                   5296: 0707070035050453241006660011710000040000010452340457563432300001500000003205sony/sense.c#include      <stdio.h>
                   5297: #include       "../scsi.h"
                   5298: #include       "../scsish.h"
                   5299: #include       "fns.h"
                   5300: 
                   5301: int
                   5302: sony_sense(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   5303: {
                   5304:        struct scsi_cmd cmd;
                   5305:        struct scsi_return ret;
                   5306:        int n;
                   5307:        char buf[4096];
                   5308: 
                   5309: #pragma ref ncargs
                   5310: #pragma ref cargs
                   5311: 
                   5312:        if(niargs == 0)
                   5313:                iargs[0] = 0;
                   5314:        set6(cmd, 0x03, iargs[0]<<5, 0, 0, 32, 0);
                   5315:        if(n = s_io(0, &cmd, 0, &ret, -32, err))
                   5316:                return(n);
                   5317:        printf("sense(%d,%d): ", s_id, iargs[0]);
                   5318:        sony_extsense(ret.data, buf, sizeof buf);
                   5319:        printf("%s\n", buf);
                   5320:        return(0);
                   5321: }
                   5322: 
                   5323: static char *exstab[16] =
                   5324: {
                   5325:        "no sense",
                   5326:        "recovered error",
                   5327:        "not ready",
                   5328:        "medium error",
                   5329:        "hardware error",
                   5330:        "illegal request",
                   5331:        "unit attention",
                   5332:        "data protect",
                   5333:        "blank check",
                   5334:        "key #9",
                   5335:        "copy aborted",
                   5336:        "aborted command",
                   5337:        "key #c",
                   5338:        "volume overflow",
                   5339:        "miscompare",
                   5340:        "key #f",
                   5341: };
                   5342: 
                   5343: void
                   5344: sony_extsense(uchar *data, char *dest, int ndata)
                   5345: {
                   5346:        char buf[4096];
                   5347:        extern char *nesd[];
                   5348: 
                   5349:        dest[0] = 0;
                   5350:        switch(data[2])
                   5351:        {
                   5352:        case 0:
                   5353:                sprintf(dest, "no error");
                   5354:                break;
                   5355:        case 0x1:       /* recovered error */
                   5356:                sprintf(dest, "recovered error");
                   5357:                break;
                   5358:        case 0xA:       /* recovered error */
                   5359:                sprintf(dest, "recovered error");
                   5360:                break;
                   5361:        default:
                   5362:                if(data[7] != 4)
                   5363:                        sprintf((char *)data, "warning: extra data is %d, not 4! ", data[7]);
                   5364:                sprintf(buf, "sense: %s", nesd[data[8]&0x7f]);
                   5365:                strcat(dest, buf);
                   5366:                if(data[8]&0x80){
                   5367:                        sprintf(buf, " at addr #%x", data[11]+256L*data[10]+256L*256*data[9]);
                   5368:                        strcat(dest, buf);
                   5369:                }
                   5370:                sprintf(buf, ", ext sense: %s", exstab[data[2]]);
                   5371:                strcat(dest, buf);
                   5372:                if(data[0]&0x80){
                   5373:                        sprintf(buf, " info=#%x", data[6]+256L*data[5]+256L*256L*data[4]+256L*256L*256L*data[3]);
                   5374:                        strcat(dest, buf);
                   5375:                }
                   5376:                break;
                   5377:        }
                   5378: }
                   5379: 0707070035050453231006660011710000040000010452350457563432300001600000002251sony/nesd.tabnesd
                   5380: 00     no sense
                   5381: 01     invalid command
                   5382: 02     recovered error
                   5383: 03     illegal request
                   5384: 06     unit attention
                   5385: 07     parity error
                   5386: 08     message reject error
                   5387: 0a     copy aborted
                   5388: 10     ecc trouible occurred
                   5389: 11     time out error
                   5390: 12     controller error
                   5391: 13     SONY I/F II hardware/firmware error
                   5392: 14     scsi hardware/firmware error
                   5393: 20     command not terminated
                   5394: 21     drive interface parity error
                   5395: 22     loading trouble
                   5396: 23     focus trouble
                   5397: 24     tracking trouble
                   5398: 25     spindle trouble
                   5399: 26     slide trouible
                   5400: 27     skew trouble
                   5401: 28     head lead out
                   5402: 29     write modulation trouble
                   5403: 2a     under laser power
                   5404: 2b     over laser power
                   5405: 2f     drive error
                   5406: 30     drive power off
                   5407: 31     no disk in drive
                   5408: 32     drive not ready
                   5409: 38     disk already exists in drive
                   5410: 39     no disk in drive
                   5411: 3a     disk already exists in shelf
                   5412: 40     write warning
                   5413: 41     write error
                   5414: 42     disk error
                   5415: 43     cannot read disk id
                   5416: 44     write protect error 1
                   5417: 45     write protect error 2
                   5418: 46     disk warning
                   5419: 47     alternation trouble
                   5420: 50     specified address not found
                   5421: 51     address block not found
                   5422: 52     all address could not be read
                   5423: 53     data could not be read
                   5424: 54     uncorrectable read error
                   5425: 55     tracking error
                   5426: 60     no data in specified address
                   5427: 68     z-axis servo error
                   5428: 69     roter servo error
                   5429: 6a     hook servo error
                   5430: 6b     i/o shelf error
                   5431: 6c     drive 0 error
                   5432: 6d     drive 1 error
                   5433: 6e     shelf error
                   5434: 6f     carrier error
                   5435: 0707070035050453711006660011710000040000010450560457563431600001100000002145unload.c#include  <stdio.h>
                   5436: #include       <stddef.h>
                   5437: #include       <string.h>
                   5438: #include       "scsi.h"
                   5439: #include       "juke.h"
                   5440: 
                   5441: j_unload(char *vol_id, char *buf)
                   5442: {
                   5443:        Side side;
                   5444:        int i, sh, dr;
                   5445:        char disk_to_unload[256];
                   5446: 
                   5447:        if(j_rdshelves(buf))    /* read in shelf names */
                   5448:                return(-1);
                   5449:        if(j_getstatus(buf))    /* get the jukebox status */
                   5450:                return(-1);
                   5451:        /* now check which side we want */
                   5452: 
                   5453:        strcpy(disk_to_unload, vol_id);
                   5454:        side = SIDEA;
                   5455:        sh = j_shelfof(disk_to_unload);
                   5456:        if(sh < 0){
                   5457:                sprintf(buf, "can not find vol_id %s", disk_to_unload);
                   5458:                return(-1);
                   5459:        }
                   5460:        dr = -1;
                   5461:        for(i = 0; i < NLUN; i++){
                   5462:                printf("dr:.. %d  ", i);
                   5463:                printf(" rtsh: %d\n", j_status.lun[i].retshelf);
                   5464: 
                   5465:                /* is sh = retshelf? */
                   5466: 
                   5467:                if( (j_status.lun[i].retshelf>>1 == sh) ||
                   5468:                                        (j_status.lun[i].retshelf == sh*2+1) ){                                         dr = i; 
                   5469:                                break;
                   5470:                } }
                   5471:        printf("dr: %d, sh: %d, side: %d, i: %d\n", dr, sh, side, i);
                   5472:        if (dr == -1){
                   5473:                sprintf(buf, "no drive has vol_id %s", disk_to_unload);
                   5474:                return(-1);
                   5475:        }
                   5476:        /* put vol_id in it's shelf*/   
                   5477:        if (j_drive_to_shelf(dr, sh, side, buf) >= 0){
                   5478:                sprintf(buf,"/dev/worm%d\n", dr);
                   5479:                return(0);
                   5480:        }
                   5481:        return(-1);     
                   5482: }
                   5483: 0707070035050446201006660011710000040000010447410457563430700000700000001357warm.c#include    <stddef.h>
                   5484: #include       <stdio.h>
                   5485: #include       <string.h>
                   5486: #include       "scsi.h"
                   5487: #include       "juke.h"
                   5488: 
                   5489: warm_inv(char *buf)
                   5490: {
                   5491:        Side side;
                   5492:        int drive, sh;
                   5493:        char vol_id[512];
                   5494:        
                   5495:        if(j_rdshelves(buf))    /* read in shelf names */
                   5496:                return(-1);
                   5497:        side = SIDEA;
                   5498:        drive = min(nlun+1, NLUN-1);
                   5499:        for(;;){
                   5500:                if(j_getstatus(buf))    /* get the jukebox status */
                   5501:                        return(-1);
                   5502:                for(sh = 0; sh < NSHELF; sh++)
                   5503:                        if(j_status.shelf[sh]&0x10) break;
                   5504:                if(sh >= NSHELF)
                   5505:                        break;
                   5506:                if(getvol(127, drive, vol_id, &side)){
                   5507:                        strcpy(buf, vol_id);
                   5508:                        return(-1);
                   5509:                }
                   5510:                for(sh = 0; j_shelf[sh]; sh++)
                   5511:                        ;
                   5512:                printf("%s -> %d\n", vol_id, sh);
                   5513:                if(j_drive_to_shelf(drive, sh, side, buf) < 0)
                   5514:                        return(-1);
                   5515:                j_wrshelf = 1;
                   5516:                j_shelf[sh] = strdup(vol_id);
                   5517:                sleep(1);
                   5518:        }
                   5519:        return(0);
                   5520: }
                   5521: 0707070035050453210407770011710000040000020452370464700560500000500000000000wren0707070035050453201006660011710000040000010452400457563432300001300000000637wren/dev.c#include       <stdio.h>
                   5522: #include       "../scsi.h"
                   5523: #include       "../scsish.h"
                   5524: #include       "fns.h"
                   5525: 
                   5526: static Function fns[] = {
                   5527:        { "diag", "diag", "", wr_diag },
                   5528:        { "extinq", "extinq", "", wr_extinq },
                   5529:        { "modesense", "modesense", "", wr_modesense },
                   5530:        { "modeselect", "modeselect er-param er-retries read-recon write-recon cache-enable", "IIIII", wr_modeselect },
                   5531:        { 0 }
                   5532: };
                   5533: Device wrendev = {
                   5534:        "wren", "Wren VI",
                   5535:        gen_extsense,
                   5536:        fns
                   5537: };
                   5538: 0707070035050453171006660011710000040000011471660464666727400001300000001326wren/inq.c#include        <stdio.h>
                   5539: #include       "../scsi.h"
                   5540: #include       "../scsish.h"
                   5541: #include       "fns.h"
                   5542: 
                   5543: extern char *gen_rmb[2];
                   5544: extern char *gen_devtype[256];
                   5545: 
                   5546: int
                   5547: wr_extinq(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   5548: {
                   5549:        struct scsi_cmd cmd;
                   5550:        struct scsi_return ret;
                   5551:        int n;
                   5552:        char vendor[9], product[17];
                   5553: 
                   5554: #pragma ref niargs
                   5555: #pragma ref iargs
                   5556: #pragma ref ncargs
                   5557: #pragma ref cargs
                   5558: 
                   5559:        set6(cmd, 0x12, 0, 0, 0, 96, 0);
                   5560:        if(n = s_io(0, &cmd, 0, &ret, 96, err))
                   5561:                return(n);
                   5562:        fixedstr(&ret.data[8], 8, vendor);
                   5563:        fixedstr(&ret.data[16], 16, product);
                   5564:        printf("inq(%d,%d): %s %s, %s/%s rev=%0.4s serial=%0.8s\n",
                   5565:                s_id, 0, gen_rmb[ret.data[1]>>7], gen_devtype[ret.data[0]],
                   5566:                vendor, product, &ret.data[32], &ret.data[36]);
                   5567:        return(0);
                   5568: }
                   5569: 0707070035050453161006660011710000040000010452420457563432300001400000011721wren/mode.c#include       <stdio.h>
                   5570: #include       "../scsi.h"
                   5571: #include       "../scsish.h"
                   5572: #include       "fns.h"
                   5573: 
                   5574: #define        SHORT(n)        ((ret.data[n]<<8)|(ret.data[n+1]))
                   5575: 
                   5576: static int
                   5577: er(int pcf, char *err)
                   5578: {
                   5579:        struct scsi_cmd cmd;
                   5580:        struct scsi_return ret;
                   5581:        int n;
                   5582:        static char *bit[8] = { "DCR", "DTE", "PER", "EEC", "RC", "TB", "ARRE", "AWRE" };
                   5583: 
                   5584:        set6(cmd, 0x1A, 0, (pcf<<6)|0x01, 0, 20, 0);
                   5585:        if(n = s_io(0, &cmd, 0, &ret, 20, err))
                   5586:                return(n);
                   5587:        printf("error recovery:\n\t");
                   5588:        for(n = 7; n >= 0; n--)
                   5589:                printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]);
                   5590:        printf("\n\t%d retries, max ecc span=%d\n", ret.data[15], ret.data[16]);
                   5591:        return(0);
                   5592: }
                   5593: 
                   5594: static int
                   5595: dr(int pcf, char *err)
                   5596: {
                   5597:        struct scsi_cmd cmd;
                   5598:        struct scsi_return ret;
                   5599:        int n;
                   5600: 
                   5601:        set6(cmd, 0x1A, 0, (pcf<<6)|0x02, 0, 24, 0);
                   5602:        if(n = s_io(0, &cmd, 0, &ret, 24, err))
                   5603:                return(n);
                   5604:        printf("disconnect/reconnect:\n");
                   5605:        printf("\tread reconnect=%d/256,", ret.data[14]);
                   5606:        printf(" write reconnect=%d/256\n", ret.data[15]);
                   5607:        return(0);
                   5608: }
                   5609: 
                   5610: static int
                   5611: fp(int pcf, char *err)
                   5612: {
                   5613:        struct scsi_cmd cmd;
                   5614:        struct scsi_return ret;
                   5615:        int n;
                   5616:        static char *bit[8] = { "", "", "", "INS", "SURF", "Remove", "HardSec", "SoftSec" };
                   5617: 
                   5618:        set6(cmd, 0x1A, 0, (pcf<<6)|0x03, 0, 36, 0);
                   5619:        if(n = s_io(0, &cmd, 0, &ret, 36, err))
                   5620:                return(n);
                   5621:        printf("format parameters:\n");
                   5622:        printf("\tsec=%dB, trk=%d secs, interleave=%d trk skew=%d cyl skew=%d\n",
                   5623:                SHORT(24), SHORT(22), SHORT(26), SHORT(28), SHORT(30));
                   5624:        printf("\t%d alt sec/%d alt trk per zone(=%d trks), %d alt trks per vol\n",
                   5625:                SHORT(16), SHORT(18), SHORT(14), SHORT(20));
                   5626:        printf("\tdrive type:");
                   5627:        for(n = 7; n >= 3; n--)
                   5628:                printf(" %s%s", (ret.data[32]&(1<<n))? "":"~", bit[n]);
                   5629:        printf("\n");
                   5630:        return(0);
                   5631: }
                   5632: 
                   5633: static int
                   5634: geom(int pcf, char *err)
                   5635: {
                   5636:        struct scsi_cmd cmd;
                   5637:        struct scsi_return ret;
                   5638:        int n;
                   5639: 
                   5640:        set6(cmd, 0x1A, 0, (pcf<<6)|0x04, 0, 32, 0);
                   5641:        if(n = s_io(0, &cmd, 0, &ret, 32, err))
                   5642:                return(n);
                   5643:        printf("drive geometry:\n\t%d cyls, %d heads\n",
                   5644:                (ret.data[14]<<16)|SHORT(15), ret.data[17]);
                   5645:        return(0);
                   5646: }
                   5647: 
                   5648: static int
                   5649: cc(int pcf, char *err)
                   5650: {
                   5651:        struct scsi_cmd cmd;
                   5652:        struct scsi_return ret;
                   5653:        int n;
                   5654:        static char *bit[8] = { "", "", "", "", "CacheEnable", "RSVD", "WIE", "RSVD" };
                   5655: 
                   5656:        set6(cmd, 0x1A, 0, (pcf<<6)|0x38, 0, 28, 0);
                   5657:        if(n = s_io(0, &cmd, 0, &ret, 28, err))
                   5658:                return(n);
                   5659:        printf("cache control:\n\t");
                   5660:        for(n = 7; n >= 4; n--)
                   5661:                printf(" %s%s", (ret.data[14]&(1<<n))? "":"~", bit[n]);
                   5662:        printf(", cache size=%d\n", ret.data[14]&0xF);
                   5663:        printf("\tprefetch: thr=%d max=%dx%d min=%dx%d\n",
                   5664:                ret.data[15], ret.data[16], ret.data[17], ret.data[18], ret.data[19]);
                   5665:        return(0);
                   5666: }
                   5667: 
                   5668: int
                   5669: wr_modesense(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   5670: {
                   5671:        int n;
                   5672: 
                   5673: #pragma ref ncargs
                   5674: #pragma ref cargs
                   5675: #pragma ref niargs
                   5676: #pragma ref iargs
                   5677: 
                   5678: #define        PCF     0       /* current values */
                   5679: 
                   5680:        printf("mode sense(%d,0):\n", s_id);
                   5681:        if(n = er(PCF, err))
                   5682:                return(n);
                   5683:        if(n = dr(PCF, err))
                   5684:                return(n);
                   5685:        if(n = fp(PCF, err))
                   5686:                return(n);
                   5687:        if(n = geom(PCF, err))
                   5688:                return(n);
                   5689:        if(n = cc(PCF, err))
                   5690:                return(n);
                   5691:        return(0);
                   5692: }
                   5693: 
                   5694: int
                   5695: wr_modeselect(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   5696: {
                   5697:        struct scsi_cmd cmd;
                   5698:        struct scsi_return ret;
                   5699:        int n;
                   5700: 
                   5701: #pragma ref niargs
                   5702: #pragma ref ncargs
                   5703: #pragma ref cargs
                   5704: 
                   5705:        printf("changing modes to ");
                   5706:        if((iargs[0] < 256) && (iargs[0] >= 0))
                   5707:                printf("er-param=%d(=#%x), ", iargs[0], iargs[0]);
                   5708:        if((iargs[1] < 256) && (iargs[1] >= 0))
                   5709:                printf("er-retries=%d, ", iargs[1]);
                   5710:        if((iargs[2] < 256) && (iargs[2] >= 0))
                   5711:                printf("read-recon=%d/256, ", iargs[2]);
                   5712:        if((iargs[3] < 256) && (iargs[3] >= 0))
                   5713:                printf("write-recon=%d/256, ", iargs[3]);
                   5714:        if((iargs[4] < 256) && (iargs[4] >= 0))
                   5715:                printf("cache %sable, ", iargs[4]?"en":"dis");
                   5716:        printf("\nsleep(10); kill me if you disagree\n");
                   5717:        fflush(stdout);
                   5718:        sleep(10);
                   5719:        /* do error recovery */
                   5720:        if(((iargs[0] < 256) && (iargs[0] >= 0)) || ((iargs[1] < 256) && (iargs[1] >= 0))){
                   5721:                set6(cmd, 0x1A, 0, (0<<6)|0x01, 0, 20, 0);
                   5722:                if(n = s_io(0, &cmd, 0, &ret, 20, err))
                   5723:                        return(n);
                   5724:                memcpy(cmd.data, ret.data, 20);
                   5725:                cmd.data[14] &= ~0x10;
                   5726:                if((iargs[0] < 256) && (iargs[0] >= 0))
                   5727:                        cmd.data[14] = iargs[0];
                   5728:                if((iargs[1] < 256) && (iargs[1] >= 0))
                   5729:                        cmd.data[15] = iargs[1];
                   5730:                set6(cmd, 0x15, 0x11, 0, 0, 20, 0);
                   5731:                if(n = s_io(0, &cmd, 20, &ret, 0, err))
                   5732:                        return(n);
                   5733:        }
                   5734:        /* reconnect */
                   5735:        if(((iargs[2] < 256) && (iargs[2] >= 0)) || ((iargs[3] < 256) && (iargs[3] >= 0))){
                   5736:                set6(cmd, 0x1A, 0, (0<<6)|0x02, 0, 24, 0);
                   5737:                if(n = s_io(0, &cmd, 0, &ret, 24, err))
                   5738:                        return(n);
                   5739:                memcpy(cmd.data, ret.data, 24);
                   5740:                if((iargs[3] < 256) && (iargs[3] >= 0))
                   5741:                        cmd.data[14] = iargs[3];
                   5742:                if((iargs[4] < 256) && (iargs[4] >= 0))
                   5743:                        cmd.data[15] = iargs[4];
                   5744:                set6(cmd, 0x15, 0x11, 0, 0, 24, 0);
                   5745:                if(n = s_io(0, &cmd, 24, &ret, 0, err))
                   5746:                        return(n);
                   5747:        }
                   5748:        /* do cache control */
                   5749:        if((iargs[4] < 256) && (iargs[4] >= 0)){
                   5750:                set6(cmd, 0x1A, 0, (0<<6)|0x38, 0, 28, 0);
                   5751:                if(n = s_io(0, &cmd, 0, &ret, 28, err))
                   5752:                        return(n);
                   5753:                memcpy(cmd.data, ret.data, 28);
                   5754:                cmd.data[14] &= ~0x10;
                   5755:                if(iargs[4])
                   5756:                        cmd.data[14] |= 0x10;
                   5757:                set6(cmd, 0x15, 0x11, 0, 0, 28, 0);
                   5758:                if(n = s_io(0, &cmd, 28, &ret, 0, err))
                   5759:                        return(n);
                   5760:        }
                   5761:        return(0);
                   5762: }
                   5763: 0707070035050453151006660011710000040000010452430457563432400001400000001427wren/diag.c#include       <stdio.h>
                   5764: #include       "../scsi.h"
                   5765: #include       "../scsish.h"
                   5766: #include       "fns.h"
                   5767: 
                   5768: int
                   5769: wr_diag(int niargs, int *iargs, int ncargs, char **cargs, char *err)
                   5770: {
                   5771:        struct scsi_cmd cmd;
                   5772:        struct scsi_return ret;
                   5773:        int n;
                   5774:        long t;
                   5775: 
                   5776: #pragma ref niargs
                   5777: #pragma ref iargs
                   5778: #pragma ref ncargs
                   5779: #pragma ref cargs
                   5780: 
                   5781:        t = time((long *)0);
                   5782:        set6(cmd, 0x1D, 0x04, 0, 0, 0, 0);
                   5783:        if(n = s_io(0, &cmd, 0, &ret, 0, err))
                   5784:                return(n);
                   5785:        set6(cmd, 0x1C, 0, 0, 0, 8, 0);
                   5786:        if(n = s_io(0, &cmd, 0, &ret, 8, err))
                   5787:                return(n);
                   5788:        t = time((long *)0)-t;
                   5789:        printf("selftest diagnostic (%ds)\n", t);
                   5790:        if((ret.data[7] == 0) && (ret.data[2] == 0))
                   5791:                printf("\tno errors\n");
                   5792:        else
                   5793:                printf("\terror==#%x,#%x FRU=(#%x,#%x,#%x,#%x)\n",
                   5794:                        ret.data[6], ret.data[7], ret.data[2],
                   5795:                        ret.data[3], ret.data[4], ret.data[5]);
                   5796:        return(0);
                   5797: }
                   5798: 0707070035050453141006660011710000040000010452450457563432400001300000000345wren/fns.hextern int wr_extinq(int, int *, int, char **, char *);
                   5799: extern int wr_modesense(int, int *, int, char **, char *);
                   5800: extern int wr_modeselect(int, int *, int, char **, char *);
                   5801: extern int wr_diag(int, int *, int, char **, char *);
                   5802: 0707070035050453141006660011710000040000010452450457563432400001300000000000TRAILER!!!ret.data[3], ret.data[4], ret.data[5]);
                   5803:        return(0);
                   5804: }
                   5805: 0

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.