BIF_RETTYPE os_getpid_0(BIF_ALIST_0)
{
char pid_string[21]; /* enough for a 64 bit number */
int n;
Eterm* hp;
sys_get_pid(pid_string, sizeof(pid_string)); /* In sys.c */
n = sys_strlen(pid_string);
hp = HAlloc(BIF_P, n*2);
BIF_RET(buf_to_intlist(&hp, pid_string, n, NIL));
}
Eterm
os_getenv_1(Process* p, Eterm key)
{
Eterm str;
int len, res;
char *key_str, *val;
char buf[1024];
size_t val_size = sizeof(buf);
len = is_string(key);
if (!len) {
BIF_ERROR(p, BADARG);
}
/* Leave at least one byte in buf for value */
key_str = len < sizeof(buf)-2 ? &buf[0] : erts_alloc(ERTS_ALC_T_TMP, len+1);
if (intlist_to_buf(key, key_str, len) != len)
erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);
key_str[len] = '\0';
if (key_str != &buf[0])
val = &buf[0];
else {
val_size -= len + 1;
val = &buf[len + 1];
}
res = erts_sys_getenv(key_str, val, &val_size);
if (res < 0) {
no_var:
str = am_false;
} else {
Eterm* hp;
if (res > 0) {
val = erts_alloc(ERTS_ALC_T_TMP, val_size);
while (1) {
res = erts_sys_getenv(key_str, val, &val_size);
if (res == 0)
break;
else if (res < 0)
goto no_var;
else
val = erts_realloc(ERTS_ALC_T_TMP, val, val_size);
}
}
if (val_size)
hp = HAlloc(p, val_size*2);
str = buf_to_intlist(&hp, val, val_size, NIL);
}
if (key_str != &buf[0])
erts_free(ERTS_ALC_T_TMP, key_str);
if (val < &buf[0] || &buf[sizeof(buf)-1] < val)
erts_free(ERTS_ALC_T_TMP, val);
BIF_RET(str);
}
Eterm
os_getpid_0(Process* p)
{
char pid_string[21]; /* enough for a 64 bit number */
int n;
Eterm* hp;
sys_get_pid(pid_string); /* In sys.c */
n = sys_strlen(pid_string);
hp = HAlloc(p, n*2);
BIF_RET(buf_to_intlist(&hp, pid_string, n, NIL));
}
/*
* Build a single {M,F,A,Loction} item to be part of
* a stack trace.
*/
Eterm*
erts_build_mfa_item(FunctionInfo* fi, Eterm* hp, Eterm args, Eterm* mfa_p)
{
BeamInstr* current = fi->current;
Eterm loc = NIL;
if (fi->loc != LINE_INVALID_LOCATION) {
Eterm tuple;
int line = LOC_LINE(fi->loc);
int file = LOC_FILE(fi->loc);
Eterm file_term = NIL;
if (file == 0) {
Atom* ap = atom_tab(atom_val(fi->current[0]));
file_term = buf_to_intlist(&hp, ".erl", 4, NIL);
file_term = buf_to_intlist(&hp, (char*)ap->name, ap->len, file_term);
} else {
Atom* ap = atom_tab(atom_val((fi->fname_ptr)[file-1]));
file_term = buf_to_intlist(&hp, (char*)ap->name, ap->len, NIL);
}
tuple = TUPLE2(hp, am_line, make_small(line));
hp += 3;
loc = CONS(hp, tuple, loc);
hp += 2;
tuple = TUPLE2(hp, am_file, file_term);
hp += 3;
loc = CONS(hp, tuple, loc);
hp += 2;
}
if (is_list(args) || is_nil(args)) {
*mfa_p = TUPLE4(hp, current[0], current[1], args, loc);
} else {
Eterm arity = make_small(current[2]);
*mfa_p = TUPLE4(hp, current[0], current[1], arity, loc);
}
return hp + 5;
}
/*
* Return list of loaded drivers {ok,[string()]}
*/
BIF_RETTYPE erl_ddll_loaded_drivers_0(BIF_ALIST_0)
{
Eterm *hp;
int need = 3;
Eterm res = NIL;
erts_driver_t *drv;
lock_drv_list();
for (drv = driver_list; drv; drv = drv->next) {
need += sys_strlen(drv->name)*2+2;
}
hp = HAlloc(BIF_P, need);
for (drv = driver_list; drv; drv = drv->next) {
Eterm l;
l = buf_to_intlist(&hp, drv->name, sys_strlen(drv->name), NIL);
res = CONS(hp,l,res);
hp += 2;
}
res = TUPLE2(hp,am_ok,res);
/* hp += 3 */
unlock_drv_list();
BIF_RET(res);
}
Eterm
os_getenv_0(Process* p)
{
GETENV_STATE state;
char *cp;
Eterm* hp;
Eterm ret;
Eterm str;
int len;
init_getenv_state(&state);
ret = NIL;
while ((cp = getenv_string(&state)) != NULL) {
len = strlen(cp);
hp = HAlloc(p, len*2+2);
str = buf_to_intlist(&hp, cp, len, NIL);
ret = CONS(hp, str, ret);
}
fini_getenv_state(&state);
return ret;
}
/*
* Backend for erl_ddll:format_error, handles all "soft" errors returned by builtins,
* possibly by calling the system specific error handler
*/
BIF_RETTYPE erl_ddll_format_error_int_1(BIF_ALIST_1)
{
Process *p = BIF_P;
Eterm code_term = BIF_ARG_1;
char *errstring = NULL;
int errint;
int len;
Eterm ret = NIL;
Eterm *hp;
/* These errors can only appear in the erlang interface, not in the interface provided
to drivers... */
switch (code_term) {
case am_inconsistent:
errstring = "Driver name and/or driver options are inconsistent with "
"currently loaded driver";
break;
case am_linked_in_driver:
errstring = "Driver is statically linked and "
"cannot be loaded/unloaded";
break;
case am_permanent:
errstring = "DDLL driver is permanent an can not be unloaded/loaded";
break;
case am_not_loaded:
errstring = "DDLL driver is not loaded";
break;
case am_not_loaded_by_this_process:
errstring = "DDLL driver was not loaded by this process";
break;
case am_not_pending:
errstring = "DDLL load not pending for this driver name";
break;
case am_already_loaded:
errstring = "DDLL driver is already loaded successfully";
break;
case am_pending_reload:
errstring = "Driver reloading is already pending";
break;
case am_pending_process:
errstring = "Driver is loaded by others when attempting "
"option {reload, pending_driver}";
break;
default:
/* A "real" error, we translate the atom to a code and translate the code
to a string in the same manner as in the interface provided to drivers... */
if (errdesc_to_code(code_term,&errint) != 0) {
goto error;
}
lock_drv_list();
errstring = erts_ddll_error(errint);
unlock_drv_list();
break;
}
if (errstring == NULL) {
goto error;
}
len = sys_strlen(errstring);
hp = HAlloc(p, 2 * len);
ret = buf_to_intlist(&hp, errstring, len, NIL);
BIF_RET(ret);
error:
BIF_ERROR(p,BADARG);
}