DistEntry *
erts_sysname_to_connected_dist_entry(Eterm sysname)
{
DistEntry de;
DistEntry *res_dep;
de.sysname = sysname;
if(erts_this_dist_entry->sysname == sysname) {
erts_refc_inc(&erts_this_dist_entry->refc, 2);
return erts_this_dist_entry;
}
erts_smp_rwmtx_rlock(&erts_dist_table_rwmtx);
res_dep = (DistEntry *) hash_get(&erts_dist_table, (void *) &de);
if (res_dep) {
erts_aint_t refc = erts_refc_inctest(&res_dep->refc, 1);
if (refc < 2) /* Pending delete */
erts_refc_inc(&res_dep->refc, 1);
}
erts_smp_rwmtx_runlock(&erts_dist_table_rwmtx);
if (res_dep) {
int deref;
erts_smp_rwmtx_rlock(&res_dep->rwmtx);
deref = is_nil(res_dep->cid);
erts_smp_rwmtx_runlock(&res_dep->rwmtx);
if (deref) {
erts_deref_dist_entry(res_dep);
res_dep = NULL;
}
}
return res_dep;
}
void erts_print_node_info(int to,
void *to_arg,
Eterm sysname,
int *no_sysname,
int *no_total)
{
int lock = !ERTS_IS_CRASH_DUMPING;
struct pn_data pnd;
pnd.to = to;
pnd.to_arg = to_arg;
pnd.sysname = sysname;
pnd.no_sysname = 0;
pnd.no_total = 0;
if (lock)
erts_smp_rwmtx_rlock(&erts_node_table_rwmtx);
hash_foreach(&erts_node_table, print_node, (void *) &pnd);
if (pnd.no_sysname != 0) {
erts_print(to, to_arg, "\n");
}
if (lock)
erts_smp_rwmtx_runlock(&erts_node_table_rwmtx);
if(no_sysname)
*no_sysname = pnd.no_sysname;
if(no_total)
*no_total = pnd.no_total;
}
ErlNode *erts_find_or_insert_node(Eterm sysname, Uint creation)
{
ErlNode *res;
ErlNode ne;
ne.sysname = sysname;
ne.creation = creation;
erts_smp_rwmtx_rlock(&erts_node_table_rwmtx);
res = hash_get(&erts_node_table, (void *) &ne);
if (res && res != erts_this_node) {
erts_aint_t refc = erts_refc_inctest(&res->refc, 0);
if (refc < 2) /* New or pending delete */
erts_refc_inc(&res->refc, 1);
}
erts_smp_rwmtx_runlock(&erts_node_table_rwmtx);
if (res)
return res;
erts_smp_rwmtx_rwlock(&erts_node_table_rwmtx);
res = hash_put(&erts_node_table, (void *) &ne);
ASSERT(res);
if (res != erts_this_node) {
erts_aint_t refc = erts_refc_inctest(&res->refc, 0);
if (refc < 2) /* New or pending delete */
erts_refc_inc(&res->refc, 1);
}
erts_smp_rwmtx_rwunlock(&erts_node_table_rwmtx);
return res;
}
int
erts_sys_getenv(char *key, char *value, size_t *size)
{
int res;
erts_smp_rwmtx_rlock(&environ_rwmtx);
res = erts_sys_getenv__(key, value, size);
erts_smp_rwmtx_runlock(&environ_rwmtx);
return res;
}
void
erts_node_table_info(int to, void *to_arg)
{
int lock = !ERTS_IS_CRASH_DUMPING;
if (lock)
erts_smp_rwmtx_rlock(&erts_node_table_rwmtx);
hash_info(to, to_arg, &erts_node_table);
if (lock)
erts_smp_rwmtx_runlock(&erts_node_table_rwmtx);
}
DistEntry *erts_find_dist_entry(Eterm sysname)
{
DistEntry *res;
DistEntry de;
de.sysname = sysname;
erts_smp_rwmtx_rlock(&erts_dist_table_rwmtx);
res = hash_get(&erts_dist_table, (void *) &de);
if (res) {
erts_aint_t refc = erts_refc_inctest(&res->refc, 1);
if (refc < 2) /* Pending delete */
erts_refc_inc(&res->refc, 1);
}
erts_smp_rwmtx_runlock(&erts_dist_table_rwmtx);
return res;
}
char*
win_build_environment(char* new_env)
{
if (new_env == NULL) {
return NULL;
} else {
char *tmp, *merged;
erts_smp_rwmtx_rlock(&environ_rwmtx);
tmp = GetEnvironmentStrings();
merged = merge_environment(tmp, new_env);
FreeEnvironmentStrings(tmp);
erts_smp_rwmtx_runlock(&environ_rwmtx);
return merged;
}
}
Uint
erts_node_table_size(void)
{
Uint res;
#ifdef DEBUG
HashInfo hi;
#endif
int lock = !ERTS_IS_CRASH_DUMPING;
if (lock)
erts_smp_rwmtx_rlock(&erts_node_table_rwmtx);
#ifdef DEBUG
hash_get_info(&hi, &erts_node_table);
ASSERT(node_entries == hi.objs);
#endif
res = hash_table_sz(&erts_node_table) + node_entries*sizeof(ErlNode);
if (lock)
erts_smp_rwmtx_runlock(&erts_node_table_rwmtx);
return res;
}
Uint
erts_dist_table_size(void)
{
Uint res;
#ifdef DEBUG
HashInfo hi;
DistEntry *dep;
int i;
#endif
int lock = !ERTS_IS_CRASH_DUMPING;
if (lock)
erts_smp_rwmtx_rlock(&erts_dist_table_rwmtx);
#ifdef DEBUG
hash_get_info(&hi, &erts_dist_table);
ASSERT(dist_entries == hi.objs);
i = 0;
for(dep = erts_visible_dist_entries; dep; dep = dep->next)
i++;
ASSERT(i == erts_no_of_visible_dist_entries);
i = 0;
for(dep = erts_hidden_dist_entries; dep; dep = dep->next)
i++;
ASSERT(i == erts_no_of_hidden_dist_entries);
i = 0;
for(dep = erts_not_connected_dist_entries; dep; dep = dep->next)
i++;
ASSERT(i == erts_no_of_not_connected_dist_entries);
ASSERT(dist_entries == (erts_no_of_visible_dist_entries
+ erts_no_of_hidden_dist_entries
+ erts_no_of_not_connected_dist_entries
+ 1 /* erts_this_dist_entry */));
#endif
res = (hash_table_sz(&erts_dist_table)
+ dist_entries*sizeof(DistEntry)
+ erts_dist_cache_size());
if (lock)
erts_smp_rwmtx_runlock(&erts_dist_table_rwmtx);
return res;
}
char*
win_build_environment(char* new_env)
{
if (new_env == NULL) {
return NULL;
} else {
WCHAR *tmp, *merged, *tmp_new;
tmp_new = (WCHAR *) new_env;
erts_smp_rwmtx_rlock(&environ_rwmtx);
tmp = GetEnvironmentStringsW();
merged = merge_environment(tmp, tmp_new);
FreeEnvironmentStringsW(tmp);
erts_smp_rwmtx_runlock(&environ_rwmtx);
return (char *) merged;
}
}
int
erts_sys_getenv(char *key, char *value, size_t *size)
{
size_t req_size = 0;
int res = 0;
DWORD new_size;
erts_smp_rwmtx_rlock(&environ_rwmtx);
SetLastError(0);
new_size = GetEnvironmentVariable((LPCTSTR) key,
(LPTSTR) value,
(DWORD) *size);
res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;
erts_smp_rwmtx_runlock(&environ_rwmtx);
if (res < 0)
return res;
res = new_size > *size ? 1 : 0;
*size = new_size;
return res;
}
int
erts_sys_getenv(char *key, char *value, size_t *size)
{
size_t req_size = 0;
int res = 0;
DWORD new_size;
WCHAR *wkey = (WCHAR *) key;
WCHAR *wvalue = (WCHAR *) value;
DWORD wsize = *size / (sizeof(WCHAR) / sizeof(char));
SetLastError(0);
erts_smp_rwmtx_rlock(&environ_rwmtx);
new_size = GetEnvironmentVariableW(wkey,
wvalue,
(DWORD) wsize);
res = !new_size && GetLastError() == ERROR_ENVVAR_NOT_FOUND ? -1 : 0;
erts_smp_rwmtx_runlock(&environ_rwmtx);
if (res < 0)
return res;
res = new_size > wsize ? 1 : 0;
*size = new_size * (sizeof(WCHAR) / sizeof(char));
return res;
}
void fini_getenv_state(GETENV_STATE *state)
{
FreeEnvironmentStrings(state->environment_strings);
state->environment_strings = state->next_string = NULL;
erts_smp_rwmtx_runlock(&environ_rwmtx);
}
void fini_getenv_state(GETENV_STATE *state)
{
*state = NULL;
erts_smp_rwmtx_runlock(&environ_rwmtx);
}
