Return to jukebox.c CVS log

Up to [Research Unix] / researchv10no / cmd / worm / oscsi

Annotation of researchv10no/cmd/worm/oscsi/jukebox.c, revision 1.1

1.1     ! root        1: #include       <stdio.h>
        !             2: #include       <limits.h>
        !             3: #include       "scsi.h"
        !             4: #include       "juke.h"
        !             5: 
        !             6: main(int argc, char *argv[])
        !             7: {
        !             8:        int c;
        !             9:        int aflag = 0, eflag = 0, mflag = 0, pflag = 0;
        !            10:        int rflag = 0, sflag = 0, uflag = 0, Uflag = 0;
        !            11:        long secs = 3600L*24*183;       /* half a year is enough */
        !            12:        char *vol_id;
        !            13:        char errbuf[1024];
        !            14:        extern int optind;
        !            15:        extern char *optarg;
        !            16: 
        !            17:        setbuf(stdout, (char *)0);      /* turn off buffering */
        !            18:        while((c = getopt(argc, argv, "aemprsuUw:")) != -1)
        !            19:                switch (c)
        !            20:                {
        !            21:                case 'a':       aflag = 1; break;
        !            22:                case 'e':       eflag = 1; break;
        !            23:                case 'm':       mflag = 1; break;
        !            24:                case 'p':       pflag = 1; break;
        !            25:                case 'r':       rflag = 1; break;
        !            26:                case 's':       sflag = 1; break;
        !            27:                case 'u':       uflag = 1; break;
        !            28:                case 'U':       Uflag = 1; break;
        !            29:                case 'w':       secs = atol(optarg); break;
        !            30:                default:        usage(); break;
        !            31:                }
        !            32:        s_id = 2;
        !            33:        setnlun();
        !            34:        if(!aflag&&!eflag&&!mflag&&!pflag&&!rflag&&!uflag&&!Uflag)
        !            35:                sflag = 1;
        !            36:        vol_id = (optind < argc)? argv[optind] : 0;
        !            37:        if(uflag || Uflag)
        !            38:                unload(Uflag);
        !            39:        if(eflag){
        !            40:                if(vol_id == 0){
        !            41:                        strcpy(errbuf, "-e needs a vol_id");
        !            42:                        goto scram;
        !            43:                }
        !            44:                if(eject(vol_id, errbuf))
        !            45:                        goto scram;
        !            46:        }
        !            47:        if(rflag){
        !            48:                unload(1);
        !            49:                sleep(1);
        !            50:                if(cold_inv(vol_id? *vol_id : 'u', errbuf) < 0)
        !            51:                        goto scram;
        !            52:        }
        !            53:        if(aflag){
        !            54:                if(vol_id == 0){
        !            55:                        strcpy(errbuf, "-a needs a vol_id");
        !            56:                        goto scram;
        !            57:                }
        !            58:                if(allocate(vol_id, errbuf))
        !            59:                        goto scram;
        !            60:        }
        !            61:        if(mflag){
        !            62:                if((c = j_load(vol_id, errbuf, secs)) < 0)
        !            63:                        goto scram;
        !            64:                if(s_start(c, errbuf) < 0)
        !            65:                        fprintf(stderr, "jukebox: %s\n", errbuf);
        !            66:                if(s_stop(c, errbuf) < 0)
        !            67:                        fprintf(stderr, "jukebox: %s\n", errbuf);
        !            68:                printf("%d\n", c);
        !            69:        }
        !            70:        if(sflag)
        !            71:                prstatus();
        !            72:        if(pflag){
        !            73:                if(j_rdshelves(errbuf) < 0)
        !            74:                        goto scram;
        !            75:                for(c = 0; c < NSHELF; c++)
        !            76:                        if(j_shelf[c])
        !            77:                                printf("%d: %s\n", c, j_shelf[c]);
        !            78:        }
        !            79:        if(j_wrshelf)
        !            80:                if(j_wrshelves(errbuf))
        !            81:                        errexit(errbuf);
        !            82:        exit(0);
        !            83: scram:
        !            84:        if(j_wrshelf)
        !            85:                j_wrshelves(errbuf);
        !            86:        errexit(errbuf);
        !            87: }
        !            88: 
        !            89: usage()
        !            90: {
        !            91:        fprintf(stderr, "Usage: jukebox [-aemprsuU] [-w secs] [vol_id\n");
        !            92:        exit(1);
        !            93: }
        !            94: 
        !            95: errexit(char *errbuf)
        !            96: {
        !            97:        fprintf(stderr, "jukebox: %s\n", errbuf);
        !            98:        exit(1);
        !            99: }
        !           100: 
        !           101: prstatus()
        !           102: {
        !           103:        struct Lunstatus *l;
        !           104:        int c;
        !           105:        char errbuf[1024];
        !           106:        static char *spin[2] = { "offline", "online" };
        !           107: 
        !           108:        if(j_getstatus(errbuf)){
        !           109:                fprintf(stderr, "jukebox: %s\n", errbuf);
        !           110:                exit(1);
        !           111:        }
        !           112:        if(j_rdshelves(errbuf)){
        !           113:                fprintf(stderr, "jukebox: %s\n", errbuf);
        !           114:                exit(1);
        !           115:        }
        !           116:        for(c = 0; c < 8; c++){
        !           117:                l = &j_status.lun[c];
        !           118:                if(!l->diskin)
        !           119:                        continue;
        !           120:                printf("lun %d(", c);
        !           121:                if(j_status.udrive == (0x80|c))
        !           122:                        printf("upper,%s", spin[l->ready]);
        !           123:                else if(j_status.ldrive == (0x80|c))
        !           124:                        printf("lower,%s", spin[l->ready]);
        !           125:                else
        !           126:                        printf("in shelf");
        !           127:                printf("): ");
        !           128:                if(l->shelfvalid){
        !           129:                        if(j_shelf[l->retshelf>>1])
        !           130:                                printf("%s%c", j_shelf[l->retshelf>>1], "ab"[l->retshelf&1]);
        !           131:                        else
        !           132:                                printf("unallocated shelf number %d??", l->retshelf);
        !           133:                } else
        !           134:                        printf("<unknown shelf??>");
        !           135:                printf("\n");
        !           136:        }
        !           137: }
        !           138: 
        !           139: unload(int force)
        !           140: {
        !           141:        struct Lunstatus *l;
        !           142:        int c;
        !           143:        char errbuf[1024];
        !           144: 
        !           145:        if(j_getstatus(errbuf)){
        !           146:                fprintf(stderr, "jukebox: %s\n", errbuf);
        !           147:                exit(1);
        !           148:        }
        !           149:        if(j_rdshelves(errbuf)){
        !           150:                fprintf(stderr, "jukebox: %s\n", errbuf);
        !           151:                exit(1);
        !           152:        }
        !           153:        for(c = 0; c < 8; c++){
        !           154:                l = &j_status.lun[c];
        !           155:                if(!l->diskin)
        !           156:                        continue;
        !           157:                if(force || !l->ready)
        !           158:                        if(j_drive_to_shelf(c, -1, SIDEA, errbuf))
        !           159:                                fprintf(stderr, "jukebox: %s\n", errbuf);
        !           160:        }
        !           161: }
        !           162: 
        !           163: eject(char *vol_id, char *errbuf)
        !           164: {
        !           165:        int sh;
        !           166:        int dr;
        !           167: 
        !           168:        if(j_rdshelves(errbuf)){
        !           169:                fprintf(stderr, "jukebox: %s\n", errbuf);
        !           170:                exit(1);
        !           171:        }
        !           172:        sh = j_shelfof(vol_id);
        !           173:        if(sh < 0){
        !           174:                sprintf(errbuf, "xcan't find vol_id %s", vol_id);
        !           175:                return(-1);
        !           176:        }
        !           177:        j_wrshelf = 1;
        !           178:        if((dr = j_driveof(vol_id)) >= 0){
        !           179:                j_shelf[sh] = 0;
        !           180:                return(s_eject(dr, errbuf));
        !           181:        }
        !           182:        dr = NLUN-1;
        !           183:        if(j_shelf_to_drive(sh, SIDEA, dr, errbuf) < 0)
        !           184:                return(-1);
        !           185:        if(s_eject(dr, errbuf))
        !           186:                return(-1);
        !           187:        j_shelf[sh] = 0;
        !           188:        return(0);
        !           189: }

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