static int
init_flash(struct sdf_agent_state *state)
{
char *device_name;
int flash_flags = 0;
// Allocate space for the Mcd_containers array
Mcd_containers = (mcd_container_t *) plat_alloc(sizeof(mcd_container_t) * max_num_containers);
memset(Mcd_containers, 0, sizeof(*Mcd_containers) * max_num_containers);
/* This initializes the code that redirects
* flash API calls to one of several alternative
* flash subsystems (see sdf/ssd).
*/
#ifdef ENABLE_MULTIPLE_FLASH_SUBSYSTEMS
ssd_Init();
#endif
#ifdef FLASH_RECOVERY
flash_flags = FLASH_OPEN_PERSISTENCE_AVAILABLE;
#endif
switch(state->config.system_recovery) {
case SYS_FLASH_RECOVERY:
default:
flash_flags |= FLASH_OPEN_NORMAL_RECOVERY;
break;
case SYS_FLASH_REFORMAT:
flash_flags |= FLASH_OPEN_REFORMAT_DEVICE;
break;
}
#ifdef MULTIPLE_FLASH_DEV_ENABLED
int ii;
for(ii=0; ii < state->config.numFlashDevs; ii++) {
if (plat_asprintf(&device_name, "%s%d", state->config.flashDevName, ii) > 0) {
state->flash_dev[ii] = (flashDev_t *)NULL;
state->flash_dev[ii] = flashOpen(device_name, &state->flash_settings, flash_flags);
plat_assert(state->flash_dev[ii]);
plat_free(device_name);
}
}
/* All the /dev/flash names have been converted to /dev/flash0
even in signle flashcard machines. So no need to handle single
card case separately */
#else
state->flash_dev = NULL;
if (strstr(state->config.flashDevName, "%")) {
if (plat_asprintf(&device_name, state->config.flashDevName,
(int)state->rank) > 0) {
state->flash_dev = flashOpen(device_name, &state->flash_settings, flash_flags);
plat_assert(state->flash_dev);
plat_free(device_name);
}
} else {
if (plat_asprintf(&device_name, "%s%d", state->config.flashDevName, 0) > 0) {
state->flash_dev = flashOpen(device_name, &state->flash_settings, flash_flags);
plat_assert(state->flash_dev);
plat_free(device_name);
}
}
#endif // MULTI_FLASH_DEV_ENABLED
state->flash_dev_count = state->config.numFlashDevs;
return (state->flash_dev != NULL);
}
/**
* @brief synchronized create_shard/write/read/delete/delete_shard operations
*/
void
rt_mix_write_delete_entry(uint64_t args) {
struct replication_test_framework *test_framework =
(struct replication_test_framework *)args;
SDF_boolean_t op_ret;
struct SDF_shard_meta *shard_meta = NULL;
SDF_replication_props_t *replication_props = NULL;
int failed;
SDF_shardid_t shard_id;
replication_test_framework_read_data_free_cb_t free_cb;
shard_id = __sync_add_and_fetch(&test_framework->max_shard_id, 1);
char key1[] = "key1";
char key2[] = "key2";
char *key;
size_t key_len;
char *data;
void *data_out;
size_t data_len_out;
int data_generation;
failed = !plat_calloc_struct(&meta);
plat_assert(!failed);
replication_test_meta_init(meta);
/* Assure test_framework is started?! */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "start test_framework");
rtfw_start(test_framework);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "test_framework started\n");
/* Start all nodes */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "start nodes");
rtfw_start_all_nodes(test_framework);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "nodes started");
failed = !plat_calloc_struct(&replication_props);
plat_assert(!failed);
rtfw_set_default_replication_props(&test_framework->config,
replication_props);
shard_meta = rtfw_init_shard_meta(&test_framework->config, 1 /* first */,
shard_id
/* shard_id, in real system generated by generate_shard_ids() */,
replication_props);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "create on node 1");
op_ret = rtfw_create_shard_sync(test_framework, 1, shard_meta);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "create on node 1 complete");
plat_assert(op_ret == SDF_SUCCESS);
data_generation = 0;
plat_asprintf(&data, "data_%s_%d", key1, data_generation);
key = key1;
key_len = strlen(key) + 1;
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"write on node 1 key:%s, key_len:%u, data:%s, data_len:%u",
key, (int)(strlen(key)), data, (int)(strlen(data)));
op_ret = rtfw_write_sync(test_framework, shard_id /* shard */, 1 /* node */,
meta /* test_meta */, key, key_len, data,
strlen(data)+1);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "write on node 1 complete");
plat_assert(op_ret == SDF_SUCCESS);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "read on node 1");
op_ret = rtfw_read_sync(test_framework, shard_id, 1 /* node */, key,
key_len, &data_out, &data_len_out, &free_cb);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "read on node 1 complete");
plat_assert(op_ret == SDF_SUCCESS);
plat_assert(strcmp(data_out, data) == 0);
plat_closure_apply(replication_test_framework_read_data_free_cb, &free_cb,
data_out, data_len_out);
++ data_generation;
plat_asprintf(&data, "data_%s_%d", key2, data_generation);
key = key2;
key_len = strlen(key) + 1;
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"write on node 1 key:%s, key_len:%u, data:%s, data_len:%u",
key, (int)(strlen(key)), data, (int)(strlen(data)));
op_ret = rtfw_write_sync(test_framework, shard_id /* shard */, 1 /* node */,
meta /* test_meta */, key, key_len, data,
strlen(data)+1);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "write on node 1 complete");
plat_assert(op_ret == SDF_SUCCESS);
key = key2;
key_len = strlen(key) + 1;
op_ret = rtfw_delete_sync(test_framework, shard_id, 1, key, key_len);
plat_assert(op_ret == SDF_SUCCESS);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "crash node 1");
op_ret = rtfw_crash_node_sync(test_framework, 1);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "crash node 1 complete");
plat_assert(op_ret == SDF_SUCCESS);
/* Sleep through the lease until switchover happens */
rtfw_sleep_usec(test_framework,
test_framework->config.replicator_config.lease_usecs * 2);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "shutdown");
rtfw_shutdown_sync(test_framework);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "shutdown complete");
plat_free(data);
plat_free(meta);
plat_free(replication_props);
plat_free(shard_meta);
/* Terminate scheduler if idle_thread exit */
while (test_framework->timer_dispatcher) {
fthYield(-1);
}
plat_free(test_framework);
fthKill(1);
}
/**
* @brief synchronized create_shard/write/read/delete/delete_shard operations
*/
void
user_operations_cursor_test(uint64_t args) {
struct replication_test_framework *test_framework =
(struct replication_test_framework *)args;
SDF_boolean_t op_ret = SDF_FALSE;
struct SDF_shard_meta *shard_meta = NULL;
SDF_replication_props_t *replication_props = NULL;
int failed = 0;
uint64_t seqno = 0;
SDF_shardid_t shard_id = 2;
vnode_t node_id = 1;
struct timeval now;
struct timeval when;
/* timeval incre */
struct timeval incre;
void *data_read;
size_t data_read_len;
uint64_t seqno_start, seqno_len, seqno_max;
int i;
int ncursors;
it_cursor_t *pit;
resume_cursor_t *prc = NULL;
char skey[1024];
SDF_time_t exptime;
SDF_time_t createtime;
int key_len;
size_t data_len;
void *pdata;
int resume_cursor_size = 0;
char *pcur;
shard_id = __sync_add_and_fetch(&test_framework->max_shard_id, 1);
char *key;
char *data;
failed = !plat_calloc_struct(&meta);
replication_test_meta_init(meta);
/* Assure test_framework is started?! */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "start test_framework");
rtfw_start(test_framework);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "test_framework started\n");
/* Start all nodes */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "start nodes");
rtfw_start_all_nodes(test_framework);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "nodes started");
plat_assert(!failed);
failed = !plat_calloc_struct(&replication_props);
plat_assert(!failed);
rtfw_set_default_replication_props(&test_framework->config, replication_props);
shard_meta = rtfw_init_shard_meta(&test_framework->config,
1 /* first_node */,
shard_id
/* shard_id, in real system generated by generate_shard_ids() */,
replication_props);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n**************************************************\n"
" create shard sync "
"\n**************************************************");
op_ret = rtfw_create_shard_sync(test_framework, 1, shard_meta);
plat_assert(op_ret == SDF_SUCCESS);
/* - write on node 1, key:google:1, data:Sebstian:1 */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n**************************************************\n"
" write object sync "
"\n**************************************************");
plat_asprintf(&key, "google:%d", 1);
plat_asprintf(&data, "Sebstian:%d", 1);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"write key:%s, key_len:%u, data:%s, data_len:%u",
key, (int)(strlen(key)), data, (int)(strlen(data)));
op_ret = rtfw_write_sync(test_framework,
shard_id /* shard */, 1 /* node */,
meta /* test_meta */,
key, strlen(key)+1, data, strlen(data)+1);
plat_assert(op_ret == SDF_SUCCESS);
plat_free(key);
plat_free(data);
/* - read on node 1, key:google:1 */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n**************************************************\n"
" read object sync "
"\n**************************************************");
replication_test_framework_read_data_free_cb_t free_cb =
replication_test_framework_read_data_free_cb_create(PLAT_CLOSURE_SCHEDULER_ANY_OR_SYNCHRONOUS,
&rtfw_read_free,
test_framework);
plat_asprintf(&key, "google:%d", 1);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"KEY:%s, key_len:%d", key, (int)strlen(key));
op_ret = rtfw_read_sync(test_framework, shard_id /* shard */, node_id /* node */, key, strlen(key) + 1,
&data_read, &data_read_len, &free_cb);
plat_free(key);
plat_assert(op_ret == SDF_SUCCESS);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"read data:%s, data_len:%d", (char *)data_read, (int)data_read_len);
plat_free(data_read);
/* crash node 2 */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n**************************************************\n"
" crash node 2 sync "
"\n**************************************************");
rtfw_crash_node_sync(test_framework, 2);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"crash node:%"PRIu32" complete", 2);
/**
* write on node 1, key2: google:2, data2: Sebstian:2,
* key3: google:3, data3: Sebstian:3
*/
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n**************************************************\n"
" write object sync "
"\n**************************************************");
plat_asprintf(&key, "google:%d", 2);
plat_asprintf(&data, "Sebstian:%d", 2);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"write key:%s, key_len:%u, data:%s, data_len:%u",
key, (int)(strlen(key)), data, (int)(strlen(data)));
op_ret = rtfw_write_sync(test_framework,
shard_id /* shard */, 1 /* node */,
meta /* test_meta */,
key, strlen(key)+1, data, strlen(data)+1);
plat_assert(op_ret == SDF_SUCCESS);
plat_free(key);
plat_free(data);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n**************************************************\n"
" write object sync "
"\n**************************************************");
plat_asprintf(&key, "google:%d", 3);
plat_asprintf(&data, "Sebstian:%d", 3);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"write key:%s, key_len:%u, data:%s, data_len:%u",
key, (int)(strlen(key)), data, (int)(strlen(data)));
op_ret = rtfw_write_sync(test_framework,
shard_id /* shard */, 1 /* node */,
meta /* test_meta */,
key, strlen(key)+1, data, strlen(data)+1);
plat_assert(op_ret == SDF_SUCCESS);
plat_free(key);
plat_free(data);
/* read on node 1, key2: google:2 */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n**************************************************\n"
" read object sync "
"\n**************************************************");
plat_asprintf(&key, "google:%d", 2);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"KEY:%s, key_len:%d", key, (int)strlen(key));
op_ret = rtfw_read_sync(test_framework, shard_id /* shard */, 1 /* node */, key, strlen(key) + 1,
&data_read, &data_read_len, &free_cb);
plat_free(key);
plat_assert(op_ret == SDF_SUCCESS);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"read data:%s, data_len:%d", (char *)data_read, (int)data_read_len);
plat_free(data_read);
/* delete from node 1, key3: google3 */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n***************************************************\n"
" delete object sync "
"\n***************************************************");
plat_asprintf(&key, "google:%d", 3);
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"KEY:%s, key_len:%d", key, (int)(strlen(key)));
op_ret = rtfw_delete_sync(test_framework, shard_id /* shard */, 1 /* node */, key, strlen(key)+1);
plat_assert(op_ret == SDF_SUCCESS);
plat_free(key);
/* restart node 2 */
op_ret = rtfw_start_node(test_framework, 2);
plat_assert(op_ret == SDF_SUCCESS);
/* block a while */
now = test_framework->now;
incre.tv_sec = 10;
incre.tv_usec = 0;
timeradd(&now, &incre, &when);
rtfw_block_until(test_framework, (const struct timeval)when);
rtfw_sleep_usec(test_framework, SLEEP_US);
/* get last seqno from node 2 */
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n************************************************************\n"
" get latest seqno from node 2 "
"\n************************************************************");
op_ret = rtfw_get_last_seqno_sync(test_framework, 2, shard_id, &seqno);
if (op_ret == SDF_SUCCESS) {
plat_log_msg(LOG_ID, LOG_CAT, LOG_INFO, "get_last_seqno succeeded! (seqno=%"PRIu64")", seqno);
} else {
plat_log_msg(LOG_ID, LOG_CAT, LOG_INFO, "get_last_seqno failed!");
}
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n************************************************************\n"
" get iteration cursors "
"\n************************************************************");
prc = NULL;
resume_cursor_size = 0;
while (1) {
replication_test_framework_read_data_free_cb_t free_cb =
replication_test_framework_read_data_free_cb_create(PLAT_CLOSURE_SCHEDULER_ANY_OR_SYNCHRONOUS,
&rtfw_read_free,
test_framework);
seqno_start = 0;
seqno_len = 10;
seqno_max = UINT64_MAX - 1;
op_ret = rtfw_get_cursors_sync(test_framework, shard_id, node_id,
seqno_start, seqno_len, seqno_max,
(void *) prc, resume_cursor_size,
(void **) &pit, &data_len, &free_cb);
if (op_ret != SDF_SUCCESS) {
plat_log_msg(LOG_ID, LOG_CAT, LOG_INFO, "get_iteration_cursors failed!");
break;
} else {
ncursors = pit->cursor_count;
if (ncursors == 0) {
break;
}
prc = &(pit->resume_cursor);
resume_cursor_size = sizeof(resume_cursor_t);
plat_assert(data_len == (sizeof(it_cursor_t) + seqno_len*pit->cursor_len));
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG, "get_iteration_cursors succeeded (%d cursors returned)!", ncursors);
pcur = pit->cursors;
for (i = 0; i < ncursors; i++) {
replication_test_framework_read_data_free_cb_t free_cb =
replication_test_framework_read_data_free_cb_create(PLAT_CLOSURE_SCHEDULER_ANY_OR_SYNCHRONOUS,
&rtfw_read_free,
test_framework);
op_ret = rtfw_get_by_cursor_sync(test_framework, shard_id, node_id,
(void *) pcur, pit->cursor_len,
skey, 1024, &key_len,
&exptime, &createtime, &seqno,
&pdata, &data_len, &free_cb);
pcur += pit->cursor_len;
if (op_ret == SDF_SUCCESS) {
plat_log_msg(LOG_ID, LOG_CAT, LOG_TRACE,
"get_by_cursor: %s, key_len:%u, data:%s, data_len:%u,"
"seqno: %"PRIu64", exptime:%"PRIu32", createtime:%"PRIu32"",
skey, key_len, (char *)pdata, (unsigned)data_len,
seqno, exptime, createtime);
plat_free(pdata);
} else {
plat_log_msg(LOG_ID, LOG_CAT, LOG_INFO, "get_by_cursor failed!");
}
}
}
}
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n************************************************************\n"
" Test framework shutdown "
"\n************************************************************");
rtfw_shutdown_sync(test_framework);
plat_log_msg(LOG_ID, LOG_CAT, LOG_DBG,
"\n************************************************************\n"
" Test framework sync summary "
"\n************************************************************");
plat_free(meta);
plat_free(replication_props);
plat_free(shard_meta);
/* Terminate scheduler if idle_thread exit */
while (test_framework->timer_dispatcher) {
fthYield(-1);
}
plat_free(test_framework);
fthKill(1);
}
