JSOC_Documentation: base/sums/apps/robotn

00001 /* robotn_svc.c
00002  * Called by tape_svc when it has a robot command to execute.
00003 */
00004 
00005 #include <SUM.h>
00006 #include <sys/errno.h>
00007 #include <sys/wait.h>
00008 #include <rpc/pmap_clnt.h>
00009 #include <sum_rpc.h>
00010 #include <soi_error.h>
00011 #include <tape.h>
00012 #include <printk.h>
00013 #include <stdio.h>
00014 #include <unistd.h>
00015 #include <sys/types.h>
00016 #include <sys/stat.h>
00017 #include <fcntl.h>
00018 //#include <stropts.h>
00019 #include <sys/mtio.h>
00020 
00021 
00022 #define MAX_WAIT 20  /* max times to wait for rdy drive in drive_ready() */
00023 #define VDUMP "/usr/local/logs/SUM/t950_status.verify"
00024 
00025 void write_time();
00026 void logkey();
00027 int rb_verify(char *action, int slot, int slotordrive);
00028 int drive_ready();
00029 extern int errno;
00030 #ifdef ROBOT_0
00031 static void robot0prog_1();
00032 #endif
00033 #ifdef ROBOT_1
00034 static void robot1prog_1();
00035 #endif
00036 static struct timeval TIMEOUT = { 120, 0 };
00037 uint32_t rinfo;     /* info returned by XXXdo_1() calls */
00038 uint32_t procnum;   /* remote procedure # to call for current_client call*/
00039 
00040 static FILE *logfp;
00041 CLIENT *current_client, *clnttape;
00042 SVCXPRT *glb_transp;
00043 int debugflg = 0;
00044 char *dbname;
00045 char *timetag;
00046 char thishost[MAX_STR];
00047 char datestr[32];
00048 char logfile[MAX_STR];
00049 char robotname[MAX_STR];
00050 
00051 int soi_errno = NO_ERROR;
00052 
00053 /*********************************************************/
00054 void open_log(char *filename)
00055 {
00056   if((logfp=fopen(filename, "a+")) == NULL) {
00057     fprintf(stderr, "Can't open the log file %s\n", filename);
00058   }
00059 }
00060 
00061 /*********************************************************/
00062 /* Return ptr to "mmm dd hh:mm:ss". Uses global datestr[]. */
00063 static char *datestring()
00064 {
00065   struct timeval tvalr;
00066   struct tm *t_ptr;
00067 
00068   gettimeofday(&tvalr, NULL);
00069   t_ptr = localtime((const time_t *)&tvalr);
00070   sprintf(datestr, "%s", asctime(t_ptr));
00071   datestr[19] = (char)NULL;
00072   return(&datestr[4]);          /* isolate the mmm dd hh:mm:ss */
00073 }
00074 
00075 /*********************************************************/
00076 /* Outputs the variable format message (re: printf) to the log file.
00077 */
00078 int write_log(const char *fmt, ...)
00079 {
00080   va_list args;
00081   char string[4096];
00082 
00083   va_start(args, fmt);
00084   vsprintf(string, fmt, args);
00085   if(logfp) {
00086     fprintf(logfp, string);
00087     fflush(logfp);
00088   }
00089   else
00090     fprintf(stderr, string);
00091   va_end(args);
00092   return(0);
00093 }
00094 
00095 /*********************************************************/
00096 void sighandler(sig)
00097   int sig;
00098 {
00099   if(sig == SIGTERM) {  /* most likely a kill from the pvmd */
00100     write_log("*** %s %s got SIGTERM. Exiting.\n", datestring(), robotname);
00101     exit(1);
00102   }
00103   if(sig == SIGINT) {
00104     write_log("*** %s %s got SIGINT. Exiting.\n", datestring(), robotname);
00105     /*DS_DisConnectDB();*/
00106     exit(1);
00107   }
00108   write_log("*** %s %s got an illegal signal %d, ignoring...\n",
00109             datestring(), robotname, sig);
00110   if (signal(SIGINT, SIG_IGN) != SIG_IGN)
00111       signal(SIGINT, sighandler);
00112   if (signal(SIGALRM, SIG_IGN) != SIG_IGN)
00113       signal(SIGALRM, sighandler);
00114 }
00115 
00116 /*********************************************************/
00117 void get_cmd(int argc, char *argv[])
00118 {
00119   int c;
00120 
00121   while(--argc > 0 && (*++argv)[0] == '-') {
00122     while(c = *++argv[0])
00123       switch(c) {
00124       case 'd':
00125         debugflg=1; /* can also be sent in by client calls */
00126         break;
00127       default:
00128         break;
00129       }
00130   }
00131   if(argc != 2) {
00132     printf("\nERROR: robotn_svc must be call with dbname and timestamp\n");
00133     exit(1);
00134   }
00135   else {
00136     dbname = argv[0];
00137     timetag = argv[1];
00138   }
00139 }
00140 
00141 /*********************************************************/
00142 void setup()
00143 {
00144   int pid;
00145   char *cptr;
00146 
00147   //when change name of dcs2 to dcs1 we found out you have to use localhost
00148   //gethostname(thishost, MAX_STR);
00149   //cptr = index(thishost, '.');       /* must be short form */
00150   //if(cptr) *cptr = (char)NULL;
00151   sprintf(thishost, "localhost");
00152   #ifdef ROBOT_0
00153   sprintf(robotname, "robot0_svc");
00154   #endif
00155   #ifdef ROBOT_1
00156   sprintf(robotname, "robot1_svc");
00157   #endif
00158   /*sprintf(logfile, "/usr/local/logs/SUM/%s_%d.log", robotname, pid);*/
00159   pid = getppid();      /* pid of sum_svc */
00160   sprintf(logfile, "/usr/local/logs/SUM/tape_svc_%s.log", timetag);
00161   open_log(logfile);
00162   printk_set(write_log, write_log);
00163   write_log("\n## %s %s on %s for pid = %d ##\n", 
00164         datestring(), robotname, thishost, pid);
00165   /*write_log("Database to connect to is %s\n", dbname);*/
00166   //if (signal(SIGINT, SIG_IGN) != SIG_IGN)
00167       signal(SIGINT, sighandler);
00168   if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
00169       signal(SIGTERM, sighandler);
00170   if (signal(SIGALRM, SIG_IGN) != SIG_IGN)
00171       signal(SIGALRM, sighandler);
00172 }
00173 
00174 /*********************************************************/
00175 int main(int argc, char *argv[])
00176 {
00177   register SVCXPRT *transp;
00178 
00179   get_cmd(argc, argv);
00180 
00181       /* register for tape_svc to talk to us */
00182       #ifdef ROBOT_0
00183       (void) pmap_unset(ROBOT0PROG, ROBOT0VERS);
00184       transp = svctcp_create(RPC_ANYSOCK, 0, 0);
00185       if (transp == NULL) {
00186     write_log("***cannot create tcp service\n");
00187     exit(1);
00188       }
00189       if(!svc_register(transp,ROBOT0PROG,ROBOT0VERS,robot0prog_1,IPPROTO_TCP)) {
00190     write_log("***unable to register (ROBOT0PROG, ROBOT0VERS, tcp)\n");
00191     exit(1);
00192       }
00193       #endif
00194       #ifdef ROBOT_1
00195       (void) pmap_unset(ROBOT1PROG, ROBOT1VERS);
00196       transp = svctcp_create(RPC_ANYSOCK, 0, 0);
00197       if (transp == NULL) {
00198     write_log("***cannot create tcp service\n");
00199     exit(1);
00200       }
00201       if(!svc_register(transp,ROBOT1PROG,ROBOT1VERS,robot1prog_1,IPPROTO_TCP)) {
00202     write_log("***unable to register (ROBOT1PROG, ROBOT1VERS, tcp)\n");
00203     exit(1);
00204       }
00205       #endif
00206   sleep(2);         /* give time to start */
00207   setup();
00208   /* Create client handle used for calling the tape_svc */
00209   clnttape = clnt_create(thishost, TAPEPROG, TAPEVERS, "tcp");
00210   if(!clnttape) {       /* server not there */
00211     clnt_pcreateerror("Can't get client handle to tape_svc");
00212     write_log("tape_svc not there on %s\n", thishost);
00213     exit(1);
00214   }
00215   /* Enter svc_run() which calls svc_getreqset when msg comes in.
00216    * svc_getreqset calls robot[n]prog_1() to process the msg.
00217    * NOTE: svc_run() never returns.
00218   */
00219   svc_run();
00220   write_log("!!!Fatal Error: svc_run() returned in robot[n]_svc\n");
00221   exit(1);
00222 }
00223 
00224 /* This is the dispatch routine that's called when the client does a
00225  * clnt_call() to ROBOT[0,1]PROG, ROBOT[0,1]VERS
00226 */
00227 static void
00228 #ifdef ROBOT_0
00229 robot0prog_1(rqstp, transp)
00230 #endif
00231 #ifdef ROBOT_1
00232 robot1prog_1(rqstp, transp)
00233 #endif
00234     struct svc_req *rqstp;
00235     SVCXPRT *transp;
00236 {
00237     union __svcargun {
00238         Rkey tapedo_1_arg;
00239     } argument;
00240     char *result, *call_err;
00241         enum clnt_stat clnt_stat;
00242 
00243     bool_t (*xdr_argument)(), (*xdr_result)();
00244     char *(*local)();
00245 
00246     switch (rqstp->rq_proc) {
00247     case NULLPROC:
00248         (void) svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
00249         return;
00250     case ROBOTDO:
00251         xdr_argument = xdr_Rkey;
00252         xdr_result = xdr_Rkey;;
00253         local = (char *(*)()) robotdo_1;
00254         break;
00255     case ROBOTDOORDO:
00256         xdr_argument = xdr_Rkey;
00257         xdr_result = xdr_Rkey;;
00258         local = (char *(*)()) robotdoordo_1;
00259         break;
00260     default:
00261                 write_log("**robot[0,1]prog_1() dispatch default procedure %d,ignore\n", rqstp->rq_proc);
00262         svcerr_noproc(transp);
00263         return;
00264     }
00265     bzero((char *)&argument, sizeof(argument));
00266     if (!svc_getargs(transp, (xdrproc_t)xdr_argument, (char *)&argument)) {
00267                 write_log("***Error on svc_getargs()\n");
00268         svcerr_decode(transp);
00269                 /*return;*/
00270                 /* NEW:23May2002 don't return.Can result in caller getting: */
00271                 /* Dsds_svc returned error code 5600 */
00272                 /* NEW: 10Jun2002 try this: */
00273                 svc_sendreply(transp, (xdrproc_t)xdr_void, (char *)NULL);
00274                 return;
00275 
00276     }
00277         glb_transp = transp;             /* needed by function */
00278     /* call the function. sets current_client, procnum & rinfo */
00279         result = (*local)(&argument, rqstp);
00280 
00281       if(result) {              /* send the result now */
00282         if(result == (char *)1) {
00283           /* no client handle. do nothing, just return */
00284         }
00285         else {
00286           if(debugflg) {
00287             write_log("\nKEYS in robot[0,1]_svc response to tape_svc are:\n");
00288             keyiterate(logkey, (KEY *)result);
00289           }
00290           clnt_stat=clnt_call(current_client, procnum, (xdrproc_t)xdr_result,
00291         (char *)result, (xdrproc_t)xdr_void, 0, TIMEOUT);
00292           if(clnt_stat != 0) {
00293             clnt_perrno(clnt_stat);     /* outputs to stderr */
00294             write_log("***Error in robotn_svc on clnt_call() back to %d procedure\n", procnum);
00295             call_err = clnt_sperror(current_client, "Err");
00296             write_log("%s\n", call_err);
00297           }
00298           /*clnt_destroy(current_client);*/ 
00299           freekeylist((KEY **)&result);
00300         }
00301       }
00302       if (!svc_freeargs(transp, (xdrproc_t)xdr_argument, (char *)&argument)) {
00303     write_log("**unable to free arguments\n");
00304     /*exit(1);*/
00305       }
00306       return;
00307 }
00308 
00309 /* Send ack to original tape_svc caller. Uses global vrbls glb_transp and
00310  * rinfo which are set up before this call.
00311  * I'm not quite sure what to do on an error here?? I've never seen it and
00312  * will ignore it for now.
00313 */
00314 void send_ack()
00315 {
00316   /* send ack back with the rinfo value */
00317   if (!svc_sendreply(glb_transp, (xdrproc_t)xdr_uint32_t, (char *)&rinfo)) {
00318     write_log("***Error on immed ack back to client. FATAL???\n");
00319     svcerr_systemerr(glb_transp);
00320   }
00321 }
00322 
00323 /* Called by tape_svc doing: clnt_call(clntrobot[0,1], ROBOTDO, ...)
00324  * The robot will execute the given command to load/unload a drive.
00325  *  A typical param list looks like:
00326  * cmd1:   KEYTYP_STRING   mtx -f /dev/sg7 load 15 0 1> /tmp/mtx_robot.log 2>&1
00327  * snum:   KEYTYP_INT      14
00328  * dnum:   KEYTYP_INT      0
00329  * wd_0:   KEYTYP_STRING   /SUM5/D1523
00330  * effective_date_0:       KEYTYP_STRING   200510211235
00331  * sumid_0:        KEYTYP_UINT64    840
00332  * bytes_0:        KEYTYP_DOUBLE              1.200000e+08
00333  * status_0:       KEYTYP_INT      4
00334  * archsub_0:      KEYTYP_INT      128
00335  * group_id_0:     KEYTYP_INT      99
00336  * safe_id_0:      KEYTYP_INT      0
00337  * ds_index_0:     KEYTYP_UINT64    1523
00338  * username_0:     KEYTYP_STRING   jim
00339  * DEBUGFLG:       KEYTYP_INT      1
00340  * wd_1:   KEYTYP_STRING   /SUM1/D464
00341  * effective_date_1:       KEYTYP_STRING   200510211235
00342  * sumid_1:        KEYTYP_UINT64    460
00343  * bytes_1:        KEYTYP_DOUBLE              1.200000e+08
00344  * status_1:       KEYTYP_INT      4
00345  * archsub_1:      KEYTYP_INT      128
00346  * group_id_1:     KEYTYP_INT      99
00347  * safe_id_1:      KEYTYP_INT      0
00348  * ds_index_1:     KEYTYP_UINT64    464
00349  * username_1:     KEYTYP_STRING   jim
00350  * wd_2:   KEYTYP_STRING   /SUM1/D460
00351  * effective_date_2:       KEYTYP_STRING   200510211235
00352  * sumid_2:        KEYTYP_UINT64    458
00353  * bytes_2:        KEYTYP_DOUBLE              1.200000e+08
00354  * status_2:       KEYTYP_INT      4
00355  * archsub_2:      KEYTYP_INT      128
00356  * group_id_2:     KEYTYP_INT      99
00357  * safe_id_2:      KEYTYP_INT      0
00358  * ds_index_2:     KEYTYP_UINT64    460
00359  * username_2:     KEYTYP_STRING   jim
00360  * reqcnt: KEYTYP_INT      3
00361  * OP:     KEYTYP_STRING   wt
00362  * current_client: KEYTYP_FILEP    6917529027641701008
00363  * procnum:        KEYTYP_UINT32    1
00364  * tapeinfo:       KEYTYP_FILEP    6917529027641652544
00365 */
00366 KEY *robotdo_1(KEY *params)
00367 {
00368   CLIENT *client;
00369   static KEY *retlist;
00370   int sim, d, s, ret, s1, s2, rv;
00371   int loadcmd = 0;
00372   char *cmd;
00373   char errstr[128], scr[80], action[80];
00374 
00375   if(findkey(params, "DEBUGFLG")) {
00376   debugflg = getkey_int(params, "DEBUGFLG");
00377   if(debugflg) {
00378     write_log("!!Keylist in robotdo_1() is:\n");
00379     keyiterate(logkey, params);
00380   }
00381   }
00382   rinfo = 0;            /* assume success */
00383   send_ack();           /* give ack to caller */
00384   retlist = newkeylist();
00385   add_keys(params, &retlist);           /* NOTE:does not do fileptr */
00386   client = (CLIENT *)getkey_fileptr(params, "current_client");
00387   /* final destination */
00388   setkey_fileptr(&retlist,  "current_client", (FILE *)client);
00389   sim = 0;
00390   if(findkey(params, "sim")) {
00391     sim = getkey_int(params, "sim");
00392   }
00393 
00394   if(findkey(params, "cmd1")) {
00395     cmd = GETKEY_str(params, "cmd1");
00396     if(strstr(cmd, " load ")) { /* cmd like: mtx -f /dev/sg12 load 14 1 */
00397       loadcmd = 1;
00398     }
00399     sscanf(cmd, "%s %s %s %s %d %d", scr, scr, scr, action, &s, &d);
00400     s--;                       /* must use internal slot # */
00401     if(strstr(cmd, " transfer ")) { //cmd like: mtx -f /dev/t950 transfer 14 15
00402       d--;          //this is also a slot#
00403     }
00404     write_log("*Rb:cmd: %s\n", cmd);
00405     if(sim) {               /* simulation mode only */
00406       sleep(2);
00407     } 
00408     else {
00409       sleep(2);             /* !!!TEMP - test for robot ready*/
00410       system(cmd);          //going to verify if success
00411       rv = rb_verify(action, s, d);
00412       if(rv != 1) {         //error, retry
00413         write_log("Err Retry: Can't verify: %s\n", cmd);
00414         system(cmd);            //try it again */
00415         rv = rb_verify(action, s, d);
00416         if(rv != 1) {           //error
00417           write_log("***Rb:failure\n\n");
00418           setkey_int(&retlist, "STATUS", 1);   /* give err back to caller */
00419           sprintf(errstr, "Error on: %s", cmd);
00420           setkey_str(&retlist, "ERRSTR", errstr);
00421           current_client = clnttape;        /* set for call to tape_svc */
00422           procnum = TAPERESPROBOTDO;        /* this proc number */
00423           return(retlist);
00424         }
00425       }
00426     }
00427     if(strstr(cmd, " transfer ")) { //cmd like: mtx -f /dev/t950 transfer 14 15
00428       sscanf(cmd, "%s %s %s %s %d %d", scr, scr, scr, scr, &s1, &s2);
00429       write_log("***Rb:success transfer %d %d\n\n", s1, s2);
00430     }
00431     else {
00432       write_log("***Rb:success\n\n");
00433     }
00434   }
00435   if(findkey(params, "cmd2")) {
00436     cmd = GETKEY_str(params, "cmd2");
00437     if(strstr(cmd, " load ")) { /* cmd like: mtx -f /dev/sg12 load 14 1 */
00438       loadcmd = 1;
00439     }
00440     sscanf(cmd, "%s %s %s %s %d %d", scr, scr, scr, action, &s, &d);
00441     s--;                       /* must use internal slot # */
00442     if(strstr(cmd, " transfer ")) { //cmd like: mtx -f /dev/t950 transfer 14 15
00443       d--;                      //this is also a slot#
00444     }
00445     write_log("*Rb:cmd: %s\n", cmd);
00446     if(sim) {               /* simulation mode only */
00447       sleep(2);
00448     } 
00449     else {
00450       sleep(2);             /* !!!TEMP - test for robot ready*/
00451       system(cmd);
00452       rv = rb_verify(action, s, d);
00453       if(rv != 1) {         //error, retry
00454         write_log("Err Retry: Can't verify: %s\n", cmd);
00455         system(cmd);            //try again
00456         rv = rb_verify(action, s, d);
00457         if(rv != 1) {                       //error
00458           write_log("***Rb:failure\n\n");
00459           setkey_int(&retlist, "STATUS", 1);   /* give err back to caller */
00460           sprintf(errstr, "Error on: %s", cmd);
00461           setkey_str(&retlist, "ERRSTR", errstr);
00462           current_client = clnttape;       /* set for call to tape_svc */
00463           procnum = TAPERESPROBOTDO;            /* this proc number */
00464           return(retlist);
00465         }
00466       }
00467     }
00468     write_log("***Rb:success\n\n");
00469   }
00470   current_client = clnttape;            /* set for call to tape_svc */
00471   procnum = TAPERESPROBOTDO;            /* this proc number */
00472   setkey_int(&retlist, "STATUS", 0);   /* give success back to caller */
00473   if(loadcmd) {             /* make sure drive is rdy after load */
00474     if(!drive_ready(sim, d)) {
00475       setkey_int(&retlist, "STATUS", 1);   /* give error back to caller */
00476       sprintf(errstr, "Error: drive not ready after: %s", cmd);
00477       setkey_str(&retlist, "ERRSTR", errstr);
00478     }
00479   }
00480   return(retlist);
00481 }
00482 
00483 /* Called by tape_svc doing: clnt_call(clntrobot[0,1], ROBOTDOORDO, ...)
00484  * The robot will execute the given commands.
00485  *  A typical param list looks like:
00486  * OP:     KEYTYP_STRING   impexp
00487  * cmd_1:  KEYTYP_STRING   mtx -f /dev/sg12 transfer 2 124 1> 
00488  *              /tmp/mtx_robot_1.log 2>&1
00489  * cmd_0:  KEYTYP_STRING   mtx -f /dev/sg12 transfer 1 123 1> 
00490  *              /tmp/mtx_robot_0.log 2>&1
00491  * reqcnt: KEYTYP_INT      2
00492  * tapeid_0:       KEYTYP_STRING   013389S1
00493  * tapeid_1:       KEYTYP_STRING   013401S1
00494 */
00495 KEY *robotdoordo_1(KEY *params)
00496 {
00497   CLIENT *client;
00498   static KEY *retlist;
00499   int sim, reqcnt, i, mvdoor2slot;
00500   char *cmd, *cptr;
00501   char ext[96], errstr[128];
00502 
00503   /*debugflg = getkey_int(params, "DEBUGFLG");*/
00504   if(debugflg) {
00505     write_log("!!Keylist in robotdoordo_1() is:\n");
00506     keyiterate(logkey, params);
00507   }
00508   mvdoor2slot = 0;
00509   rinfo = 0;            /* assume success */
00510   send_ack();           /* give ack to caller */
00511   retlist = newkeylist();
00512   add_keys(params, &retlist);
00513   client = (CLIENT *)getkey_fileptr(params, "current_client");
00514   /* final destination */
00515   setkey_fileptr(&retlist,  "current_client", (FILE *)client);
00516   current_client = clnttape;            /* set for call to tape_svc */
00517   procnum = TAPERESPROBOTDOORDO;            /* this proc number */
00518   sim = 0;
00519   if(findkey(params, "sim")) {
00520     sim = getkey_int(params, "sim");
00521   }
00522   reqcnt = getkey_int(params, "reqcnt");
00523   cptr = GETKEY_str(params, "OP");
00524   if(!strcmp(cptr, "door")) {    /* tapes were moved from door to slots */
00525     mvdoor2slot = 1;
00526   }
00527   for(i=0; i < reqcnt; i++) {
00528     sprintf(ext, "cmd_%d", i);
00529     cmd = GETKEY_str(params, ext);
00530     if(mvdoor2slot)
00531       write_log("*Rb:t50door: %s\n", cmd);
00532     else
00533       write_log("*Rb:door: %s\n", cmd);
00534     if(sim) {               /* simulation mode only */
00535       sleep(2);
00536     } 
00537     else {
00538       sleep(2);             /* !!!TEMP - test for robot ready*/
00539       if(system(cmd)) {
00540     write_log("Err Retry: %s\n", cmd);
00541     if(system(cmd)) {               /* try it again */
00542         if(mvdoor2slot)
00543           write_log("**Rb:t50doorfailure\n\n");
00544         else
00545           write_log("**Rb:doorfailure\n\n");
00546         setkey_int(&retlist, "STATUS", 1);   /* give err back to caller */
00547         sprintf(errstr, "Error on: %s", cmd);
00548         setkey_str(&retlist, "ERRSTR", errstr);
00549         return(retlist);
00550       }
00551     }
00552     }
00553     if(mvdoor2slot)
00554       write_log("**Rb:t50doorsuccess\n\n");
00555     else
00556       write_log("**Rb:doorsuccess\n\n");
00557   }
00558   if(mvdoor2slot)
00559     write_log("**Rb:t50doorcomplete\n\n");
00560   else
00561     write_log("**Rb:doorcomplete\n\n");
00562   setkey_int(&retlist, "STATUS", 0);   /* give success back to caller */
00563   return(retlist);
00564 }
00565 
00566 /* Return with 1 if the given drive goes ready before the timeout.
00567  * Else return 0.
00568 */
00569 int drive_ready(int sim, int drive)
00570 {
00571   int fd;
00572   int ret = 1;
00573   int waitcnt = 0;
00574   char devname[16];
00575   struct mtget mt_stat;
00576 
00577   if(sim) { return(1); }
00578   sprintf(devname, "/dev/nst%d", drive);
00579   fd = open(devname, O_RDONLY | O_NONBLOCK);
00580   while(1) {
00581     ioctl(fd, MTIOCGET, &mt_stat);
00582     /*write_log("mt_gstat = 0x%0x\n", mt_stat.mt_gstat); /* !!!TEMP */
00583     if(mt_stat.mt_gstat == 0) {     /* not ready yet */
00584       if(++waitcnt == MAX_WAIT) {
00585         ret = 0;
00586         break;
00587       }
00588       sleep(1);
00589     }
00590     else break;
00591   }
00592   close(fd);
00593   return(ret);
00594 }
00595 
00596 void write_time()
00597 {
00598   struct timeval tvalr;
00599   struct tm *t_ptr;
00600   char datestr[32];
00601 
00602   gettimeofday(&tvalr, NULL);
00603   t_ptr = localtime((const time_t *)&tvalr.tv_sec);
00604   sprintf(datestr, "%s", asctime(t_ptr));
00605   write_log("%s", datestr);
00606 }
00607 
00608 
00609 /* Verify that the given operation succesfully completed.
00610  * For the given action, checks if the slot and slotordrive
00611  * are full or empty accordingly. For example for the command,
00612  * mtx -f /dev/t950 load 13 1
00613  * will check that slot 13 is empty and slot 1 contains a tape.
00614  * If the check is true, returns 1, if not true returns 0.
00615  * If can't verify, returns -1.
00616  * 
00617  * The actions are load, unload, transfer. For load and unload the
00618  * slotordrive is a drive#. Foe transfer, the slotordrive is a slot#.
00619 */
00620 int rb_verify(char *action, int slot, int slotordrive)
00621 {
00622   FILE *finv;
00623   int s, sord, retry;
00624   int drivenum, slotnum, i, j, k, tstate;
00625   char *drive_tapes[MAX_DRIVES], *slot_tapes[MAX_SLOTS];
00626   char *token, *cptr;
00627   char cmd[MAXSTR], row[MAXSTR];
00628 
00629   retry = 6;
00630   while(retry) {
00631     sprintf(cmd, "/usr/sbin/mtx -f %s status 1> %s 2>&1", LIBDEV, VDUMP);
00632     if(system(cmd)) {
00633       write_log("***Verify: failure. errno=%d\n", errno);
00634       return(-1);
00635     }
00636     if (!(finv = fopen(VDUMP, "r"))) {
00637       write_log("**Fatal error: can't open %s\n", VDUMP);
00638       return(-1);
00639     }
00640     drivenum = slotnum = 0;  /* remember that externally slot#s start at 1 */
00641     for(i=0; i < MAX_DRIVES; i++) { drive_tapes[i] = "NoTape"; }
00642     while (fgets (row,MAXSTR,finv)) {
00643       if(strstr(row, "Data Transfer Element")) {
00644         if(strstr(row, ":Full")) {  /* Drive has tape */
00645           token = (char *)strtok(row, "=");
00646           token = (char *)strtok(NULL, "=");
00647           if(!token) {          /* no bar code */
00648             token = "NoTape";       /* treat as NoTape
00649           } else {
00650             token = token+1;        /* skip leading space */
00651             cptr = index(token, ' ');   /* find trailing space */
00652             if(cptr) {
00653               *cptr = (char)NULL;   /* elim trailing stuff */
00654             }
00655             else  {         //Bad. this is with no Volume Tag =
00656               write_log("Bad mtx line: %s\n", row); 
00657               token = "NoTape";     //treat as NoTape. May not work??
00658             }
00659           }
00660           drive_tapes[drivenum] = (char *)strdup(token);
00661         }
00662         //write_log("tapeid in drive %d = %s\n", 
00663     //      drivenum, drive_tapes[drivenum]);
00664         drivenum++;
00665       }
00666       else if(strstr(row, "Storage Element")) {
00667         if(strstr(row, ":Full")) {  /* slot has tape */
00668           token = (char *)strtok(row, "=");
00669           token = (char *)strtok(NULL, "=");
00670           if(!token) {          /* no bar code */
00671             token = "NoTape";       /* treat as no tape */
00672           } else {
00673             cptr = index(token, ' ');   /* find trailing space */
00674             if(cptr) {
00675               *cptr = (char)NULL;   /* elim trailing stuff */
00676             }
00677             else  {         //Bad. this is with no Volume Tag =
00678               write_log("Bad mtx line: %s\n", row); 
00679               token = "NoTape";     //treat as NoTape. May not work??
00680             }
00681           }
00682           slot_tapes[slotnum] = (char *)strdup(token);
00683         }
00684         else {              /* slot EMPTY */
00685           slot_tapes[slotnum] = "NoTape";
00686         }
00687         //write_log("tapeid in slot# %d = %s\n", 
00688         //  slotnum+1, slot_tapes[slotnum]);
00689         slotnum++;
00690       }
00691     }
00692     fclose(finv);
00693     if(slotnum != MAX_SLOTS) {
00694       write_log("Inv returned wrong # of slots. Retry.\n");
00695       --retry;
00696       if(retry == 0) {
00697         write_log("***Fatal error: Can't do tape inventory\n");
00698         return(-1);
00699       }
00700     }
00701     else { retry = 0; }
00702   }
00703   //Now check if the given slot and slotordrive args are ok
00704   if(!strcmp(action, "unload")) {   //drive emtpy and slot full
00705     if(strcmp(drive_tapes[slotordrive], "NoTape")) { //drive has tape. NG
00706       return(0);
00707     }
00708     if(!strcmp(slot_tapes[slot], "NoTape")) {   //slot has no tape. NG
00709       return(0);
00710     }
00711     return(1);      //verifies ok
00712   }
00713   else if(!strcmp(action, "load")) {    //slot empty and drive full
00714     if(!strcmp(drive_tapes[slotordrive], "NoTape")) { //drive has no tape. NG
00715       return(0);
00716     }
00717     if(strcmp(slot_tapes[slot], "NoTape")) {   //slot has tape. NG
00718       return(0);
00719     }
00720     return(1);          //verifies ok
00721   }
00722   else {            //it's a transfer. 1st slot empty, 2nd full
00723     if(strcmp(slot_tapes[slot], "NoTape")) {   //slot has tape. NG
00724       return(0);
00725     }
00726     if(!strcmp(slot_tapes[slotordrive], "NoTape")) { //slot has no tape. NG
00727       return(0);
00728     }
00729     return(1);
00730   }
00731 }
base/sums/apps/robotn_svc.c
