void read_cb(struct rpc_context *rpc, int status, void *data, void *private_data)
{
struct client *client = private_data;
COMPOUND4res *res = data;
if (status != RPC_STATUS_SUCCESS) {
fprintf(stderr, "Failed to read file on server %s\n",
client->server);
exit(10);
}
if (res->status != NFS4_OK) {
fprintf(stderr, "Failed to read file on server %s\n",
client->server);
exit(10);
}
write(1, res->resarray.resarray_val[1].nfs_resop4_u.opread.READ4res_u.resok4.data.data_val, res->resarray.resarray_val[1].nfs_resop4_u.opread.READ4res_u.resok4.data.data_len);
/*
* Are we at end-of-file? If so we can close the file and exit.
*/
if (res->resarray.resarray_val[1].nfs_resop4_u.opread.READ4res_u.resok4.eof) {
send_close(rpc, client->fh, close_cb, client);
return;
}
/*
* We still have more data to read.
*/
client->offset += res->resarray.resarray_val[1].nfs_resop4_u.opread.READ4res_u.resok4.data.data_len;
send_read(rpc, client->fh, client->offset, 4096, read_cb, client);
}
void open_cb(struct rpc_context *rpc, int status, void *data, void *private_data)
{
struct client *client = private_data;
COMPOUND4res *res = data;
int idx;
if (status != RPC_STATUS_SUCCESS) {
fprintf(stderr, "Failed to open file on server %s\n",
client->server);
exit(10);
}
if (res->status != NFS4_OK) {
fprintf(stderr, "Failed to open file on server %s\n",
client->server);
exit(10);
}
/* Find the index for the OPEN opcode */
for (idx = 1; idx < res->resarray.resarray_len - 1; idx++) {
if ((res->resarray.resarray_val[idx].resop == OP_OPEN) &&
(res->resarray.resarray_val[idx + 1].resop == OP_GETFH)) {
break;
}
}
if (idx >= res->resarray.resarray_len - 1) {
fprintf(stderr, "No OP_OPEN in server response\n");
exit(10);
}
/* Store the open handle in the client structure */
client->fh.nfs_fh4_len = res->resarray.resarray_val[idx+1].nfs_resop4_u.opgetfh.GETFH4res_u.resok4.object.nfs_fh4_len;
client->fh.nfs_fh4_val = malloc(client->fh.nfs_fh4_len);
if (client->fh.nfs_fh4_val == NULL) {
fprintf(stderr, "Failed to allocate data for nfs_fh4\n");
exit(10);
}
memcpy(client->fh.nfs_fh4_val, res->resarray.resarray_val[idx+1].nfs_resop4_u.opgetfh.GETFH4res_u.resok4.object.nfs_fh4_val, client->fh.nfs_fh4_len);
/* Store stateid for the open handle in the client structure */
client->stateid.seqid = res->resarray.resarray_val[idx].nfs_resop4_u.opopen.OPEN4res_u.resok4.stateid.seqid;
memcpy(client->stateid.other, res->resarray.resarray_val[idx].nfs_resop4_u.opopen.OPEN4res_u.resok4.stateid.other, 12);
/* Check if server wants us to confirm the open */
if (res->resarray.resarray_val[idx].nfs_resop4_u.opopen.OPEN4res_u.resok4.rflags & OPEN4_RESULT_CONFIRM) {
send_open_confirm(rpc, client->fh, open_confirm_cb, client);
return;
}
send_read(rpc, client->fh, client->offset, 4096, read_cb, client);
}
int read_result (const alarm_stage * asp)
{
uint8_t data[3];
int rc;
rc = iBSPACMi2cRead(asp->tpp, SHT21_ADDRESS, data, sizeof(data));
if ((0 <= rc) && (0 == sht21_crc(data, rc))) {
rc = ((data[0] << 8) | data[1]) & ~0x03;
if (asp->cmd) {
t_raw = rc;
rc = send_read(asp);
} else {
rh_raw = rc;
show_results(asp);
}
}
return rc;
}
void open_confirm_cb(struct rpc_context *rpc, int status, void *data, void *private_data)
{
struct client *client = private_data;
COMPOUND4res *res = data;
if (status != RPC_STATUS_SUCCESS) {
fprintf(stderr, "Failed to confirm open file on server %s\n",
client->server);
exit(10);
}
if (res->status != NFS4_OK) {
fprintf(stderr, "Failed to confirm open file on server %s\n",
client->server);
exit(10);
}
send_read(rpc, client->fh, client->offset, 4096, read_cb, client);
}
int test_clone_ioctl(int cmd)
{
struct ctx myctx;
int i;
pid_t cpid;
struct ctx *p_ctx=&myctx;
uint64_t nlba;
uint64_t st_lba;
uint64_t stride=0x1000;
int rc=0;
uint64_t src_ctx_id;
uint64_t src_adap_fd;
pthread_t thread;
uint64_t resource[MAX_RES_HANDLE];
uint64_t RES_CLOSED=-1;
int cl_index[5]={ 1,7,10,12,15 };
pid = getpid();
rc =ctx_init(p_ctx);
CHECK_RC(rc, "Context init failed");
pthread_create(&thread, NULL, ctx_rrq_rx, p_ctx);
p_ctx->flags = DK_UVF_ALL_PATHS;
for (i=0;i<MAX_RES_HANDLE;i++)
{
p_ctx->lun_size = (i+1)*p_ctx->chunk_size;
rc = create_res(p_ctx);
CHECK_RC(rc, "create res failed");
resource[i]=p_ctx->rsrc_handle;
}
for (i=0;i<5;i++)
{
p_ctx->rsrc_handle= resource[cl_index[i]];
close_res(p_ctx);
resource[cl_index[i]]= RES_CLOSED;
}
for (i=0; i<MAX_RES_HANDLE;i++)
{
if (RES_CLOSED == resource[i])
continue;
nlba = (i+1)*p_ctx->chunk_size;
p_ctx->rsrc_handle = resource[i];
p_ctx->res_hndl = p_ctx->rsrc_handle & RES_HNDLR_MASK;
for (st_lba=0;st_lba<nlba;st_lba += (NUM_CMDS*stride))
{
rc = send_write(p_ctx,st_lba,stride,pid);
CHECK_RC(rc, "send write failed\n");
}
}
//write done cancel thread now
pthread_cancel(thread);
cpid = fork();
if (cpid == 0)
{
//child process
pid = getpid();
ppid = getppid();
//take backup parent ctx_id
src_ctx_id= p_ctx->context_id;
src_adap_fd = p_ctx->adap_fd;
//do unmap parent mmio 1st
rc =munmap((void *)p_ctx->p_host_map, p_ctx->mmio_size);
CHECK_RC_EXIT(rc, "munmap failed\n");
//do fresh attach for child
rc = ctx_init_internal(p_ctx,DK_AF_ASSIGN_AFU,p_ctx->devno);
CHECK_RC_EXIT(rc, "ctx_init_internal failed");
pthread_create(&thread, NULL,ctx_rrq_rx,p_ctx);
//do clone
rc = ioctl_dk_capi_clone(p_ctx, src_ctx_id,src_adap_fd);
CHECK_RC_EXIT(rc, "clone ioctl failed");
//do read data
for (i=0; i< MAX_RES_HANDLE;i++)
{
if (RES_CLOSED == resource[i])
continue;
p_ctx->rsrc_handle = resource[i];
p_ctx->res_hndl = p_ctx->rsrc_handle & RES_HNDLR_MASK;
nlba = (i+1)*p_ctx->chunk_size;
for (st_lba=0;st_lba<nlba; st_lba+=(NUM_CMDS*stride))
{
rc = send_read(p_ctx,st_lba,stride);
CHECK_RC_EXIT(rc,"send_read failed\n");
rc = rw_cmp_buf_cloned(p_ctx, st_lba);
CHECK_RC_EXIT(rc,"rw_cmp_buf_cloned failed\n");
}
}
sleep(1);
//now create closed resources
p_ctx->flags = DK_UVF_ALL_PATHS;
for (i=0; i < 5;i++)
{
p_ctx->lun_size = (cl_index[i]+1)*p_ctx->chunk_size;
rc = create_res(p_ctx);
CHECK_RC_EXIT(rc,"res_create failed\n");
resource[cl_index[i]] = p_ctx->rsrc_handle;
}
//do io on new resources
p_ctx->st_lba = 0;
for (i=0;i<5;i++)
{
p_ctx->last_lba = ((cl_index[i]+1)*p_ctx->chunk_size) -1;
p_ctx->res_hndl = resource[cl_index[i]] & RES_HNDLR_MASK;
rc = do_io(p_ctx, stride);
CHECK_RC_EXIT(rc, "do_io failed\n");
}
pthread_cancel(thread);
ctx_close(p_ctx);
exit(0);
} //child process end
else
{
//create pthread
sleep(1); //let child process do clone & read written data
pthread_create(&thread, NULL, ctx_rrq_rx, p_ctx);
//do open closed res
//now create closed resources
p_ctx->flags = DK_UVF_ALL_PATHS;
for (i=0; i < 5;i++)
{
p_ctx->lun_size = (cl_index[i]+1)*p_ctx->chunk_size;
rc = create_res(p_ctx);
CHECK_RC_EXIT(rc,"res_create failed\n");
resource[cl_index[i]] = p_ctx->rsrc_handle;
}
//do resize all resources & IO
for (i=0;i<MAX_RES_HANDLE;i++)
{
p_ctx->req_size = (rand()%MAX_RES_HANDLE +1) * p_ctx->chunk_size;
p_ctx->rsrc_handle = resource[i];
p_ctx->res_hndl = p_ctx->rsrc_handle & RES_HNDLR_MASK;
rc = ioctl_dk_capi_vlun_resize(p_ctx);
CHECK_RC(rc, "dk_capi_resize_ioctl failed\n");
rc = do_io(p_ctx, stride);
CHECK_RC(rc, "do_io failed\n");
}
//close res
for (i=0;i<MAX_RES_HANDLE;i++)
{
p_ctx->rsrc_handle = resource[i];
rc = close_res(p_ctx);
CHECK_RC(rc, "cose_res failed\n");
}
pthread_cancel(thread);
ctx_close(p_ctx);
rc = wait4all();
}
return rc;
}
int main(int argc,char* argv[])
{
int ret=true;
char ch;
char *p,*p1;
char buf[100];
char temp[50];
char str[1000];
signal(SIGALRM,timeout_handle);
alarm(TIMEOUT_TIME);
if((argc==1))
{
printf("usage: 3Ginfo [-d] [-c] [-s]\n");
return -1;
}
//openlog(LOG_IDENT,LOG_PID,LOG_USER);
//chdir(SDK_FORDER);
memset(para_in[0],0,sizeof(para_in[0]));
memset(para_in[1],0,sizeof(para_in[1]));
memset(para_in[2],0,sizeof(para_in[2]));
memset(para_in[3],0,sizeof(para_in[3]));
while((ch=getopt(argc,argv,"d:c:s:m:"))!=(char)-1)
{
switch(ch)
{
case 'd':
if(optarg!=NULL)
{
strcpy(para_in[0],optarg);
}
break;
case 'c':
if(optarg!=NULL)
{
strcpy(para_in[1],optarg);
}
break;
case 's':
if(optarg!=NULL)
{
strcpy(para_in[2],optarg);
}
break;
case 'm':
if(optarg!=NULL)
{
strcpy(para_in[3],optarg);
}
break;
default:
printf("error command");
ret=false;
exit(0);
break;
}
}
p=default_command;
if(strlen(para_in[0])==0)
strcpy(para_in[0],default_device);
if(strlen(para_in[1])==0)
strcpy(para_in[1],default_command);
if(strlen(para_in[2])==0)
strcpy(para_in[2],default_sign);
if(strlen(para_in[3])==0)
strcpy(para_in[3],default_max_signal);
//printf("para_in[0]=%s,strlen=%d\n",para_in[0],strlen(para_in[0]));
//printf("para_in[1]=%s,strlen=%d\n",para_in[1],strlen(para_in[1]));
//printf("para_in[2]=%s,strlen=%d\n",para_in[2],strlen(para_in[2]));
strcat(para_in[1],"\r\n");
serial_init(para_in[0]);
//system("echo \"open 3g device for get signal \" ");
if(open_device(&fd,para_in[0])==false)
{
printf("open device error!");
ret=false;
exit(0);
}
//system("echo \"!!!!!!!send ate0 \" ");
send_read(fd,"ATE0\r\n",buf,WAIT_OK);
// sprintf(str,"echo \"send %s\n\" ",para_in[0]);
//system(str);
if(send_read(fd,para_in[1],buf,WAIT_VALUE)==false)
{
// system("echo \"ret=false\" ");
ret=false;
printf("read error!");
close_device(fd);
clear_fd(&fd);
exit(0);
}
//sprintf(str,"echo \"buf %s\n\" ",buf);
//system(str);
//printf("last_buf:%s\n",buf);
if(buf==NULL)
{
printf("read error!");
ret=false;
close_device(fd);
clear_fd(&fd);
exit(0);
}
//ret
close_device(fd);
clear_fd(&fd);
p=strchr(buf,':');
if(p!=NULL)
{
p++;
p1=strchr(buf,',');
if(p1!=NULL)
{
strncpy(temp,p,p1-p);
printf("%s , ",temp);
printf("(");
printf("%s",para_in[3]);
printf(")");
}
else{
printf("");
}
}
else{
printf("");
}
exit(0);
}
int child_mc_reg_error(int cmd)
{
int rc;
struct ctx myctx;
struct ctx *p_ctx = &myctx;
__u64 *map=(__u64 *)0xabcdf;
__u64 actual_size=0;
__u64 stride;
__u64 st_lba =0;
__u64 nlba;
mc_hndl_t new_mc_hndl, dup_mc_hndl;
int rc1, rc2, rc3, rc4, rc5;
pthread_t thread;
mc_stat_t l_mc_stat;
__u64 size = 128;
if(mc_init() !=0 ) {
fprintf(stderr, "mc_init failed.\n");
return -1;
}
debug("mc_init success.\n");
rc = ctx_init(p_ctx);
if(rc != 0) {
fprintf(stderr, "Context init failed, errno %d\n", errno);
return -1;
}
pid = getpid();
if(1 == cmd) //mc_reg with NULL MMIOP
{
pthread_create(&thread,NULL,ctx_rrq_rx, p_ctx);
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
NULL,&p_ctx->mc_hndl);
if(rc) return rc;
rc = mc_open(p_ctx->mc_hndl,MC_RDWR, &p_ctx->res_hndl);
if(rc) return rc;
rc = mc_open(p_ctx->mc_hndl,MC_RDWR, &p_ctx->res_hndl);
if(rc) return rc;
rc = mc_size(p_ctx->mc_hndl, p_ctx->res_hndl, 2, &actual_size);
if(rc) return rc;
rc = mc_stat(p_ctx->mc_hndl, p_ctx->res_hndl, &l_mc_stat);
if(rc) return rc;
pid = getpid();
stride = (1 << l_mc_stat.nmask);
st_lba = (actual_size * (1 << l_mc_stat.nmask))-1;
rc = send_write(p_ctx, st_lba ,stride, pid, VLBA);
if(rc) return rc;
rc = send_read(p_ctx, st_lba ,stride, VLBA);
if(rc) return rc;
rc = rw_cmp_buf(p_ctx, st_lba);
rc = rc ? 1:0;
}
else if(2 == cmd) //NULL device path
{
rc = mc_register(NULL, p_ctx->ctx_hndl,
(volatile __u64 *) p_ctx->p_host_map,&p_ctx->mc_hndl);
rc = rc ? 2:0;
}
else if(3 == cmd) //with afu_path device
{
rc = mc_register(afu_path, p_ctx->ctx_hndl,
(volatile __u64 *) p_ctx->p_host_map,&p_ctx->mc_hndl);
rc = rc ? 3:0;
}
else if(4 == cmd) //with invalid device path
{
rc = mc_register("/dev/cxl/afu50.0m", p_ctx->ctx_hndl,
(volatile __u64 *) p_ctx->p_host_map,&p_ctx->mc_hndl);
rc = rc ? 4:0;
}
else if(5 == cmd) //with invalid ctx hndl(not assigned)
{
debug("actual ctx hndl :%d\n", p_ctx->ctx_hndl);
p_ctx->ctx_hndl = p_ctx->ctx_hndl + 4;
debug("invalid ctx hndl :%d\n", p_ctx->ctx_hndl);
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
(volatile __u64 *) p_ctx->p_host_map,&p_ctx->mc_hndl);
rc = rc ? 5:0;
}
else if(6 == cmd) //with invalid mmap adress
{
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
(volatile __u64 *)map,&p_ctx->mc_hndl);
rc = rc ? 6:0;
}
else if(7 == cmd) //twice mc_reg
{
pthread_create(&thread,NULL,ctx_rrq_rx, p_ctx);
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
(volatile __u64 *)p_ctx->p_host_map, &p_ctx->mc_hndl);
CHECK_RC(rc, "mc_register");
rc = mc_open(p_ctx->mc_hndl, MC_RDWR, &p_ctx->res_hndl);
CHECK_RC(rc, "mc_open");
rc = mc_size(p_ctx->mc_hndl, p_ctx->res_hndl, size, &actual_size);
CHECK_RC(rc, "mc_size");
rc = mc_stat(p_ctx->mc_hndl, p_ctx->res_hndl, &l_mc_stat);
//twice mc_register on same ctx
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
(volatile __u64 *)p_ctx->p_host_map, &new_mc_hndl);
//send write on 1st mc hndl
rc1 = send_single_write(p_ctx, 0, pid);
//do mc_size & open on old mc_reg
rc2 = mc_open(p_ctx->mc_hndl, MC_RDWR, &p_ctx->res_hndl);
rc3 = mc_size(p_ctx->mc_hndl, p_ctx->res_hndl, size, &actual_size);
rc4 = mc_stat(p_ctx->mc_hndl, p_ctx->res_hndl, &l_mc_stat);
rc5 = mc_hdup(p_ctx->mc_hndl, &dup_mc_hndl);
debug("mc_hdup rc is : %d\n", rc5);
//now do mc_unreg on old one
rc = mc_unregister(p_ctx->mc_hndl);
CHECK_RC(rc, "mc_unregister");
//do everything on new mc hndl
p_ctx->mc_hndl = new_mc_hndl;
rc = mc_open(p_ctx->mc_hndl, MC_RDWR, &p_ctx->res_hndl);
CHECK_RC(rc, "mc_open");
rc = mc_size(p_ctx->mc_hndl, p_ctx->res_hndl, size, &actual_size);
CHECK_RC(rc, "mc_size");
rc = mc_stat(p_ctx->mc_hndl, p_ctx->res_hndl, &l_mc_stat);
nlba = l_mc_stat.size * (1 << l_mc_stat.nmask);
stride = 1 << l_mc_stat.nmask;
for(st_lba = 0; st_lba < nlba; st_lba += (stride * NUM_CMDS)) {
rc = send_write(p_ctx, st_lba, stride, pid, VLBA);
CHECK_RC(rc, "send_write");
}
if(rc1 && rc2 && rc3 && rc4 && rc5) {
rc = 7;
}
pthread_cancel(thread);
mc_unregister(p_ctx->mc_hndl);
}
else if(8 == cmd) //mc_reg twice from 2 diff process
{
if(fork() == 0) {//mc_reg in child process as well
pid = getpid();
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
(volatile __u64 *)p_ctx->p_host_map, &p_ctx->mc_hndl);
sleep(1);
rc = mc_open(p_ctx->mc_hndl,MC_RDWR, &p_ctx->res_hndl);
if(!rc) {
fprintf(stderr, "%d : mc_open should fail rc = %d\n", pid, rc);
exit(-1);
}
else {
debug("%d : mc_open failed as expectd\n", pid);
}
rc = mc_size(p_ctx->mc_hndl, p_ctx->res_hndl, 2, &actual_size);
if(!rc) {
fprintf(stderr, "%d : mc_size should fail rc = %d\n", pid, rc);
exit(-1);
}
else {
debug("%d : mc_size failed as expectd\n", pid);
}
rc = rc ? 8:0;
exit(rc);
}
else
{
sleep(1); //let child proc cal mc_reg 1str
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
(volatile __u64 *)p_ctx->p_host_map, &p_ctx->mc_hndl);
CHECK_RC(rc, "mc_register");
pthread_create(&thread,NULL,ctx_rrq_rx, p_ctx);
rc = mc_open(p_ctx->mc_hndl,MC_RDWR, &p_ctx->res_hndl);
CHECK_RC(rc, "mc_open");
rc = mc_size(p_ctx->mc_hndl, p_ctx->res_hndl, 2, &actual_size);
CHECK_RC(rc, "mc_mc_size");
rc = mc_stat(p_ctx->mc_hndl, p_ctx->res_hndl, &l_mc_stat);
CHECK_RC(rc, "mc_stat");
st_lba = (actual_size * (1 << l_mc_stat.nmask))-1;
rc += send_single_write(p_ctx, st_lba, pid);
wait(&rc);
pthread_cancel(thread);
if (WIFEXITED(rc)) {
rc = WEXITSTATUS(rc);
rc = rc ? 8:0;
}
mc_unregister(p_ctx->mc_hndl);
}
}
ctx_close(p_ctx);
if(9 == cmd) //mc_reg with closed ctx
{
pthread_create(&thread,NULL,ctx_rrq_rx, p_ctx);
printf("calling mc_reg api after ctx close..\n");
rc = mc_register(master_dev_path, p_ctx->ctx_hndl,
(volatile __u64 *)p_ctx->p_host_map, &p_ctx->mc_hndl);
rc = rc ? 9:0;
}
mc_term();
return rc;
}
int ioctl_7_1_196()
{
int rc,i,j;
struct ctx myctx[21],myctx_1, myctx_2;
struct ctx *p_ctx[21],*p_ctx_1,*p_ctx_2;
__u64 stride=0x1000,st_lba=0;
pthread_t thread[20];
struct flash_disk disks[MAX_FDISK];
char disk1[30];
char disk2[30];
int cfdisk = MAX_FDISK;
pid = getpid();
cfdisk = get_flash_disks(disks, FDISKS_SAME_ADPTR);
//need to check the number of disks
if (cfdisk < 2)
{
fprintf(stderr,"Must have 2 flash disks..\n");
TESTCASE_SKIP("Need disk from same adapter and each disk multipathed");
return 0;
}
strcpy(disk1,disks[0].dev);
strcpy(disk2,disks[1].dev);
// creating first context
for (i=0;i<21;i++)
{
p_ctx[i]=&myctx[i];
}
p_ctx_1=&myctx_1;
p_ctx_2=&myctx_2;
debug("1ST PROCEDURE\n");
// using p_ctx[[0] for LUN direct for firect disk
/* rc = ctx_init2(p_ctx[0], disks[0].dev, DK_AF_ASSIGN_AFU, disks[0].devno[0]);
pthread_create(&thread[0], NULL, ctx_rrq_rx, p_ctx[0]);
*/
/* rc = create_resource(p_ctx[0], 0, DK_UDF_ASSIGN_PATH, LUN_DIRECT);
CHECK_RC(rc, "create LUN_DIRECT failed");
*/
// creating another 19 context LUN VIRTUAL
for ( i=2;i<21;i++)
{
sleep(2);
rc = ctx_init2(p_ctx[i], disks[1].dev, DK_AF_ASSIGN_AFU, disks[1].devno[0]);
rc=create_resource(p_ctx[i], p_ctx[i]->chunk_size, DK_UVF_ASSIGN_PATH, LUN_VIRTUAL);
}
// do context reuse for direct LUN
strcpy(p_ctx[0]->dev,disks[0].dev);
strcpy(p_ctx[1]->dev,disks[1].dev);
p_ctx[0]->fd = open_dev(disks[0].dev, O_RDWR);
if (p_ctx[0]->fd < 0)
{
fprintf(stderr, "open() failed: device %s, errno %d\n", disks[0].dev, errno);
g_error = -1;
return -1;
}
p_ctx[1]->fd = open_dev(disks[1].dev, O_RDWR); //Hoping to open second disk
if (p_ctx[1]->fd < 0)
{
fprintf(stderr, "open() failed: device %s, errno %d\n", disks[1].dev, errno);
g_error = -1;
}
#ifdef _AIX
rc = ioctl_dk_capi_query_path(p_ctx[0]);
CHECK_RC(rc, "DK_CAPI_QUERY_PATH failed");
#else
//TBD for linux
#endif
p_ctx[0]->work.num_interrupts = p_ctx[1]->work.num_interrupts = 4;
rc=ioctl_dk_capi_attach_reuse(p_ctx[0],p_ctx[1],LUN_DIRECT);
// CHECK_RC(rc, "DK_CAPI_ATTACH with reuse flag failed");
if ( rc != 0 )
{
fprintf(stderr,"LUN DIRECT got attached to new disk with VLUN, should have succeeded");
return rc;
}
// initiate I/O on all the LUNs
for (i=2;i<21;i++)
{
pthread_create(&thread[i], NULL, ctx_rrq_rx, p_ctx[i]);
rc = do_io(p_ctx[i], stride);
}
if ( rc != 0 )
{ fprintf(stderr,"io on some LUN failed");
return rc;
}
/* using a goto-label removes the compile warning (-O3 issue) */
i=2;
for_loop:
pthread_cancel(thread[i]);
close_res(p_ctx[i]);
if (++i < 21) {goto for_loop;}
ctx_close(p_ctx[2]);
debug("2nd PROCEDURE\n");
// procedure 2 of the same case
debug("%d: ........Phase 1 done.. Starting 2nd Phase........\n",getpid());
memset(p_ctx_1, 0, sizeof(struct ctx));
memset(p_ctx_2, 0, sizeof(struct ctx));
// open the first flash disk in write mode and create a DIRECT LUN
// restoring from backup
strcpy(disks[0].dev,disk1);
p_ctx_1->fd = open_dev(disks[0].dev, O_WRONLY);
if (p_ctx_1->fd < 0)
{
fprintf(stderr, "open() failed: device %s, errno %d\n", disks[0].dev, errno);
return -1;
}
rc = ctx_init2(p_ctx_1, disks[0].dev, DK_AF_ASSIGN_AFU, disks[0].devno[0]);
pthread_create(&thread[0], NULL, ctx_rrq_rx, p_ctx_1);
CHECK_RC(rc, "create context failed");
rc = create_resource(p_ctx_1, 0, DK_UDF_ASSIGN_PATH, LUN_DIRECT);
CHECK_RC(rc, "create LUN_DIRECT failed");
// open the same flash disk in read mode again.
p_ctx_2->fd = open_dev(disks[0].dev, O_RDONLY);
if (p_ctx_2->fd < 0)
{
fprintf(stderr, "open() failed: device %s, errno %d\n", disks[0].dev, errno);
return -1;
}
rc = ctx_init2(p_ctx_2, disks[0].dev, DK_AF_ASSIGN_AFU, disks[0].devno[0]);
pthread_create(&thread[1], NULL, ctx_rrq_rx, p_ctx_2);
CHECK_RC(rc, "create context failed");
rc = create_resource(p_ctx_2, 0, DK_UDF_ASSIGN_PATH, LUN_DIRECT);
CHECK_RC(rc, "create LUN_DIRECT failed");
// now write to the disk and then read
for (st_lba = 0; st_lba <= p_ctx_1->last_lba; st_lba += (NUM_CMDS*stride))
{
rc = send_write(p_ctx_1, st_lba, stride, pid);
CHECK_RC(rc, "send_write failed");
rc = send_read(p_ctx_2, st_lba, stride);
CHECK_RC(rc, "send_read failed");
/*if (rc !=0 )
{
rc = rw_cmp_buf(p_ctx_1, st_lba);
if (rc != 0)
{
fprintf(stderr,"buf cmp failed for lba 0x%lX,rc =%d\n",st_lba,rc);
break;
}
}*/
}
if ( rc != 0 )
return rc;
for (i=0;i<2;i++)
{
pthread_cancel(thread[i]);
}
//close_res(p_ctx_1);
ctx_close(p_ctx_1);
//close_res(p_ctx_2);
ctx_close(p_ctx_2);
debug("3rd PROCEDURE\n");
debug("%d: ........Phase 2 done.. Starting 3rd Phase........\n",getpid());
// case 3 of the same case
// creating multiple process for LUN_DIRECT creation.
for (j=0;j<long_run;j++)
{
for (i=0; i<20;i++)
{
if ( 0 == fork())
{ rc = ctx_init(p_ctx[i]);
CHECK_RC_EXIT(rc, "Context init failed");
// CHECK_RC(rc, "Context init failed");
//thread to handle AFU interrupt & events
rc = create_resource(p_ctx[i], 0, DK_UDF_ASSIGN_PATH , LUN_DIRECT);
CHECK_RC_EXIT(rc, "create LUN_DIRECT failed");
// do io on context
pthread_create(&thread[i], NULL, ctx_rrq_rx, p_ctx[i]);
stride=0x1000;
sleep(2);
//do_io(p_ctx[i], stride);
pthread_cancel(thread[i]);
close_res(p_ctx[i]);
exit(rc);
}
}
wait4all();
}
return 0;
}
//////////////////////////////////////////////////////////////////////////
// PDES process
//////////////////////////////////////////////////////////////////////////
tmpl (void)::execLoop ()
{
while(true)
{
// deactivation if all channels are stopped:
// send desactivation message... and deschedule
if ( m_dma_activated and all_channels_stopped() )
{
m_activity_extension.set_active();
send_activity();
m_dma_activated = false;
wait( m_event );
}
// activation if at least one channel not stopped
// send activation message... and continue
if ( not m_dma_activated and all_channels_idle() )
{
m_activity_extension.set_inactive();
send_activity();
m_dma_activated = true;
}
// enters the loop on all channels when activated
for ( size_t k = 0 ; k < m_channels ; k++ )
{
// update local time : one cycle
m_pdes_local_time->add(UNIT_TIME);
switch ( m_state[k] ) {
////////////////
case STATE_IDLE:
{
if ( not m_stop[k] ) m_state[k] = STATE_READ_CMD;
break;
}
////////////////////
case STATE_READ_CMD:
{
if ( m_length[k] >= m_max_burst ) m_burst_length[k] = m_max_burst;
else m_burst_length[k] = m_length[k];
send_read( k );
m_state[k] = STATE_READ_RSP;
break;
}
////////////////////
case STATE_READ_RSP:
{
if ( m_rsp_received[k] )
{
m_rsp_received[k] = false;
if ( m_stop[k] )
{
m_state[k] = STATE_IDLE;
}
else if( not m_vci_payload[k].is_response_error() )
{
m_state[k] = STATE_WRITE_CMD;
}
else
{
m_state[k] = STATE_ERROR_WRITE;
m_irq_value[k] = 0xFF;
if ( not m_irq_disabled[k] ) send_irq( k );
}
}
break;
}
/////////////////////
case STATE_WRITE_CMD:
{
send_write( k );
m_state[k] = STATE_WRITE_RSP;
break;
}
/////////////////////
case STATE_WRITE_RSP:
{
if ( m_rsp_received[k] )
{
m_rsp_received[k] = false;
if ( m_stop[k] )
{
m_state[k] = STATE_IDLE;
}
else if ( m_vci_payload[k].is_response_error() )
{
m_state[k] = STATE_ERROR_WRITE;
m_irq_value[k] = 0xFF;
if ( not m_irq_disabled[k] ) send_irq( k );
}
else if ( m_length[k] == 0 )
{
m_state[k] = STATE_SUCCESS;
m_irq_value[k] = 0xFF;
if ( not m_irq_disabled[k] ) send_irq( k );
}
else
{
m_length[k] = m_length[k] - m_burst_length[k];
m_source[k] = m_source[k] + m_burst_length[k];
m_destination[k] = m_destination[k] + m_burst_length[k];
m_state[k] = STATE_READ_CMD;
}
}
break;
}
//////////////////////
case STATE_ERROR_READ:
case STATE_ERROR_WRITE:
case STATE_SUCCESS:
{
if ( not m_stop[k] )
{
m_state[k] = STATE_IDLE;
m_irq_value[k] = 0x00;
if ( not m_irq_disabled[k] ) send_irq( k );
}
} } // end channel state switch
} // end loop on channels
// send NULL and deschedule if required
if ( m_pdes_local_time->need_sync() and m_dma_activated )
{
send_null();
wait( sc_core::SC_ZERO_TIME );
}
} // end infinite while
} // end execLoop
