/* PVFS_finalize
*
* shuts down the PVFS system interface
*
* returns 0 on success, -errno on failure
*/
int PVFS_sys_finalize()
{
id_gen_safe_finalize();
PINT_util_digest_finalize();
PINT_ncache_finalize();
PINT_acache_finalize();
PINT_cached_config_finalize();
/* flush all known server configurations */
PINT_server_config_mgr_finalize();
/* finalize the I/O interfaces */
job_time_mgr_finalize();
job_close_context(pint_client_sm_context);
job_finalize();
PINT_flow_finalize();
PINT_req_sched_finalize();
BMI_finalize();
PINT_encode_finalize();
PINT_dist_finalize();
PINT_event_finalize();
PINT_release_pvfstab();
gossip_disable();
PINT_client_state_machine_release(g_smcb);
return 0;
}
int main(
int argc,
char **argv)
{
int ret = -1;
int outcount = 0, count;
struct BMI_unexpected_info request_info;
flow_descriptor *flow_d = NULL;
double time1, time2;
int i;
PINT_Request *req;
char path_name[PATH_SIZE];
TROVE_op_id op_id;
TROVE_coll_id coll_id;
TROVE_handle file_handle, parent_handle;
TROVE_ds_state state;
char *file_name;
TROVE_keyval_s key, val;
bmi_context_id context;
TROVE_context_id trove_context;
PVFS_handle_extent cur_extent;
PVFS_handle_extent_array extent_array;
/*************************************************************/
/* initialization stuff */
/* set debugging level */
gossip_enable_stderr();
gossip_set_debug_mask(0, GOSSIP_FLOW_PROTO_DEBUG | GOSSIP_BMI_DEBUG_TCP );
/* start up BMI */
ret = BMI_initialize("bmi_tcp", "tcp://NULL:3335", BMI_INIT_SERVER);
if (ret < 0)
{
fprintf(stderr, "BMI init failure.\n");
return (-1);
}
ret = BMI_open_context(&context);
if (ret < 0)
{
fprintf(stderr, "BMI_open_context() failure.\n");
return (-1);
}
ret = trove_initialize(
TROVE_METHOD_DBPF, NULL, storage_space, 0);
if (ret < 0)
{
fprintf(stderr, "initialize failed: run trove-mkfs first.\n");
return -1;
}
/* initialize the flow interface. protocol specific */
ret = PINT_flow_initialize("flowproto_bmi_cache", 0);
if (ret < 0)
{
fprintf(stderr, "flow init failure.\n");
return (-1);
}
/* try to look up collection used to store file system */
ret = trove_collection_lookup(
TROVE_METHOD_DBPF, file_system, &coll_id, NULL, &op_id);
if (ret < 0)
{
fprintf(stderr, "collection lookup failed.\n");
return -1;
}
ret = trove_open_context(coll_id, &trove_context);
if (ret < 0)
{
fprintf(stderr, "TROVE_open_context() failure.\n");
return (-1);
}
/* find the parent directory name */
strcpy(path_name, path_to_file);
for (i = strlen(path_name); i >= 0; i--)
{
if (path_name[i] != '/')
path_name[i] = '\0';
else
break;
}
file_name = path_to_file + strlen(path_name);
printf("path is %s\n", path_name);
printf("file is %s\n", file_name);
/* find the parent directory handle */
ret = path_lookup(coll_id, trove_context, path_name, &parent_handle);
if (ret < 0)
{
return -1;
}
file_handle = 0;
cur_extent.first = cur_extent.last = requested_file_handle;
extent_array.extent_count = 1;
extent_array.extent_array = &cur_extent;
ret = trove_dspace_create(coll_id,
&extent_array,
&file_handle,
TROVE_TEST_FILE,
NULL,
TROVE_FORCE_REQUESTED_HANDLE,
NULL, trove_context, &op_id, NULL);
while (ret == 0)
ret =
trove_dspace_test(coll_id, op_id, trove_context, &count, NULL, NULL,
&state, TROVE_DEFAULT_TEST_TIMEOUT);
if (ret < 0)
{
fprintf(stderr, "dspace create failed.\n");
return -1;
}
/* TODO: set attributes of file? */
/* add new file name/handle pair to parent directory */
key.buffer = file_name;
key.buffer_sz = strlen(file_name) + 1;
val.buffer = &file_handle;
val.buffer_sz = sizeof(file_handle);
ret =
trove_keyval_write(coll_id, parent_handle, &key, &val, 0, NULL, NULL,
trove_context, &op_id, NULL);
while (ret == 0)
ret =
trove_dspace_test(coll_id, op_id, trove_context, &count, NULL, NULL,
&state, TROVE_DEFAULT_TEST_TIMEOUT);
if (ret < 0)
{
fprintf(stderr, "keyval write failed.\n");
return -1;
}
/* wait for an initial communication via BMI */
/* we don't give a crap about that message except that it tells us
* where to find the client
*/
do
{
ret = BMI_testunexpected(1, &outcount, &request_info, 10);
} while (ret == 0 && outcount == 0);
if (ret < 0 || request_info.error_code != 0)
{
fprintf(stderr, "waitunexpected failure.\n");
return (-1);
}
BMI_unexpected_free(request_info.addr, request_info.buffer);
/******************************************************/
/* setup request/dist stuff */
/* request description */
/* just want one contiguous region */
ret = PVFS_Request_contiguous(TEST_SIZE, PVFS_BYTE, &req);
if (ret < 0)
{
fprintf(stderr, "PVFS_Request_contiguous() failure.\n");
return (-1);
}
/******************************************************/
/* setup communicaton stuff */
/* create a flow descriptor */
flow_d = PINT_flow_alloc();
if (!flow_d)
{
fprintf(stderr, "flow_alloc failed.\n");
return (-1);
}
/* file data */
flow_d->file_data.fsize = TEST_SIZE;
flow_d->file_data.server_nr = 0;
flow_d->file_data.server_ct = 1;
flow_d->file_data.extend_flag = 1;
flow_d->file_data.dist = PINT_dist_create("basic_dist");
if (!flow_d->file_data.dist)
{
fprintf(stderr, "Error: failed to create dist.\n");
return (-1);
}
ret = PINT_dist_lookup(flow_d->file_data.dist);
if (ret != 0)
{
fprintf(stderr, "Error: failed to lookup dist.\n");
return (-1);
}
flow_d->file_req = req;
flow_d->tag = 0;
flow_d->user_ptr = NULL;
flow_d->aggregate_size = TEST_SIZE;
/* fill in flow details */
flow_d->src.endpoint_id = BMI_ENDPOINT;
flow_d->src.u.bmi.address = request_info.addr;
flow_d->dest.endpoint_id = TROVE_ENDPOINT;
flow_d->dest.u.trove.handle = file_handle;
flow_d->dest.u.trove.coll_id = coll_id;
/***************************************************
* test bmi to file (analogous to a client side write)
*/
time1 = Wtime();
ret = block_on_flow(flow_d);
if (ret < 0)
{
return (-1);
}
time2 = Wtime();
#if 0
printf("Server bw (recv): %f MB/sec\n",
((TEST_SIZE) / ((time2 - time1) * 1000000.0)));
#endif
/*******************************************************/
/* final cleanup and output */
PINT_flow_free(flow_d);
/* shut down flow interface */
ret = PINT_flow_finalize();
if (ret < 0)
{
fprintf(stderr, "flow finalize failure.\n");
return (-1);
}
/* shut down BMI */
BMI_close_context(context);
BMI_finalize();
trove_close_context(coll_id, trove_context);
trove_finalize(TROVE_METHOD_DBPF);
gossip_disable();
return (0);
}
int main(
int argc,
char **argv)
{
struct options *user_opts = NULL;
struct server_request *my_req = NULL;
struct server_ack *my_ack = NULL;
int ret = -1;
PVFS_BMI_addr_t client_addr;
void *recv_buffer1 = NULL;
void *recv_buffer2 = NULL;
bmi_op_id_t server_ops[2];
bmi_error_code_t error_code;
int outcount = 0;
struct BMI_unexpected_info request_info;
bmi_size_t actual_size;
bmi_size_t size_list[2];
void *buffer_list[2];
int last = 0;
int i = 0;
bmi_context_id context;
char method[24], *cp;
int len;
/* grab any command line options */
user_opts = parse_args(argc, argv);
if (!user_opts)
{
return (-1);
}
/* set debugging stuff */
gossip_enable_stderr();
gossip_set_debug_mask(0, GOSSIP_BMI_DEBUG_ALL);
/* convert address to bmi method type by prefixing bmi_ */
cp = strchr(user_opts->hostid, ':');
if (!cp)
return 1;
len = cp - user_opts->hostid;
strcpy(method, "bmi_");
strncpy(method + 4, user_opts->hostid, len);
method[4+len] = '\0';
/* initialize local interface (default options) */
ret = BMI_initialize(method, user_opts->hostid, BMI_INIT_SERVER);
if (ret < 0)
{
errno = -ret;
perror("BMI_initialize");
return (-1);
}
ret = BMI_open_context(&context);
if (ret < 0)
{
errno = -ret;
perror("BMI_open_context()");
return (-1);
}
/* wait for an initial request */
do
{
ret = BMI_testunexpected(1, &outcount, &request_info, 10);
} while (ret == 0 && outcount == 0);
if (ret < 0)
{
fprintf(stderr, "Request recv failure (bad state).\n");
errno = -ret;
perror("BMI_testunexpected");
return (-1);
}
if (request_info.error_code != 0)
{
fprintf(stderr, "Request recv failure (bad state).\n");
return (-1);
}
printf("Received a new request.\n");
if (request_info.size != sizeof(struct server_request))
{
fprintf(stderr, "Bad Request!\n");
exit(-1);
}
my_req = (struct server_request *) request_info.buffer;
client_addr = request_info.addr;
/* create an ack */
my_ack = (struct server_ack *) BMI_memalloc(client_addr,
sizeof(struct server_ack),
BMI_SEND);
if (!my_ack)
{
fprintf(stderr, "BMI_memalloc failed.\n");
return (-1);
}
memset(my_ack, 0, sizeof(struct server_ack));
/* create 2 buffers to recv into */
recv_buffer1 = BMI_memalloc(client_addr, (my_req->size / 2), BMI_RECV);
recv_buffer2 = BMI_memalloc(client_addr,
(my_req->size - (my_req->size / 2)), BMI_RECV);
if (!recv_buffer1 || !recv_buffer2)
{
fprintf(stderr, "BMI_memalloc failed.\n");
return (-1);
}
buffer_list[0] = recv_buffer1;
buffer_list[1] = recv_buffer2;
size_list[0] = my_req->size / 2;
size_list[1] = my_req->size - (my_req->size / 2);
/* post the ack */
ret = BMI_post_send(&(server_ops[1]), client_addr, my_ack,
sizeof(struct server_ack), BMI_PRE_ALLOC, 0, NULL,
context, NULL);
if (ret < 0)
{
fprintf(stderr, "BMI_post_send_failure.\n");
return (-1);
}
if (ret == 0)
{
/* turning this into a blocking call for testing :) */
/* check for completion of ack send */
do
{
ret = BMI_test(server_ops[1], &outcount, &error_code,
&actual_size, NULL, 10, context);
} while (ret == 0 && outcount == 0);
if (ret < 0 || error_code != 0)
{
fprintf(stderr, "ack send failed.\n");
return (-1);
}
}
/* post the recv */
ret = BMI_post_recv_list(&(server_ops[0]), client_addr, buffer_list,
size_list, 2, my_req->size, &actual_size,
BMI_PRE_ALLOC, 0, NULL, context, NULL);
if (ret < 0)
{
fprintf(stderr, "BMI_post_recv_failure.\n");
return (-1);
}
if (ret == 0)
{
/* turning this into a blocking call for testing :) */
/* check for completion of data payload recv */
do
{
ret = BMI_test(server_ops[0], &outcount, &error_code,
&actual_size, NULL, 10, context);
} while (ret == 0 && outcount == 0);
if (ret < 0 || error_code != 0)
{
fprintf(stderr, "data recv failed.\n");
return (-1);
}
}
if (actual_size != my_req->size)
{
printf("Short recv.\n");
printf("diff: %d\n", (int) (my_req->size - actual_size));
}
/* check validity of received message */
for (i = 0; i < ((my_req->size / 2) / sizeof(int)); i++)
{
if (((int *) recv_buffer1)[i] != i)
{
fprintf(stderr, "Validation failure, offset %d.\n", i);
}
}
last = i;
for (i = last;
i < (last + ((my_req->size - (my_req->size / 2)) / sizeof(int))); i++)
{
if (((int *) recv_buffer2)[i - last] != i)
{
fprintf(stderr, "Validation failure, offset %d.\n", i);
}
}
/* free up the message buffers */
BMI_memfree(client_addr, recv_buffer1, (my_req->size / 2), BMI_RECV);
BMI_memfree(client_addr, recv_buffer2, (my_req->size -
(my_req->size / 2)), BMI_RECV);
BMI_memfree(client_addr, my_ack, sizeof(struct server_ack), BMI_SEND);
BMI_unexpected_free(client_addr, my_req);
/* shutdown the local interface */
BMI_close_context(context);
ret = BMI_finalize();
if (ret < 0)
{
errno = -ret;
perror("BMI_finalize");
return (-1);
}
/* turn off debugging stuff */
gossip_disable();
free(user_opts->hostid);
free(user_opts);
return (0);
}
int main(int argc, char **argv)
{
struct options *opts = NULL;
int ret = -1;
bmi_context_id context;
/* grab any command line options */
opts = parse_args(argc, argv);
if (!opts) {
print_usage();
return (-1);
}
/* set debugging stuff */
gossip_enable_stderr();
gossip_set_debug_mask(0, GOSSIP_BMI_DEBUG_ALL);
#ifdef WIN32
/* get performance counter frequency */
QueryPerformanceFrequency(&freq);
#endif
/* initialize local interface (default options) */
if (opts->which == SERVER)
ret = BMI_initialize(opts->method, opts->hostid, BMI_INIT_SERVER);
else
ret = BMI_initialize(NULL, NULL, 0);
if (ret < 0) {
errno = -ret;
perror("BMI_initialize");
return (-1);
}
ret = BMI_open_context(&context);
if (ret < 0) {
errno = -ret;
perror("BMI_open_context()");
return (-1);
}
if (opts->which == SERVER) {
ret = do_server(opts, &context);
} else {
ret = do_client(opts, &context);
}
/* shutdown the local interface */
BMI_close_context(context);
ret = BMI_finalize();
if (ret < 0) {
errno = -ret;
perror("BMI_finalize");
return (-1);
}
/* turn off debugging stuff */
gossip_disable();
return (0);
}
int main(int argc, char **argv)
{
PINT_llist *cur = NULL;
struct server_configuration_s serverconfig;
struct host_alias_s *cur_alias;
struct filesystem_configuration_s *cur_fs = NULL;
int alias_count = 1;
if (argc != 3)
{
printf("Usage: %s <fs.conf> <server-alias>\n",argv[0]);
return 1;
}
gossip_enable_stderr();
memset(&serverconfig,0,sizeof(serverconfig));
if (PINT_parse_config(&serverconfig, argv[1], argv[2], 1))
{
printf("Failed to parse config files\n");
return 1;
}
/* dump all gathered config values */
fprintf(stderr,"--- Printing filesystem configuration\n\n");
fprintf(stderr,"Server ID : %s\n",
serverconfig.host_id);
fprintf(stderr,"Data Storage Space : %s\n",
serverconfig.data_path);
fprintf(stderr,"Meta Storage Space : %s\n",
serverconfig.meta_path);
fprintf(stderr,"FS Config File Name : %s (%d bytes)\n",
serverconfig.fs_config_filename,
(int)serverconfig.fs_config_buflen);
fprintf(stderr,"Initial Unexp Requests : %d\n",
serverconfig.initial_unexpected_requests);
fprintf(stderr,"Configured Log File : %s\n",
serverconfig.logfile);
fprintf(stderr,"Configured FlowModules : %s\n",
serverconfig.flow_modules);
fprintf(stderr,"Configured BMIModules : %s\n",
serverconfig.bmi_modules);
fprintf(stderr,"Event Logging Mask String: %s\n",
serverconfig.event_logging);
fprintf(stderr,"\n--- Host Aliases (alias => address):\n");
cur = serverconfig.host_aliases;
while(cur)
{
cur_alias = PINT_llist_head(cur);
if (!cur_alias)
{
break;
}
fprintf(stderr,"%.2d) %s => %s\n", alias_count++,
cur_alias->host_alias, cur_alias->bmi_address);
cur = PINT_llist_next(cur);
}
fprintf(stderr,"\n");
cur = serverconfig.file_systems;
while(cur)
{
cur_fs = PINT_llist_head(cur);
if (!cur_fs)
{
break;
}
print_filesystem_configuration(cur_fs);
cur = PINT_llist_next(cur);
}
fprintf(stderr,"\n--- Analyzing filesystem configuration\n\n");
if (PINT_config_is_valid_configuration(&serverconfig))
{
fprintf(stderr,"\nOK: Configuration file is VALID\n");
}
else
{
fprintf(stderr,"\nERROR: Configuration file is INVALID\n");
}
PINT_config_release(&serverconfig);
gossip_disable();
return 0;
}
int main(
int argc,
char **argv)
{
int ret = -1;
int outcount = 0;
void *mybuffer;
PVFS_BMI_addr_t server_addr;
bmi_op_id_t op;
bmi_error_code_t error_code;
flow_descriptor *flow_d = NULL;
int i = 0;
bmi_size_t actual_size;
double time1, time2;
PINT_Request *req;
bmi_context_id context;
/*************************************************************/
/* initialization stuff */
/* set debugging level */
gossip_enable_stderr();
gossip_set_debug_mask(
0, (GOSSIP_FLOW_PROTO_DEBUG | GOSSIP_BMI_DEBUG_TCP));
/* Dist init */
PINT_dist_initialize(NULL);
/* start up BMI */
ret = BMI_initialize("bmi_tcp", NULL, 0);
if (ret < 0)
{
fprintf(stderr, "BMI init failure.\n");
return (-1);
}
ret = BMI_open_context(&context);
if (ret < 0)
{
fprintf(stderr, "BMI_open_context() failure.\n");
return (-1);
}
/* initialize the flow interface */
ret = PINT_flow_initialize("flowproto_multiqueue", 0);
if (ret < 0)
{
fprintf(stderr, "flow init failure.\n");
return (-1);
}
/* send some random crap to the other side to start up communication */
ret = BMI_addr_lookup(&server_addr, "tcp://localhost:3335");
if (ret < 0)
{
fprintf(stderr, "BMI lookup failure.\n");
return (-1);
}
ret = BMI_post_sendunexpected(&op, server_addr, &mybuffer, 1,
BMI_EXT_ALLOC, 0, NULL, context, NULL);
if (ret < 0)
{
fprintf(stderr, "BMI_post_sendunexpected failure.\n");
return (-1);
}
if (ret == 0)
{
/* turning this into a blocking call for testing :) */
/* check for completion of request */
do
{
ret = BMI_test(op, &outcount, &error_code, &actual_size,
NULL, 10, context);
} while (ret == 0 && outcount == 0);
if (ret < 0 || error_code != 0)
{
fprintf(stderr, "Request send failed.\n");
if (ret < 0)
{
errno = -ret;
perror("BMI_test");
}
return (-1);
}
}
/******************************************************/
/* setup request/dist stuff */
/* request description */
/* just want one contiguous region */
ret = PVFS_Request_contiguous(TEST_SIZE, PVFS_BYTE, &req);
if (ret < 0)
{
fprintf(stderr, "PVFS_Request_contiguous() failure.\n");
return (-1);
}
/******************************************************/
/* setup communicaton stuff */
/* memory buffer to xfer */
mybuffer = (void *) malloc(TEST_SIZE);
if (!mybuffer)
{
fprintf(stderr, "mem.\n");
return (-1);
}
/* mark it so that we can check correctness */
for (i = 0; i < (TEST_SIZE / (sizeof(int))); i++)
{
((int *) mybuffer)[i] = i;
}
/* create a flow descriptor */
flow_d = PINT_flow_alloc();
if (!flow_d)
{
fprintf(stderr, "mem.\n");
return (-1);
}
/* file data */
flow_d->file_data.fsize = TEST_SIZE;
flow_d->file_data.server_nr = 0;
flow_d->file_data.server_ct = 1;
flow_d->file_data.extend_flag = 0;
flow_d->file_data.dist = PINT_dist_create("basic_dist");
if (!flow_d->file_data.dist)
{
fprintf(stderr, "Error: failed to create dist.\n");
return (-1);
}
ret = PINT_dist_lookup(flow_d->file_data.dist);
if (ret != 0)
{
fprintf(stderr, "Error: failed to lookup dist.\n");
return (-1);
}
flow_d->file_req = req;
flow_d->tag = 0;
flow_d->user_ptr = NULL;
flow_d->aggregate_size = TEST_SIZE;
/* fill in flow details */
flow_d->src.endpoint_id = MEM_ENDPOINT;
flow_d->src.u.mem.buffer = mybuffer;
flow_d->dest.endpoint_id = BMI_ENDPOINT;
flow_d->dest.u.bmi.address = server_addr;
/***************************************************
* test memory to bmi (analogous to client side write)
*/
time1 = Wtime();
ret = block_on_flow(flow_d);
if (ret < 0)
{
return (-1);
}
time2 = Wtime();
/*******************************************************/
/* final cleanup and output */
#if 0
printf("Client bw (send): %f MB/sec\n",
((TEST_SIZE) / ((time2 - time1) * 1000000.0)));
#endif
PINT_flow_free(flow_d);
/* shut down flow interface */
ret = PINT_flow_finalize();
if (ret < 0)
{
fprintf(stderr, "flow finalize failure.\n");
return (-1);
}
/* shut down BMI */
BMI_close_context(context);
BMI_finalize();
free(mybuffer);
gossip_disable();
return (0);
}