void hash_table_destroy(HashTable* ht)
{
size_t i;
for(i = 0; i < ht->size; i++) {
if(ht->buckets[i] != NULL) {
Bucket *b = ht->buckets[i];
while(b != NULL) {
free(b->key);
var_destroy(b->value);
free(b);
b = b->next;
}
}
}
/* free the buckets pointer */
free(ht->buckets);
/* finally free the HashTable struct */
free(ht);
}
int main(int argc, char **argv)
{
var_init();
yyparse();
var_destroy();
yylex_destroy();
return (0);
}
PHPAPI void php_var_unserialize_destroy(php_unserialize_data_t d) {
/* fprintf(stderr, "UNSERIALIZE_DESTROY == lock: %u, level: %u\n", BG(serialize_lock), BG(unserialize).level); */
if (BG(serialize_lock) || BG(unserialize).level == 1) {
var_destroy(&d);
efree(d);
}
if (!BG(serialize_lock) && !--BG(unserialize).level) {
BG(unserialize).data = NULL;
}
}
/*
* Expand an input line and return it.
*
* Returns: 0 on failure
* 1 on success and exp has expanded input
*/
int variable_expansion(JCR *jcr, char *inp, POOLMEM *&exp)
{
var_t *var_ctx;
var_rc_t status;
char *outp;
int in_len, out_len;
int rtn_stat = 0;
in_len = strlen(inp);
outp = NULL;
out_len = 0;
/*
* Create context
*/
if ((status = var_create(&var_ctx)) != VAR_OK) {
Jmsg(jcr, M_ERROR, 0, _("Cannot create var context: ERR=%s\n"), var_strerror(var_ctx, status));
goto bail_out;
}
/*
* Define callback
*/
if ((status = var_config(var_ctx, VAR_CONFIG_CB_VALUE, lookup_var, (void *)jcr)) != VAR_OK) {
Jmsg(jcr, M_ERROR, 0, _("Cannot set var callback: ERR=%s\n"), var_strerror(var_ctx, status));
goto bail_out;
}
/*
* Define special operations
*/
if ((status = var_config(var_ctx, VAR_CONFIG_CB_OPERATION, operate_var, (void *)jcr)) != VAR_OK) {
Jmsg(jcr, M_ERROR, 0, _("Cannot set var operate: ERR=%s\n"), var_strerror(var_ctx, status));
goto bail_out;
}
/*
* Unescape in place
*/
if ((status = var_unescape(var_ctx, inp, in_len, inp, in_len+1, 0)) != VAR_OK) {
Jmsg(jcr, M_ERROR, 0, _("Cannot unescape string: ERR=%s\n"), var_strerror(var_ctx, status));
goto bail_out;
}
in_len = strlen(inp);
/*
* Expand variables
*/
if ((status = var_expand(var_ctx, inp, in_len, &outp, &out_len, 0)) != VAR_OK) {
Jmsg(jcr, M_ERROR, 0, _("Cannot expand expression \"%s\": ERR=%s\n"), inp, var_strerror(var_ctx, status));
goto bail_out;
}
/*
* Unescape once more in place
*/
if ((status = var_unescape(var_ctx, outp, out_len, outp, out_len+1, 1)) != VAR_OK) {
Jmsg(jcr, M_ERROR, 0, _("Cannot unescape string: ERR=%s\n"), var_strerror(var_ctx, status));
goto bail_out;
}
pm_strcpy(exp, outp);
rtn_stat = 1;
bail_out:
/*
* Destroy expansion context
*/
if ((status = var_destroy(var_ctx)) != VAR_OK) {
Jmsg(jcr, M_ERROR, 0, _("Cannot destroy var context: ERR=%s\n"), var_strerror(var_ctx, status));
}
if (outp) {
free(outp);
}
return rtn_stat;
}
void hash_table_delete_element(HashTable* ht, char* key, size_t key_len)
{
uint32_t hashed_value = do_hash(key, key_len);
size_t hashed_index = hashed_value % ht->size;
Bucket* curr = ht->buckets[hashed_index];
Bucket* prev = NULL;
while(curr != NULL) {
prev = curr;
if((curr->hash == hashed_value) && (curr->key_len == key_len) && (memcmp(curr->key, key, key_len) == 0)) {
/* head of list */
if(curr == ht->buckets[hashed_index]) {
/* there is only one node in the list */
if(curr->next == NULL) {
var_destroy(curr->value);
free(curr->key);
free(curr);
ht->num_elements--;
ht->buckets[hashed_index] = NULL;
return;
} else {
/* there is a next node in list */
/* store the next node */
var_destroy(curr->value);
free(curr->key);
free(curr);
prev = curr->next;
ht->buckets[hashed_index] = prev;
ht->num_elements--;
return;
}
} else {
/* curr is not the head of the list */
/* now, get the node before the curr node */
Bucket* b = ht->buckets[hashed_index];
while(b->next != NULL && b->next != curr) {
b = b->next;
}
/* b->next is curr */
b->next = b->next->next;
var_destroy(curr->value);
free(curr->key);
free(curr);
ht->buckets[hashed_index] = b;
ht->num_elements--;
return;
}
}
curr = curr->next;
}
}
static void ExecuteStatement(GNode* node, gpointer data)
{
Statement* stmt = (Statement*) node->data;
Verbose("* Visiting GNode at level %d", g_node_depth(node));
if (parseOnly && (stmt->type < STMT_REPEAT)) return;
switch (stmt->type) {
case STMT_ASSIGN: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
gchar* varident = param_string_get(paramList, 0, &status[0]);
Expression* expression = param_index_get(paramList, 1);
// evaluator error check
if (status[0] != STATUS_EVAL_OK) {
Error("Malicious assign parameters! (status = %s)", expr_status_to_string(status[0]));
}
switch (expression->type) {
case EXPR_RICH_INT:
case EXPR_CONSTANT_INT: {
Verbose("~ Executing STMT_ASSIGN: variable = %s, type = INT", varident);
glong result = param_int_get(paramList, 1, &status[1]);
// evaluator error check
if (status[1] != STATUS_EVAL_OK) {
Error("Malicious assign parameters! (status = %s)", expr_status_to_string(status[1]));
}
var_set_value(varident, VAR_INT, &result);
break;
}
case EXPR_RICH_STRING:
case EXPR_CONSTANT_STRING: {
Verbose("~ Executing STMT_ASSIGN: variable = %s, type = STRING", varident);
gchar* result_raw = param_string_get(paramList, 1, &status[1]);
// evaluator error check
if (status[1] != STATUS_EVAL_OK) {
Error("Malicious assign parameters! (status = %s)", expr_status_to_string(status[1]));
}
gchar* result = var_replace_substrings(result_raw);
var_set_value(varident, VAR_STRING, result);
g_free(result_raw);
g_free(result);
break;
}
default: Error("Expression type %d not supported in assign statement!\n", expression->type);
}
g_free(varident);
break;
}
case STMT_REPEAT: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
gchar* varident = param_string_get(paramList, 0, &status[0]);
glong i, loopCount = param_int_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_REPEAT: variable = %s, loopCount = %ld", varident, loopCount);
g_assert(loopCount >= 0);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious repeat parameters! (%s:%d)", __FILE__, __LINE__);
}
for (i=0; i<loopCount; i++) {
var_set_value(varident, VAR_INT, &i);
g_node_children_foreach(node, G_TRAVERSE_ALL, &ExecuteStatement, NULL);
}
var_destroy(varident);
g_free(varident);
break;
}
case STMT_TIME: {
Verbose("~ Executing STMT_TIME: label = %s", stmt->label);
static gint timeId = 0;
gdouble time;
GTimer* timer = g_timer_new();
g_node_children_foreach(node, G_TRAVERSE_ALL, &ExecuteStatement, NULL);
g_timer_stop(timer);
time = g_timer_elapsed(timer, NULL);
g_timer_destroy(timer);
gchar* label = var_replace_substrings(stmt->label);
timeList = g_slist_prepend(timeList, timeevent_new(timeId++, label, time));
g_free(label);
break;
}
case STMT_CTIME: {
Verbose("~ Executing STMT_CTIME: label = %s", stmt->label);
static gint coreTimeId = 0;
gchar* label = var_replace_substrings(stmt->label);
CoreTimeEvent* coreTimeEvent = coretime_event_new(coreTimeId++, label, coretime_new(0, 0));
coreTimeStack = g_list_prepend(coreTimeStack, coreTimeEvent);
g_node_children_foreach(node, G_TRAVERSE_ALL, &ExecuteStatement, NULL);
coreTimeList = g_slist_prepend(coreTimeList, coreTimeEvent);
coreTimeStack = g_list_remove_link(coreTimeStack, g_list_first(coreTimeStack));
g_free(label);
break;
}
#ifdef HAVE_MPI
case STMT_GROUP: {
Verbose("~ Executing STMT_GROUP: group = %s", stmt->label);
GroupBlock* groupBlock = g_hash_table_lookup(groupMap, stmt->label);
if(groupBlock && groupBlock->member) {
groupStack = g_list_prepend(groupStack, groupBlock);
g_node_children_foreach(node, G_TRAVERSE_ALL, &ExecuteStatement, NULL);
groupStack = g_list_remove_link(groupStack, g_list_first(groupStack));
}
else if(!groupBlock) {
backtrace(stmt);
Error("Group \"%s\" doesn't exist!", stmt->label);
}
break;
}
case STMT_MASTER: {
GroupBlock* groupBlock;
MPI_Comm comm = MPI_COMM_WORLD;
if(groupStack) {
groupBlock = (GroupBlock*) g_list_first(groupStack)->data;
comm = groupBlock->mpicomm;
}
gint groupRank;
MPI_ASSERT(MPI_Comm_rank(comm, &groupRank), "Master Statement", TRUE)
if(groupStack) Verbose("~ Executing STMT_MASTER: rank = %d, type = implicit group", groupRank);
else Verbose("~ Executing STMT_MASTER: rank = %d, type = world", groupRank);
if(groupRank == MASTER) {
g_node_children_foreach(node, G_TRAVERSE_ALL, &ExecuteStatement, NULL);
}
else Verbose("Im not the master here... groupRank = %d", groupRank);
break;
}
case STMT_BARRIER: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* groupName = param_string_get_optional(paramList, 0, &status[0], NULL);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
GroupBlock* groupBlock = groupblock_get(groupName);
if(groupName) Verbose("~ Executing STMT_BARRIER: type = explicit group, name = %s", groupName);
else Verbose("~ Executing STMT_BARRIER: type = implicit active group");
MPI_ASSERT(MPI_Barrier(groupBlock->mpicomm), "Barrier Statement", TRUE)
g_free(groupName);
break;
}
#endif
case STMT_SLEEP: {
if (agileMode) return;
Verbose("~ Executing STMT_SLEEP");
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
glong time = param_int_get(paramList, 0, &status[0]);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
g_usleep(time);
//sleep(time);
break;
}
case STMT_BLOCK: {
Verbose("~ Executing STMT_BLOCK");
g_node_children_foreach(node, G_TRAVERSE_ALL, &ExecuteStatement, NULL);
break;
}
case STMT_PRINT: {
Verbose("~ Executing STMT_PRINT");
ParameterList* paramList = stmt->parameters;
GString* buffer = g_string_new("");
ExpressionStatus status;
gint i;
for (i=0; i<paramList->len; i++) {
gchar* string = param_string_get(paramList, i, &status);
if (status == STATUS_EVAL_OK) {
g_string_append(buffer, string);
g_free(string);
if (i < (paramList->len-1))
g_string_append(buffer, " ");
}
else {
backtrace(stmt);
Error("Error during print parameter evaluation (index=%d, status=%s).\n",
i, expr_status_to_string(status));
}
}
gchar* processed = var_replace_substrings(buffer->str);
g_printf("[%d] %s\n", rank, processed);
g_free(processed);
g_string_free(buffer, TRUE);
break;
}
case STMT_FCREAT: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
gchar* fhname = param_string_get(paramList, 0, &status[0]);
gchar* fname_raw = param_string_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_FCREAT: fhname = %s, fname = %s", fhname, fname_raw);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
File* file;
IOStatus ioStatus = iio_fcreat(fname, &file);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success) {
Verbose(" > file = %p", file);
var_set_value(fhname, VAR_FILE, &file);
statementsSucceed[STMT_FCREAT]++;
}
else
statementsFail[STMT_FCREAT]++;
g_free(fhname);
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_FOPEN: {
ExpressionStatus status[3];
ParameterList* paramList = stmt->parameters;
gchar* fhname = param_string_get(paramList, 0, &status[0]);
gchar* fname_raw = param_string_get(paramList, 1, &status[1]);
gint flags = param_int_get(paramList, 2, &status[2]);
Verbose("~ Executing STMT_FOPEN: fhname = %s, fname = %s, flags = %d", fhname, fname_raw, flags);
// evaluator error check
if (!expr_status_assert(status, 3)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
File* file;
IOStatus ioStatus = iio_fopen(fname, flags, &file);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success) {
Verbose(" > file = %p", file);
var_set_value(fhname, VAR_FILE, &file);
statementsSucceed[STMT_FOPEN]++;
}
else
statementsFail[STMT_FOPEN]++;
g_free(fhname);
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_FCLOSE: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_FCLOSE: file = %p", file);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
g_assert(file);
IOStatus ioStatus = iio_fclose(file);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success) {
gchar* fhname = (gchar*) param_value_get(paramList, 0);
var_destroy(fhname);
statementsSucceed[STMT_FCLOSE]++;
}
else
statementsFail[STMT_FCLOSE]++;
break;
}
case STMT_FREAD: {
ExpressionStatus status[3];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
glong dataSize = param_int_get_optional(paramList, 1, &status[1], READALL);
glong offset = param_int_get_optional(paramList, 2, &status[2], OFFSET_CUR);
Verbose("~ Executing STMT_FREAD: file = %p, dataSize = %ld, offset = %ld", file, dataSize, offset);
// evaluator error check
if (!expr_status_assert(status, 3)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
IOStatus ioStatus = iio_fread(file, dataSize, offset);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_FREAD]++;
else
statementsFail[STMT_FREAD]++;
break;
}
case STMT_FWRITE: {
ExpressionStatus status[3];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
glong dataSize = param_int_get(paramList, 1, &status[1]);
glong offset = param_int_get_optional(paramList, 2, &status[2], -1);
Verbose("~ Executing STMT_FWRITE: file = %p, dataSize = %ld, offset = %ld", file, dataSize, offset);
// evaluator error check
if (!expr_status_assert(status, 3)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
IOStatus ioStatus = iio_fwrite(file, dataSize, offset);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_FWRITE]++;
else
statementsFail[STMT_FWRITE]++;
break;
}
case STMT_FSEEK: {
ExpressionStatus status[3];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
glong offset = param_int_get(paramList, 1, &status[1]);
gint whence = param_int_get_optional(paramList, 2, &status[2], SEEK_SET);
Verbose("~ Executing STMT_FSEEK: file = %p, offset = %ld, whence = %d", file, offset, whence);
// evaluator error check
if (!expr_status_assert(status, 3)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
IOStatus ioStatus = iio_fseek(file, offset, whence);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_FSEEK]++;
else
statementsFail[STMT_FSEEK]++;
break;
}
case STMT_FSYNC: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
IOStatus ioStatus = iio_fsync(file);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_FSYNC]++;
else {
statementsFail[STMT_FSYNC]++;
}
break;
}
case STMT_WRITE: {
ExpressionStatus status[3];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
glong dataSize = param_int_get(paramList, 1, &status[1]);
glong offset = param_int_get_optional(paramList, 2, &status[2], 0);
Verbose("~ Executing STMT_WRITE: file = %s, dataSize = %ld, offset = %ld", fname_raw, dataSize, offset);
// evaluator error check
if (!expr_status_assert(status, 3)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_write(fname, dataSize, offset);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_WRITE]++;
else
statementsFail[STMT_WRITE]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_APPEND: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
glong dataSize = param_int_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_APPEND: file = %s, dataSize = %ld", fname_raw, dataSize);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_append(fname, dataSize);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_APPEND]++;
else
statementsFail[STMT_APPEND]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_READ: {
ExpressionStatus status[3];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
glong dataSize = param_int_get_optional(paramList, 1, &status[1], READALL);
glong offset = param_int_get_optional(paramList, 2, &status[2], 0);
Verbose("~ Executing STMT_READ: file = %s, dataSize = %ld, offset = %ld",
fname_raw, dataSize, offset);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_read(fname, dataSize, offset);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_READ]++;
else
statementsFail[STMT_READ]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_LOOKUP: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_LOOKUP: file = %s", fname_raw);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_lookup(fname);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_LOOKUP]++;
else
statementsFail[STMT_LOOKUP]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_DELETE: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_DELETE: file = %s", fname_raw);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_delete(fname);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_DELETE]++;
else
statementsFail[STMT_DELETE]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_MKDIR: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_MKDIR: file = %s", fname_raw);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_mkdir(fname);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_MKDIR]++;
else
statementsFail[STMT_MKDIR]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_RMDIR: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_RMDIR: file = %s", fname_raw);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_rmdir(fname);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_RMDIR]++;
else
statementsFail[STMT_RMDIR]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_CREATE: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_CREATE: file = %s", fname_raw);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_create(fname);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_CREATE]++;
else
statementsFail[STMT_CREATE]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_STAT: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_STAT: file = %s", fname_raw);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
IOStatus ioStatus = iio_stat(fname);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_STAT]++;
else
statementsFail[STMT_STAT]++;
g_free(fname_raw);
g_free(fname);
break;
}
case STMT_RENAME: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
gchar* oldname_raw = param_string_get(paramList, 0, &status[0]);
gchar* newname_raw = param_string_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_RENAME: oldname = %s, newname = %s", oldname_raw, oldname_raw);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* oldname = var_replace_substrings(oldname_raw);
gchar* newname = var_replace_substrings(newname_raw);
IOStatus ioStatus = iio_rename(oldname, newname);
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_RENAME]++;
else
statementsFail[STMT_RENAME]++;
g_free(oldname_raw);
g_free(newname_raw);
g_free(oldname);
g_free(newname);
break;
}
#ifdef HAVE_MPI
case STMT_PFOPEN: {
ExpressionStatus status[3];
ParameterList* paramList = stmt->parameters;
gchar* fhname = param_string_get(paramList, 0, &status[0]);
gchar* fname_raw = param_string_get(paramList, 1, &status[1]);
gchar* mode = param_string_get(paramList, 2, &status[2]);
Verbose("~ Executing STMT_FOPEN: fhname = %s, fname = %s mode = %s", fhname, fname_raw, mode);
// evaluator error check
if (!expr_status_assert(status, 3)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
MPI_Comm comm = MPI_COMM_WORLD;
if(groupStack)
comm = ((GroupBlock*) g_list_first(groupStack)->data)->mpicomm;
File* file;
if (iio_pfopen(fname, mode, comm, &file)) {
Verbose(" > file = %p", file);
var_set_value(fhname, VAR_FILE, &file);
statementsSucceed[STMT_PFOPEN]++;
}
else
statementsFail[STMT_PFOPEN]++;
g_free(fhname);
g_free(fname_raw);
g_free(fname);
g_free(mode);
break;
}
case STMT_PFCLOSE: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_FCLOSE: file = %p", file);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
if (file && iio_pfclose(file)) {
gchar* fhname = (gchar*) param_value_get(paramList, 0);
var_destroy(fhname);
statementsSucceed[STMT_PFCLOSE]++;
}
else
statementsFail[STMT_PFCLOSE]++;
break;
}
case STMT_PFWRITE: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
gchar* pname = param_string_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_PFWRITE: file = %p, pattern = %s", file, pname);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
Pattern* pattern = g_hash_table_lookup(patternMap, pname);
if (!pattern) {
g_printf("Invalid pattern parameter in statement pfwrite.\n");
Error("Malicious statement parameters!");
break;
}
MPI_Comm comm = MPI_COMM_WORLD;
if(groupStack)
comm = ((GroupBlock*) g_list_first(groupStack)->data)->mpicomm;
IOStatus ioStatus;
switch(pattern->level) {
/* Level 0: non-collective, contiguous */
case 0:
Verbose(" > level = 0");
ioStatus = iio_pfwrite_level0(file, pattern);
break;
/* Level 1: collective, contiguous */
case 1:
Verbose(" > level = 1");
ioStatus = iio_pfwrite_level1(file, pattern);
break;
/* Level 2: non-collective, non-contiguous */
case 2:
Verbose(" > level = 2");
ioStatus = iio_pfwrite_level2(file, pattern);
break;
/* Level 3: collective, non-contiguous */
case 3:
Verbose(" > level = 3");
ioStatus = iio_pfwrite_level3(file, pattern);
break;
default: Error("Invalid level (%d) for statement pfwrite!", pattern->level);
}
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_PFWRITE]++;
else
statementsFail[STMT_PFWRITE]++;
g_free(pname);
break;
}
case STMT_PFREAD: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
File* file = param_file_get(paramList, 0, &status[0]);
gchar* pname = param_string_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_PFREAD: file = %p, pattern = %s", file, pname);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
Pattern* pattern = g_hash_table_lookup(patternMap, pname);
if (!pattern) {
g_printf("Invalid pattern parameter in statement pread.\n");
Error("Malicious statement parameters!");
break;
}
MPI_Comm comm = MPI_COMM_WORLD;
if(groupStack)
comm = ((GroupBlock*) g_list_first(groupStack)->data)->mpicomm;
IOStatus ioStatus;
switch(pattern->level) {
/* Level 0: non-collective, contiguous */
case 0:
Verbose(" > level = 0");
ioStatus = iio_pfread_level0(file, pattern);
break;
/* Level 1: collective, contiguous */
case 1:
Verbose(" > level = 1");
ioStatus = iio_pfread_level1(file, pattern);
break;
/* Level 2: non-collective, non-contiguous */
case 2:
Verbose(" > level = 2");
ioStatus = iio_pfread_level2(file, pattern);
break;
/* Level 3: collective, non-contiguous */
case 3:
Verbose(" > level = 3");
ioStatus = iio_pfread_level3(file, pattern);
break;
default: Error("Invalid level (%d) for statement pfread!", pattern->level);
}
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_PFREAD]++;
else
statementsFail[STMT_PFREAD]++;
g_free(pname);
break;
}
case STMT_PWRITE: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
gchar* pname = param_string_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_PWRITE: file = %s, pattern = %s", fname_raw, pname);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
Pattern* pattern = g_hash_table_lookup(patternMap, pname);
if (!pattern) {
g_printf("Invalid pattern parameter in statement pwrite.\n");
Error("Malicious statement parameters!");
break;
}
MPI_Comm comm = MPI_COMM_WORLD;
if(groupStack)
comm = ((GroupBlock*) g_list_first(groupStack)->data)->mpicomm;
IOStatus ioStatus;
switch(pattern->level) {
/* Level 0: non-collective, contiguous */
case 0:
Verbose(" > level = 0");
ioStatus = iio_pwrite_level0(fname, pattern, comm);
break;
/* Level 1: collective, contiguous */
case 1:
Verbose(" > level = 1");
ioStatus = iio_pwrite_level1(fname, pattern, comm);
break;
/* Level 2: non-collective, non-contiguous */
case 2:
Verbose(" > level = 2");
ioStatus = iio_pwrite_level2(fname, pattern, comm);
break;
/* Level 3: collective, non-contiguous */
case 3:
Verbose(" > level = 3");
ioStatus = iio_pwrite_level3(fname, pattern, comm);
break;
default: Error("Invalid level (%d) for statement pwrite!", pattern->level);
}
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_PWRITE]++;
else
statementsFail[STMT_PWRITE]++;
g_free(fname_raw);
g_free(fname);
g_free(pname);
break;
}
case STMT_PREAD: {
ExpressionStatus status[2];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
gchar* pname = param_string_get(paramList, 1, &status[1]);
Verbose("~ Executing STMT_PREAD: file = %s, pattern = %s", fname_raw, pname);
// evaluator error check
if (!expr_status_assert(status, 2)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
Pattern* pattern = g_hash_table_lookup(patternMap, pname);
if (!pattern) {
g_printf("Invalid pattern parameter in statement pread.\n");
g_free(fname);
Error("Malicious statement parameters!");
break;
}
MPI_Comm comm = MPI_COMM_WORLD;
if(groupStack)
comm = ((GroupBlock*) g_list_first(groupStack)->data)->mpicomm;
IOStatus ioStatus;
switch(pattern->level) {
/* Level 0: non-collective, contiguous */
case 0:
Verbose(" > level = 0");
ioStatus = iio_pread_level0(fname, pattern, comm);
break;
/* Level 1: collective, contiguous */
case 1:
Verbose(" > level = 1");
ioStatus = iio_pread_level1(fname, pattern, comm);
break;
/* Level 2: non-collective, non-contiguous */
case 2:
Verbose(" > level = 2");
ioStatus = iio_pread_level2(fname, pattern, comm);
break;
/* Level 3: collective, non-contiguous */
case 3:
Verbose(" > level = 3");
ioStatus = iio_pread_level3(fname, pattern, comm);
break;
default: Error("Invalid level (%d) for statement pread!", pattern->level);
}
dump_coretime(coreTimeStack, ioStatus.coreTime);
if (ioStatus.success)
statementsSucceed[STMT_PREAD]++;
else
statementsFail[STMT_PREAD]++;
g_free(fname_raw);
g_free(fname);
g_free(pname);
break;
}
case STMT_PDELETE: {
ExpressionStatus status[1];
ParameterList* paramList = stmt->parameters;
gchar* fname_raw = param_string_get(paramList, 0, &status[0]);
Verbose("~ Executing STMT_PDELETE: file = %s", fname_raw);
// evaluator error check
if (!expr_status_assert(status, 1)) {
backtrace(stmt);
Error("Malicious statement parameters!");
}
gchar* fname = var_replace_substrings(fname_raw);
if (iio_pdelete(fname))
statementsSucceed[STMT_PDELETE]++;
else
statementsFail[STMT_PDELETE]++;
g_free(fname_raw);
g_free(fname);
break;
}
#endif
/* ![ModuleHook] statement_exec */
default: Error("Invalid statement! (id=%d)\n", stmt->type);
}
}
