int main(int argc, char **argv)
{
int i, start_option;
int n_rid;
char *query_text;
rs_query_t *rq;
ex_off_t block_size, total_size;
exnode_t *ex;
segment_create_t *screate;
char *fname_out = NULL;
exnode_exchange_t *exp;
segment_t *seg = NULL;
op_generic_t *gop;
if (argc < 5) {
printf("\n");
printf("mk_linear LIO_COMMON_OPTIONS -q rs_query_string n_rid block_size total_size file.ex3\n");
lio_print_options(stdout);
printf("\n");
return(1);
}
lio_init(&argc, &argv);
//*** Parse the args
i=1;
do {
start_option = i;
if (strcmp(argv[i], "-q") == 0) { //** Load the query
i++;
query_text = argv[i];
i++;
}
} while (start_option < i);
//** Load the fixed options
n_rid = atoi(argv[i]);
i++;
block_size = atoi(argv[i]);
i++;
total_size = atoi(argv[i]);
i++;
fname_out = argv[i];
i++;
//** Do some simple sanity checks
//** Make sure we loaded a simple res service
if (fname_out == NULL) {
printf("Missing output filename!\n");
return(2);
}
//** Create an empty linear segment
screate = lookup_service(lio_gc->ess, SEG_SM_CREATE, SEGMENT_TYPE_LINEAR);
seg = (*screate)(lio_gc->ess);
//** Parse the query
rq = rs_query_parse(lio_gc->rs, query_text);
// rs_query_add(rs, &rq, RSQ_BASE_OP_AND, "lun", RSQ_BASE_KV_EXACT, "", RSQ_BASE_KV_ANY);
if (rq == NULL) {
printf("Error parsing RS query: %s\n", query_text);
printf("Exiting!\n");
exit(1);
}
//** Make the actual segment
gop = segment_linear_make(seg, NULL, rq, n_rid, block_size, total_size, lio_gc->timeout);
i = gop_waitall(gop);
if (i != 0) {
printf("ERROR making segment! nerr=%d\n", i);
return(-1);
}
gop_free(gop, OP_DESTROY);
//** Make an empty exnode
ex = exnode_create();
//** and insert it
view_insert(ex, seg);
//** Print it
exp = exnode_exchange_create(EX_TEXT);
exnode_serialize(ex, exp);
printf("%s", exp->text.text);
//** and Save if back to disk
FILE *fd = fopen(fname_out, "w");
fprintf(fd, "%s", exp->text.text);
fclose(fd);
exnode_exchange_destroy(exp);
//** Clean up
exnode_destroy(ex);
rs_query_destroy(lio_gc->rs, rq);
lio_shutdown();
return(0);
}
op_status_t segment_put_func(void *arg, int id)
{
segment_copy_t *sc = (segment_copy_t *)arg;
tbuffer_t *wbuf, *rbuf, *tmpbuf;
tbuffer_t tbuf1, tbuf2;
char *rb, *wb, *tb;
ex_off_t bufsize;
int err;
ex_off_t rpos, wpos, rlen, wlen, tlen, nbytes, got, dend;
ex_iovec_t wex;
op_generic_t *gop;
op_status_t status;
apr_time_t loop_start, file_start;
double dt_loop, dt_file;
//** Set up the buffers
bufsize = sc->bufsize / 2; //** The buffer is split for R/W
rb = sc->buffer;
wb = &(sc->buffer[bufsize]);
tbuffer_single(&tbuf1, bufsize, rb);
tbuffer_single(&tbuf2, bufsize, wb);
rbuf = &tbuf1;
wbuf = &tbuf2;
nbytes = sc->len;
status = op_success_status;
//** Go ahead and reserve the space in the destintaion
dend = sc->dest_offset + nbytes;
gop_sync_exec(segment_truncate(sc->dest, sc->da, -dend, sc->timeout));
//** Read the initial block
rpos = 0;
wpos = sc->dest_offset;
if (nbytes < 0) {
rlen = bufsize;
} else {
rlen = (nbytes > bufsize) ? bufsize : nbytes;
}
wlen = 0;
rpos += rlen;
nbytes -= rlen;
log_printf(0, "FILE fd=%p bufsize=" XOT " rlen=" XOT " nbytes=" XOT "\n", sc->fd, bufsize, rlen, nbytes);
loop_start = apr_time_now();
got = fread(rb, 1, rlen, sc->fd);
dt_file = apr_time_now() - loop_start;
dt_file /= (double)APR_USEC_PER_SEC;
if (got == 0) {
if (feof(sc->fd) == 0) {
log_printf(1, "ERROR from fread=%d dest sid=" XIDT " rlen=" XOT " got=" XOT "\n", errno, segment_id(sc->dest), rlen, got);
status = op_failure_status;
}
goto finished;
}
rlen = got;
do {
//** Swap the buffers
tb = rb;
rb = wb;
wb = tb;
tmpbuf = rbuf;
rbuf = wbuf;
wbuf = tmpbuf;
tlen = rlen;
rlen = wlen;
wlen = tlen;
log_printf(1, "dseg=" XIDT " wpos=" XOT " rlen=" XOT " wlen=" XOT "\n", segment_id(sc->dest), wpos, rlen, wlen);
//** Start the write
ex_iovec_single(&wex, wpos, wlen);
wpos += wlen;
loop_start = apr_time_now();
gop = segment_write(sc->dest, sc->da, sc->rw_hints, 1, &wex, wbuf, 0, sc->timeout);
gop_start_execution(gop); //** Start doing the transfer
//** Read in the next block
if (nbytes < 0) {
rlen = bufsize;
} else {
rlen = (nbytes > bufsize) ? bufsize : nbytes;
}
if (rlen > 0) {
file_start = apr_time_now();
got = fread(rb, 1, rlen, sc->fd);
dt_file = apr_time_now() - file_start;
dt_file /= (double)APR_USEC_PER_SEC;
if (got == 0) {
if (feof(sc->fd) == 0) {
log_printf(1, "ERROR from fread=%d dest sid=" XIDT " got=" XOT " rlen=" XOT "\n", errno, segment_id(sc->dest), got, rlen);
status = op_failure_status;
gop_waitall(gop);
gop_free(gop, OP_DESTROY);
goto finished;
}
}
rlen = got;
rpos += rlen;
nbytes -= rlen;
}
//** Wait for it to complete
err = gop_waitall(gop);
dt_loop = apr_time_now() - loop_start;
dt_loop /= (double)APR_USEC_PER_SEC;
log_printf(1, "dt_loop=%lf dt_file=%lf\n", dt_loop, dt_file);
if (err != OP_STATE_SUCCESS) {
log_printf(1, "ERROR write(dseg=" XIDT ") failed! wpos=" XOT " len=" XOT "\n", segment_id(sc->dest), wpos, wlen);
status = op_failure_status;
gop_free(gop, OP_DESTROY);
goto finished;
}
gop_free(gop, OP_DESTROY);
} while (rlen > 0);
if (sc->truncate == 1) { //** Truncate if wanted
gop_sync_exec(segment_truncate(sc->dest, sc->da, wpos, sc->timeout));
}
finished:
// status.error_code = rpos;
return(status);
}
op_status_t segment_copy_func(void *arg, int id)
{
segment_copy_t *sc = (segment_copy_t *)arg;
tbuffer_t *wbuf, *rbuf, *tmpbuf;
tbuffer_t tbuf1, tbuf2;
int err;
ex_off_t bufsize;
ex_off_t rpos, wpos, rlen, wlen, tlen, nbytes, dend;
ex_iovec_t rex, wex;
opque_t *q;
op_generic_t *rgop, *wgop;
op_status_t status;
//** Set up the buffers
bufsize = sc->bufsize / 2; //** The buffer is split for R/W
tbuffer_single(&tbuf1, bufsize, sc->buffer);
tbuffer_single(&tbuf2, bufsize, &(sc->buffer[bufsize]));
rbuf = &tbuf1;
wbuf = &tbuf2;
//** Check the length
nbytes = segment_size(sc->src) - sc->src_offset;
if (nbytes < 0) {
rlen = bufsize;
} else {
rlen = (nbytes > bufsize) ? bufsize : nbytes;
}
if ((sc->len != -1) && (sc->len < nbytes)) nbytes = sc->len;
//** Go ahead and reserve the space in the destintaion
dend = sc->dest_offset + nbytes;
log_printf(1, "reserving space=" XOT "\n", dend);
gop_sync_exec(segment_truncate(sc->dest, sc->da, -dend, sc->timeout));
//** Read the initial block
rpos = sc->src_offset;
wpos = sc->dest_offset;
// rlen = (nbytes > bufsize) ? bufsize : nbytes;
wlen = 0;
ex_iovec_single(&rex, rpos, rlen);
rpos += rlen;
nbytes -= rlen;
rgop = segment_read(sc->src, sc->da, sc->rw_hints, 1, &rex, rbuf, 0, sc->timeout);
err = gop_waitall(rgop);
if (err != OP_STATE_SUCCESS) {
log_printf(1, "Intial read failed! src=%" PRIu64 " rpos=" XOT " len=" XOT "\n", segment_id(sc->src), rpos, rlen);
gop_free(rgop, OP_DESTROY);
return(op_failure_status);
}
gop_free(rgop, OP_DESTROY);
q = new_opque();
do {
//** Swap the buffers
tmpbuf = rbuf;
rbuf = wbuf;
wbuf = tmpbuf;
tlen = rlen;
rlen = wlen;
wlen = tlen;
log_printf(1, "sseg=" XIDT " dseg=" XIDT " wpos=%" PRId64 " rlen=%" PRId64 " wlen=%" PRId64 "\n", segment_id(sc->src), segment_id(sc->dest), wpos, rlen, wlen);
//** Start the write
ex_iovec_single(&wex, wpos, wlen);
wpos += wlen;
wgop = segment_write(sc->dest, sc->da, sc->rw_hints, 1, &wex, wbuf, 0, sc->timeout);
opque_add(q, wgop);
//** Read in the next block
// rlen = (nbytes > bufsize) ? bufsize : nbytes;
if (nbytes < 0) {
rlen = bufsize;
} else {
rlen = (nbytes > bufsize) ? bufsize : nbytes;
}
if (rlen > 0) {
ex_iovec_single(&rex, rpos, rlen);
rpos += rlen;
nbytes -= rlen;
rgop = segment_read(sc->src, sc->da, sc->rw_hints, 1, &rex, rbuf, 0, sc->timeout);
opque_add(q, rgop);
}
err = opque_waitall(q);
if (err != OP_STATE_SUCCESS) {
log_printf(1, "ERROR read/write failed! src=" XIDT " rpos=" XOT " len=" XOT "\n", segment_id(sc->src), rpos, rlen);
opque_free(q, OP_DESTROY);
return(op_failure_status);
}
} while (rlen > 0);
opque_free(q, OP_DESTROY);
if (sc->truncate == 1) { //** Truncate if wanted
gop_sync_exec(segment_truncate(sc->dest, sc->da, wpos, sc->timeout));
}
status = op_success_status;
status.error_code = rpos;
return(status);
}
op_status_t segment_get_func(void *arg, int id)
{
segment_copy_t *sc = (segment_copy_t *)arg;
tbuffer_t *wbuf, *rbuf, *tmpbuf;
tbuffer_t tbuf1, tbuf2;
char *rb, *wb, *tb;
ex_off_t bufsize;
int err;
ex_off_t rpos, wpos, rlen, wlen, tlen, nbytes, got, total;
ex_iovec_t rex;
apr_time_t loop_start, file_start;
double dt_loop, dt_file;
op_generic_t *gop;
op_status_t status;
//** Set up the buffers
bufsize = sc->bufsize / 2; //** The buffer is split for R/W
rb = sc->buffer;
wb = &(sc->buffer[bufsize]);
tbuffer_single(&tbuf1, bufsize, rb);
tbuffer_single(&tbuf2, bufsize, wb);
rbuf = &tbuf1;
wbuf = &tbuf2;
status = op_success_status;
//** Read the initial block
rpos = sc->src_offset;
wpos = 0;
nbytes = segment_size(sc->src) - sc->src_offset;
if (nbytes < 0) {
rlen = bufsize;
} else {
rlen = (nbytes > bufsize) ? bufsize : nbytes;
}
log_printf(5, "FILE fd=%p\n", sc->fd);
ex_iovec_single(&rex, rpos, rlen);
wlen = 0;
rpos += rlen;
nbytes -= rlen;
loop_start = apr_time_now();
gop = segment_read(sc->src, sc->da, sc->rw_hints, 1, &rex, rbuf, 0, sc->timeout);
err = gop_waitall(gop);
if (err != OP_STATE_SUCCESS) {
log_printf(1, "Intial read failed! src=" XIDT " rpos=" XOT " len=" XOT "\n", segment_id(sc->src), rpos, rlen);
gop_free(gop, OP_DESTROY);
return(op_failure_status);
}
gop_free(gop, OP_DESTROY);
total = 0;
do {
//** Swap the buffers
tb = rb;
rb = wb;
wb = tb;
tmpbuf = rbuf;
rbuf = wbuf;
wbuf = tmpbuf;
tlen = rlen;
rlen = wlen;
wlen = tlen;
log_printf(1, "sseg=" XIDT " rpos=" XOT " wpos=" XOT " rlen=" XOT " wlen=" XOT " nbytes=" XOT "\n", segment_id(sc->src), rpos, wpos, rlen, wlen, nbytes);
//** Read in the next block
if (nbytes < 0) {
rlen = bufsize;
} else {
rlen = (nbytes > bufsize) ? bufsize : nbytes;
}
if (rlen > 0) {
ex_iovec_single(&rex, rpos, rlen);
loop_start = apr_time_now();
gop = segment_read(sc->src, sc->da, sc->rw_hints, 1, &rex, rbuf, 0, sc->timeout);
gop_start_execution(gop); //** Start doing the transfer
rpos += rlen;
nbytes -= rlen;
}
//** Start the write
file_start = apr_time_now();
got = fwrite(wb, 1, wlen, sc->fd);
dt_file = apr_time_now() - file_start;
dt_file /= (double)APR_USEC_PER_SEC;
total += got;
log_printf(5, "sid=" XIDT " fwrite(wb,1," XOT ", sc->fd)=" XOT " total=" XOT "\n", segment_id(sc->src), wlen, got, total);
if (wlen != got) {
log_printf(1, "ERROR from fread=%d dest sid=" XIDT "\n", errno, segment_id(sc->dest));
status = op_failure_status;
gop_waitall(gop);
gop_free(gop, OP_DESTROY);
goto fail;
}
wpos += wlen;
//** Wait for the read to complete
if (rlen > 0) {
err = gop_waitall(gop);
gop_free(gop, OP_DESTROY);
if (err != OP_STATE_SUCCESS) {
log_printf(1, "ERROR write(dseg=" XIDT ") failed! wpos=" XOT " len=" XOT "\n", segment_id(sc->dest), wpos, wlen);
status = op_failure_status;
goto fail;
}
}
dt_loop = apr_time_now() - loop_start;
dt_loop /= (double)APR_USEC_PER_SEC;
log_printf(1, "dt_loop=%lf dt_file=%lf\n", dt_loop, dt_file);
} while (rlen > 0);
fail:
return(status);
}