//------------------------------------------------------------------------- // Delete a crate from the crate db //------------------------------------------------------------------------- int DelCrate() { char crateName[CRATE_NAME_SIZE + 1]; int index, numOfEntries; int status = SUCCESS; static DESCRIPTOR( phy_name_p, "PHY_NAME" ); static DYNAMIC_DESCRIPTOR( phy_name ); // get user input str_free1_dx(&phy_name); // per twf -- clear out field cli_get_value( &phy_name_p, &phy_name ); str_upcase( &phy_name, &phy_name ); // trim it... sprintf(crateName, "%.6s", phy_name.pointer); // check to see if db file memory mapped if( CRATEdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CRATE_DB) != SUCCESS ) { // we're dead in the water status = FAILURE; // MAP_ERROR; [2001.07.12] goto DelCrate_Exit; } } // get number of current entries if( (numOfEntries = get_file_count(CRATE_DB)) == 0 ) { // no entries in crate db file if( MSGLVL(IMPORTANT) ) fprintf( stderr, "db file empty, no entries to remove\n" ); status = FAILURE; // DELCRATE_ERROR; [2001.07.12] goto DelCrate_Exit; } // try to remove from crate.db if( (index = lookup_entry(CRATE_DB, crateName)) >= 0 ) { // module does exist if( remove_entry(CRATE_DB, index) != SUCCESS ) { // removal failed status = FAILURE; // DELCRATE_ERROR; [2001.07.12] goto DelCrate_Exit; } } else { // no such module if( MSGLVL(IMPORTANT) ) fprintf( stderr, "delcrate(): entry '%s' not found\n", crateName); status = FAILURE; // DELCRATE_ERROR; [2001.07.12] goto DelCrate_Exit; } DelCrate_Exit: if( MSGLVL(DETAILS) ) { printf("DelCrate() status = %d\n", status); } return SUCCESS; }
//------------------------------------------------------------------------- // translate a logical module name to a physical representation (ie 'Key' format) //------------------------------------------------------------------------- // Fri May 25 12:23:23 EDT 2001 // Fri Feb 8 10:42:57 EST 2002 -- fixed type of 'key->scsi_port' //------------------------------------------------------------------------- // input: logical module name // output: status, and modified data referenced by pointer //------------------------------------------------------------------------- int xlate_logicalname( char *Name, CamKey *key ) { int i; int status = SUCCESS; // otpimistic struct Module_ Mod; extern struct MODULE *CTSdb; extern int CTSdbFileIsMapped; if( MSGLVL(FUNCTION_NAME) ) printf( "xlate_logicalname()\n" ); if( strchr(Name, ':') != NULL ) { // invalid logical name ... status = ERROR; // ... was passed a physical name goto Xlate_LogicalName_Exit; } // check to see if CTS db is memory mapped if( CTSdbFileIsMapped == FALSE ) { if( map_data_file( CTS_DB ) != SUCCESS ) { status = MAP_ERROR; // not mapped, we're done :< goto Xlate_LogicalName_Exit; } } // look up entry in db file if( (i = lookup_entry( CTS_DB, Name )) < 0 ) { status = NO_DEVICE; goto Xlate_LogicalName_Exit; } parse_cts_db( CTSdb+i, &Mod ); // get info ... // load up struct with vital info key->scsi_port = Mod.adapter +'A'; // SCSI host adapter [2002.02.08] key->scsi_address = Mod.id; // SCSI id key->crate = Mod.crate; // CAMAC crate number key->slot = Mod.slot; // CAMAC slot (ie station) Xlate_LogicalName_Exit: if( MSGLVL(DETAILS) ) { printf( "xlate(): name['%s'] ==>> HA[%c] id[%d] crate[%02d] slot[%d]\n", Name, key->scsi_port, key->scsi_address, key->crate, key->slot ); } return status; }
//------------------------------------------------------------------------- // set a crate on-line or off-line //------------------------------------------------------------------------- int SetCrate() { int status; char *cratename; void *ctx=0; static DESCRIPTOR( crate_p, "CRATE" ); static DESCRIPTOR( quietq, "QUIET" ); static DYNAMIC_DESCRIPTOR( wild ); static DYNAMIC_DESCRIPTOR( crate ); static DESCRIPTOR( offq, "OFFLINE" ); static DESCRIPTOR( onq, "ONLINE" ); int off = cli_present(&offq) & 1; int on = cli_present(&onq ) & 1; int quiet = cli_present(&quietq) & 1; cli_get_value( &crate_p, &wild ); str_upcase( &wild, &wild ); // check to see if db file memory mapped if( CRATEdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CRATE_DB) != SUCCESS ) { // we're dead in the water if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error memory mapping crate db file\n" ); status = FAILURE; // MAP_ERROR; [2001.07.12] goto SetCrate_Exit; } } while (find_crate(wild.pointer,&cratename,&ctx)) { status = turn_crate_on_off_line( cratename , (on) ? ON : OFF ); if (!(status & 1) && !quiet) printf("Error turning crate %s %s\n",cratename,on ? "online" : "offline"); free(cratename); } find_crate_end(&ctx); SetCrate_Exit: return SUCCESS; }
//------------------------------------------------------------------------- // contract_db() // Wed Jan 30 10:44:01 EST 2002 //------------------------------------------------------------------------- // Contract the CTS or CRATE db files // // input: db type, // current number of entries in CTS data file // output: status //------------------------------------------------------------------------- int contract_db( int dbType, int numOfEntries ) { char *FileName; int FileIncr, newCount; int status = SUCCESS; // optimistic, aren't we ... :> char tmpfile[1024]; strcpy(tmpfile,get_file_name("mdscts_temp_file_XXXXXX")); if( MSGLVL(FUNCTION_NAME) ) printf( "contract_db()\n" ); // assimilate db specific information ... switch( dbType ) { case CTS_DB: FileName = CTS_DB_FILE; FileIncr = CTS_DB_INCREMENT; break; case CRATE_DB: FileName = CRATE_DB_FILE; FileIncr = CRATE_DB_INCREMENT; break; } // make db file smaller .... [2002.01.30] // // // calculate new db file size newCount = (((int)numOfEntries / FileIncr) + 1) * FileIncr; // create a TMP file if( (status = create_tmp_file( dbType, newCount, tmpfile )) != SUCCESS ) { if( MSGLVL(ALWAYS) ) fprintf( stderr, "error creating TMP file\n" ); goto ContractDB_Exit; } // only need to copy old data if there is any if( numOfEntries ) { // copy current db file to TMP file if( (status = copy( dbType, FileName, tmpfile, numOfEntries )) != SUCCESS ) { if( MSGLVL(ALWAYS) ) fprintf( stderr, "error copying db to TMP file\n" ); goto ContractDB_Exit; } // remove old db file if( Remove( FileName ) ) { // non-zero is an error if( MSGLVL(ALWAYS) ) { fprintf( stderr, "error removing old db file\n" ); perror("remove()"); } status = CONTRACT_ERROR; goto ContractDB_Exit; } } if( rename(tmpfile, get_file_name( FileName )) ) { // non-zero is an error if( MSGLVL(ALWAYS) ) { fprintf( stderr, "error renaming temp db file\n" ); perror("rename()"); } status = CONTRACT_ERROR; goto ContractDB_Exit; } chmod(get_file_name( FileName ), O666); // re-map file if( map_data_file( dbType ) != SUCCESS ) { if( MSGLVL(ALWAYS) ) fprintf( stderr, "unable to map contracted file\n" ); status = MAP_ERROR; goto ContractDB_Exit; } ContractDB_Exit: if( MSGLVL(DETAILS) ) { printf( "contract_db('%s'): ", get_file_name( FileName )); ShowStatus( status ); } return status; }
//------------------------------------------------------------------------- // get_file_count() // Thu Jan 4 12:06:05 EST 2001 // Wed Apr 18 11:22:47 EDT 2001 -- use macro support, ie 'Open()' // Thu Sep 6 13:43:00 EDT 2001 -- fixed debug printout // Wed Sep 19 12:19:00 EDT 2001 -- switched to memory mapped file use; faster // Tue Jan 8 17:16:18 EST 2002 -- fixed end of dbfile problem //------------------------------------------------------------------------- // Get number of entries in database file. Unused records have a leading // space character. Uses memory mapped 'version' of db file. // // input: db type // output: number of entries [0..n]; FILE_ERROR [-2 * 2] if error //------------------------------------------------------------------------- int get_file_count( int dbType ) { void *dbptr; // generic pointer to struct's char dbFileName[16]; int dbFileSize, entrySize, i, numOfEntries; int *FileIsMapped; extern struct MODULE *CTSdb; extern struct CRATE *CRATEdb; extern int CTSdbFileIsMapped; extern int CRATEdbFileIsMapped; switch( dbType ) { case CTS_DB: dbptr = (void *)CTSdb; entrySize = MODULE_ENTRY; FileIsMapped = &CTSdbFileIsMapped; sprintf(dbFileName, "%s", CTS_DB_FILE); break; case CRATE_DB: dbptr = (void *)CRATEdb; entrySize = CRATE_ENTRY; FileIsMapped = &CRATEdbFileIsMapped; sprintf(dbFileName, "%s", CRATE_DB_FILE); break; } if( MSGLVL(FUNCTION_NAME) ) printf( "get_file_count()\n" ); // check for memory mapped file if( *FileIsMapped == FALSE ) { if( map_data_file(dbType) != SUCCESS ) { numOfEntries = MAP_ERROR; goto GetFileCount_Exit; } } // get total db file size in bytes if(( dbFileSize = get_db_file_size(dbFileName)) < 0 ) { numOfEntries = FAILURE; goto GetFileCount_Exit; } // get the appropriate count numOfEntries = 0; for( i = 0; ; i += entrySize ) { if( (i + entrySize) > dbFileSize ) // make sure we don't fall off the end ... break; // sprintf(&ch, "%.1s", (char *)(dbptr+i)); if( *(char *)(dbptr+i) == ' ' ) // we're done, so out'a here break; ++numOfEntries; } GetFileCount_Exit: if( MSGLVL(DETAILS) ) printf( "get_file_count(%d):\n", numOfEntries ); return numOfEntries; }
//------------------------------------------------------------------------- // assign a new module to CTS database //------------------------------------------------------------------------- int Assign() { char line[MODULE_ENTRY+1]; int dbFileSize, fd, i, nullMask, numOfEntries, rc; int status = SUCCESS; // assume the best static DESCRIPTOR( phy_name_p, "PHY_NAME" ); static DYNAMIC_DESCRIPTOR( phy_name ); static DESCRIPTOR( log_name_p, "LOG_NAME" ); static DYNAMIC_DESCRIPTOR( log_name ); static DESCRIPTOR( comment_p, "COMMENT" ); static DYNAMIC_DESCRIPTOR( comment ); // get user input cli_get_value( &phy_name_p, &phy_name ); str_upcase( &phy_name, &phy_name ); cli_get_value( &log_name_p, &log_name ); str_upcase( &log_name, &log_name ); str_free1_dx(&comment); // per twf -- clear out comment field cli_get_value( &comment_p, &comment ); // check to see if db file exists if( check_for_file(CTS_DB_FILE) != SUCCESS ) { // does not exist, yet // try to creat (sic) it if( (fd = Creat(CTS_DB_FILE, 0666)) == ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; // we're done :< } else close(fd); } // check to see if db file is memory mapped if( CTSdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CTS_DB) != SUCCESS ) { // we're dead in the water status = FAILURE; // MAP_ERROR; [2001.07.12] goto Assign_Exit; } } // get current db file count if( (numOfEntries = get_file_count(CTS_DB)) < 0 ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; } if( numOfEntries ) { // 1 or more if( lookup_entry(CTS_DB, log_name.pointer) >= 0 ) { // duplicate ! if( MSGLVL(IMPORTANT) ) fprintf( stderr, "duplicate module name '%s' -- not allowed\n", log_name.pointer ); status = FAILURE; // DUPLICATE; [2001.07.12] goto Assign_Exit; } } // get db file size if( (dbFileSize = get_db_file_size(CTS_DB_FILE)) == ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; } dbFileSize /= MODULE_ENTRY; // .. current maximum number of possible module entries // do we need to expand db file? if( (dbFileSize == 0) || (numOfEntries == dbFileSize) ) { // ... yes if( expand_db(CTS_DB, numOfEntries) != SUCCESS ) { // expand ... status = FAILURE; // EXPAND_ERROR; [2001.07.12] // ... failure goto Assign_Exit; } } // else OK // create a temporary string sprintf( line, "%-32s %-10s %-40s\n", log_name.pointer, // these were entered by the user phy_name.pointer, comment.pointer ? comment.pointer : "" ); // check comment field for null string, ie "(null)" nullMask = (1 << strlen(nullStr)) - 1; // set all mask bits for( i = COMMENT_INDEX; i < COMMENT_INDEX + strlen(nullStr); ++i ) if( line[i] == nullStr[i - COMMENT_INDEX] ) nullMask &= ~(1 << (i - COMMENT_INDEX)); // clear a bit in mask if( nullMask == 0 ) // all mask bit have been reset, ie matched for( i = COMMENT_INDEX; i < COMMENT_INDEX + strlen(nullStr); ++i ) line[i] = ' '; // make it spaces // add it ... if( add_entry(CTS_DB, line) != SUCCESS ) { status = FAILURE; // ASSIGN_ERROR; [2001.07.12] goto Assign_Exit; } #if NEED_WARM_N_FUZZY // write to a buffer file for a warm fuzzy ... if( (fd = Creat("buffer.db", 0666)) == ERROR ) { if( MSGLVL(ALWAYS) ) perror("creat()"); status = FAILURE; // FILE_ERROR; [2001.07.12] goto Assign_Exit; } rc = write(fd, line, sizeof(line)); close(fd); if( rc != sizeof(line) ) { if( MSGLVL(ALWAYS) ) perror("write()"); status = FAILURE; // FILE_ERROR; [2001.07.12] } #endif Assign_Exit: // we're done, so out'a here! if( MSGLVL(DETAILS) ) { printf("Assign(): "); ShowStatus(status); } return status; }
//------------------------------------------------------------------------- // Add a crate to the crate db //------------------------------------------------------------------------- int AddCrate() { char line[CRATE_ENTRY + 1]; int dbFileSize, fd, numOfEntries; int status = SUCCESS; // assume the best static DESCRIPTOR( phy_name_p, "PHY_NAME" ); static DYNAMIC_DESCRIPTOR( phy_name ); // get user input str_free1_dx(&phy_name); // per twf -- clear out field cli_get_value( &phy_name_p, &phy_name ); str_upcase( &phy_name, &phy_name ); // [2002.01.08] if( CRATEdbFileIsMapped == FALSE ) { // ... no if( check_for_file(CRATE_DB_FILE) != SUCCESS ) { // ... no if( (fd = Creat(CRATE_DB_FILE, 0666)) == ERROR ) { // no status = FAILURE; goto AddCrate_Exit; } else close(fd); // yes } if( map_data_file(CRATE_DB) != SUCCESS ) { // failure :( status = MAP_ERROR; goto AddCrate_Exit; } // else OK :) } // get current db file count if( (numOfEntries = get_file_count(CRATE_DB)) == FILE_ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto AddCrate_Exit; } if( numOfEntries ) { // 1 or more char pname[7]; sprintf(pname,"%.6s",phy_name.pointer); if( lookup_entry(CRATE_DB, pname) >= 0 ) { // duplicate ! if( MSGLVL(IMPORTANT) ) fprintf( stderr, "duplicate crate name '%.6s' -- not allowed\n", phy_name.pointer ); status = FAILURE; // DUPLICATE; [2001.07.12] goto AddCrate_Exit; } } // get db file size if( (dbFileSize = get_db_file_size(CRATE_DB_FILE)) == ERROR ) { status = FAILURE; // FILE_ERROR; [2001.07.12] goto AddCrate_Exit; } dbFileSize /= CRATE_ENTRY; // .. current maximum number of possible crate entries // do we need to expand db file? if( (dbFileSize == 0) || (numOfEntries == dbFileSize) ) { // ... yes if( (status = expand_db(CRATE_DB, numOfEntries)) != SUCCESS ) { // expand status = FAILURE; // EXPAND_ERROR; [2001.07.12] // failure goto AddCrate_Exit; } } // else OK // make an entry line, with online and enhanced set as undefined sprintf( line, "%-.6s:...:.:.:.\n", phy_name.pointer ); // add it ... if( (status = add_entry(CRATE_DB, line)) != SUCCESS ) { status = FAILURE; // ASSIGN_ERROR; [2001.07.12] goto AddCrate_Exit; } AddCrate_Exit: if( MSGLVL(DETAILS) ) { printf("AddCrate(): "); ShowStatus(status); } if( status == SUCCESS ) // if everything is OK ... Autoconfig(); // ... map crate to /dev/sg# //ShowCrate(); return status; }
//------------------------------------------------------------------------- //------------------------------------------------------------------------- int ShowModule() { char db_tmp[64]; // enough space for a logical name and a cstring terminator [2002.02.20] int i, numOfEntries, status = SUCCESS; static DESCRIPTOR( physical, "PHYSICAL" ); static DESCRIPTOR( module_p, "MODULE" ); static DESCRIPTOR( format_p, "FORMAT" ); static DESCRIPTOR( blank, " " ); static DESCRIPTOR( heading1, " # Logical Name Physical Comment" ); // header static DESCRIPTOR( heading2, "==== ================================ ========== ========================================" ); static DYNAMIC_DESCRIPTOR( wild ); struct Module_ Mod, *pMod; struct descriptor pattern; int format = cli_present(&format_p) & 1; int physical_name = cli_present(&physical) & 1; // 2002.01.16 cli_get_value( &module_p, &wild ); StrUpcase( &wild, &wild ); // convert to upper case if( MSGLVL(DETAILS) ) printf("ShowModule(): in %s order\n", (physical_name) ? "physical" : "logical" ); // check to see if db file memory mapped if( CTSdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CTS_DB) != SUCCESS ) { // we're dead in the water if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error memory mapping database file\n" ); status = FAILURE; // MAP_ERROR; [2001.07.12] goto Showmodule_Exit; } } // db file now mapped, continue pMod = &Mod; // point to some actual storage if( (numOfEntries = get_file_count(CTS_DB)) > 0 ) { // something to show printf( "%s\n", heading1.pointer ); printf( "%s%d\n", heading2.pointer, numOfEntries ); for( i = 0; i < numOfEntries; i++ ) { parse_cts_db( CTSdb+i, pMod ); // extract info from db memset(db_tmp, ' ', 32); db_tmp[33] = '\0'; if( physical_name ) // duh, physical name sprintf( db_tmp, "GK%c%d%02d:N%d", pMod->adapter + 'A', pMod->id, pMod->crate, pMod->slot ); else sprintf( db_tmp, "%s", pMod->name ); pattern.pointer = db_tmp; pattern.length = strlen(db_tmp); if( StrMatchWild( &pattern, &wild ) & 1 ) { // printf( "%s%3d: %.84s<%s\n", CYAN, i+1, (char *)CTSdb+(i * MODULE_ENTRY), NORMAL ); // fancy, with color printf( "%3d: %.84s<\n", i+1, (char *)CTSdb+(i * MODULE_ENTRY) ); } } // end of for() loop printf( "%s\n", heading2.pointer ); } else { if( MSGLVL(IMPORTANT) ) fprintf( stderr, "db file is empty, no modules to show\n" ); status = SUCCESS; // Not necessarily an ERROR; [2002.02.19] goto Showmodule_Exit; } Showmodule_Exit: if( MSGLVL(DETAILS) ) { printf("ShowModule(): "); ShowStatus(status); } return status; }
//------------------------------------------------------------------------- //------------------------------------------------------------------------- // show crate status, using crates in 'crate.db' file //------------------------------------------------------------------------- int ShowCrate() { char colorENH[9], colorON[9]; char tmp[7]; char tmp2[11]; int enhanced, i, j, online, moduleFound, numOfCrates, numOfModules; int crateStatus; int status; struct Crate_ Cr8, *pCr8; struct Module_ Mod, *pMod; static DESCRIPTOR( crate_p, "MODULE" ); static DESCRIPTOR( heading1, " CRATE ONL LAM PRV ENH" ); static DESCRIPTOR( heading2, "======= === === === ===" ); static DYNAMIC_DESCRIPTOR( wild ); static DYNAMIC_DESCRIPTOR( crate ); if( ScsiSystemStatus() == 0 ) { status = SUCCESS; // this is the function's status printf("scsi system is %sdown!%s\n", RED, NORMAL); goto ShowCrate_Exit; } if( MSGLVL(DETAILS) ) printf("scsi system is %sup!%s\n", GREEN, NORMAL); // user input cli_get_value( &crate_p, &wild ); str_upcase( &wild, &wild ); // check to see if crate db file memory mapped if( CRATEdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CRATE_DB) != SUCCESS ) { // we're dead in the water if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error memory mapping crate.db file\n" ); status = FAILURE; // MAP_ERROR; [2001.07.12] goto ShowCrate_Exit; } } // check to see if module db file memory mapped if( CTSdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CTS_DB) != SUCCESS ) { // we're dead in the water if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error memory mapping cts.db file\n" ); status = FAILURE; // MAP_ERROR; [2001.07.12] goto ShowCrate_Exit; } } printf( "%s\n", heading1.pointer ); // header printf( "%s\n", heading2.pointer ); // header pCr8 = &Cr8; // point to some actual storage pMod = &Mod; // get number of crates in db file if( (numOfCrates = get_file_count(CRATE_DB)) > 0 ) { // possibly something to show if( (numOfModules = get_file_count(CTS_DB)) > 0 ) { // maybe some crates controllers .. for( i = 0; i < numOfCrates; i++ ) { parse_crate_db(CRATEdb+i, pCr8); if( wildcard_match( wild.pointer, pCr8->name, 0,0,0 ) ) { // moduleFound = FALSE; // // for( j = 0; j < numOfModules; ++j ) { // parse_cts_db(CTSdb+j, pMod); // sprintf(tmp, "GK%c%d%02d", // pMod->adapter + 'A', // pMod->id, // pMod->crate // ); // // if( strcmp(tmp, pCr8->name) == EQUAL ) { // if( pMod->slot == 30 ) { // found a crate controller // moduleFound = TRUE; // break; // } // } // } // end of for(modules) ... moduleFound = TRUE; if( moduleFound ) { crateStatus = 0; if(MSGLVL(8)) printf("checking '%s'\n", pCr8->name); status = get_crate_status(pCr8->name, &crateStatus); if( MSGLVL(DETAILS) ) printf("gcs(%s) returned %d, crate 0x%x\n", pCr8->name, status, crateStatus); if( status == SUCCESS ) { // online = !(crateStatus & 0x3c00) ? TRUE : FALSE; // [2002.12.09] // online = !(crateStatus & 0x1000) ? TRUE : FALSE; // [2002.12.09] online = ((crateStatus & 0x1000) != 0x1000) ? TRUE : FALSE; // [2002.12.09] if( !crateStatus || crateStatus == 0x3 ) // [2001.09.10] // [2002.12.09] online = FALSE; // [2002.12.09] sprintf(colorON, "%s", (online) ? GREEN : RED); // enhanced = (online && (crateStatus & 0x4030)) ? TRUE : FALSE; // [2002.12.09] enhanced = (online && (crateStatus & 0x4000)) ? TRUE : FALSE; // [2002.12.09] sprintf(colorENH, "%s", (enhanced) ? GREEN : RED); printf("%s: %s%c%s . . %s%c%s", pCr8->name, colorON, (online) ? '*' : 'X', NORMAL, colorENH, (enhanced) ? '*' : '-', NORMAL ); if( MSGLVL(4) ) printf( " 0x%04x", crateStatus ); printf("\n"); } } // end of if(moduleFound) ... else { printf("%.6s: . . . .\n", pCr8->name); } } // end of if(wildcard) ... } // end of for(crates) ... } // crates, but no modules (ie no controllers) } printf( "%s\n", heading2.pointer ); // header status = SUCCESS; // always (???) ShowCrate_Exit: return status; }
//------------------------------------------------------------------------- // deassign a module //------------------------------------------------------------------------- int Deassign() { char db_tmp[64]; int i, index, modulesToDeassign, modulesDeassigned, numOfEntries, physical_name; int status = SUCCESS; struct Module_ Mod, *pMod; static DESCRIPTOR( physical, "PHYSICAL" ); static DESCRIPTOR( modname_p, "MODULE" ); static DYNAMIC_DESCRIPTOR( modname ); static DYNAMIC_DESCRIPTOR( wild ); struct descriptor pattern; // get user data cli_get_value( &modname_p, &wild ); StrUpcase( &wild, &wild ); physical_name = cli_present(&physical) & 1; if( MSGLVL(DETAILS) ) printf("Deassign(): %s module: <%s>\n", physical_name ? "physical" : "logical", wild.pointer); // check to see if db file memory mapped if( CTSdbFileIsMapped == FALSE ) { // is not, so try ... if( map_data_file(CTS_DB) != SUCCESS ) { // we're dead in the water status = MAP_ERROR; // [2002.02.21] goto Deassign_Exit; } } // get number of current entries if( (numOfEntries = get_file_count(CTS_DB)) == 0 ) { // no entries in cts db file if( MSGLVL(IMPORTANT) ) fprintf( stderr, "db file empty, no entries to remove\n" ); status = DEASSIGN_ERROR; // [2002.02.21] goto Deassign_Exit; } // if we get this far, then there are modules in the database modulesToDeassign = modulesDeassigned = 0; // initialize counts pMod = &Mod; // point to some actual storage // first, we need to count the number to deassign ... for( i = 0; i < numOfEntries; ++i ) { // scan entire list // look up module name(s). NB! more than one logical name may be // assigned to the same, unique physical name. parse_cts_db( CTSdb+i, pMod ); // extract info from db memset(db_tmp, ' ', 32); // clear out buffer db_tmp[33] = '\0'; // ensure buffer 'ends' if( physical_name ) // physical name sprintf( db_tmp, "GK%c%d%02d:N%d", pMod->adapter + 'A', pMod->id, pMod->crate, pMod->slot ); else // logical name sprintf( db_tmp, "%s", pMod->name ); // prepare for 'wild' match pattern.pointer = db_tmp; pattern.length = strlen(db_tmp); if( StrMatchWild( &pattern, &wild ) & 1 ) { ++modulesToDeassign; // } } // end of for() loop, all entries checked // now actually remove them while( modulesToDeassign ) { for( i = 0; i < get_file_count(CTS_DB); ++i ) { // look up module name(s). NB! more than one logical name may be // assigned to the same, unique physical name. parse_cts_db( CTSdb+i, pMod ); // extract info from db memset(db_tmp, ' ', 32); // clear out buffer db_tmp[33] = '\0'; // ensure buffer 'ends' if( physical_name ) // physical name sprintf( db_tmp, "GK%c%d%02d:N%d", pMod->adapter + 'A', pMod->id, pMod->crate, pMod->slot ); else // logical name sprintf( db_tmp, "%s", pMod->name ); // prepare for 'wild' match pattern.pointer = db_tmp; pattern.length = strlen(db_tmp); if( StrMatchWild( &pattern, &wild ) & 1 ) { if( remove_entry(CTS_DB, i) != SUCCESS ) { // removal failed status = DEASSIGN_ERROR; // [2002.02.21] goto Deassign_Exit; } else ++modulesDeassigned; // keep track of successes :) } } --modulesToDeassign; // one less to remove ... } Deassign_Exit: if( MSGLVL(DETAILS) ) { printf("Deassign(%d): ", modulesDeassigned); ShowStatus(status); } return status; }
//------------------------------------------------------------------------- // map generic scsi device names to crate table names //------------------------------------------------------------------------- int Autoconfig() { char highway_name[CRATE_NAME_SIZE + 1], *pHighwayName; char line[CRATE_ENTRY]; int i, numOfEntries; int status = SUCCESS; // optimistic FILE *fp; int j; int found, retries; // check to see if db file memory mapped if( CRATEdbFileIsMapped == FALSE ) { // is not, so try if( map_data_file(CRATE_DB) != SUCCESS ) { // we're dead in the water if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error memory mapping crate db file\n" ); status = MAP_ERROR; goto AutoConfig_Exit; // we're done :< } } // get current db file count if( (numOfEntries = get_file_count(CRATE_DB)) <= 0 ) { // nothing to do ... status = FILE_ERROR; goto AutoConfig_Exit; // we're done :< } // open file for read-only if( (fp = Fopen(CRATE_DB_FILE, "r")) == NULL ) { if( MSGLVL(2) ) fprintf( stderr, "crate.db does not exist\n" ); status = FILE_ERROR; goto AutoConfig_Exit; } pHighwayName = highway_name; // point to real memory ... // loop thru list for( i = 0; i < numOfEntries; ++i ) { fscanf(fp, "%s", line); // get a crate.db entry sprintf(pHighwayName, "%.6s", line); // trim it // NB! this is a work-around -- seems necessary for the moment for( j = 0; j < 2; j++ ) { if( map_scsi_device(pHighwayName) != SUCCESS ) { // map it if possible if( MSGLVL(IMPORTANT) ) fprintf( stderr, "error mapping scsi device '%s'\n", pHighwayName ); } } // NB! this is a work-around -- seems necessary for the moment [2001.11.02] -- see above // retries = 2; // maximum retry count // found = FALSE; // while( !found && retries-- ) { // if( (found = map_scsi_device(pHighwayName)) != SUCCESS ) { // map it if possible // fprintf( stderr, "error mapping scsi device '%s'\n", pHighwayName ); // } // } } // end of for()... AutoConfig_Exit: status = SUCCESS; return status; }