int GetPattern(struct sockaddr_in ServerID, char *patternbuf, int pattern_max, struct htx_data * stats)
{
SOCKET ToServerSock;
int rc;
int i;
struct CoordMsg CMsg;
int pflength;
char msg_text[1024];
ToServerSock = SetUpConnect(&ServerID, stats, 0);
memset(&CMsg, '\0', sizeof(CMsg));
CMsg.msg_type = htonl(CM_REQ_PATTERN);
CMsg.ID.Wsize.size = htonl((uint32_t)pattern_max);
rc = StreamWrite(ToServerSock, (char *) &CMsg, sizeof(CMsg));
if(rc == -1) {
sprintf(msg_text, "GetPattern: Error writing to Server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT1,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT1);
}
rc = StreamRead(ToServerSock, (char *) &CMsg, sizeof(CMsg));
CMsg.msg_type = ntohl(CMsg.msg_type);
if(CMsg.msg_type != CM_PATTERN) {
sprintf(msg_text, "GetPattern: Unable to obtain pattern file - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT2,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT2);
}
pflength = ntohl(CMsg.ID.Wsize.size);
if(pflength > pattern_max || pflength <= 0) {
sprintf(msg_text, "GetPattern: Server wrote too many characters - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT3,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT3);
}
rc = StreamRead(ToServerSock, (char *) patternbuf, pflength);
if(rc != pflength) {
sprintf(msg_text, "GetPattern: Unable to receive pattern file - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_PATT4,ERRNO), HTX_HE_SOFT_ERROR, msg_text);
HE_exit(EX_PAT4);
}
closesocket(ToServerSock);
/********************************************************************/
/* Fill remainder of patternbuf. */
/********************************************************************/
for(i=pflength; i<pattern_max; i++)
patternbuf[i] = patternbuf[i%pflength];
return pattern_max;
}
unsigned long long
memory_per_thread(unsigned int pvr) {
char msg_buf[1024];
/* General concept here is Fabricbus exerciser
* needs to write to 2 * L3CACHE_SIZE to push the
* data on fabric busses
*/
if(pvr == PVR_POWER6) {
return(2 * P6_L3CACHE_SIZE);
} else if(pvr == PVR_POWER7) {
/* Due to P7 and above systems LCO affinity, L3 private cache for each core cache are shared,
* to get a memory out of NODE,
* effective L3 memory size = 2 * NUM_CORES_PER_CHIP * L3CACHE_SIZE
*/
return(2 * P7_MAX_CORES_PER_CHIP * P7_L3CACHE_SIZE);
} else if(pvr == PVR_POWER7PLUS) {
/* Its just a plus added to Power7, everything else remains same */
return(2 * P7PLUS_MAX_CORES_PER_CHIP * P7PLUS_L3CACHE_SIZE) ;
} else if(pvr == PVR_POWER8_MURANO) {
/* MURANO has 6 cores per chip */
return(2 * P8_MURANO_MAX_CORES_PER_CHIP * P8_L3CACHE_SIZE);
} else if(pvr == PVR_POWER8_VENICE || pvr == PVR_POWERP8P_GARRISION) {
return(2 * P8_VENICE_MAX_CORES_PER_CHIP * P8_L3CACHE_SIZE);
}else if(pvr == PVR_POWER9_NIMBUS){
return(2 * P9_NIMBUS_MAX_CORES_PER_CHIP * P9_L3CACHE_SIZE);
}else if(pvr == PVR_POWER9_CUMULUS){
return(2 * P9_CUMULUS_MAX_CORES_PER_CHIP * P9_L3CACHE_SIZE);
} else {
sprintf(msg_buf, " %s, Illegal PVR = %#x \n", __FUNCTION__, pvr);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg_buf);
exit(1);
}
}
void Cmsg::SendMsg(int err, enum sev_code sev)
{
if(ArgData->Flags&ABORT) return;
if(ArgData->Rules.crash==2) {
if(sev==HTX_SYS_HARD_ERROR ||
sev==HTX_HE_HARD_ERROR ||
sev==HTX_HE_SOFT_ERROR) {
/*
* libmisc in linux will provide do_trap_htx for this purpose
* once its ready, it will be implemented..
*/
#ifndef __HTX_LINUX__
trap((int) MISC,(int) 2,(int) 2,(int) ArgData->my_ttynum);
#endif
}
}
if(sev!= HTX_HE_INFO) {
// add pass info to msg_text
char add_info[512];
sprintf(add_info,"\nbase num_oper=%d,"
" ixon=%c, ixoff=%c,"
" rts=%d, dtr=%d"
" num_chars=%d,"
" bufsize=%d,\n"
"direction=%d,"
" baudrate=%d,"
" chsize=%d,"
" cstop=%d,"
" parity=%c"
" wrap_type=%d,"
" Flags=%02X,\n"
"rule_id=%s,"
" pass_count=%d",
ArgData->Rules.num_oper,
ArgData->Rules.ixon,
ArgData->Rules.ixoff,
ArgData->Rules.rts,
ArgData->Rules.dtr,
ArgData->Rules.num_chars,
ArgData->Rules.bufsize,
ArgData->Rules.default_dir,
ArgData->TestParms.BaudRate,
ArgData->TestParms.ChSize,
ArgData->TestParms.CStopB,
ArgData->TestParms.Parity,
ArgData->TestParms.wrap_type,
ArgData->Flags,
ArgData->Rules.rule_id,
(int)ArgData->pass_count);
strcat(msg_text,add_info);
}
hxfmsg(TempStatsPtr,err,sev,msg_text );
return;
}
int prefetch_randomise_dscr(unsigned long long random_number, unsigned int what, unsigned int thread_no) {
/*
Structure of DSCR
+------------+-------+-------+-------+-------+-------+-------+-----------+-------+-------+-------+-------+-------+
| // | SWTE | HWTE | STE | LTE | SWUE | HWUE | UNIT CNT | URG | LSD | SNSE | SSE | DPFD |
+------------+-------+-------+-------+-------+-------+-------+-----------+-------+-------+-------+-------+-------+
0 3839 40 41 42 43 44 45 5455 5758 59 60 61 63
*/
unsigned long long local_random_number;
unsigned long long read_dscr;
int rc = 0;
mfspr_dscr(&read_dscr);
th_array[thread_no].read_dscr_val = read_dscr;
switch ( what ) {
case DSCR_RANDOM:
mtspr_dscr(random_number);
th_array[thread_no].written_dscr_val = random_number;
rc = 0;
break;
case DSCR_LSDISABLE:
local_random_number = random_number | (0x1<<5);
mtspr_dscr(random_number);
th_array[thread_no].written_dscr_val = random_number;
#ifdef DEBUG
printf("[%d] Original random number = 0x%x , After setting 58th bit = 0x%x\n",__LINE__,random_number,local_random_number);
#endif
rc = 0;
break;
case DSCR_DEFAULT:
break;
default:
sprintf(msg,"[%d] Wrong parameter = %d\n", __LINE__, what);
hxfmsg(&h_d, -1, HTX_HE_HARD_ERROR, msg);
rc = -1;
break;
}
/*sleep (1);*/
return rc;
}
void prefetch_irritator(void *arg)
{
int i, rc, no_of_pages, tid , thread_no, tc, oper , number_of_operations;
unsigned long long saved_seed, random_no , starting_address , memory_fetch_size;
pthread_t ptid;
unsigned char *start_addr;
struct thread_context *th = (struct thread_context *)arg;
struct ruleinfo *current_rule = th->current_rule;
int cache_type = current_rule->tgt_cache;
int cache_line_size = system_information.cinfo[cache_type].line_size;
unsigned int loop_count ;
long int offset;
unsigned long long temp_storage = 0x1, temp_pattern = 0x1;
/*
* char *contig_mem[NUM_SEGS*SEG_SIZE/(16*M)]; Physically contiguous
* memory pointer. memory_set_size variable gives total memory
* allocated both are variables of global structure.
*/
thread_no = th->thread_no ;
int pcpu = pcpus_thread_wise[thread_no];
tid = th->bind_to_cpu; /* Bind to the processor */
ptid = th->tid; /* PThread Id for this thread */
prefetch_streams = th->prefetch_streams; /* Number of prefetch streams for this thread. */
if (current_rule->testcase_type != PREFETCH_ONLY) {
/* Set Thread Cancel Type as ASYNCHRONOUS */
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
}
#ifdef __HTX_LINUX__
/*printf(" Prefetch:calling htx_bind with pcpu=%d for thread_no= %d\n",pcpu,thread_no);*/
if(pcpu == -1){
pcpu = htx_bind_thread(tid, -1);
rc = pcpu;
pcpus_thread_wise[thread_no]=pcpu;
if(pcpu < 0){
pcpus_thread_wise[thread_no]= -1;
}
}
else {
rc = htx_bind_thread(tid,pcpu);
}
#else
rc = bindprocessor(BINDTHREAD, thread_self(), tid);
#endif
DEBUG_LOG("[%d] thread %d, binding to cpu %d \n",__LINE__,thread_no,tid);
if(rc < 0) {
#ifdef __HTX_LINUX__
if( rc == -2) {
tot_thread_count --;
sprintf(msg,"lcpu:%d(pcpu=%d) prefetch has been hot removed, thread will be terminating now tot_thread_count=%d\n",tid,pcpu,tot_thread_count);
hxfmsg(&h_d, errno, HTX_HE_INFO, msg);
pthread_exit(NULL);
}
else {
sprintf(msg, "%d: Bindprocessor for prefetch irritator on lcpu:%d and corresponding pcpu:%d failed with rc=%d\n", __LINE__, tid,pcpu,rc);
hxfmsg(&h_d, errno, HTX_HE_HARD_ERROR, msg);
}
#else
sprintf(msg, "Binding to cpu:%d failed with errno: %d \n",tid,errno);
hxfmsg(&h_d, errno, HTX_HE_SOFT_ERROR, msg);
#endif
} /* End of if */
else {
/*sprintf(msg,"::physical cpu:%d for log cpu:%d\n",pcpu,tid);
hxfmsg(&h_d, rc , HTX_HE_INFO, msg);*/
#ifdef DEBUG
sprintf(msg,"[%d] Bindprocessor success [prefetch thread_bo %d]! cpu_no : %d , pthread id : 0x%x \n",__LINE__,thread_no,tid,ptid);
hxfmsg(&h_d, errno, HTX_HE_INFO, msg);
#endif
}
th->seedval = time(NULL);
srand48_r(th->seedval,&th->buffer);
number_of_operations = current_rule->num_oper;
starting_address = (unsigned long long)(th_array[thread_no].start_of_contiguous_memory);
memory_fetch_size = current_rule->prefetch_memory_size - BYTES_EXC ;
loop_count = memory_fetch_size / cache_line_size;
for (oper = 0; oper < number_of_operations ; oper++) {
/* if SIGTERM was received, exit */
if(exit_flag != 0) {
break;
}
random_no = get_random_number_perf(thread_no);
random_no = (unsigned long long)(random_no<<32) | (random_no);
/*random_no = 0xaabbccdd;
random_no = th_array[thread_no].random_pattern;*/
th_array[thread_no].prev_seed = random_no;
/* Now write DSCR if needed */
if ( system_information.pvr >= POWER8_MURANO ) {
prefetch_randomise_dscr(random_no, th->current_rule->pf_dscr , thread_no);
}
if (th_array[thread_no].prefetch_algorithm == RR_ALL_ENABLED_PREFETCH_ALGORITHMS) {
/* Run all the enabled prefetch variants in round robin method */
/* If prefetch nstride is set in the current prefetch configuration */
if ( (PREFETCH_NSTRIDE & current_rule->pf_conf) == PREFETCH_NSTRIDE ) {
n_stride(starting_address,memory_fetch_size,random_no,&th_array[thread_no].prefetch_scratch_mem[0]);
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
/* If prefetch partial is set in the current prefetch configuration */
if ( (PREFETCH_PARTIAL & current_rule->pf_conf) == PREFETCH_PARTIAL ) {
partial_dcbt(starting_address,memory_fetch_size,random_no,&th_array[thread_no].prefetch_scratch_mem[0]);
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
if ( (PREFETCH_IRRITATOR & current_rule->pf_conf) == PREFETCH_IRRITATOR ) {
rc = do_prefetch( starting_address , memory_fetch_size , random_no, thread_no, loop_count, th_array[thread_no].pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
/*prefetch(starting_address,memory_fetch_size,random_no,&th_array[thread_no].prefetch_scratch_mem[0]);*/
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
if( (PREFETCH_TRANSIENT & current_rule->pf_conf) == PREFETCH_TRANSIENT ) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = transient_dcbt((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern );
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
if ( (PREFETCH_NA & current_rule->pf_conf) == PREFETCH_NA ) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = prefetch_dcbtna((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern,&temp_storage,&temp_pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x copied data = %x0x, copied pattern = %x0x, thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), temp_storage, temp_pattern, thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
if (exit_flag != 0) {
break;
}
}
else { /* Else Run only the specified algorithm */
/*starting_address = (unsigned long long)(th_array[thread_no].start_of_contiguous_memory);
memory_fetch_size = current_rule->prefetch_memory_size - BYTES_EXC ;*/
if(th_array[thread_no].prefetch_algorithm == PREFETCH_NSTRIDE) {
/*lrand48_r(&th->buffer, &random_no);*/
n_stride(starting_address, memory_fetch_size, random_no, &th_array[thread_no].prefetch_scratch_mem[0]);
}
else if(th_array[thread_no].prefetch_algorithm == PREFETCH_PARTIAL) {
partial_dcbt(starting_address, memory_fetch_size, random_no, &th_array[thread_no].prefetch_scratch_mem[0]);
}
else if(th_array[thread_no].prefetch_algorithm == PREFETCH_TRANSIENT) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = transient_dcbt((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern );
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
else if(th_array[thread_no].prefetch_algorithm == PREFETCH_IRRITATOR) {
rc = do_prefetch( starting_address , memory_fetch_size , random_no, thread_no, loop_count, th_array[thread_no].pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
else if ( th_array[thread_no].prefetch_algorithm == PREFETCH_NA ) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = prefetch_dcbtna((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern,&temp_storage, &temp_pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch ( returned %d)!! Expected data = 0x%x Actual data = 0x%x copied data = 0x%x, copied pattern = 0x%x, thread_index : 0x%x Start of memory = %p, offset = %d\n"
,__LINE__, rc, th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)start_addr + 128*(loop_count-rc)), temp_storage, temp_pattern, thread_no, starting_address, offset);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
/* if SIGTERM was received, exit */
if(exit_flag != 0) {
break;
}
}
} /* End of for loop */
#ifdef __HTX_LINUX__
/* Restore original/default CPU affinity so that it binds to ANY available processor */
rc = htx_unbind_thread();
#else
rc = bindprocessor(BINDTHREAD, thread_self(), PROCESSOR_CLASS_ANY);
#endif
if(rc == -1) {
sprintf(msg, "%d: Unbinding from cpu:%d failed with errno %d \n",__LINE__, tid, errno);
hxfmsg(&h_d, errno, HTX_HE_SOFT_ERROR, msg);
}
#if defined(__HTX_MAMBO__) || defined(AWAN)
printf("[%d] Thread no: %d, completed passes : %d\n",__LINE__, thread_no, oper);
#endif
}
int GetRules(struct sockaddr_in ServerID, struct rule_format rule[], int max_rules, struct htx_data * stats)
{
SOCKET ToServerSock;
struct CoordMsg CMsg;
int rc;
int i;
int NoStanzas;
char msg[1024];
errno = 0;
ToServerSock = SetUpConnect(&ServerID, stats, 0);
memset(&CMsg, '\0', sizeof(CMsg));
CMsg.msg_type = htonl(CM_REQ_RULES);
CMsg.ID.Wsize.size = htonl((uint32_t)sizeof(struct rule_format));
rc = StreamWrite(ToServerSock, (char *) &CMsg, sizeof(CMsg));
if(rc == -1) {
sprintf(msg, "GetRules: Error writing to Server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_RULE1,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE1);
}
StreamRead(ToServerSock, (char *) &CMsg, sizeof(CMsg));
CMsg.msg_type = ntohl(CMsg.msg_type);
CMsg.ID.Wsize.size = ntohl(CMsg.ID.Wsize.size);
if(CMsg.msg_type != CM_RULES_STANZA) {
sprintf(msg, "GetRules: Illegal Packet recvd.\n");
hxfmsg(stats, HTXERROR(EX_RULE3,0), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE3);
}
#ifdef __DEBUG__
sprintf(msg, "GetRules: Sock = %d, Recvd msg = %x of size = %#x, rule_format size = %x, pid = %d \n", ToServerSock, CMsg.msg_type, sizeof(CMsg), (uint32_t)sizeof(struct rule_format), getpid());
hxfmsg(stats, 0, 7, msg);
#endif
memset(rule, '\0', sizeof(struct rule_format) * max_rules);
memset(&CMsg, '\0', sizeof(CMsg));
for(i=0; i < max_rules; i++) {
rc = StreamRead(ToServerSock, (char *) &CMsg.msg_type, sizeof(CMsg.msg_type));
CMsg.msg_type = ntohl(CMsg.msg_type);
#ifdef __DEBUG__
sprintf(msg, "i = %#x, GetRules: Recvd msg = %x, of size = %x \n", i, CMsg.msg_type, sizeof(CMsg.msg_type));
hxfmsg(stats, 0, 7, msg);
#endif
if(CMsg.msg_type == CM_RULES_FINISHED)
break;
if(CMsg.msg_type != CM_RULES_STANZA) {
sprintf(msg, "GetRules: Unable to obtain rules - type %x\n", (int)CMsg.msg_type);
hxfmsg(stats, HTXERROR(EX_RULE2,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE2);
}
rc = StreamRead(ToServerSock, (char*) &rule[i], sizeof(struct rule_format));
if(rc != sizeof(struct rule_format)) {
sprintf(msg, "GetRules: Unable to read rules from server - %s\n", STRERROR(errno));
hxfmsg(stats, HTXERROR(EX_RULE4,ERRNO), HTX_HE_SOFT_ERROR, msg);
HE_exit(EX_RULE3);
}
NetToHostRules(&rule[i]);
}
NoStanzas = i;
closesocket(ToServerSock);
return NoStanzas;
}
int
read_hardware_config(SYS_CONF_TYP * scfg, unsigned int tot_cpus, unsigned int pvr) {
int i, j = 0;
int bind_to_cpu , rc, pir;
int node, chip , proc;
char msg[4096];
SYS_CONF_TYP physical_scfg ;
int num_nodes = 0, chips_per_node = 0;
for(i = 0; i < MAX_CPUS ; i++) {
l_p[i] = NO_CPU_DEFINED;
}
#ifndef __HTX_LINUX__
for(i = 0 ; i < tot_cpus ; i++ ) {
bind_to_cpu = i ;
rc = bindprocessor(BINDPROCESS, getpid(), bind_to_cpu);
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with rc = %d, i = %d, errno = %d", rc, i, errno);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
pir = getPir();
l_p[i] = pir ;
rc = bindprocessor(BINDPROCESS, getpid(), PROCESSOR_CLASS_ANY);
if(rc == -1) {
sprintf( msg, "\n%d: bindprocessor failed with %d while unbinding, rc = %d, i = %d ",__LINE__, errno, rc, i);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
#else
FILE *fp;
char command[200],fname[256];
int rad, lcpu, nrads, num_procs;
strcpy(fname,htx_d.htx_exer_log_dir);
sprintf(fname,"%s/node_details.%d",fname,getpid());
/*sprintf(command,"/usr/lpp/htx/etc/scripts/get_node_details.sh "
"> %s\n",fname);*/
strcpy(command,getenv("HTXSCRIPTS"));
sprintf(command, "%s/get_node_details.sh > %s\n", command, fname);
if ( (rc = system(command)) == -1 ) {
sprintf(msg, "sytem command to get_node_details failed with %d",rc);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
if ((fp=fopen(fname,"r"))==NULL){
sprintf(msg, "fopen of file %s failed with errno=%d",fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
/* Get total number of chips */
rc = fscanf(fp,"num_nodes=%d\n",&nrads);
if (rc == 0 || rc == EOF) {
sprintf(msg, "fscanf of num_nodes on file %s failed with errno =%d",fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
for (rad = 0; rad < nrads; rad++) {
int cpu_index = 0;
int cur_chip = -1; /* Current chip */
/* Fetch the current chip and the num procs in the chip */
rc = fscanf(fp,"node=%d,cpus_in_node=%d,cpus",&cur_chip,&num_procs);
if (rc == 0 || rc == EOF) {
sprintf(msg, "fscanf: chip =%d,Fetching of cpus in chip error from"
" file %s failed with errno =%d",rad,fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
if ( num_procs > tot_cpus ) {
sprintf(msg, "num_procs %d in this chip cannot be more than max procs %d "
,num_procs,tot_cpus);
hxfmsg(&htx_d,0,HTX_HE_HARD_ERROR, msg);
return(-1);
}
/*
* To find the actual processors (logical cpu Ids that can be
* specified in an rset):
*/
cpu_index = 0 ;
while ( cpu_index < num_procs) {
rc = fscanf(fp,":%d",&lcpu);
if ( rc == 0 || rc == EOF) {
sprintf(msg, "fscanf: cpu fetch for chip=%d caused error from "
" file %s failed with errno =%d",rad,fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
/* Bind to lcpu and get the PIR value for it */
rc = htx_bind_process(BIND_THE_PROCESS, lcpu);
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with %d, binding cpu=%d", errno, lcpu);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
l_p[lcpu] = get_cpu_id(lcpu);
rc = htx_unbind_process();
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with %d, unbinding th=%d, cpu=%d", errno, lcpu);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
DEBUGON("l_p[%d]=%d\n",lcpu, l_p[lcpu]);
cpu_index++;
}
rc = fscanf(fp,"\n");
if (rc == EOF) {
sprintf(msg, "fscanf: expecting new line character at the end of"
" node %d data reading from file %s failed with errno =%d",\
rad,fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
#endif
/* Intialize the sysconf data structure */
for(node = 0; node < MAX_NODES; node++) {
for(chip = 0; chip < MAX_CHIPS_PER_NODE; chip ++) {
for(proc = 0; proc < MAX_CPUS_PER_CHIP; proc ++) {
physical_scfg.node[node].chip[chip].lprocs[proc] = -1;
}
physical_scfg.node[node].chip[chip].num_procs = 0;
}
physical_scfg.node[node].num_chips = 0;
}
physical_scfg.num_nodes = 0 ;
i = 0 ;
while(i < MAX_CPUS) {
if(l_p[i] == NO_CPU_DEFINED) {
i++;
continue;
}
if(pvr == PVR_POWER9_NIMBUS){
node = P9_NIMBUS_GET_NODE(l_p[i]);
chip = P9_NIMBUS_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER9_CUMULUS){
node = P9_CUMULUS_GET_NODE(l_p[i]);
chip = P9_CUMULUS_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER8_MURANO || pvr == PVR_POWER8_VENICE || pvr == PVR_POWERP8P_GARRISION) {
node = P8_GET_NODE(l_p[i]);
chip = P8_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER7 || pvr == PVR_POWER7PLUS) {
node = P7_GET_NODE(l_p[i]);
chip = P7_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER6) {
node = P6_GET_NODE(l_p[i]);
chip = P6_GET_CHIP(l_p[i]);
} else {
sprintf(msg, "\n We shldnt have been here pvr = %x, PVR mismatch. Exiting !!\n", pvr);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
DEBUGON("Node=%d,Chip%d,proc=%d\n",node,chip,i);
physical_scfg.node[node].chip[chip].lprocs[physical_scfg.node[node].chip[chip].num_procs++] = i ;
i++;
}
for(i = 0; i < MAX_NODES; i ++) {
for( j = 0; j < MAX_CHIPS_PER_NODE; j++) {
if(physical_scfg.node[i].chip[j].num_procs > 0) {
physical_scfg.node[i].num_chips ++;
}
}
if(physical_scfg.node[i].num_chips > 0) {
physical_scfg.num_nodes ++;
}
}
/* Copy the system configuration to scfg */
for(node = 0; node < MAX_NODES; node++) {
if(physical_scfg.node[node].num_chips == 0)
continue;
chips_per_node = 0;
for(chip = 0; chip < MAX_CHIPS_PER_NODE; chip ++) {
if(physical_scfg.node[node].chip[chip].num_procs == 0)
continue;
memcpy(&scfg->node[num_nodes].chip[chips_per_node], &physical_scfg.node[node].chip[chip], sizeof(CHIP));
chips_per_node++;
}
if(chips_per_node != physical_scfg.node[node].num_chips) {
sprintf(msg, "%s: Something Wrong !!! Node = %d, chips_per_node = %d, physical_scfg_chip = %d \n",
__FUNCTION__,node, chips_per_node, physical_scfg.node[node].num_chips) ;
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
scfg->node[num_nodes].num_chips = physical_scfg.node[node].num_chips;
num_nodes++;
}
if(num_nodes != physical_scfg.num_nodes) {
sprintf(msg, "%s: Something Wrong !!! Num_nodes = %d, physical_num_nodes = %d \n",
__FUNCTION__, num_nodes, physical_scfg.num_nodes);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
scfg->num_nodes = physical_scfg.num_nodes;
return 0 ;
}
int
fill_random_buffer(unsigned long long size, unsigned long long ** seg_addr, MEMORY_SET * mem) {
size_t shm_size;
char msg[4096];
int shm_id, rc = 0;
unsigned int memflg;
unsigned long long *addr_8, *end_addr, *addr;
unsigned long long i , j ;
#ifndef __HTX_LINUX__ /* AIX Specific */
psize_t psize = 16*M;
struct shmid_ds shm_buf = { 0 };
memflg = (IPC_CREAT | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
if(SET_PAGESIZE) {
memflg |= (SHM_LGPAGE | SHM_PIN);
psize = 16*M;
} else {
psize = 4 * K;
}
#else /* Linux Specific */
unsigned long long psize;
memflg = (IPC_CREAT | IPC_EXCL |SHM_R | SHM_W);
if(SET_PAGESIZE) {
memflg |= (SHM_HUGETLB);
psize = 16*M;
} else {
psize = 4 * K;
}
#endif
shm_size = size;
shm_id = shmget(IPC_PRIVATE, shm_size , memflg);
if(shm_id == -1) {
sprintf(msg,"shmget failed with %d !\n", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
#ifndef __HTX_LINUX__
if( SET_PAGESIZE) {
if ( shm_size > 256*M) {
if ((rc = shmctl(shm_id, SHM_GETLBA, &shm_buf)) == -1) {
sprintf(msg,"\n shmctl failed to get minimum alignment requirement - %d", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
shm_buf.shm_pagesize = psize;
if( (rc = shmctl(shm_id, SHM_PAGESIZE, &shm_buf)) == -1) {
sprintf(msg,"\n shmctl failed with %d while setting page size.",errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
#endif
addr = (unsigned long long *) shmat(shm_id, 0, 0);
if(-1 == (int)addr) {
sprintf(msg,"\n shmat failed with %d",errno);
hxfmsg(&htx_d, -1,HTX_HE_HARD_ERROR, msg);
memory_set_cleanup();
return(-1);
}
addr_8 = (unsigned long long *)addr;
end_addr = (unsigned long long *) ((char *)addr + shm_size);
DEBUGON("%s: addr_8 = %llx , end_addr = %llx \n",__FUNCTION__, addr_8, end_addr);
for(; addr_8 < end_addr; ) {
*addr_8 = get_random_number();
addr_8++;
}
/* Lock the new shared memory, so that its always memory resident */
rc = mlock(addr, shm_size);
if(rc == -1) {
sprintf(msg,"\n mlock failed with %d", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
memory_set_cleanup();
return(-1);
}
mem->seg_addr = (char *)addr ;
mem->shm_id = shm_id ;
mem->memory_set_size = size;
*seg_addr = (unsigned long long *)addr ;
return 0;
}
int
get_cont_phy_mem(unsigned int num_cpus_mapped, unsigned int memory_mapping[][2], long long size, MEMORY_SET mem[]) {
char *p, *addr, msg[4096];
int i=0, ii, rc, host_cpu , j;
size_t shm_size;
unsigned int cpu, bind_to_cpu;
unsigned int memflg;
#ifndef __HTX_LINUX__ /* AIX Specific */
psize_t psize = 16*M;
struct shmid_ds shm_buf = { 0 };
struct vminfo_psize vminfo_64k = { 0 };
memflg = (IPC_CREAT | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
if(SET_PAGESIZE) {
psize = 16*M;
} else {
psize = 4 * K;
}
#else /* Linux Specific */
unsigned long long psize;
memflg = (IPC_CREAT | IPC_EXCL |SHM_R | SHM_W);
if(SET_PAGESIZE) {
memflg |= (SHM_HUGETLB);
psize = 16*M;
} else {
psize = 4 * K;
}
/* shmmax controls the maximum amount of memory to be allocated for shared memory */
rc = system ("echo 268435456 > /proc/sys/kernel/shmmax");
if (rc < 0){
sprintf(msg,"unable to change the /proc/sys/kernel/shmmax variable\n");
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
}
/* The maximum amount of shared memory that can be allocated. */
rc = system ("echo 268435456 > /proc/sys/kernel/shmall");
if (rc < 0) {
sprintf(msg,"unable to change the /proc/sys/kernel/shmall");
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
}
#endif
DEBUGON("\n Need %llx physically contiguous memory \n", size);
shm_size = (size < PG_SZ_16M ? PG_SZ_16M : size);
for(cpu = 0; cpu < num_cpus_mapped; cpu ++) {
if(memory_mapping[cpu][DEST_CPU] != NO_CPU_DEFINED) {
host_cpu = memory_mapping[cpu][HOST_CPU];
bind_to_cpu = memory_mapping[cpu][DEST_CPU];
} else {
continue;
}
#ifdef __HTX_LINUX__
rc = htx_bind_process(BIND_THE_PROCESS, bind_to_cpu);
#else
rc = bindprocessor(BINDPROCESS, getpid(), bind_to_cpu);
#endif
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with %d, binding th=%d, cpu=%d", errno, cpu,bind_to_cpu);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
mem[host_cpu].shm_id = shmget(IPC_PRIVATE, shm_size, memflg);
if(mem[host_cpu].shm_id == -1) {
memory_set_cleanup();
sprintf(msg,"shmget failed with %d !\n", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
#ifndef __HTX_LINUX__
if(SET_PAGESIZE) {
if ( shm_size > 256*M) {
if ((rc = shmctl(mem[host_cpu].shm_id, SHM_GETLBA, &shm_buf)) == -1) {
memory_set_cleanup();
sprintf(msg,"\n shmctl failed to get minimum alignment requirement - %d", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
shm_buf.shm_pagesize = psize;
if( (rc = shmctl(mem[host_cpu].shm_id, SHM_PAGESIZE, &shm_buf)) == -1) {
memory_set_cleanup();
sprintf(msg,"\n shmctl failed with %d while setting page size.",errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
#endif
addr = (char *) shmat(mem[host_cpu].shm_id, 0, 0);
if(-1 == (int)addr) {
sprintf(msg,"\n shmat failed with %d",errno);
hxfmsg(&htx_d, -1,HTX_HE_HARD_ERROR, msg);
memory_set_cleanup();
return(-1);
}
/* to be on safer side write touch the remote memory obtained */
char * mem_addr = addr;
for(i=0; i < (shm_size/psize); i++) {
*(unsigned long long *)mem_addr = 0xFFFFffffFFFFffff ;
mem_addr += psize;
}
sprintf(msg, "%s: cpu %d, bound to cpu %d, seg_addr = 0x%llx of size = 0x%llx\n",
__FUNCTION__, host_cpu, bind_to_cpu, (unsigned long long *)addr, shm_size);
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
/* Lock the new shared memory, so that its always memory resident */
rc = mlock(addr, shm_size);
if(rc == -1) {
sprintf(msg,"\n mlock failed with %d", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
memory_set_cleanup();
return(-1);
}
mem[host_cpu].seg_addr = addr;
mem[host_cpu].memory_set_size = shm_size;
#ifdef __HTX_LINUX__
rc = htx_unbind_process();
#else
rc = bindprocessor(BINDPROCESS, getpid(), PROCESSOR_CLASS_ANY);
#endif
if(rc == -1) {
sprintf(msg, "\n%d: bindprocessor failed with %d while unbinding",__LINE__, errno);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
} /* Off num_cpus_mapped loop */
return(0);
}
int
configure_memory_allocation(SYS_CONF_TYP * scfg, unsigned int mem_alloc, unsigned int memory_mapping[][2], unsigned int * num_cpus_mapped, unsigned int threads_per_node,
unsigned long long num_pages_available, unsigned long long fabbus_requested, unsigned int pvr, unsigned int query_memconf, unsigned int query_pages) {
char msg[4096];
/*
* cpu_node keeps nodes vs logical procs configurations.
* cpu_chip keeps chip vs logical procs configurations.
* This is filled by reading PIR register of each physical processor.
* -1 indicates no logical cpu on that place.
*/
int cpu_sys[MAX_NODES][MAX_CHIPS][MAX_CPUS_PER_CHIP];
int cpu_node[MAX_NODES][MAX_CPUS_PER_NODE];
int cpu_chip[MAX_CHIPS][MAX_CPUS_PER_CHIP];
/*
* scfg_node maintains no of logical cpus on every node.
* scfg_chip maintains no of logical cpus on every chip.
*/
int scfg_sys[MAX_NODES][MAX_CHIPS],scfg_node[MAX_NODES], scfg_chip[MAX_CHIPS];
/*
* num_nodes : total number of nodes in system.
* num_chips : total number of chips in system.
* chips_per_node[] : number of chips available in each node
*/
int num_nodes, num_chips;
int chips_per_node[MAX_NODES] = {0};
unsigned int i, j,k;
int node, cpu, pjmp, chip, cpus_mapped = 0;
/* Intialize local variables */
num_nodes = num_chips = 0;
memset(scfg_node, 0, MAX_NODES * sizeof(unsigned int));
memset(chips_per_node, 0, MAX_NODES * sizeof(unsigned int));
memset(scfg_chip, 0, MAX_CHIPS * sizeof(unsigned int));
memset(scfg_sys,0,(MAX_NODES * MAX_CHIPS * sizeof(unsigned int)));
for(i = 0; i < MAX_NODES; i++) {
for(j = 0; j < MAX_CHIPS; j++) {
for(k = 0; k<MAX_CPUS_PER_CHIP;k++) {
cpu_sys[i][j][k] = NO_CPU_DEFINED;
}
}
}
for(i = 0; i < MAX_NODES; i++) {
for(j = 0; j < MAX_CPUS_PER_NODE; j++) {
cpu_node[i][j] = NO_CPU_DEFINED;
cpu_node[i][j] = NO_CPU_DEFINED;
}
}
for(i = 0; i < MAX_CHIPS; i++) {
for(j = 0; j<MAX_CPUS_PER_CHIP;j++) {
cpu_chip[i][j] = NO_CPU_DEFINED ;
cpu_chip[i][j] = NO_CPU_DEFINED ;
}
}
/* extract Node/Chip level info from SYS_CONF_TYP structure for InterNode/IntraNode memory mapping */
num_nodes = scfg->num_nodes ;
for(node = 0; node < num_nodes; node++) {
chips_per_node[node] = scfg->node[node].num_chips;
for(chip = 0; chip < chips_per_node[node]; chip++) {
scfg_chip[num_chips] = scfg->node[node].chip[chip].num_procs;
scfg_sys[node][chip] = scfg->node[node].chip[chip].num_procs;
for(cpu = 0; cpu < scfg_chip[num_chips]; cpu ++) {
cpu_chip[num_chips][cpu] = scfg->node[node].chip[chip].lprocs[cpu];
cpu_node[node][scfg_node[node]] = scfg->node[node].chip[chip].lprocs[cpu];
cpu_sys[node][chip][cpu] = scfg->node[node].chip[chip].lprocs[cpu];
scfg_node[node]++;
}
num_chips++;
}
}
if(query_pages ==0 && query_memconf == 0) {
if(num_pages_available < fabbus_requested) {
/* System is falling short of 16M pages, We need to equally distribute these pages amongst nodes/chips */
unsigned long long memory_set_size = 0, pages_per_rad;
if(mem_alloc == 3 ) {
pages_per_rad = num_pages_available / num_nodes;
} else if(mem_alloc == 4) {
pages_per_rad = num_pages_available / num_chips;
} else {
pages_per_rad = MAX_CPUS;
}
memory_set_size = memory_per_thread(pvr);
if(SET_PAGESIZE) {
threads_per_node = ( pages_per_rad * 16 * M) / memory_set_size ;
} else {
threads_per_node = ( pages_per_rad * 4 * K ) / memory_set_size ;
}
if(threads_per_node < 1) {
sprintf(msg," System is too short to create one thread per node/chip, num_pages_available=%#llx, pages_per_rad = %#x, memory_set_size = %#x, threads_per_node = %#x, SET_PAGESIZE=%#x this instance will exit...\n",
num_pages_available, pages_per_rad, memory_set_size, threads_per_node, SET_PAGESIZE);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
}
if((mem_alloc == 3) && (num_nodes < 2)) {
sprintf(msg,"Only one CEC node detected num_nodes= %d, insufficient hardware to run inter node fabric bus test. Atleast two CEC nodes are needed on system \n",
num_nodes);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
switch(mem_alloc) {
case 0 : { /* Local */
for(node = 0; node < num_nodes; node++) {
pjmp = scfg_node[node]/threads_per_node;
if(pjmp == 0) pjmp = 1;
for(cpu = 0; cpu < scfg_node[node]; cpu += pjmp) {
memory_mapping[cpus_mapped][HOST_CPU] = cpu_node[node][cpu];
memory_mapping[cpus_mapped][DEST_CPU] = cpu_node[node][cpu];
cpus_mapped++;
}
}
}
break;
case 1 : { /* Remote */
for(node = 0; node < num_nodes; node++) {
int x, y;
pjmp = scfg_node[node]/threads_per_node;
if(pjmp == 0) pjmp = 1;
x = (node + 1) % num_nodes;
for(cpu = 0, y = 0; cpu < scfg_node[node]; cpu += pjmp, y += pjmp) {
if(cpu_node[x][y] == NO_CPU_DEFINED ) {
if(pjmp > 1) {
y = 1;
cpu -= pjmp;
continue;
} else {
break;
}
}
memory_mapping[cpus_mapped][HOST_CPU] = cpu_node[node][cpu];
memory_mapping[cpus_mapped][DEST_CPU] = cpu_node[x][y];
cpus_mapped++;
}
}
}
break;
case 2 : { /* Remote Spreaded */
for(node = 0; node < num_nodes; node++) {
int x, y = 0, exhausted = -1;
int cnt_thrds = 0 ;
pjmp = scfg_node[node]/threads_per_node;
if(pjmp == 0) pjmp = 1;
x = node;
for(cpu = 0; cpu < scfg_node[node]; cpu += pjmp) {
cnt_thrds ++ ;
if ( cnt_thrds > threads_per_node )
break ;
x = (x + 1) % num_nodes;
if(x == node) {
x = (x + 1) % num_nodes;
y++;
}
if(y >= scfg_node[x]) {
if(exhausted == -1) exhausted = x;
else if (x == exhausted) break;
cpu -= pjmp;
continue;
} else {
exhausted = -1;
}
memory_mapping[cpus_mapped][HOST_CPU] = cpu_node[node][cpu];
memory_mapping[cpus_mapped][DEST_CPU] = cpu_node[x][y];
cpus_mapped++;
}
}
}
break;
case 3: { /* Remote Spreaded - all */
for(node = 0; node < num_nodes; node++) {
int remote_node, remote_cpu = 0,remote_chip=0;
int thread_per_chip = threads_per_node/chips_per_node[node];
for(chip = 0; chip<chips_per_node[node];chip++,remote_chip++){
remote_cpu = 0;
remote_node = node;
for(cpu=0;cpu < ((scfg_sys[node][chip] < thread_per_chip)? scfg_sys[node][chip]:thread_per_chip);cpu++){
remote_node = (remote_node + 1) % num_nodes;
if(remote_node == node) {
remote_node = (remote_node + 1) % num_nodes;
remote_cpu++;
}
if(chip > chips_per_node[remote_node]){
remote_chip = (chips_per_node[remote_node] - 1);
}
if(remote_cpu >= thread_per_chip){
continue;
}
if(remote_cpu >= scfg_sys[remote_node][remote_chip]){
memory_mapping[cpus_mapped][HOST_CPU] = cpu_sys[node][chip][cpu];
memory_mapping[cpus_mapped][DEST_CPU] = cpu_sys[remote_node][remote_chip][scfg_sys[remote_node][remote_chip]-1];
}else {
memory_mapping[cpus_mapped][HOST_CPU] = cpu_sys[node][chip][cpu];
memory_mapping[cpus_mapped][DEST_CPU] = cpu_sys[remote_node][remote_chip][remote_cpu];
}
cpus_mapped++;
}
}
}
}
break;
case 4 : { /* Intra Node memory mapping */
int chip_cnt = 0;
for(node = 0; node < num_nodes; node++) {
int remote_chip, remote_cpu = 0, exhausted = -1;
if( chips_per_node[node] < 2 ) {
chip_cnt += chips_per_node[node] ;
continue;
}
for(chip = 0; chip < chips_per_node[node]; chip++) {
remote_chip = chip;
remote_cpu = 0;
for(cpu = 0 ; cpu < ((scfg_chip[chip_cnt + chip] < threads_per_node) ? scfg_chip[chip_cnt + chip] : threads_per_node) ; cpu++ ) {
remote_chip = (remote_chip + 1) % chips_per_node[node];
if(remote_chip == chip) {
remote_chip = (remote_chip + 1) % chips_per_node[node];
remote_cpu++;
}
if(remote_cpu >= threads_per_node) {
continue;
}
if( remote_cpu >= scfg_chip[remote_chip]) {
memory_mapping[cpus_mapped][HOST_CPU] = cpu_chip[chip_cnt + chip][cpu];
memory_mapping[cpus_mapped][DEST_CPU] = cpu_chip[chip_cnt + remote_chip][scfg_chip[remote_chip] - 1];
} else {
memory_mapping[cpus_mapped][HOST_CPU] = cpu_chip[chip_cnt + chip][cpu];
memory_mapping[cpus_mapped][DEST_CPU] = cpu_chip[chip_cnt + remote_chip][remote_cpu];
}
cpus_mapped++;
}
}
chip_cnt += chips_per_node[node] ;
}
}
break;
default : {
sprintf(msg," Wrong rules file parm memory_allocation type =%d \n",mem_alloc);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
} /* Off Switch */
*num_cpus_mapped = cpus_mapped;
#ifdef DEBUGON
sprintf(msg," num_cpus_mapped = %d \n",cpus_mapped);
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
for(j = 0; j < cpus_mapped; j++) {
sprintf(msg,"cpu - %d memory on - %d \n",memory_mapping[j][HOST_CPU], memory_mapping[j][DEST_CPU]);
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
}
#endif
return 0;
}
int get_rule(FILE *fd, int *line, struct rule_format * r_ptr)
{
char error; /* global error flag */
char lerror; /* field error flag */
char keywd[80]; /* keyword buffer */
char s[200]; /* rules file line buffer */
char ss[5][80]; /* buffer for operands */
int first_line; /* line # of 1st stanza keyword */
int i; /* loop counter */
int keywd_count; /* keyword count */
int rc; /* return code */
int LoadDefFlag; /* Only load defaults once ea stanza*/
int Stanza1Flag; /* First stanza? */
char msg_text [1024];
struct htx_data * stats = (struct htx_data *)&htx_ds;
/****************************************************************************/
/* The hardware parameters can only be set once. If multiple HW values are */
/* in the rule file, the last value will be used. */
/****************************************************************************/
if(*line == 0) {
SetHwDefaults(r_ptr);
Stanza1Flag = 1;
}
else {
Stanza1Flag = 0;
}
LoadDefFlag = 1;
keywd_count = 0;
error = 'n';
lerror = 'n';
first_line = *line + 1;
while ((get_line(fd, s, 200)) > 1) {
/* We don't want to disturb settings on a blank line */
if(LoadDefFlag) {
LoadDefFlag = 0;
SetStanzaDefaults(r_ptr);
}
*line = *line + 1;
if (s[0] == '*')
continue;
for (i = 0; s[i] != '\n'; i++) {
if (s[i] == '=')
s[i] = ' ';
} /* endfor */
keywd_count++;
sscanf(s, "%s", keywd);
for(i=0;i < (int)strlen(keywd);i++)
keywd[i] = (char) toupper((int) keywd[i]);
if ((strcmp(keywd, "RULE_ID")) == 0) {
sscanf(s, "%*s %s", r_ptr->rule_id);
if ((strlen(r_ptr->rule_id)) > 8) {
sprintf(msg_text, "line# %d %s = %s (must be 8 characters or less)\n", *line, keywd, r_ptr->rule_id);
hxfmsg(stats, HERINFO1, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "PATTERN_ID")) == 0) {
sscanf(s, "%*s %s", r_ptr->pattern_id);
if ((strlen(r_ptr->pattern_id)) > 8 || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %s (must be 8 characters or less) FIRST STANZA ONLY.\n", *line, keywd, r_ptr->pattern_id);
hxfmsg(stats, HERINFO2, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
} else if ((strcmp(keywd, "COMNET_NAME")) == 0) {
sscanf(s, "%*s %s", r_ptr->ComName);
if ((strlen(r_ptr->ComName)) > HXECOM_HOSTNAMELEN || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %s (must be %d characters or less) FIRST STANZA ONLY.\n", *line, keywd, r_ptr->ComName, HXECOM_HOSTNAMELEN);
hxfmsg(stats, HERINFO3, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
} else if ((strcmp(keywd, "TESTNET_NAME")) == 0) {
sscanf(s, "%*s %s", r_ptr->TestNetName);
if ((strlen(r_ptr->TestNetName)) > HXECOM_HOSTNAMELEN || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %s (must be %d characters or less) FIRST STANZA ONLY.\n", *line, keywd, r_ptr->TestNetName, HXECOM_HOSTNAMELEN);
hxfmsg(stats, HERINFO3, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
} else if ((strcmp(keywd, "LAYER")) == 0) {
sscanf(s, "%*s %s", ss[0]);
for(i=0;i < (int)strlen(ss[0]);i++)
ss[0][i] = (char) toupper((int) ss[0][i]);
if(strcmp(ss[0], "UDP") == 0 && Stanza1Flag == 1) {
r_ptr->layer = UDP_LAYER;
}
else if(strcmp(ss[0], "TCP") == 0 && Stanza1Flag == 1) {
r_ptr->layer = TCP_LAYER;
}
else if(strcmp(ss[0], "RDMA") == 0 && Stanza1Flag == 1) {
r_ptr->layer = RDMA_LAYER;
printf("RDMA_LAYER selected = %d\n", r_ptr->layer);
}
else {
sprintf(msg_text, "line# %d %s = %s (must be UDP or TCP) FIRST STANZA ONLY.\n",*line, keywd, ss[0]);
hxfmsg(stats, HERINFO4, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
} else if ((strcmp(keywd, "COM_STREAM_PORT")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->ComPortStream));
if (r_ptr->ComPortStream < 5000 || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %hu (must be greater than 5000) FIRST STANZA ONLY.\n",*line, keywd, r_ptr->ComPortStream);
hxfmsg(stats, HERINFO5, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "COM_DGRAM_PORT")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->ComPortDgram));
if (r_ptr->ComPortDgram < 5000 || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %hu (must be greater than 5000) FIRST STANZA ONLY.\n", *line, keywd, r_ptr->ComPortDgram);
hxfmsg(stats, HERINFO6, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "COM_RDMA_PORT")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->ComPortDapl));
if (r_ptr->ComPortDapl < 5000 || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %hu (must be greater than 5000) FIRST STANZA ONLY.\n",*line, keywd, r_ptr->ComPortStream);
hxfmsg(stats, HERINFO5, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
printf("COM_RDMA_PORT = 0x%x\n", r_ptr->ComPortDapl);
} else if ((strcmp(keywd, "REPLICATES")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->replicates));
if (r_ptr->replicates < 1 || r_ptr->replicates >50 || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %hu (must be >= 1 and <=50) FIRST STANZA ONLY.\n", *line, keywd, r_ptr->replicates);
hxfmsg(stats, HERINFO7, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "BUFMIN")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->bufmin));
if (r_ptr->bufmin < 1) {
sprintf(msg_text, "line# %d %s = %hu (must be 1 or greater) \n", *line, keywd, r_ptr->bufmin);
hxfmsg(stats, HERINFO9, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "BUFMAX")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->bufmax));
if (r_ptr->bufmax < 1) {
sprintf(msg_text, "line# %d %s = %hu (must be 1 or greater) \n", *line, keywd, r_ptr->bufmax);
hxfmsg(stats, HERINFO10, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "BUFINC")) == 0) {
sscanf(s, "%*s %hi", &(r_ptr->bufinc));
if (r_ptr->bufinc < -1) {
sprintf(msg_text, "line# %d %s = %hu (must be -1 or greater) \n", *line, keywd, r_ptr->bufinc);
hxfmsg(stats, HERINFO11, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if((strcmp(keywd, "BUFSEED")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->bufseed));
if (r_ptr->bufseed < 1 || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %hu (must be 0 or greater) FIRST STANZA ONLY. \n", *line, keywd, r_ptr->bufseed);
hxfmsg(stats, HERINFO11, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
} else if ((strcmp(keywd, "ACK_TRIG")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->ack_trig));
/* if (r_ptr->ack_trig < 0) {
sprintf(msg_text,
"line# %d %s = %hu (must be 0 or greater) \n",
*line, keywd, r_ptr->ack_trig);
hxfmsg(stats, HERINFO12, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
*/
} else if ((strcmp(keywd, "NUM_OPER")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->num_oper));
if (r_ptr->num_oper < 1) {
sprintf(msg_text, "line# %d %s = %hu (must be 1 or greater) \n", *line, keywd, r_ptr->num_oper);
hxfmsg(stats, HERINFO13, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "WRITE_AHEAD")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->write_ahead));
if (r_ptr->write_ahead < 1 || r_ptr->write_ahead > ACK_MAX) {
sprintf(msg_text, "line# %d %s = %hu (must be > 1 and <= %d) \n", *line, keywd, r_ptr->write_ahead, ACK_MAX);
hxfmsg(stats, HERINFO14, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "ONESYS")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->onesys));
if (r_ptr->onesys < 0 || r_ptr->onesys > 1) {
sprintf(msg_text, "line# %d %s = %hu (must be 0 or 1) \n", *line, keywd, r_ptr->onesys);
hxfmsg(stats, HERINFO14, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "DEBUG_PATTERN")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->debug_pattern));
if (r_ptr->debug_pattern < 0 || r_ptr->debug_pattern > 1) {
sprintf(msg_text, "line# %d %s = %hu (must be 0 or 1) \n", *line, keywd, r_ptr->debug_pattern);
hxfmsg(stats, HERINFO14, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "NO_COMPARE")) == 0) {
sscanf(s, "%*s %hu", &(r_ptr->no_compare));
if (r_ptr->no_compare < 0 || r_ptr->no_compare > 1) {
sprintf(msg_text, "line# %d %s = %hu (must be 0 or 1) \n", *line, keywd, r_ptr->no_compare);
hxfmsg(stats, HERINFO14, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "WRITE_SLEEP")) == 0) {
sscanf(s, "%*s %d", &i);
r_ptr->write_sleep = 0xffff & i;
if (i < 0) {
sprintf(msg_text, "line# %d %s = %d (must be >= 0) \n", *line, keywd, i);
hxfmsg(stats, HERINFO15, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "IO_ALARM_TIME")) == 0) {
sscanf(s, "%*s %d", &i);
r_ptr->alarm = 0xffff & i;
if (i < 0) {
sprintf(msg_text, "line# %d %s = %d (must be >= 0) \n", *line, keywd, i);
hxfmsg(stats, HERINFO16, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} else if ((strcmp(keywd, "SHUTDOWN_FLAGS")) == 0) {
sscanf(s, "%*s %hx", &(r_ptr->shutdown));
if (r_ptr->shutdown < 0) {
sprintf(msg_text, "line# %d %s = %d (must be >= 0).\nShutdown flag should be positive value. Check hxecom.readme for possible values.\n", *line, keywd, r_ptr->shutdown);
hxfmsg(stats, HERINFO17, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
} else if ((strcmp(keywd, "MASTER")) == 0) {
ss[0][0] = '\0';
sscanf(s, "%*s %s", ss[0]);
switch (ss[0][0]) {
case '\0':
break;
case 'Y':
case 'y':
r_ptr->transact |= MASTER_VAL;
break;
case 'N':
case 'n':
r_ptr->transact &= ~((u_short)MASTER_VAL);
break;
default:
lerror = 'y';
break;
} /* endswitch */
if(lerror == 'y' || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %s (value must be Y(yes) or N(no)) FIRST STANZA ONLY.\n", *line, keywd, ss[0]);
hxfmsg(stats, HERINFO18, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
lerror = 'n';
}
} else if ((strcmp(keywd, "TCP_NODELAY")) == 0) {
ss[0][0] = '\0';
sscanf(s, "%*s %s", ss[0]);
switch (ss[0][0]) {
case '\0':
break;
case 'Y':
case 'y':
r_ptr->transact |= TCP_NODELAY_VAL;
break;
case 'N':
case 'n':
r_ptr->transact &= ~((u_short)TCP_NODELAY_VAL);
break;
default:
lerror = 'y';
break;
} /* endswitch */
if(lerror == 'y' || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %s (value must be Y(yes) or N(no)) FIRST STANZA ONLY (%d).\n", *line, keywd, ss[0], Stanza1Flag);
hxfmsg(stats, HERINFO18, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
lerror = 'n';
}
} else if ((strcmp(keywd, "SO_LINGER")) == 0) {
ss[0][0] = '\0';
sscanf(s, "%*s %s", ss[0]);
switch (ss[0][0]) {
case '\0':
break;
case 'Y':
case 'y':
r_ptr->transact |= SO_LINGER_VAL;
break;
case 'N':
case 'n':
r_ptr->transact &= ~((u_short)SO_LINGER_VAL);
break;
default:
lerror = 'y';
break;
} /* endswitch */
if(lerror == 'y' || Stanza1Flag == 0) {
sprintf(msg_text, "line# %d %s = %s (value must be Y(yes) or N(no)) FIRST STANZA ONLY (%d).\n", *line, keywd, ss[0], Stanza1Flag);
hxfmsg(stats, HERINFO18, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
lerror = 'n';
}
} else if ((strcmp(keywd, "OPER")) == 0) {
sscanf(s, "%*s %s", ss[0]);
if (Stanza1Flag == 0 || (strcmp(ss[0],"R") != 0 && strcmp(ss[0], "W") != 0 && strcmp(ss[0], "RW") != 0
&& strcmp(ss[0], "WR") != 0)) {
sprintf(msg_text, "line# %d %s = %s (must be \"R\", \"W\", \"RW\", or \"WR\") FIRST STANZA ONLY.\n", *line, keywd, ss[0]);
hxfmsg(stats, HERINFO1, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
else {
if(ss[0][0] == 'R' || ss[0][1] == 'R')
r_ptr->transact |= READ_VAL;
else
r_ptr->transact &= ~((u_short)READ_VAL);
if(ss[0][0] == 'W' || ss[0][1] == 'W')
r_ptr->transact |= WRITE_VAL;
else
r_ptr->transact &= ~((u_short)WRITE_VAL);
}
} else {
sprintf(msg_text, "line# %d keywd = %s (invalid) \n",
*line, keywd);
hxfmsg(stats, HERINFO19, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
} /* endif */
} /* endwhile */
*line = *line + 1;
if (keywd_count > 0) {
if (r_ptr->rule_id[0] == '\0') {
sprintf(msg_text, "line# %d rule_id not specified \n", first_line);
hxfmsg(stats, HERINFO20, HTX_HE_SOFT_ERROR, msg_text);
rc = 1;
} else {
rc = 0;
}
if(r_ptr->bufinc == USHRT_MAX)
r_ptr->bufinc = 1;
if(r_ptr->bufmin == USHRT_MAX)
r_ptr->bufmin = r_ptr->bufmax = 100;
if(r_ptr->bufmax == USHRT_MAX)
r_ptr->bufmax = r_ptr->bufmin;
if(r_ptr->ack_trig == USHRT_MAX)
r_ptr->ack_trig = r_ptr->write_ahead -1;
if(error == 'n' && r_ptr->bufmin > r_ptr->bufmax) {
sprintf(msg_text, "BUFMIN = %d, BUFMAX = %d, BUFINC = %d, Invalid combination.\n",
r_ptr->bufmin, r_ptr->bufmax, r_ptr->bufinc);
hxfmsg(stats, HERINFO21, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
if(error == 'n' && r_ptr->bufmin < r_ptr->bufmax && r_ptr->bufinc == 0) {
sprintf(msg_text, "BUFMIN = %d, BUFMAX = %d, BUFINC = %d, Invalid combination.\n",
r_ptr->bufmin, r_ptr->bufmax, r_ptr->bufinc);
hxfmsg(stats, HERINFO22, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
/****************************************************************************/
/* We have just added OPER rule. To make backward compatible for rules */
/* that don't specify OPER -- if Master, OPER=RW. if not master, OPER=W. */
/****************************************************************************/
if(error == 'n' && (r_ptr->transact & (WRITE_VAL | READ_VAL)) == 0) {
if(r_ptr->transact & MASTER_VAL == 0)
r_ptr->transact |= WRITE_VAL;
else
r_ptr->transact |= (WRITE_VAL | READ_VAL);
}
if(error != 'y' && Stanza1Flag == 1 && (strcmp(r_ptr->ComName, "") == 0 || strcmp(r_ptr->TestNetName, "") == 0)) {
sprintf(msg_text, "COMNET_NAME and TESTNET_NAME must be specified.\n");
hxfmsg(stats, HERINFO22, HTX_HE_SOFT_ERROR, msg_text);
error = 'y';
}
if (error == 'y') {
rc = 1;
}
} else {
rc = EOF;
}
return (rc);
} /* get_rule() */
/*
* Function to cleanup the the page (4K, 64K, 16M) pool shared memory
*/
int iomm_cleanup_page_pool(int free_index, long psize)
{
int rc, index = -1, free_count = 0, i;
struct buf_node *tmp = NULL, *bn = NULL;
char *shm_start_addr;
PRINT(("IN %s: freeing the buf nodes for page size = 0x%lx\n", __FUNCTION__, psize))
/* check free index for psize */
for(i = 0; i < NUM_BUF_SIZES; i++) {
if (buflist[i].page_size == psize) {
index = i;
break;
}
}
PRINT(("index = %d, free_index = %d\n", index, free_index))
if (index == -1 || index != free_index) {
sprintf(htx_d.msg_text,"IN %s: Large Page Pool Not Found", __FUNCTION__);
hxfmsg(&htx_d, -1, HTX_HE_HARD_ERROR, htx_d.msg_text);
return -1;
}
PRINT(("IN %s: index = %d, shm_start_addr = %p\n", __FUNCTION__, index, buflist[index].shm_start_addr))
shm_start_addr = buflist[index].shm_start_addr;
if (shm_start_addr) {
PRINT(("IN %s: Calling shmdt for addr = %p\n", __FUNCTION__, shm_start_addr))
rc = shmdt(shm_start_addr);
if (rc != 0) {
sprintf(htx_d.msg_text,"%s: shmdt failed with %d", __FUNCTION__, errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, htx_d.msg_text);
return(-1);
}
}
if (buflist[index].shm_id != 0) {
rc = shmctl(buflist[index].shm_id, IPC_RMID, (struct shmid_ds *)NULL);
if (rc != 0) {
sprintf(htx_d.msg_text,"%s: shmctl for IPC_RMID failed with %d",__FUNCTION__, errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, htx_d.msg_text);
return(-1) ;
}
buflist[index].shm_id = 0 ;
}
buflist[index].num_free = 0;
buflist[index].num_elements = 0;
buflist[index].size = 0;
buflist[index].page_size = 0;
buflist[index].shm_id = 0;
buflist[index].shm_pool = 0;
for(bn = buflist[index].free, free_count = 0; bn;) {
tmp = bn;
bn = bn->next;
free(tmp);
free_count++;
}
PRINT(("%d nodes of free list freed\n", free_count))
PRINT(("Freeing inuse list\n"))
for(bn = buflist[index].inuse, free_count = 0; bn;) {
tmp = bn;
bn = bn->next;
free(tmp);
free_count++;
}
PRINT(("%d nodes of inuse list freed\n", free_count))
PRINT(("OUT %s: done\n", __FUNCTION__))
return (0);
}
int
get_rule(struct htx_data *phtx_info, struct ruleinfo *prule_info,
char *rules_name)
{
int keywd_count, rc=0, i, d, k, found;
int first_line;
char *p, digit[3] = " ", keywd[80], pipe_swtch[3], t[200];
char error, s[200], msg[221], tmp_msg[100];
static int line = 0;
set_defaults(prule_info);
keywd_count = 0;
cnt = 0;
error = 'n';
first_line = line + 1;
while ( (get_line(s, 200)) > 1 ) { /* read in & process the next line */
line = line + 1;
if ( s[0] == '*' )
continue;
for ( i = 0; s[i] != '\n'; i++ ) {
t[i] = s[i];
s[i] = toupper(s[i]);
if (s[i] == '=')
s[i] = ' ';
}
keywd_count++;
sscanf(s, "%s", keywd);
if ( (strcmp(keywd, "RULE_ID")) == 0 ) { /* Valid RULE_ID ? */
sscanf(s, "%*s %s", prule_info->rule_id);
if ( (strlen(prule_info->rule_id)) > 8 ) {
sprintf(msg, "line# %d %s = %s (must be 8 characters or less) \n",
line, keywd, prule_info->rule_id);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
} else {
d = strlen(prule_info->rule_id);
i = 0;
found = 0;
for ( k = 0; k < d; k++ ) {
if ( isdigit(prule_info->rule_id[k]) ) {
digit[i] = prule_info->rule_id[k];
i++;
found = 1;
}
}
if ( found ) {
rule_stanza[cnt] = atoi(digit);
for ( i = 0; i < cnt; i++ ) {
if ( rule_stanza[cnt] == rule_stanza[i] ) {
sprintf(msg, "line# %d %s = %s (Duplicate Stanza "
"number found in RULE_ID) \n",
line, keywd, prule_info->rule_id);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
}
} else {
sprintf(msg, "line# %d %s = %s (NO Stanza number found "
"in RULE_ID) \n",
line, keywd, prule_info->rule_id);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
}
} else if ( (strcmp(keywd, "PATTERN_ID")) == 0 ) {/* Valid PATTERN_ID ? */
sscanf(s, "%*s %s", prule_info->pattern_id);
if ( (strlen(prule_info->pattern_id)) > 8 ) {
sprintf(msg, "line# %d %s = %s (must be 8 characters or less) \n",
line, keywd, prule_info->pattern_id);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
} else if ( (strcmp(keywd, "NUM_OPER")) == 0 ) { /* Valid NUM_OPER ? */
sscanf(s, "%*s %d", &prule_info->num_oper);
if ( prule_info->num_oper < 0 ) {
sprintf(msg, "line# %d %s = %d (must be >= 0) \n",
line, keywd, prule_info->num_oper);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
} else if ( (strcmp(keywd, "OPER")) == 0 ) { /* Valid OPER ? */
sscanf(s, "%*s %s", prule_info->oper);
if ( strcmp(prule_info->oper, "W") == 0 ||
strcmp(prule_info->oper, "R") == 0 ||
strcmp(prule_info->oper, "RC") == 0 ||
strcmp(prule_info->oper, "D") == 0 ||
strcmp(prule_info->oper, "RW") == 0 ||
strcmp(prule_info->oper, "WEOF") == 0 ||
strcmp(prule_info->oper, "S") == 0 ||
strcmp(prule_info->oper, "E") == 0 ||
strcmp(prule_info->oper, "SF") == 0 ||
strcmp(prule_info->oper, "SR") == 0 ||
strcmp(prule_info->oper, "CO") == 0 ||
strcmp(prule_info->oper, "WEOT") == 0 ||
strcmp(prule_info->oper, "C") == 0 ||
strcmp(prule_info->oper, "O") == 0 ||
strcmp(prule_info->oper, "RCEOT") == 0 ||
strcmp(prule_info->oper, "REOT") == 0 || /* dgs */
strcmp(prule_info->oper, "RS") == 0 ||
#ifndef __HTX_LINUX__
strcmp(prule_info->oper, "DBUG") == 0 ||
strcmp(prule_info->oper, "IE") == 0 ||
strcmp(prule_info->oper, "RES") == 0 ||
strcmp(prule_info->oper, "ML") == 0 ||
strcmp(prule_info->oper, "MUL") == 0 ||
strcmp(prule_info->oper, "ASF") == 0 ||
strcmp(prule_info->oper, "ASR") == 0 ||
strcmp(prule_info->oper, "LB") == 0 ||
strcmp(prule_info->oper, "RP") == 0 ||
strcmp(prule_info->oper, "ADUL") == 0 ||
strcmp(prule_info->oper, "TWIE") == 0 ||
strcmp(prule_info->oper, "TWPE") == 0 ||
strcmp(prule_info->oper, "TWRE") == 0 ||
strcmp(prule_info->oper, "TWUL") == 0 ||
strcmp(prule_info->oper, "WUL") == 0 ||
strcmp(prule_info->oper, "TWMM") == 0 ||
strcmp(prule_info->oper, "CDRE") == 0 ||
strcmp(prule_info->oper, "CDMM") == 0 ||
strcmp(prule_info->oper, "HUNL") == 0 ||
strcmp(prule_info->oper, "HINI") == 0 ||
strcmp(prule_info->oper, "HREL") == 0 ||
strcmp(prule_info->oper, "HWUN") == 0 ||
strcmp(prule_info->oper, "SPEC") == 0 ||
#endif
strcmp(prule_info->oper, "VBSWR") == 0 ||
strcmp(prule_info->oper, "VBSRD") == 0 ||
strcmp(prule_info->oper, "VBSRDC") == 0||
strcmp(prule_info->oper, "XCMD") == 0 ) ;
else {
sprintf(msg, "ERROR in rules file %s:\n", rules_name);
hxfmsg(phtx_info, 0, INFO, msg);
sprintf(msg, " Line# %d %s = %s is an INVALID operation.\n",
line, keywd, prule_info->oper);
hxfmsg(phtx_info, 0, INFO, msg);
#ifndef __HTX_LINUX__
sprintf(msg, " Valid Operations are W,R,RC,D,RW,WEOF,S,E,SF,SR,CO"
"WEOT,C,O,RCEOT,\nRS,DBUG,IE,RES,ML,MUL,ASF,ASR,LB"
"RP,ADUL,TWIE,TWPE,TWRE,TWUL,\nWUL,TWMM,VBSWR,VBSRD, VBSRDC"
"SPEC, XCMD.\n");
#else
sprintf(msg, " Valid Operations are W,R,RC,D,RW,WEOF,S,E,SF,SR,CO"
"WEOT,C,O,RCEOT,\nRS,VBSWR,VBSRD, VBSRDC, XCMD.\n");
#endif
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
} else if ( (strcmp(keywd, "NUM_BLKS")) == 0 ) {
sscanf(s, "%*s %d", &prule_info->num_blks);
if ( strcmp(prule_info->oper,"SF") == 0 ||
strcmp(prule_info->oper,"SR") == 0 )
prule_info->pattern_id[0] = 0;
} else if ( (strcmp(keywd, "#CLOSE_PIPE")) == 0 ) {
sscanf(s, "%*s %s", pipe_swtch);
if ( strcmp(pipe_swtch, "NO") == 0 )
signal_flag = 'R';
else {
sprintf(msg, "rm %s", pipe_name);
system(msg);
sprintf(msg, "line# %d %s = %s (must be NO) \n",
line, keywd, pipe_swtch);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
} else if ((strcmp(keywd, "#CRASH_ON_MIS")) == 0) {
char dummy[30];
if(crash_on_mis == 0) {
sscanf(s, "%*s %s", dummy);
if ( strcmp(dummy, "YES") == 0 ) crash_on_mis = 1;
else if ( strcmp(dummy, "NO") == 0 ) crash_on_mis = 0;
else {
sprintf(msg, "rm %s", pipe_name);
system(msg);
sprintf(msg,"line# %d %s = %s (must be YES or NO) \n",
line, keywd, dummy);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
}
} else if ( (strcmp(keywd, "#RULES_NAME")) == 0 ) {
sscanf(s, "%*s %s", rules_name);
sprintf(msg, "Using New Rules File > %s", rules_name);
hxfmsg(phtx_info, 0, INFO, msg);
} else if ( (strcmp(keywd, "UNLOAD_SLEEP")) == 0 ) {
sscanf(s, "%*s %d", &prule_info->u_sleep);
} else if ( (strcmp(keywd, "SOURCE_ID")) == 0 ) {
sscanf(s, "%*s %d", &prule_info->source_id);
} else if ( (strcmp(keywd, "DEST_ID")) == 0 ) {
sscanf(s, "%*s %d", &prule_info->dest_id);
} else if ( (strcmp(keywd, "CHS_FILE")) == 0 ) {
for ( d = 0; s[d] != '\n'; d++ )
s[d] = tolower(s[d]);
sscanf(s, "%*s %s", prule_info->chs_file);
} else if ( (strcmp(keywd, "SOURCE_ID1")) == 0 ) {
sscanf(s, "%*s %d", &prule_info->source_id1);
} else if ( (strcmp(keywd, "DEST_ID1")) == 0 ) {
sscanf(s, "%*s %d", &prule_info->dest_id1);
} else if ( strcmp(keywd, "CRASH_ON_MIS") == 0 ) {
sscanf(s, "%*s %s", msg);
crash_on_mis = (*msg == 'Y') ? 1 : 0;
} else if ( strcmp(keywd, "VBS_SEED") == 0 ) {
sscanf(s, "%*s %n", &i);
while ( isspace(s[i]) ) i++;
strcpy(msg, &s[i]);
if ( strncmp(prule_info->oper, "VBS", 3) != 0 ) {
sprintf(msg, "line# %d %s = %s (Only valid in VBSRD or VBSWR)",
line, keywd, msg);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
} else if ( strncmp(msg, "RANDOM", 6) == 0 ) {
init_seed(prule_info->seed);
prule_info->VBS_seed_type = 'R';
VBS_seed_initialized = 1;
} else if ( strncmp(msg, "FIXED", 5) == 0 ) {
VBS_seed_initialized = 1;
prule_info->VBS_seed_type = 'F';
} else {
p = msg;
i = 0;
while ( *p && i < 4 ) /* scan for first digit */
if ( isdigit(*p) ) {
if ( i < 3 )
prule_info->seed[i++] = atoi(p); /* convert the arg */
else {
VBS_last_write = atoi(p); /* convert the arg */
i++;
}
while ( isdigit(*(++p)) ) ; /* scan past the arg */
} else
p++;
if ( i != 4 ) {
sprintf(tmp_msg,
"line# %d %s = %s (must be RANDOM or 4 integers)"
"/nThe last integer being the # of bytes in the last"
"Variable Write command",
line, keywd, msg);
hxfmsg(phtx_info, 0, SYSERR, tmp_msg);
error = 'y';
} else {
VBS_seed_initialized = 1;
prule_info->VBS_seed_type = 'U';
}
}
} else if ( (strcmp(keywd, "COMMAND")) == 0 ) {
d = 0;
for ( i = 10; s[i] != '\n' && s[i] != '\0'; i++, d++ ) {
prule_info->cmd_list[d] = t[i];
}
prule_info->cmd_list[d] = '\0';
} else {
sprintf(msg, "line# %d keywd = %s (invalid) \n",
line, keywd);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
}
}
line = line + 1;
if ( keywd_count > 0 ) {
if ( (htx_strcmp(prule_info->rule_id, " ") == 0) &&
(signal_flag != 'X') && (signal_flag != 'R') ) {
sprintf(msg, "line# %d rule_id not specified \n",
first_line);
hxfmsg(phtx_info, 0, SYSERR, msg);
error = 'y';
} else
rc = 0;
} else {
rc = EOF;
line = 0;
}
if ( error == 'y' )
rc = 1;
return(rc);
}
int
proc_rule(struct htx_data *phtx_info, struct ruleinfo *prule_info,
char *wbuf, char *rbuf, struct blk_num_typ *pblk_num)
{
int dlen, loop, rc;
char msg[220], path[100];
unsigned short seed[3];
rc = 0;
init_seed(seed); /* initialize seed for random number generator */
dlen = prule_info->num_blks * BLK_SIZE; /* initialize length of data */
/*-------------------------------*/
/* initialize the write buffer */
/*-------------------------------*/
if ( (prule_info->pattern_id[0] != '#') &&
(prule_info->pattern_id[0] != 0) ) {
path[0] ='\0';
if ( (int) htx_strlen((char *) htx_strcpy(path, getenv("HTXPATTERNS"))) == 0 )
htx_strcpy(path, "../pattern/"); /* default ONLY */
htx_strcat (path, prule_info->pattern_id);
rc = hxfpat(path, wbuf, dlen);
if ( rc == 1 ) {
sprintf(msg, "cannot open pattern file - %s\n", path);
hxfmsg(phtx_info, 0, SYSERR, msg);
return(1);
}
if ( rc == 2 ) {
sprintf(msg, "cannot read pattern file - %s\n", path);
hxfmsg(phtx_info, 0, SYSERR, msg);
return(1);
}
} else if ( prule_info->pattern_id[0] == '#' )
bldbuf((unsigned short*)wbuf, dlen, prule_info->pattern_id, pblk_num);
pblk_num->in_rule = 0; /* initialize block number within current rule */
rc = 0;
tape_error_code = 0;
for ( loop = 1; loop <= prule_info->num_oper; loop++ ) {
if ( strcmp(prule_info->oper, "R") == 0 ) {
rc = read_tape(phtx_info, prule_info, loop, pblk_num, rbuf);
} else if ( strcmp(prule_info->oper, "W") == 0 ) {
rc = write_tape(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "RC") == 0 ) {
rc = read_tape(phtx_info, prule_info, loop, pblk_num, rbuf);
if ( rc >= 0 )
rc = cmpbuf(phtx_info, prule_info, loop, pblk_num, wbuf, rbuf);
} else if ( strcmp(prule_info->oper, "RW") == 0 ) {
rc = rewind_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "WEOF") == 0 ) {
rc = weof_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "SF") == 0 ) {
rc = search_file(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "SR") == 0 ) {
rc = search_rec(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "D") == 0 ) {
rc = diag_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "E") == 0 ) {
rc = erase_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "S") == 0 ) {
rc = do_sleep(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "CO") == 0 ) {
rc = close_open(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "C") == 0 ) {
rc = tclose(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "O") == 0 ) {
rc = topen(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "WEOT") == 0 ) {
rc = write_eot(phtx_info, prule_info,loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "RCEOT") == 0 ) {
rc = read_eot(phtx_info, prule_info, loop,pblk_num, wbuf, rbuf);
} else if ( strcmp(prule_info->oper, "REOT") == 0 ) {
rc = read_teot(phtx_info, prule_info, loop, pblk_num, wbuf, rbuf);
} else if ( strcmp(prule_info->oper, "RS") == 0 ) {
rc = prt_req_sense(phtx_info, prule_info, loop, pblk_num);
}
#ifndef __HTX_LINUX__
else if ( strcmp(prule_info->oper, "ML") == 0 ) {
rc = medium_load(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "MUL") == 0 ) {
rc = medium_unload(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "RES") == 0 ) {
rc = read_status(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "IE") == 0 ) {
rc = init_element(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "RP") == 0 ) {
rc = read_posit(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "LB") == 0 ) {
rc = loc_block(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "ASF") == 0 ) {
rc = asearch_file(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "ASR") == 0 ) {
rc = asearch_rec(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "ADUL") == 0 ) {
rc = write_unload(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "TWIE") == 0 ) {
rc = twin_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWPE") == 0 ) {
rc = twps_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWRE") == 0 ) {
rc = twrd_stat(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWMM") == 0 ) {
rc = twmv_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "TWUL") == 0 ) {
rc = unload_write(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "WUL") == 0 ) {
rc = tape_unload(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "CDRE") == 0 ) {
rc = cdrd_stat(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "CDMM") == 0 ) {
rc = cdmv_tape(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HUNL") == 0 ) {
rc = himove(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HINI") == 0 ) {
rc = hiinit(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HREL") == 0 ) {
rc = hielem(phtx_info, prule_info, loop, pblk_num);
} else if ( strcmp(prule_info->oper, "HWUN") == 0 ) {
rc = hidal_unload(phtx_info, prule_info, loop, pblk_num, wbuf);
} else if ( strcmp(prule_info->oper, "DBUG") == 0 ) {
rc = set_dbug(phtx_info, prule_info, pblk_num);
}
#endif
else if ( strcmp(prule_info->oper, "XCMD") == 0 ) {
rc = do_cmd(phtx_info, prule_info, pblk_num);
} else {
;
}
hxfupdate(UPDATE, phtx_info);
if ( phtx_info->run_type[0] == 'O' ) {
info_msg(phtx_info, prule_info, loop, pblk_num, msg);
hxfmsg(phtx_info, 0, INFO, msg);
}
if ( rc != 0 )
break;
}
return(rc);
}
int proc_rule(struct htx_data *ps, struct ruleinfo *pr, char *wbuf, char *rbuf, unsigned int *last_lba, unsigned int *pblk_size)
{
int blkno[3], blkno_save[3]; /* block # ptrs 0-curr,1-up,2-dwn */
int rc, i, rc_ptr, save_dlen, loop;
unsigned short seed[3];
char path[100], msg[221], *tbuf, *tbuf_malloc;
int read_res = -1;
tbuf_malloc = malloc(TMP_BUF_SIZE + PAGE_SIZE);
if(tbuf_malloc == NULL) { /* Out of memory? */
sprintf(msg, "Cannot allocate memory for tbuf: %d bytes\n", TMP_BUF_SIZE + PAGE_SIZE);
hxfmsg(ps, 0, SYSERR, msg);
return(1);
}
#ifndef __HTX_LINUX__ /* AIX */
tbuf = tbuf_malloc;
#else /* Linux */
/* Page align the tmp buffer for linux raw IO */
tbuf = (char *)HTX_PAGE_ALIGN(tbuf_malloc);
#endif
init_seed(seed); /* init seed for random number generator */
if ( strcmp(pr->addr_type, "SEQ") == 0 || /* init length of data */
strcmp(pr->type_length, "FIXED") == 0) /* to be transmitted */
pr->dlen = pr->num_blks * pr->bytpsec;
else
pr->dlen = random_dlen(pr->bytpsec, pr->tot_blks, seed);
if ( strcmp(pr->oper, "RC") == 0 ) { /* init write buff for oper RC */
/* get HTXPATTERNS environment variable */
strcpy(path, ""); /* Linux will need this initialization */
if ((char *) getenv("HTXPATTERNS") != NULL) {
strcpy(path, (char *) getenv("HTXPATTERNS"));
} else {
strcpy(path, "../pattern/"); /* default ONLY */
}
strcat (path, pr->pattern_id);
rc = hxfpat(path, wbuf, pr->dlen);
if ( rc == 1 ) {
sprintf(msg, "Cannot open pattern file - %s\n", path);
hxfmsg(ps, 0, SYSERR, msg);
return(1);
}
if ( rc == 2 ) {
sprintf(msg, "Cannot read pattern file - %s\n", path);
hxfmsg(ps, 0, SYSERR, msg);
return(1);
}
}
if ( strcmp(pr->addr_type, "SEQ") == 0 ) /* init current block number */
init_blkno(pr, blkno);
else
random_blkno(blkno, pr->dlen, pr->bytpsec, pr->max_blkno, seed,
pr->min_blkno);
for ( i = 0; i < 3; i++ )
blkno_save[i] = blkno[i];
for ( loop = 1 ; loop <= pr->num_oper ; loop++ ) {
if ( strcmp(pr->oper, "MS") == 0 ) {
ms_get(pr, ps, last_lba, pblk_size);
} else if ( strcmp(pr->oper, "R") == 0 ) {
read_cdrom(ps, pr, loop, blkno, rbuf);
} else if ( strcmp(pr->oper, "RWP") == 0 ) {
read_write_pattern(ps, pr, loop, blkno, rbuf);
} else if ( strcmp(pr->oper, "RRC") == 0 ) {
/*read_cdrom(ps, pr, loop, blkno, wbuf);
read_cdrom(ps, pr, loop, blkno, rbuf);*/
if( (read_res = read_cdrom(ps, pr, loop, blkno, wbuf) ) == 0 ) {/* read success */
if( (read_res = read_cdrom(ps, pr, loop, blkno, rbuf) ) == 0 ) {/* read success, again */
cmpbuf(ps, pr, loop, blkno, wbuf, rbuf); /* safe to compare */
} else { /* second read fail */
sprintf(msg, "read_cdrom() failed in Re-Read sequence of RRC oper\n"
"Skipping compare operation\n");
prt_msg(ps, pr, loop, blkno, 0, SOFT, msg);
}
} else { /* first read fail */
sprintf(msg, "read_cdrom() failed in Read sequence of RRC oper\n"
"Skipping compare operation\n");
prt_msg(ps, pr, loop, blkno, 0, SOFT, msg);
}
} else if ( strcmp(pr->oper, "RC") == 0 ) {
for ( i = 0; i < 3; i++ )
blkno[i] = blkno_save[i]; /* RC = always start at same blkno */
/******************************************************/
/*- First, read the successive data blocks into rbuf -*/
/******************************************************/
save_dlen = pr->dlen;
rc_ptr = 0; /*- init read/compare pointer --*/
pr->dlen = pr->bytpsec; /*-- read 1 block at a time into rbuf --*/
while ( rc_ptr <= pr->num_blks ) {
/*read_cdrom(ps, pr, loop, blkno, tbuf);*/
if( ( read_res = read_cdrom(ps, pr, loop, blkno, tbuf) ) != 0 ) /* read un-succesfull ?*/
break;
for ( i = 0; i <= pr->dlen; i++ )
rbuf[(pr->dlen*rc_ptr)+i] = tbuf[i];
set_blkno(blkno, pr->direction, pr->increment, 1);
rc_ptr++;
}
if( read_res == 0 ) {/* only if all reads are successful ... */
pr->dlen = save_dlen;
cmpbuf(ps, pr, loop, blkno_save, wbuf, rbuf);
} else { /* read fail */
sprintf(msg, "read_cdrom() failed in Read sequence of RC oper\n"
"Skipping compare operation\n");
prt_msg(ps, pr, loop, blkno, 0, SOFT, msg);
}
} else if ( strcmp(pr->oper, "D") == 0 ) {
diag_cdrom(ps, pr, loop, blkno);
} else if ( strcmp(pr->oper, "A") == 0 ) {
#ifndef __HTX_LINUX__
audio_cdrom(ps, pr, loop, blkno);
#endif
} else if ( strcmp(pr->oper, "AMM") == 0 ) {
if ( (0 != strncmp(device_subclass, "sata", 16)) && (0 != strncmp(device_subclass, "usbif", 16)) ) {
/* PLAYUDIO MSF is not supported for SATA drives */
audio_mm(ps, pr, loop, blkno);
}
else {
sprintf(msg, "Skipping AMM stanza for SATA/USB drive, rule_id = %s\n", pr->rule_id);
hxfmsg(ps, 0, INFO, msg);
}
} else if ( strcmp(pr->oper, "RS") == 0 ) {
prt_req_sense(ps, pr, loop, blkno);
} else if ( strcmp(pr->oper, "S") == 0 ) {
do_sleep(ps, pr, loop, blkno);
} else if ( strcmp(pr->oper, "XCMD") == 0 ) {
rc = do_cmd(ps, pr);
} else {
;
}
hxfupdate(UPDATE, ps);
if ( ps->run_type[0] == 'O' ) {
info_msg(ps, pr, loop, blkno, msg);
hxfmsg(ps, 0, INFO, msg);
}
if ( strcmp(pr->type_length, "RANDOM") == 0 && /* set lgth of data trans */
strcmp(pr->addr_type, "RANDOM") == 0 ) /* if random is specified */
pr->dlen = random_dlen(pr->bytpsec, pr->tot_blks, seed);
if ( strcmp(pr->addr_type, "RANDOM") == 0 ) /* set block # for next oper */
random_blkno(blkno, pr->dlen, pr->bytpsec, pr->max_blkno, seed,
pr->min_blkno);
else if ( (strcmp(pr->oper, "RC") != 0 ) /* set blkno if not RC or RWP */
&& ( strcmp(pr->oper, "RWP") != 0 ))
set_blkno(blkno, pr->direction, pr->increment, pr->num_blks);
if ( strcmp(pr->addr_type, "SEQ") == 0 ) {
rc = wrap(pr, blkno);
if ( rc == 1 )
init_blkno(pr,blkno);
}
}
free(tbuf_malloc);
return(0);
}
