void global_names()
{
Block* block = find_or_create_block(global_root_block(), "names_test");
Term* a = block->compile("a = 1");
circa::Value globalName;
get_global_name(a, &globalName);
test_equals(&globalName, "names_test:a");
Term* a_2 = block->compile("a = 2");
get_global_name(a, &globalName);
test_equals(&globalName, "names_test:a#1");
get_global_name(a_2, &globalName);
test_equals(&globalName, "names_test:a#2");
Block* block2 = create_block(block, "block2");
Term* b = block2->compile("b = 3");
Term* b_2 = block2->compile("b = 4");
get_global_name(b, &globalName);
test_equals(&globalName, "names_test:block2:b#1");
get_global_name(b_2, &globalName);
test_equals(&globalName, "names_test:block2:b#2");
// Now try finding terms via their global name.
test_assert(find_from_global_name(global_world(), "names_test:a") == a_2);
test_assert(find_from_global_name(global_world(), "names_test:a#1") == a);
test_assert(find_from_global_name(global_world(), "names_test:a#2") == a_2);
test_assert(find_from_global_name(global_world(), "names_test:block2:b") == b_2);
test_assert(find_from_global_name(global_world(), "names_test:block2:b#1") == b);
test_assert(find_from_global_name(global_world(), "names_test:block2:b#2") == b_2);
}
int am_agent_instance_init_init(int id) {
int status = AM_ERROR;
#if defined(_WIN32)
ic_sem = CreateSemaphoreA(NULL, 1, 1, get_global_name("Global\\"AM_CONFIG_INIT_NAME, id));
if (ic_sem != NULL) {
status = AM_SUCCESS;
}
#elif defined(__APPLE__)
kern_return_t rv = semaphore_create(mach_task_self(), &ic_sem, SYNC_POLICY_FIFO, 1);
if (rv == KERN_SUCCESS) {
status = AM_SUCCESS;
}
#else
ic_sem = sem_open(get_global_name(AM_CONFIG_INIT_NAME, id), O_CREAT, 0600, 1);
if (ic_sem != SEM_FAILED) {
status = AM_SUCCESS;
}
#endif
return status;
}
void am_agent_instance_init_release(int id, char unlink) {
#if defined(_WIN32)
CloseHandle(ic_sem);
#elif defined(__APPLE__)
semaphore_destroy(mach_task_self(), ic_sem);
#else
sem_close(ic_sem);
if (unlink) {
sem_unlink(get_global_name(AM_CONFIG_INIT_NAME, id));
}
#endif
}
void module_possibly_patch_new_function(World* world, Block* function)
{
NativePatchWorld* moduleWorld = world->nativePatchWorld;
Value globalName;
get_global_name(function, &globalName);
// No global name: no patch.
if (!is_string(&globalName))
return;
// Lookup in the global table.
caValue* patchEntry = hashtable_get(&moduleWorld->everyPatchedFunction, &globalName);
if (patchEntry == NULL) {
// No patch for this function.
return;
}
caValue* nativeModuleName = list_get(patchEntry, 0);
caValue* functionName = list_get(patchEntry, 1);
// Found a patch; apply it.
NativePatch* module = get_existing_native_patch(world, as_cstring(nativeModuleName));
if (module == NULL) {
std::cout << "in module_possibly_patch_new_function, couldn't find module: "
<< as_cstring(nativeModuleName) << std::endl;
return;
}
std::map<std::string, EvaluateFunc>::const_iterator it;
it = module->patches.find(as_cstring(functionName));
if (it == module->patches.end()) {
std::cout << "in module_possibly_patch_new_function, couldn't find function: "
<< as_cstring(functionName) << std::endl;
return;
}
EvaluateFunc evaluateFunc = it->second;
install_function(function->owningTerm, evaluateFunc);
}
void search_every_global_name()
{
// This test is brave. We go through every single term in the world, find its
// global name (if it exists), then see if we can find the original term using
// the global name.
circa::Value globalName;
for (BlockIterator it(global_root_block()); it.unfinished(); it.advance()) {
get_global_name(*it, &globalName);
if (!is_string(&globalName))
continue;
Term* searchResult = find_from_global_name(global_world(), as_cstring(&globalName));
if (searchResult != *it) {
std::cout << "Global name search failed for term: " << global_id(*it)
<< ", with global name: " << as_cstring(&globalName) << std::endl;
declare_current_test_failed();
}
}
}
void am_log_init(int id, int status) {
int i;
char opened = 0;
am_agent_instance_init_init(id);
if (am_log_handle == NULL) {
am_log_handle = (struct am_shared_log *) malloc(sizeof (struct am_shared_log));
if (am_log_handle == NULL) {
return;
}
} else if (am_log_handle->reader_pid == getpid()) {
return;
}
am_log_handle->reader_pid = getpid();
snprintf(am_log_handle->area_file_name, sizeof (am_log_handle->area_file_name),
#ifdef __sun
"/am_log_%d"
#else
AM_GLOBAL_PREFIX"am_log_%d"
#endif
, id);
am_log_handle->area_size = page_size(sizeof (struct am_log));
#ifdef _WIN32
am_log_handle->area_file_id = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
0, (DWORD) am_log_handle->area_size, am_log_handle->area_file_name);
if (am_log_handle->area_file_id == NULL) return;
if (NULL != am_log_handle->area_file_id && GetLastError() == ERROR_ALREADY_EXISTS) {
opened = 1;
}
if (am_log_handle->area_file_id != NULL) {
am_log_handle->area = MapViewOfFile(am_log_handle->area_file_id, FILE_MAP_ALL_ACCESS,
0, 0, am_log_handle->area_size);
}
if (am_log_handle->area != NULL) {
if (status == AM_SUCCESS || status == AM_EAGAIN) {
struct am_log *log = (struct am_log *) am_log_handle->area;
memset(log, 0, am_log_handle->area_size);
log->bucket_count = AM_LOG_QUEUE_SIZE;
log->bucket_size = AM_LOG_MESSAGE_SIZE;
log->in = log->out = log->read_count = log->write_count = 0;
for (i = 0; i < AM_MAX_INSTANCES; i++) {
struct log_files *f = &log->files[i];
f->fd_audit = f->fd_debug = -1;
f->used = AM_FALSE;
f->instance_id = 0;
f->level_debug = f->level_audit = AM_LOG_LEVEL_NONE;
f->max_size_debug = f->max_size_audit = 0;
}
am_log_lck.exit = CreateEvent(NULL, FALSE, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_exit", id));
if (am_log_lck.exit == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.exit = OpenEventA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_exit", id));
}
am_log_lck.lock = CreateMutex(NULL, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_lock", id));
if (am_log_lck.lock == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.lock = OpenMutexA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_lock", id));
}
am_log_lck.new_data_cond = CreateEvent(NULL, FALSE, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_empty", id));
if (am_log_lck.new_data_cond == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.new_data_cond = OpenEventA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_empty", id));
}
am_log_lck.new_space_cond = CreateEvent(NULL, FALSE, FALSE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_overflow", id));
if (am_log_lck.new_space_cond == NULL && GetLastError() == ERROR_ACCESS_DENIED) {
am_log_lck.new_space_cond = OpenEventA(SYNCHRONIZE, TRUE, get_global_name(AM_GLOBAL_PREFIX"am_log_queue_overflow", id));
}
log->owner = getpid();
am_log_handle->reader_thr = CreateThread(NULL, 0,
(LPTHREAD_START_ROUTINE) am_log_worker, NULL, 0, NULL);
}
}
#else
am_log_handle->area_file_id = shm_open(am_log_handle->area_file_name, O_CREAT | O_EXCL | O_RDWR, 0666);
if (am_log_handle->area_file_id == -1 && EEXIST != errno) {
return;
}
if (am_log_handle->area_file_id == -1) {
/* already there, open without O_EXCL and go; if
* something goes wrong, close and cleanup */
am_log_handle->area_file_id = shm_open(am_log_handle->area_file_name, O_RDWR, 0666);
if (am_log_handle->area_file_id == -1) {
fprintf(stderr, "am_log_init() shm_open failed (%d)\n", errno);
free(am_log_handle);
am_log_handle = NULL;
return;
} else {
opened = 1;
}
} else {
/* we just created the shm area, must setup; if
* something goes wrong, delete the shm area and
* cleanup
*/
if (ftruncate(am_log_handle->area_file_id, am_log_handle->area_size) == -1) {
fprintf(stderr, "am_log_init() ftruncate failed\n");
return;
}
}
if (am_log_handle->area_file_id != -1) {
am_log_handle->area = mmap(NULL, am_log_handle->area_size,
PROT_READ | PROT_WRITE, MAP_SHARED, am_log_handle->area_file_id, 0);
if (am_log_handle->area == MAP_FAILED) {
fprintf(stderr, "am_log_init() mmap failed (%d)\n", errno);
free(am_log_handle);
am_log_handle = NULL;
} else {
pthread_mutexattr_t exit_attr, lock_attr;
pthread_condattr_t new_data_attr, new_space_attr;
struct am_log *log = (struct am_log *) am_log_handle->area;
pthread_mutexattr_init(&exit_attr);
pthread_mutexattr_init(&lock_attr);
pthread_condattr_init(&new_data_attr);
pthread_condattr_init(&new_space_attr);
pthread_mutexattr_setpshared(&exit_attr, PTHREAD_PROCESS_SHARED);
pthread_mutexattr_setpshared(&lock_attr, PTHREAD_PROCESS_SHARED);
pthread_condattr_setpshared(&new_data_attr, PTHREAD_PROCESS_SHARED);
pthread_condattr_setpshared(&new_space_attr, PTHREAD_PROCESS_SHARED);
if (status == AM_SUCCESS || status == AM_EAGAIN) {
memset(log, 0, am_log_handle->area_size);
log->bucket_count = AM_LOG_QUEUE_SIZE;
log->bucket_size = AM_LOG_MESSAGE_SIZE;
log->in = log->out = log->read_count = log->write_count = 0;
for (i = 0; i < AM_MAX_INSTANCES; i++) {
struct log_files *f = &log->files[i];
f->fd_audit = f->fd_debug = -1;
f->used = AM_FALSE;
f->instance_id = 0;
f->level_debug = f->level_audit = AM_LOG_LEVEL_NONE;
f->max_size_debug = f->max_size_audit = 0;
}
pthread_mutex_init(&log->exit, &exit_attr);
pthread_mutex_init(&log->lock, &lock_attr);
pthread_cond_init(&log->new_data_cond, &new_data_attr);
pthread_cond_init(&log->new_space_cond, &new_space_attr);
pthread_mutex_lock(&log->exit);
pthread_create(&am_log_handle->reader_thr, NULL, am_log_worker, NULL);
log->owner = getpid();
}
pthread_mutexattr_destroy(&exit_attr);
pthread_mutexattr_destroy(&lock_attr);
pthread_condattr_destroy(&new_data_attr);
pthread_condattr_destroy(&new_space_attr);
}
}
#endif
}
