JSOC_Documentation: base/sums/apps/tape

00001 /* tape_inventory.c
00002  *
00003  * This is called by tape_svc.c during its setup. It will send a status
00004  * cmd to the Spectra Logic T120 to get an inventory of the slots and
00005  * drives and what tapeid each contains. Here's what an inventory looks like:
00006  *
00007  *   Storage Changer /dev/sg7:2 Drives, 38 Slots ( 8 Import/Export )
00008  * Data Transfer Element 0:Empty
00009  * Data Transfer Element 1:Empty
00010  *       Storage Element 1:Full :VolumeTag=000000S1                            
00011  *       Storage Element 2:Full :VolumeTag=000001S1                            
00012  *       Storage Element 3:Full :VolumeTag=000002S1                            
00013  *       Storage Element 4:Full :VolumeTag=000003S1                            
00014  *       Storage Element 5:Full :VolumeTag=000004S1                            
00015  *       Storage Element 6:Full :VolumeTag=000005S1                            
00016  *       Storage Element 7:Full :VolumeTag=000006S1                            
00017  *       Storage Element 8:Full :VolumeTag=000007S1                            
00018  *       Storage Element 9:Full :VolumeTag=000008S1                            
00019  *       Storage Element 10:Full :VolumeTag=000009S1                            
00020  *       Storage Element 11:Full :VolumeTag=000010S1                            
00021  *       Storage Element 12:Full :VolumeTag=000011S1                            
00022  *       Storage Element 13:Full :VolumeTag=000012S1                            
00023  *       Storage Element 14:Full :VolumeTag=000013S1                            
00024  *       Storage Element 15:Full :VolumeTag=000014S1                            
00025  *       Storage Element 16:Full :VolumeTag=000015S1                            
00026  *       Storage Element 17:Full :VolumeTag=000016S1                            
00027  *       Storage Element 18:Full :VolumeTag=000017S1                            
00028  *       Storage Element 19:Full :VolumeTag=000018S1                            
00029  *       Storage Element 20:Full :VolumeTag=000019S1                            
00030  *       Storage Element 21:Full :VolumeTag=000020S1                            
00031  *       Storage Element 22:Full :VolumeTag=000021S1                            
00032  *       Storage Element 23:Full :VolumeTag=000022S1                            
00033  *       Storage Element 24:Full :VolumeTag=000023S1                            
00034  *       Storage Element 25:Empty
00035  *       Storage Element 26:Empty
00036  *       Storage Element 27:Empty
00037  *       Storage Element 28:Empty
00038  *       Storage Element 29:Empty
00039  *       Storage Element 30:Full 
00040  *       Storage Element 31 IMPORT/EXPORT:Empty
00041  *       Storage Element 32 IMPORT/EXPORT:Empty
00042  *       Storage Element 33 IMPORT/EXPORT:Empty
00043  *       Storage Element 34 IMPORT/EXPORT:Empty
00044  *       Storage Element 35 IMPORT/EXPORT:Empty
00045  *       Storage Element 36 IMPORT/EXPORT:Empty
00046  *       Storage Element 37 IMPORT/EXPORT:Empty
00047  *       Storage Element 38 IMPORT/EXPORT:Empty
00048  *
00049  * tape_inventory() then reads this status and sets up its internal tables
00050  * for what was found.
00051 */
00052 
00053 #include <SUM.h>
00054 #include <sum_rpc.h>
00055 #include <tape.h>
00056 #include <string.h>
00057 #include <sys/errno.h>
00058 extern int errno;
00059 
00060 #ifdef SUMDC
00061   #define STATUSDUMP "/tmp/t50_status_dump.out"
00062   #define STATUSDUMPSIM "/usr/local/logs/SUM/t50_status_dump.out.sim"
00063 #elif SUMT120
00064   #define STATUSDUMP "/tmp/t120_status_dump.out"
00065   #define STATUSDUMPSIM "/usr/local/logs/SUM/t120_status_dump.out.sim"
00066 #elif SUMT950
00067   #define STATUSDUMP "/tmp/t950_status_dump.out"
00068   #define STATUSDUMPSIM "/usr/local/logs/SUM/t950_status_dump.out.sim"
00069   #define STATUSDUMPSIMREINV "/tmp/t950_status_dump.jmtx"
00070 #endif
00071 #define VDUMP "/usr/local/logs/SUM/t950_status.verify"
00072 
00073 extern int write_log();
00074 
00075 extern SLOT slots[];
00076 extern DRIVE drives[];
00077 extern int Empty_Slot_Cnt;
00078 
00079 /* Get the tape inventory and set up our internal tables. If catalog is
00080  * set, also make a sum_tape table entry if necessary.
00081  * Return 0 on error. Return -1 if don't see the full slot count.
00082  * (remember that externally slot#s start at 1)
00083  * Counts the number of empty slots found in the glb vrbl Empty_Slot_Cnt.
00084 */
00085 int tape_inventory(int sim, int catalog)
00086 {
00087   FILE *finv;
00088   char cmd[MAXSTR], row[MAXSTR], smsg[MAXSTR];
00089   char *token, *cptr;
00090   char *tapeidclosed[MAX_SLOTS+MAX_DRIVES];
00091   int drivenum, slotnum, i, j, k, tstate;
00092   int drive_full[MAX_DRIVES];
00093   int cx = 0;
00094 
00095   write_log("tape_inventory() called with sim = %d\n", sim);
00096 /*  sprintf(cmd, "/bin/rm -f %s", STATUSDUMP);
00097 /*  system(cmd);
00098 */
00099   sprintf(cmd, "/usr/sbin/mtx -f %s status 1> %s 2>&1", LIBDEV, STATUSDUMP);
00100   write_log("*Inv: %s\n", cmd);
00101   if(sim) {         /* simulation mode only */
00102     sleep(5);
00103     sprintf(cmd, "cp %s %s", STATUSDUMPSIM, STATUSDUMP);
00104     system(cmd);
00105   }
00106   else {
00107     if(system(cmd)) {
00108        /* write_log("***Inv: failure\n\n");/* Can't do this here. caller does*/
00109       return(0);
00110     }
00111   }
00112   write_log("***Inv: success\n\n");
00113   if (!(finv = fopen(STATUSDUMP, "r"))) {
00114     write_log("**Fatal error: can't open %s\n", STATUSDUMP);
00115     return(0);
00116   }
00117   drivenum = slotnum = 0;  /* remember that externally slot#s start at 1 */
00118   Empty_Slot_Cnt = 0;
00119   for(i=0; i < MAX_DRIVES; i++) { drive_full[i] = -1; }
00120   i = j = 0;
00121   while (fgets (row,MAXSTR,finv)) {
00122     if(strstr(row, "Data Transfer Element")) {
00123       if(drivenum == MAX_DRIVES) {
00124         write_log("**Warning: there are more drives then MAX_DRIVES (%d)\n",
00125             MAX_DRIVES);
00126         /*return(0);*/
00127       }
00128       if(strstr(row, ":Full")) {    /* Drive has tape */
00129         token = (char *)strtok(row, "=");
00130         token = (char *)strtok(NULL, "=");
00131         if(!token) {            /* no bar code */
00132           token = "NoBar  ";
00133         } else {
00134           token = token+1;      /* skip leading space */
00135           cptr = index(token, ' '); /* find trailing space */
00136           *cptr = (char)NULL;       /* elim trailing stuff */
00137         }
00138         drive_full[i++] = drivenum; /* this drive needs a free slot */
00139         drives[drivenum].tapeid = (char *)strdup(token);
00140         drives[drivenum].sumid = 0;
00141         drives[drivenum].busy = 0;
00142         drives[drivenum].tapemode = 0;
00143         drives[drivenum].filenum = 0;
00144         drives[drivenum].blocknum = 0;
00145         drives[drivenum].slotnum = 0; /* filled in w/free slot# below */
00146         write_log("tapeid in drive %d = %s\n", 
00147             drivenum, drives[drivenum].tapeid);
00148         if(catalog) { 
00149       if((tstate=SUMLIB_TapeCatalog(drives[drivenum].tapeid)) == 0) {
00150             write_log("***ERROR: Can't catalog new tapeid = %s\n", 
00151             drives[drivenum].tapeid);
00152           }
00153           else {
00154             if(tstate == TAPECLOSED) {  /* let tui know already closed */
00155               tapeidclosed[cx++] = drives[drivenum].tapeid;
00156             }
00157           }
00158         }
00159       }
00160       else {                /* EMPTY */
00161         drives[drivenum].tapeid = NULL;
00162         drives[drivenum].sumid = 0;
00163         drives[drivenum].busy = 0;
00164         drives[drivenum].tapemode = 0;
00165         drives[drivenum].filenum = 0;
00166         drives[drivenum].blocknum = 0;
00167         drives[drivenum].slotnum = -1;
00168         write_log("tapeid in drive %d = %s\n", 
00169             drivenum, drives[drivenum].tapeid);
00170       }
00171       drivenum++;
00172     }
00173     else if(strstr(row, "Storage Element")) {
00174       if(slotnum == MAX_SLOTS) {
00175         write_log("**Fatal error: there are more slots then MAX_SLOTS=%d\n",
00176             MAX_SLOTS);
00177         return(0);
00178       }
00179       sprintf(smsg, " ");
00180       if(strstr(row, ":Full")) {    /* slot has tape */
00181         token = (char *)strtok(row, "=");
00182         token = (char *)strtok(NULL, "=");
00183         if(!token) {            /* no bar code */
00184           token = "NoBar  ";
00185         } else {
00186           cptr = index(token, ' '); /* find trailing space */
00187           *cptr = (char)NULL;       /* elim trailing stuff */
00188         }
00189         slots[slotnum].slotnum = slotnum;
00190         slots[slotnum].tapeid = (char *)strdup(token);
00191         if(catalog) { 
00192           if((tstate=SUMLIB_TapeCatalog(slots[slotnum].tapeid)) == 0) {
00193             write_log("***ERROR: Can't catalog new tapeid = %s\n", 
00194             slots[slotnum].tapeid);
00195           }
00196           else {
00197             if(tstate == TAPECLOSED) {  /* let tui know already closed */
00198               tapeidclosed[cx++] = slots[slotnum].tapeid;
00199             }
00200           }
00201         }
00202       }
00203       else {                /* EMPTY */
00204         if(j < MAX_DRIVES) {        /* more empty slots then drives */
00205           if((k = drive_full[j++]) != -1) { /* drive need this empty slot# */
00206             drives[k].slotnum = slotnum;
00207             sprintf(smsg, "Slot assigned to drive #%d", k);
00208           }
00209         }
00210         slots[slotnum].slotnum = slotnum;
00211         slots[slotnum].tapeid = NULL;
00212         Empty_Slot_Cnt++;
00213       }
00214       write_log("tapeid in slot# %d = %s %s\n", 
00215         slotnum+1, slots[slotnum].tapeid, smsg);
00216       slotnum++;
00217     }
00218   }
00219   write_log("***ENDInv: slots=%d\n", slotnum);
00220   fclose(finv);
00221   if(slotnum != MAX_SLOTS) {
00222     write_log("Inv returned wrong # of slots. Retry.\n");
00223     return(-1);
00224   }
00225   /* now can output the ReClose tapeids. Must be done after ***ENDInv
00226    * msg as tui gobbles up outout in the log file during an inventory
00227    * until it finds this msg.
00228   */
00229   write_log("***ENDInvPhase:\n");       /* for tui to see */
00230   for(i=0; i < cx; i++) {
00231       //write_log("*Tp:ReClose: tapeid=%s\n", tapeidclosed[i]);
00232   }
00233   return(1);
00234 }
00235 
00236 /* Called from tape_svc_proc.c  to re-inventory all the drives and slots
00237  * to find out what's really where.
00238  * Return 0 on error. Return -1 if don't see the full slot count.
00239  *
00240  * Also called from tape_svc_proc.c onoffdo_1() when the user calls the
00241  * 'tapeonoff inv' utility.
00242 */
00243 int tape_reinventory(int sim, int catalog)
00244 {
00245   FILE *finv;
00246   char cmd[MAXSTR], row[MAXSTR], smsg[MAXSTR];
00247   char *token, *cptr;
00248   char *tapeidclosed[MAX_SLOTS+MAX_DRIVES];
00249   int drivenum, slotnum, i, j, k, tstate;
00250   int drive_full[MAX_DRIVES];
00251   int cx = 0;
00252 
00253   write_log("tape_reinventory() called with catalog = %d\n", catalog);
00254 /*  sprintf(cmd, "/bin/rm -f %s", STATUSDUMP);
00255 /*  system(cmd);
00256 */
00257   sprintf(cmd, "/usr/sbin/mtx -f %s status 1> %s 2>&1", LIBDEV, STATUSDUMP);
00258   if(sim) {         /* simulation mode only */
00259     sleep(5);
00260     sprintf(cmd, "cp %s %s", STATUSDUMPSIMREINV, STATUSDUMP);
00261     write_log("*Inv: %s\n", cmd);
00262     system(cmd);
00263   }
00264   else {
00265     write_log("*Inv: %s\n", cmd);
00266     if(system(cmd)) {
00267       write_log("ReInv Fail on: %s\n", cmd);
00268       return(0);
00269     }
00270   }
00271   if (!(finv = fopen(STATUSDUMP, "r"))) {
00272     write_log("**Fatal error: can't open %s\n", STATUSDUMP);
00273     return(0);
00274   }
00275   write_log("***Inv: success\n\n");
00276   drivenum = slotnum = 0;  /* remember that externally slot#s start at 1 */
00277   Empty_Slot_Cnt = 0;
00278   for(i=0; i < MAX_DRIVES; i++) { drive_full[i] = -1; }
00279   i = j = 0;
00280   while (fgets (row,MAXSTR,finv)) {
00281     if(strstr(row, "Data Transfer Element")) {
00282       if(drivenum == MAX_DRIVES) {
00283         write_log("**Warning: there are more drives then MAX_DRIVES (%d)\n",
00284             MAX_DRIVES);
00285         return(0);
00286       }
00287       if(strstr(row, ":Full")) {    /* Drive has tape */
00288         token = (char *)strtok(row, "=");
00289         token = (char *)strtok(NULL, "=");
00290         if(!token) {            /* no bar code */
00291           token = "NoBar  ";
00292         } else {
00293           token = token+1;      /* skip leading space */
00294           cptr = index(token, ' '); /* find trailing space */
00295           *cptr = (char)NULL;       /* elim trailing stuff */
00296         }
00297         drive_full[i++] = drivenum; /* this drive needs a free slot */
00298         drives[drivenum].tapeid = (char *)strdup(token);
00299         //drives[drivenum].sumid = 0;
00300         //drives[drivenum].busy = 0;
00301         //drives[drivenum].tapemode = 0;
00302         drives[drivenum].filenum = 0;   //force reposition
00303         //drives[drivenum].blocknum = 0;
00304         //drives[drivenum].slotnum = 0; /* filled in w/free slot# below */
00305         write_log("tapeid in drive %d = %s\n", 
00306             drivenum, drives[drivenum].tapeid);
00307         if(catalog) { 
00308       if((tstate=SUMLIB_TapeCatalog(drives[drivenum].tapeid)) == 0) {
00309             write_log("***ERROR: Can't catalog new tapeid = %s\n", 
00310             drives[drivenum].tapeid);
00311           }
00312           else {
00313             if(tstate == TAPECLOSED) {  /* let tui know already closed */
00314               tapeidclosed[cx++] = drives[drivenum].tapeid;
00315             }
00316           }
00317         }
00318       }
00319       else {                /* EMPTY */
00320           drives[drivenum].tapeid = NULL;
00321           drives[drivenum].sumid = 0;
00322           drives[drivenum].busy = 0;
00323           drives[drivenum].tapemode = 0;
00324           drives[drivenum].filenum = 0;
00325           drives[drivenum].blocknum = 0;
00326           drives[drivenum].slotnum = -1;
00327           write_log("tapeid in drive %d = %s\n", 
00328             drivenum, drives[drivenum].tapeid);
00329       }
00330       drivenum++;
00331     }
00332     else if(strstr(row, "Storage Element")) {
00333       if(slotnum == MAX_SLOTS) {
00334         write_log("**Fatal error: there are more slots then MAX_SLOTS=%d\n",
00335             MAX_SLOTS);
00336         return(0);
00337       }
00338       sprintf(smsg, " ");
00339       if(strstr(row, ":Full")) {    /* slot has tape */
00340         token = (char *)strtok(row, "=");
00341         token = (char *)strtok(NULL, "=");
00342         if(!token) {            /* no bar code */
00343           token = "NoBar  ";
00344         } else {
00345           cptr = index(token, ' '); /* find trailing space */
00346           *cptr = (char)NULL;       /* elim trailing stuff */
00347         }
00348         slots[slotnum].slotnum = slotnum;
00349         slots[slotnum].tapeid = (char *)strdup(token);
00350         if(catalog) { 
00351           if((tstate=SUMLIB_TapeCatalog(slots[slotnum].tapeid)) == 0) {
00352             write_log("***ERROR: Can't catalog new tapeid = %s\n", 
00353             slots[slotnum].tapeid);
00354           }
00355           else {
00356             if(tstate == TAPECLOSED) {  /* let tui know already closed */
00357               tapeidclosed[cx++] = slots[slotnum].tapeid;
00358             }
00359           }
00360         }
00361       }
00362       else {                /* EMPTY */
00363         if(j < MAX_DRIVES) {        /* more empty slots then drives */
00364           if((k = drive_full[j++]) != -1) { /* drive need this empty slot# */
00365             drives[k].slotnum = slotnum;
00366             sprintf(smsg, "Slot assigned to drive #%d", k);
00367           }
00368         }
00369         slots[slotnum].slotnum = slotnum;
00370         slots[slotnum].tapeid = NULL;
00371         Empty_Slot_Cnt++;
00372       }
00373       write_log("tapeid in slot# %d = %s %s\n", 
00374         slotnum+1, slots[slotnum].tapeid, smsg);
00375       slotnum++;
00376     }
00377   }
00378   write_log("***ENDInv: slots=%d\n", slotnum);
00379   fclose(finv);
00380   if(slotnum != MAX_SLOTS) {
00381     write_log("Inv returned wrong # of slots. Retry.\n");
00382     return(-1);
00383   }
00384   /* now can output the ReClose tapeids. Must be done after ***ENDInv
00385    * msg as tui gobbles up outout in the log file during an inventory
00386    * until it finds this msg.
00387   */
00388   write_log("***ENDInvPhase:\n");       /* for tui to see */
00389   for(i=0; i < cx; i++) {
00390       write_log("*Tp:ReClose: tapeid=%s\n", tapeidclosed[i]);
00391   }
00392   return(1);
00393 }
00394 
00395 /* Verify that the given operation succesfully completed.
00396  * For the given action, checks if the slot and slotordrive
00397  * are full or empty accordingly. For example for the command,
00398  * mtx -f /dev/t950 load 13 1
00399  * will check that slot 13 is empty and slot 1 contains a tape.
00400  * If the check is true, returns 1, if not true returns 0.
00401  * If can't verify, returns -1.
00402  * 
00403  * The actions are load, unload, transfer. For load and unload the
00404  * slotordrive is a drive#. Foe transfer, the slotordrive is a slot#.
00405  *
00406  *NOTE:!!This starts out as the same code in rb_verify() found in robotn.c
00407 */
00408 int robot_verify(char *action, int slot, int slotordrive)
00409 {
00410   FILE *finv;
00411   int s, sord, retry;
00412   int drivenum, slotnum, i, j, k, tstate;
00413   char *drive_tapes[MAX_DRIVES], *slot_tapes[MAX_SLOTS];
00414   char *token, *cptr;
00415   char cmd[MAXSTR], row[MAXSTR];
00416 
00417   retry = 6;
00418   while(retry) {
00419     sprintf(cmd, "/usr/sbin/mtx -f %s status 1> %s 2>&1", LIBDEV, VDUMP);
00420     if(system(cmd)) {
00421       write_log("***Verify: failure. errno=%d\n", errno);
00422       return(-1);
00423     }
00424     if (!(finv = fopen(VDUMP, "r"))) {
00425       write_log("**Fatal error: can't open %s\n", VDUMP);
00426       return(-1);
00427     }
00428     drivenum = slotnum = 0;  /* remember that externally slot#s start at 1 */
00429     for(i=0; i < MAX_DRIVES; i++) { drive_tapes[i] = "NoTape"; }
00430     while (fgets (row,MAXSTR,finv)) {
00431       if(strstr(row, "Data Transfer Element")) {
00432         if(strstr(row, ":Full")) {  /* Drive has tape */
00433           token = (char *)strtok(row, "=");
00434           token = (char *)strtok(NULL, "=");
00435           if(!token) {          /* no bar code */
00436             token = "NoTape";       /* treat as NoTape
00437           } else {
00438             token = token+1;        /* skip leading space */
00439             cptr = index(token, ' ');   /* find trailing space */
00440             *cptr = (char)NULL;     /* elim trailing stuff */
00441           }
00442           drive_tapes[drivenum] = (char *)strdup(token);
00443         }
00444         write_log("tapeid in drive %d = %s\n", 
00445             drivenum, drive_tapes[drivenum]);
00446         drivenum++;
00447       }
00448       else if(strstr(row, "Storage Element")) {
00449         if(strstr(row, ":Full")) {  /* slot has tape */
00450           token = (char *)strtok(row, "=");
00451           token = (char *)strtok(NULL, "=");
00452           if(!token) {          /* no bar code */
00453             token = "NoTape";       /* treat as no tape */
00454           } else {
00455             cptr = index(token, ' ');   /* find trailing space */
00456             *cptr = (char)NULL;     /* elim trailing stuff */
00457           }
00458           slot_tapes[slotnum] = (char *)strdup(token);
00459         }
00460         else {              /* slot EMPTY */
00461           slot_tapes[slotnum] = "NoTape";
00462         }
00463         write_log("tapeid in slot# %d = %s\n", 
00464         slotnum+1, slot_tapes[slotnum]);
00465         slotnum++;
00466       }
00467     }
00468     fclose(finv);
00469     if(slotnum != MAX_SLOTS) {
00470       write_log("Inv returned wrong # of slots. Retry.\n");
00471       --retry;
00472       if(retry == 0) {
00473         write_log("***Fatal error: Can't do tape inventory\n");
00474         return(-1);
00475       }
00476     }
00477     else { retry = 0; }
00478   }
00479   //Now check if the given slot and slotordrive args are ok
00480   if(!strcmp(action, "unload")) {   //drive emtpy and slot full
00481     if(strcmp(drive_tapes[slotordrive], "NoTape")) { //drive has tape. NG
00482       return(0);
00483     }
00484     if(!strcmp(slot_tapes[slot], "NoTape")) {   //slot has no tape. NG
00485       return(0);
00486     }
00487     return(1);      //verifies ok
00488   }
00489   else if(!strcmp(action, "load")) {    //slot empty and drive full
00490     if(!strcmp(drive_tapes[slotordrive], "NoTape")) { //drive has no tape. NG
00491       return(0);
00492     }
00493     if(strcmp(slot_tapes[slot], "NoTape")) {   //slot has tape. NG
00494       return(0);
00495     }
00496     return(1);          //verifies ok
00497   }
00498   else {            //it's a transfer. 1st slot empty, 2nd full
00499     if(strcmp(slot_tapes[slot], "NoTape")) {   //slot has tape. NG
00500       return(0);
00501     }
00502     if(!strcmp(slot_tapes[slotordrive], "NoTape")) { //slot has no tape. NG
00503       return(0);
00504     }
00505     return(1);
00506   }
00507 }
base/sums/apps/tape_inventory.c
