BIF_RETTYPE port_connect_2(BIF_ALIST_2)
{
Port* prt;
Process* rp;
Eterm pid = BIF_ARG_2;
if (is_not_internal_pid(pid)) {
error:
BIF_ERROR(BIF_P, BADARG);
}
prt = id_or_name2port(BIF_P, BIF_ARG_1);
if (!prt) {
goto error;
}
rp = erts_pid2proc(BIF_P, ERTS_PROC_LOCK_MAIN,
pid, ERTS_PROC_LOCK_LINK);
if (!rp) {
erts_smp_port_unlock(prt);
ERTS_SMP_ASSERT_IS_NOT_EXITING(BIF_P);
goto error;
}
erts_add_link(&(rp->nlinks), LINK_PID, prt->id);
erts_add_link(&(prt->nlinks), LINK_PID, pid);
erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_LINK);
prt->connected = pid; /* internal pid */
erts_smp_port_unlock(prt);
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(port_connect)) {
DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);
DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
DTRACE_CHARBUF(newprocess_str, DTRACE_TERM_BUF_SIZE);
dtrace_pid_str(prt->connected, process_str);
erts_snprintf(port_str, sizeof(port_str), "%T", prt->id);
dtrace_proc_str(rp, newprocess_str);
DTRACE4(port_connect, process_str, port_str, prt->name, newprocess_str);
}
#endif
BIF_RET(am_true);
}
/* Add messages last in message queue */
static Sint
queue_messages(Process* receiver,
erts_aint32_t *receiver_state,
ErtsProcLocks receiver_locks,
ErtsMessage* first,
ErtsMessage** last,
Uint len,
Eterm from)
{
ErtsTracingEvent* te;
Sint res;
int locked_msgq = 0;
erts_aint32_t state;
ASSERT(is_value(ERL_MESSAGE_TERM(first)));
ASSERT(ERL_MESSAGE_TOKEN(first) == am_undefined ||
ERL_MESSAGE_TOKEN(first) == NIL ||
is_tuple(ERL_MESSAGE_TOKEN(first)));
#ifdef ERTS_ENABLE_LOCK_CHECK
ERTS_LC_ASSERT(erts_proc_lc_my_proc_locks(receiver) < ERTS_PROC_LOCK_MSGQ ||
receiver_locks == erts_proc_lc_my_proc_locks(receiver));
#endif
if (!(receiver_locks & ERTS_PROC_LOCK_MSGQ)) {
if (erts_proc_trylock(receiver, ERTS_PROC_LOCK_MSGQ) == EBUSY) {
ErtsProcLocks need_locks;
if (receiver_state)
state = *receiver_state;
else
state = erts_atomic32_read_nob(&receiver->state);
if (state & (ERTS_PSFLG_EXITING|ERTS_PSFLG_PENDING_EXIT))
goto exiting;
need_locks = receiver_locks & ERTS_PROC_LOCKS_HIGHER_THAN(ERTS_PROC_LOCK_MSGQ);
if (need_locks) {
erts_proc_unlock(receiver, need_locks);
}
need_locks |= ERTS_PROC_LOCK_MSGQ;
erts_proc_lock(receiver, need_locks);
}
locked_msgq = 1;
}
state = erts_atomic32_read_nob(&receiver->state);
if (state & (ERTS_PSFLG_PENDING_EXIT|ERTS_PSFLG_EXITING)) {
exiting:
/* Drop message if receiver is exiting or has a pending exit... */
if (locked_msgq)
erts_proc_unlock(receiver, ERTS_PROC_LOCK_MSGQ);
erts_cleanup_messages(first);
return 0;
}
res = receiver->msg.len;
if (receiver_locks & ERTS_PROC_LOCK_MAIN) {
/*
* We move 'in queue' to 'private queue' and place
* message at the end of 'private queue' in order
* to ensure that the 'in queue' doesn't contain
* references into the heap. By ensuring this,
* we don't need to include the 'in queue' in
* the root set when garbage collecting.
*/
res += receiver->msg_inq.len;
ERTS_MSGQ_MV_INQ2PRIVQ(receiver);
LINK_MESSAGE_PRIVQ(receiver, first, last, len);
}
else
{
LINK_MESSAGE(receiver, first, last, len);
}
if (IS_TRACED_FL(receiver, F_TRACE_RECEIVE)
&& (te = &erts_receive_tracing[erts_active_bp_ix()],
te->on)) {
ErtsMessage *msg = first;
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
Sint tok_label = 0;
Sint tok_lastcnt = 0;
Sint tok_serial = 0;
Eterm seq_trace_token = ERL_MESSAGE_TOKEN(msg);
dtrace_proc_str(receiver, receiver_name);
if (seq_trace_token != NIL && is_tuple(seq_trace_token)) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(seq_trace_token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(seq_trace_token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(seq_trace_token));
}
DTRACE6(message_queued,
receiver_name, size_object(ERL_MESSAGE_TERM(msg)),
receiver->msg.len,
tok_label, tok_lastcnt, tok_serial);
}
#endif
while (msg) {
trace_receive(receiver, from, ERL_MESSAGE_TERM(msg), te);
msg = msg->next;
}
}
if (locked_msgq) {
erts_proc_unlock(receiver, ERTS_PROC_LOCK_MSGQ);
}
erts_proc_notify_new_message(receiver, receiver_locks);
return res;
}
void
erts_queue_dist_message(Process *rcvr,
ErtsProcLocks rcvr_locks,
ErtsDistExternal *dist_ext,
Eterm token,
Eterm from)
{
ErtsMessage* mp;
#ifdef USE_VM_PROBES
Sint tok_label = 0;
Sint tok_lastcnt = 0;
Sint tok_serial = 0;
#endif
erts_aint_t state;
ERTS_LC_ASSERT(rcvr_locks == erts_proc_lc_my_proc_locks(rcvr));
mp = erts_alloc_message(0, NULL);
mp->data.dist_ext = dist_ext;
ERL_MESSAGE_TERM(mp) = THE_NON_VALUE;
#ifdef USE_VM_PROBES
ERL_MESSAGE_DT_UTAG(mp) = NIL;
if (token == am_have_dt_utag)
ERL_MESSAGE_TOKEN(mp) = NIL;
else
#endif
ERL_MESSAGE_TOKEN(mp) = token;
if (!(rcvr_locks & ERTS_PROC_LOCK_MSGQ)) {
if (erts_proc_trylock(rcvr, ERTS_PROC_LOCK_MSGQ) == EBUSY) {
ErtsProcLocks need_locks = ERTS_PROC_LOCK_MSGQ;
ErtsProcLocks unlocks =
rcvr_locks & ERTS_PROC_LOCKS_HIGHER_THAN(ERTS_PROC_LOCK_MSGQ);
if (unlocks) {
erts_proc_unlock(rcvr, unlocks);
need_locks |= unlocks;
}
erts_proc_lock(rcvr, need_locks);
}
}
state = erts_atomic32_read_acqb(&rcvr->state);
if (state & (ERTS_PSFLG_PENDING_EXIT|ERTS_PSFLG_EXITING)) {
if (!(rcvr_locks & ERTS_PROC_LOCK_MSGQ))
erts_proc_unlock(rcvr, ERTS_PROC_LOCK_MSGQ);
/* Drop message if receiver is exiting or has a pending exit ... */
erts_cleanup_messages(mp);
}
else
if (IS_TRACED_FL(rcvr, F_TRACE_RECEIVE)) {
if (from == am_Empty)
from = dist_ext->dep->sysname;
/* Ahh... need to decode it in order to trace it... */
if (!(rcvr_locks & ERTS_PROC_LOCK_MSGQ))
erts_proc_unlock(rcvr, ERTS_PROC_LOCK_MSGQ);
if (!erts_decode_dist_message(rcvr, rcvr_locks, mp, 0))
erts_free_message(mp);
else {
Eterm msg = ERL_MESSAGE_TERM(mp);
token = ERL_MESSAGE_TOKEN(mp);
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
dtrace_proc_str(rcvr, receiver_name);
if (have_seqtrace(token)) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
}
DTRACE6(message_queued,
receiver_name, size_object(msg), rcvr->msg.len,
tok_label, tok_lastcnt, tok_serial);
}
#endif
erts_queue_message(rcvr, rcvr_locks, mp, msg, from);
}
}
else {
/* Enqueue message on external format */
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
dtrace_proc_str(rcvr, receiver_name);
if (have_seqtrace(token)) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
}
/*
* TODO: We don't know the real size of the external message here.
* -1 will appear to a D script as 4294967295.
*/
DTRACE6(message_queued, receiver_name, -1, rcvr->msg.len + 1,
tok_label, tok_lastcnt, tok_serial);
}
#endif
LINK_MESSAGE(rcvr, mp, &mp->next, 1);
if (!(rcvr_locks & ERTS_PROC_LOCK_MSGQ))
erts_proc_unlock(rcvr, ERTS_PROC_LOCK_MSGQ);
erts_proc_notify_new_message(rcvr,
rcvr_locks
);
}
}
static Port *
open_port(Process* p, Eterm name, Eterm settings, int *err_typep, int *err_nump)
{
Sint i;
Eterm option;
Uint arity;
Eterm* tp;
Uint* nargs;
erts_driver_t* driver;
char* name_buf = NULL;
SysDriverOpts opts;
Sint linebuf;
Eterm edir = NIL;
byte dir[MAXPATHLEN];
erts_aint32_t sflgs = 0;
Port *port;
/* These are the defaults */
opts.packet_bytes = 0;
opts.use_stdio = 1;
opts.redir_stderr = 0;
opts.read_write = 0;
opts.hide_window = 0;
opts.wd = NULL;
opts.envir = NULL;
opts.exit_status = 0;
opts.overlapped_io = 0;
opts.spawn_type = ERTS_SPAWN_ANY;
opts.argv = NULL;
opts.parallelism = erts_port_parallelism;
linebuf = 0;
*err_nump = 0;
if (is_not_list(settings) && is_not_nil(settings)) {
goto badarg;
}
/*
* Parse the settings.
*/
if (is_not_nil(settings)) {
nargs = list_val(settings);
while (1) {
if (is_tuple_arity(*nargs, 2)) {
tp = tuple_val(*nargs);
arity = *tp++;
option = *tp++;
if (option == am_packet) {
if (is_not_small(*tp)) {
goto badarg;
}
opts.packet_bytes = signed_val(*tp);
switch (opts.packet_bytes) {
case 1:
case 2:
case 4:
break;
default:
goto badarg;
}
} else if (option == am_line) {
if (is_not_small(*tp)) {
goto badarg;
}
linebuf = signed_val(*tp);
if (linebuf <= 0) {
goto badarg;
}
} else if (option == am_env) {
byte* bytes;
if ((bytes = convert_environment(p, *tp)) == NULL) {
goto badarg;
}
opts.envir = (char *) bytes;
} else if (option == am_args) {
char **av;
char **oav = opts.argv;
if ((av = convert_args(*tp)) == NULL) {
goto badarg;
}
opts.argv = av;
if (oav) {
opts.argv[0] = oav[0];
oav[0] = erts_default_arg0;
free_args(oav);
}
} else if (option == am_arg0) {
char *a0;
if ((a0 = erts_convert_filename_to_native(*tp, NULL, 0, ERTS_ALC_T_TMP, 1, 1, NULL)) == NULL) {
goto badarg;
}
if (opts.argv == NULL) {
opts.argv = erts_alloc(ERTS_ALC_T_TMP,
2 * sizeof(char **));
opts.argv[0] = a0;
opts.argv[1] = NULL;
} else {
if (opts.argv[0] != erts_default_arg0) {
erts_free(ERTS_ALC_T_TMP, opts.argv[0]);
}
opts.argv[0] = a0;
}
} else if (option == am_cd) {
edir = *tp;
} else if (option == am_parallelism) {
if (*tp == am_true)
opts.parallelism = 1;
else if (*tp == am_false)
opts.parallelism = 0;
else
goto badarg;
} else {
goto badarg;
}
} else if (*nargs == am_stream) {
opts.packet_bytes = 0;
} else if (*nargs == am_use_stdio) {
opts.use_stdio = 1;
} else if (*nargs == am_stderr_to_stdout) {
opts.redir_stderr = 1;
} else if (*nargs == am_line) {
linebuf = 512;
} else if (*nargs == am_nouse_stdio) {
opts.use_stdio = 0;
} else if (*nargs == am_binary) {
sflgs |= ERTS_PORT_SFLG_BINARY_IO;
} else if (*nargs == am_in) {
opts.read_write |= DO_READ;
} else if (*nargs == am_out) {
opts.read_write |= DO_WRITE;
} else if (*nargs == am_eof) {
sflgs |= ERTS_PORT_SFLG_SOFT_EOF;
} else if (*nargs == am_hide) {
opts.hide_window = 1;
} else if (*nargs == am_exit_status) {
opts.exit_status = 1;
} else if (*nargs == am_overlapped_io) {
opts.overlapped_io = 1;
} else {
goto badarg;
}
if (is_nil(*++nargs))
break;
if (is_not_list(*nargs)) {
goto badarg;
}
nargs = list_val(*nargs);
}
}
if (opts.read_write == 0) /* implement default */
opts.read_write = DO_READ|DO_WRITE;
/* Mutually exclusive arguments. */
if((linebuf && opts.packet_bytes) ||
(opts.redir_stderr && !opts.use_stdio)) {
goto badarg;
}
/*
* Parse the first argument and start the appropriate driver.
*/
if (is_atom(name) || (i = is_string(name))) {
/* a vanilla port */
if (is_atom(name)) {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP,
atom_tab(atom_val(name))->len+1);
sys_memcpy((void *) name_buf,
(void *) atom_tab(atom_val(name))->name,
atom_tab(atom_val(name))->len);
name_buf[atom_tab(atom_val(name))->len] = '\0';
} else {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP, i + 1);
if (intlist_to_buf(name, name_buf, i) != i)
erts_exit(ERTS_ERROR_EXIT, "%s:%d: Internal error\n", __FILE__, __LINE__);
name_buf[i] = '\0';
}
driver = &vanilla_driver;
} else {
if (is_not_tuple(name)) {
goto badarg; /* Not a process or fd port */
}
tp = tuple_val(name);
arity = *tp++;
if (arity == make_arityval(0)) {
goto badarg;
}
if (*tp == am_spawn || *tp == am_spawn_driver || *tp == am_spawn_executable) { /* A process port */
int encoding;
if (arity != make_arityval(2)) {
goto badarg;
}
name = tp[1];
encoding = erts_get_native_filename_encoding();
/* Do not convert the command to utf-16le yet, do that in win32 specific code */
/* since the cmd is used for comparsion with drivers names and copied to port info */
if (encoding == ERL_FILENAME_WIN_WCHAR) {
encoding = ERL_FILENAME_UTF8;
}
if ((name_buf = erts_convert_filename_to_encoding(name, NULL, 0, ERTS_ALC_T_TMP,0,1, encoding, NULL, 0))
== NULL) {
goto badarg;
}
if (*tp == am_spawn_driver) {
opts.spawn_type = ERTS_SPAWN_DRIVER;
} else if (*tp == am_spawn_executable) {
opts.spawn_type = ERTS_SPAWN_EXECUTABLE;
}
driver = &spawn_driver;
} else if (*tp == am_fd) { /* An fd port */
int n;
struct Sint_buf sbuf;
char* p;
if (arity != make_arityval(3)) {
goto badarg;
}
if (is_not_small(tp[1]) || is_not_small(tp[2])) {
goto badarg;
}
opts.ifd = unsigned_val(tp[1]);
opts.ofd = unsigned_val(tp[2]);
/* Syntesize name from input and output descriptor. */
name_buf = erts_alloc(ERTS_ALC_T_TMP,
2*sizeof(struct Sint_buf) + 2);
p = Sint_to_buf(opts.ifd, &sbuf);
n = sys_strlen(p);
sys_strncpy(name_buf, p, n);
name_buf[n] = '/';
p = Sint_to_buf(opts.ofd, &sbuf);
sys_strcpy(name_buf+n+1, p);
driver = &fd_driver;
} else {
goto badarg;
}
}
if ((driver != &spawn_driver && opts.argv != NULL) ||
(driver == &spawn_driver &&
opts.spawn_type != ERTS_SPAWN_EXECUTABLE &&
opts.argv != NULL)) {
/* Argument vector only if explicit spawn_executable */
goto badarg;
}
if (edir != NIL) {
if ((opts.wd = erts_convert_filename_to_native(edir, NULL, 0, ERTS_ALC_T_TMP,0,1,NULL)) == NULL) {
goto badarg;
}
}
if (driver != &spawn_driver && opts.exit_status) {
goto badarg;
}
if (IS_TRACED_FL(p, F_TRACE_SCHED_PROCS)) {
trace_sched(p, ERTS_PROC_LOCK_MAIN, am_out);
}
erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
port = erts_open_driver(driver, p->common.id, name_buf, &opts, err_typep, err_nump);
#ifdef USE_VM_PROBES
if (port && DTRACE_ENABLED(port_open)) {
DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);
DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
dtrace_proc_str(p, process_str);
erts_snprintf(port_str, sizeof(DTRACE_CHARBUF_NAME(port_str)), "%T", port->common.id);
DTRACE3(port_open, process_str, name_buf, port_str);
}
#endif
if (port && IS_TRACED_FL(port, F_TRACE_PORTS))
trace_port(port, am_getting_linked, p->common.id);
erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
if (IS_TRACED_FL(p, F_TRACE_SCHED_PROCS)) {
trace_sched(p, ERTS_PROC_LOCK_MAIN, am_in);
}
if (!port) {
DEBUGF(("open_driver returned (%d:%d)\n",
err_typep ? *err_typep : 4711,
err_nump ? *err_nump : 4711));
goto do_return;
}
if (linebuf && port->linebuf == NULL){
port->linebuf = allocate_linebuf(linebuf);
sflgs |= ERTS_PORT_SFLG_LINEBUF_IO;
}
if (sflgs)
erts_atomic32_read_bor_relb(&port->state, sflgs);
do_return:
if (name_buf)
erts_free(ERTS_ALC_T_TMP, (void *) name_buf);
if (opts.argv) {
free_args(opts.argv);
}
if (opts.wd && opts.wd != ((char *)dir)) {
erts_free(ERTS_ALC_T_TMP, (void *) opts.wd);
}
return port;
badarg:
if (err_typep)
*err_typep = -3;
if (err_nump)
*err_nump = BADARG;
port = NULL;
goto do_return;
}
/* Add a message last in message queue */
static Sint
queue_message(Process *c_p,
Process* receiver,
erts_aint32_t *receiver_state,
ErtsProcLocks *receiver_locks,
ErtsMessage* mp,
Eterm message,
Eterm seq_trace_token
#ifdef USE_VM_PROBES
, Eterm dt_utag
#endif
)
{
Sint res;
int locked_msgq = 0;
erts_aint32_t state;
ERTS_SMP_LC_ASSERT(*receiver_locks == erts_proc_lc_my_proc_locks(receiver));
#ifdef ERTS_SMP
if (!(*receiver_locks & ERTS_PROC_LOCK_MSGQ)) {
if (erts_smp_proc_trylock(receiver, ERTS_PROC_LOCK_MSGQ) == EBUSY) {
ErtsProcLocks need_locks = ERTS_PROC_LOCK_MSGQ;
if (receiver_state)
state = *receiver_state;
else
state = erts_smp_atomic32_read_nob(&receiver->state);
if (state & (ERTS_PSFLG_EXITING|ERTS_PSFLG_PENDING_EXIT))
goto exiting;
if (*receiver_locks & ERTS_PROC_LOCK_STATUS) {
erts_smp_proc_unlock(receiver, ERTS_PROC_LOCK_STATUS);
need_locks |= ERTS_PROC_LOCK_STATUS;
}
erts_smp_proc_lock(receiver, need_locks);
}
locked_msgq = 1;
}
#endif
state = erts_smp_atomic32_read_nob(&receiver->state);
if (state & (ERTS_PSFLG_PENDING_EXIT|ERTS_PSFLG_EXITING)) {
#ifdef ERTS_SMP
exiting:
#endif
/* Drop message if receiver is exiting or has a pending exit... */
if (locked_msgq)
erts_smp_proc_unlock(receiver, ERTS_PROC_LOCK_MSGQ);
erts_cleanup_messages(mp);
return 0;
}
ERL_MESSAGE_TERM(mp) = message;
ERL_MESSAGE_TOKEN(mp) = seq_trace_token;
#ifdef USE_VM_PROBES
ERL_MESSAGE_DT_UTAG(mp) = dt_utag;
#endif
res = receiver->msg.len;
#ifdef ERTS_SMP
if (*receiver_locks & ERTS_PROC_LOCK_MAIN) {
/*
* We move 'in queue' to 'private queue' and place
* message at the end of 'private queue' in order
* to ensure that the 'in queue' doesn't contain
* references into the heap. By ensuring this,
* we don't need to include the 'in queue' in
* the root set when garbage collecting.
*/
res += receiver->msg_inq.len;
ERTS_SMP_MSGQ_MV_INQ2PRIVQ(receiver);
LINK_MESSAGE_PRIVQ(receiver, mp);
}
else
#endif
{
LINK_MESSAGE(receiver, mp);
}
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
Sint tok_label = 0;
Sint tok_lastcnt = 0;
Sint tok_serial = 0;
dtrace_proc_str(receiver, receiver_name);
if (seq_trace_token != NIL && is_tuple(seq_trace_token)) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(seq_trace_token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(seq_trace_token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(seq_trace_token));
}
DTRACE6(message_queued,
receiver_name, size_object(message), receiver->msg.len,
tok_label, tok_lastcnt, tok_serial);
}
#endif
if (IS_TRACED_FL(receiver, F_TRACE_RECEIVE))
trace_receive(receiver, message);
if (locked_msgq)
erts_smp_proc_unlock(receiver, ERTS_PROC_LOCK_MSGQ);
erts_proc_notify_new_message(receiver,
#ifdef ERTS_SMP
*receiver_locks
#else
0
#endif
);
#ifndef ERTS_SMP
ERTS_HOLE_CHECK(receiver);
#endif
return res;
}
void
erts_queue_dist_message(Process *rcvr,
ErtsProcLocks *rcvr_locks,
ErtsDistExternal *dist_ext,
Eterm token)
{
ErlMessage* mp;
#ifdef USE_VM_PROBES
Sint tok_label = 0;
Sint tok_lastcnt = 0;
Sint tok_serial = 0;
#endif
#ifdef ERTS_SMP
erts_aint_t state;
#endif
ERTS_SMP_LC_ASSERT(*rcvr_locks == erts_proc_lc_my_proc_locks(rcvr));
mp = message_alloc();
#ifdef ERTS_SMP
if (!(*rcvr_locks & ERTS_PROC_LOCK_MSGQ)) {
if (erts_smp_proc_trylock(rcvr, ERTS_PROC_LOCK_MSGQ) == EBUSY) {
ErtsProcLocks need_locks = ERTS_PROC_LOCK_MSGQ;
if (*rcvr_locks & ERTS_PROC_LOCK_STATUS) {
erts_smp_proc_unlock(rcvr, ERTS_PROC_LOCK_STATUS);
need_locks |= ERTS_PROC_LOCK_STATUS;
}
erts_smp_proc_lock(rcvr, need_locks);
}
}
state = erts_smp_atomic32_read_acqb(&rcvr->state);
if (state & (ERTS_PSFLG_PENDING_EXIT|ERTS_PSFLG_EXITING)) {
if (!(*rcvr_locks & ERTS_PROC_LOCK_MSGQ))
erts_smp_proc_unlock(rcvr, ERTS_PROC_LOCK_MSGQ);
/* Drop message if receiver is exiting or has a pending exit ... */
if (is_not_nil(token)) {
ErlHeapFragment *heap_frag;
heap_frag = erts_dist_ext_trailer(mp->data.dist_ext);
erts_cleanup_offheap(&heap_frag->off_heap);
}
erts_free_dist_ext_copy(dist_ext);
message_free(mp);
}
else
#endif
if (IS_TRACED_FL(rcvr, F_TRACE_RECEIVE)) {
/* Ahh... need to decode it in order to trace it... */
ErlHeapFragment *mbuf;
Eterm msg;
if (!(*rcvr_locks & ERTS_PROC_LOCK_MSGQ))
erts_smp_proc_unlock(rcvr, ERTS_PROC_LOCK_MSGQ);
message_free(mp);
msg = erts_msg_distext2heap(rcvr, rcvr_locks, &mbuf, &token, dist_ext);
if (is_value(msg))
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
dtrace_proc_str(rcvr, receiver_name);
if (token != NIL && token != am_have_dt_utag) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
}
DTRACE6(message_queued,
receiver_name, size_object(msg), rcvr->msg.len,
tok_label, tok_lastcnt, tok_serial);
}
#endif
erts_queue_message(rcvr, rcvr_locks, mbuf, msg, token);
}
else {
/* Enqueue message on external format */
ERL_MESSAGE_TERM(mp) = THE_NON_VALUE;
#ifdef USE_VM_PROBES
ERL_MESSAGE_DT_UTAG(mp) = NIL;
if (token == am_have_dt_utag) {
ERL_MESSAGE_TOKEN(mp) = NIL;
} else {
#endif
ERL_MESSAGE_TOKEN(mp) = token;
#ifdef USE_VM_PROBES
}
#endif
mp->next = NULL;
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
dtrace_proc_str(rcvr, receiver_name);
if (token != NIL && token != am_have_dt_utag) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(token));
}
/*
* TODO: We don't know the real size of the external message here.
* -1 will appear to a D script as 4294967295.
*/
DTRACE6(message_queued, receiver_name, -1, rcvr->msg.len + 1,
tok_label, tok_lastcnt, tok_serial);
}
#endif
mp->data.dist_ext = dist_ext;
LINK_MESSAGE(rcvr, mp);
if (!(*rcvr_locks & ERTS_PROC_LOCK_MSGQ))
erts_smp_proc_unlock(rcvr, ERTS_PROC_LOCK_MSGQ);
erts_proc_notify_new_message(rcvr,
#ifdef ERTS_SMP
*rcvr_locks
#else
0
#endif
);
}
}
static int
open_port(Process* p, Eterm name, Eterm settings, int *err_nump)
{
#define OPEN_PORT_ERROR(VAL) do { port_num = (VAL); goto do_return; } while (0)
int i, port_num;
Eterm option;
Uint arity;
Eterm* tp;
Uint* nargs;
erts_driver_t* driver;
char* name_buf = NULL;
SysDriverOpts opts;
int binary_io;
int soft_eof;
Sint linebuf;
Eterm edir = NIL;
byte dir[MAXPATHLEN];
/* These are the defaults */
opts.packet_bytes = 0;
opts.use_stdio = 1;
opts.redir_stderr = 0;
opts.read_write = 0;
opts.hide_window = 0;
opts.wd = NULL;
opts.envir = NULL;
opts.exit_status = 0;
opts.overlapped_io = 0;
opts.spawn_type = ERTS_SPAWN_ANY;
opts.argv = NULL;
binary_io = 0;
soft_eof = 0;
linebuf = 0;
*err_nump = 0;
if (is_not_list(settings) && is_not_nil(settings)) {
goto badarg;
}
/*
* Parse the settings.
*/
if (is_not_nil(settings)) {
nargs = list_val(settings);
while (1) {
if (is_tuple_arity(*nargs, 2)) {
tp = tuple_val(*nargs);
arity = *tp++;
option = *tp++;
if (option == am_packet) {
if (is_not_small(*tp)) {
goto badarg;
}
opts.packet_bytes = signed_val(*tp);
switch (opts.packet_bytes) {
case 1:
case 2:
case 4:
break;
default:
goto badarg;
}
} else if (option == am_line) {
if (is_not_small(*tp)) {
goto badarg;
}
linebuf = signed_val(*tp);
if (linebuf <= 0) {
goto badarg;
}
} else if (option == am_env) {
byte* bytes;
if ((bytes = convert_environment(p, *tp)) == NULL) {
goto badarg;
}
opts.envir = (char *) bytes;
} else if (option == am_args) {
char **av;
char **oav = opts.argv;
if ((av = convert_args(*tp)) == NULL) {
goto badarg;
}
opts.argv = av;
if (oav) {
opts.argv[0] = oav[0];
oav[0] = erts_default_arg0;
free_args(oav);
}
} else if (option == am_arg0) {
char *a0;
if ((a0 = erts_convert_filename_to_native(*tp, ERTS_ALC_T_TMP, 1)) == NULL) {
goto badarg;
}
if (opts.argv == NULL) {
opts.argv = erts_alloc(ERTS_ALC_T_TMP,
2 * sizeof(char **));
opts.argv[0] = a0;
opts.argv[1] = NULL;
} else {
if (opts.argv[0] != erts_default_arg0) {
erts_free(ERTS_ALC_T_TMP, opts.argv[0]);
}
opts.argv[0] = a0;
}
} else if (option == am_cd) {
edir = *tp;
} else {
goto badarg;
}
} else if (*nargs == am_stream) {
opts.packet_bytes = 0;
} else if (*nargs == am_use_stdio) {
opts.use_stdio = 1;
} else if (*nargs == am_stderr_to_stdout) {
opts.redir_stderr = 1;
} else if (*nargs == am_line) {
linebuf = 512;
} else if (*nargs == am_nouse_stdio) {
opts.use_stdio = 0;
} else if (*nargs == am_binary) {
binary_io = 1;
} else if (*nargs == am_in) {
opts.read_write |= DO_READ;
} else if (*nargs == am_out) {
opts.read_write |= DO_WRITE;
} else if (*nargs == am_eof) {
soft_eof = 1;
} else if (*nargs == am_hide) {
opts.hide_window = 1;
} else if (*nargs == am_exit_status) {
opts.exit_status = 1;
} else if (*nargs == am_overlapped_io) {
opts.overlapped_io = 1;
} else {
goto badarg;
}
if (is_nil(*++nargs))
break;
if (is_not_list(*nargs)) {
goto badarg;
}
nargs = list_val(*nargs);
}
}
if (opts.read_write == 0) /* implement default */
opts.read_write = DO_READ|DO_WRITE;
/* Mutually exclusive arguments. */
if((linebuf && opts.packet_bytes) ||
(opts.redir_stderr && !opts.use_stdio)) {
goto badarg;
}
/*
* Parse the first argument and start the appropriate driver.
*/
if (is_atom(name) || (i = is_string(name))) {
/* a vanilla port */
if (is_atom(name)) {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP,
atom_tab(atom_val(name))->len+1);
sys_memcpy((void *) name_buf,
(void *) atom_tab(atom_val(name))->name,
atom_tab(atom_val(name))->len);
name_buf[atom_tab(atom_val(name))->len] = '\0';
} else {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP, i + 1);
if (intlist_to_buf(name, name_buf, i) != i)
erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);
name_buf[i] = '\0';
}
driver = &vanilla_driver;
} else {
if (is_not_tuple(name)) {
goto badarg; /* Not a process or fd port */
}
tp = tuple_val(name);
arity = *tp++;
if (arity == make_arityval(0)) {
goto badarg;
}
if (*tp == am_spawn || *tp == am_spawn_driver) { /* A process port */
if (arity != make_arityval(2)) {
goto badarg;
}
name = tp[1];
if (is_atom(name)) {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP,
atom_tab(atom_val(name))->len+1);
sys_memcpy((void *) name_buf,
(void *) atom_tab(atom_val(name))->name,
atom_tab(atom_val(name))->len);
name_buf[atom_tab(atom_val(name))->len] = '\0';
} else if ((i = is_string(name))) {
name_buf = (char *) erts_alloc(ERTS_ALC_T_TMP, i + 1);
if (intlist_to_buf(name, name_buf, i) != i)
erl_exit(1, "%s:%d: Internal error\n", __FILE__, __LINE__);
name_buf[i] = '\0';
} else {
goto badarg;
}
if (*tp == am_spawn_driver) {
opts.spawn_type = ERTS_SPAWN_DRIVER;
}
driver = &spawn_driver;
} else if (*tp == am_spawn_executable) { /* A program */
/*
* {spawn_executable,Progname}
*/
if (arity != make_arityval(2)) {
goto badarg;
}
name = tp[1];
if ((name_buf = erts_convert_filename_to_native(name,ERTS_ALC_T_TMP,0)) == NULL) {
goto badarg;
}
opts.spawn_type = ERTS_SPAWN_EXECUTABLE;
driver = &spawn_driver;
} else if (*tp == am_fd) { /* An fd port */
int n;
struct Sint_buf sbuf;
char* p;
if (arity != make_arityval(3)) {
goto badarg;
}
if (is_not_small(tp[1]) || is_not_small(tp[2])) {
goto badarg;
}
opts.ifd = unsigned_val(tp[1]);
opts.ofd = unsigned_val(tp[2]);
/* Syntesize name from input and output descriptor. */
name_buf = erts_alloc(ERTS_ALC_T_TMP,
2*sizeof(struct Sint_buf) + 2);
p = Sint_to_buf(opts.ifd, &sbuf);
n = sys_strlen(p);
sys_strncpy(name_buf, p, n);
name_buf[n] = '/';
p = Sint_to_buf(opts.ofd, &sbuf);
sys_strcpy(name_buf+n+1, p);
driver = &fd_driver;
} else {
goto badarg;
}
}
if ((driver != &spawn_driver && opts.argv != NULL) ||
(driver == &spawn_driver &&
opts.spawn_type != ERTS_SPAWN_EXECUTABLE &&
opts.argv != NULL)) {
/* Argument vector only if explicit spawn_executable */
goto badarg;
}
if (edir != NIL) {
/* A working directory is expressed differently if spawn_executable, i.e. Unicode is handles
for spawn_executable... */
if (opts.spawn_type != ERTS_SPAWN_EXECUTABLE) {
Eterm iolist;
DeclareTmpHeap(heap,4,p);
int r;
UseTmpHeap(4,p);
heap[0] = edir;
heap[1] = make_list(heap+2);
heap[2] = make_small(0);
heap[3] = NIL;
iolist = make_list(heap);
r = io_list_to_buf(iolist, (char*) dir, MAXPATHLEN);
UnUseTmpHeap(4,p);
if (r < 0) {
goto badarg;
}
opts.wd = (char *) dir;
} else {
if ((opts.wd = erts_convert_filename_to_native(edir,ERTS_ALC_T_TMP,0)) == NULL) {
goto badarg;
}
}
}
if (driver != &spawn_driver && opts.exit_status) {
goto badarg;
}
if (IS_TRACED_FL(p, F_TRACE_SCHED_PROCS)) {
trace_virtual_sched(p, am_out);
}
erts_smp_proc_unlock(p, ERTS_PROC_LOCK_MAIN);
port_num = erts_open_driver(driver, p->id, name_buf, &opts, err_nump);
#ifdef USE_VM_PROBES
if (port_num >= 0 && DTRACE_ENABLED(port_open)) {
DTRACE_CHARBUF(process_str, DTRACE_TERM_BUF_SIZE);
DTRACE_CHARBUF(port_str, DTRACE_TERM_BUF_SIZE);
dtrace_proc_str(p, process_str);
erts_snprintf(port_str, sizeof(port_str), "%T", erts_port[port_num].id);
DTRACE3(port_open, process_str, name_buf, port_str);
}
#endif
erts_smp_proc_lock(p, ERTS_PROC_LOCK_MAIN);
if (port_num < 0) {
DEBUGF(("open_driver returned %d(%d)\n", port_num, *err_nump));
if (IS_TRACED_FL(p, F_TRACE_SCHED_PROCS)) {
trace_virtual_sched(p, am_in);
}
OPEN_PORT_ERROR(port_num);
}
if (IS_TRACED_FL(p, F_TRACE_SCHED_PROCS)) {
trace_virtual_sched(p, am_in);
}
if (binary_io) {
erts_port_status_bor_set(&erts_port[port_num],
ERTS_PORT_SFLG_BINARY_IO);
}
if (soft_eof) {
erts_port_status_bor_set(&erts_port[port_num],
ERTS_PORT_SFLG_SOFT_EOF);
}
if (linebuf && erts_port[port_num].linebuf == NULL){
erts_port[port_num].linebuf = allocate_linebuf(linebuf);
erts_port_status_bor_set(&erts_port[port_num],
ERTS_PORT_SFLG_LINEBUF_IO);
}
do_return:
if (name_buf)
erts_free(ERTS_ALC_T_TMP, (void *) name_buf);
if (opts.argv) {
free_args(opts.argv);
}
if (opts.wd && opts.wd != ((char *)dir)) {
erts_free(ERTS_ALC_T_TMP, (void *) opts.wd);
}
return port_num;
badarg:
*err_nump = BADARG;
OPEN_PORT_ERROR(-3);
goto do_return;
#undef OPEN_PORT_ERROR
}
/* Add a message last in message queue */
void
erts_queue_message(Process* receiver,
ErtsProcLocks *receiver_locks,
ErlHeapFragment* bp,
Eterm message,
Eterm seq_trace_token
#ifdef USE_VM_PROBES
, Eterm dt_utag
#endif
)
{
ErlMessage* mp;
#ifdef ERTS_SMP
ErtsProcLocks need_locks;
#else
ASSERT(bp != NULL || receiver->mbuf == NULL);
#endif
ERTS_SMP_LC_ASSERT(*receiver_locks == erts_proc_lc_my_proc_locks(receiver));
mp = message_alloc();
#ifdef ERTS_SMP
need_locks = ~(*receiver_locks) & (ERTS_PROC_LOCK_MSGQ
| ERTS_PROC_LOCK_STATUS);
if (need_locks) {
*receiver_locks |= need_locks;
if (erts_smp_proc_trylock(receiver, need_locks) == EBUSY) {
if (need_locks == ERTS_PROC_LOCK_MSGQ) {
erts_smp_proc_unlock(receiver, ERTS_PROC_LOCK_STATUS);
need_locks = (ERTS_PROC_LOCK_MSGQ
| ERTS_PROC_LOCK_STATUS);
}
erts_smp_proc_lock(receiver, need_locks);
}
}
if (receiver->is_exiting || ERTS_PROC_PENDING_EXIT(receiver)) {
/* Drop message if receiver is exiting or has a pending
* exit ...
*/
if (bp)
free_message_buffer(bp);
message_free(mp);
return;
}
#endif
ERL_MESSAGE_TERM(mp) = message;
ERL_MESSAGE_TOKEN(mp) = seq_trace_token;
#ifdef USE_VM_PROBES
ERL_MESSAGE_DT_UTAG(mp) = dt_utag;
#endif
mp->next = NULL;
mp->data.heap_frag = bp;
#ifdef ERTS_SMP
if (*receiver_locks & ERTS_PROC_LOCK_MAIN) {
/*
* We move 'in queue' to 'private queue' and place
* message at the end of 'private queue' in order
* to ensure that the 'in queue' doesn't contain
* references into the heap. By ensuring this,
* we don't need to include the 'in queue' in
* the root set when garbage collecting.
*/
ERTS_SMP_MSGQ_MV_INQ2PRIVQ(receiver);
LINK_MESSAGE_PRIVQ(receiver, mp);
}
else {
LINK_MESSAGE(receiver, mp);
}
#else
LINK_MESSAGE(receiver, mp);
#endif
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
Sint tok_label = 0;
Sint tok_lastcnt = 0;
Sint tok_serial = 0;
dtrace_proc_str(receiver, receiver_name);
if (seq_trace_token != NIL && is_tuple(seq_trace_token)) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(seq_trace_token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(seq_trace_token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(seq_trace_token));
}
DTRACE6(message_queued,
receiver_name, size_object(message), receiver->msg.len,
tok_label, tok_lastcnt, tok_serial);
}
#endif
notify_new_message(receiver);
if (IS_TRACED_FL(receiver, F_TRACE_RECEIVE)) {
trace_receive(receiver, message);
}
#ifndef ERTS_SMP
ERTS_HOLE_CHECK(receiver);
#endif
}
//将消息放入目标进程的消息队列中
static Sint
queue_message(Process *c_p,
Process* receiver,
ErtsProcLocks *receiver_locks,
erts_aint32_t *receiver_state,
ErlHeapFragment* bp,
Eterm message,
Eterm seq_trace_token
#ifdef USE_VM_PROBES
, Eterm dt_utag
#endif
)
{
Sint res;
ErlMessage* mp;
int locked_msgq = 0;
erts_aint_t state;
#ifndef ERTS_SMP
ASSERT(bp != NULL || receiver->mbuf == NULL);
#endif
ERTS_SMP_LC_ASSERT(*receiver_locks == erts_proc_lc_my_proc_locks(receiver));
mp = message_alloc();
if (receiver_state){
state = *receiver_state;
}else{
state = erts_smp_atomic32_read_acqb(&receiver->state);
}
#ifdef ERTS_SMP
//如果目标进程处在退出的状态，直接进入退出清理
if (state & (ERTS_PSFLG_EXITING|ERTS_PSFLG_PENDING_EXIT)){
goto exiting;
}
//如果当前没有目标Erlang进程的消息队列锁
//尝试获取消息队列的锁
if (!(*receiver_locks & ERTS_PROC_LOCK_MSGQ)) {
if (erts_smp_proc_trylock(receiver, ERTS_PROC_LOCK_MSGQ) == EBUSY) {
ErtsProcLocks need_locks = ERTS_PROC_LOCK_MSGQ;
if (*receiver_locks & ERTS_PROC_LOCK_STATUS) {
erts_smp_proc_unlock(receiver, ERTS_PROC_LOCK_STATUS);
need_locks |= ERTS_PROC_LOCK_STATUS;
}
erts_smp_proc_lock(receiver, need_locks);
}
locked_msgq = 1;
state = erts_smp_atomic32_read_nob(&receiver->state);
//获取目标Erlang进程的状态
if (receiver_state){
*receiver_state = state;
}
}
#endif
//Erlang进程处于退出的状态
//直接释放目标进程的锁，和当前消息
if (state & (ERTS_PSFLG_PENDING_EXIT|ERTS_PSFLG_EXITING)) {
#ifdef ERTS_SMP
exiting:
#endif
/* Drop message if receiver is exiting or has a pending exit... */
if (locked_msgq){
erts_smp_proc_unlock(receiver, ERTS_PROC_LOCK_MSGQ);
}
if (bp){
free_message_buffer(bp);
}
message_free(mp);
return 0;
}
//从此处可以看出，放入目标进程的消息，只是对当前进程的消息的一个指针应用
//那我们需要找出，message是如何被处理的，何时增加的引用计数
ERL_MESSAGE_TERM(mp) = message;
ERL_MESSAGE_TOKEN(mp) = seq_trace_token;
#ifdef USE_VM_PROBES
ERL_MESSAGE_DT_UTAG(mp) = dt_utag;
#endif
mp->next = NULL;
mp->data.heap_frag = bp;
#ifndef ERTS_SMP
res = receiver->msg.len;
#else
res = receiver->msg_inq.len;
//把消息attach的目标Erlang进程的消息队列或者private
//的消息队列
if (*receiver_locks & ERTS_PROC_LOCK_MAIN) {
/*
* We move 'in queue' to 'private queue' and place
* message at the end of 'private queue' in order
* to ensure that the 'in queue' doesn't contain
* references into the heap. By ensuring this,
* we don't need to include the 'in queue' in
* the root set when garbage collecting.
*/
//这个时候可以操作msg_inq和msg
res += receiver->msg.len;
ERTS_SMP_MSGQ_MV_INQ2PRIVQ(receiver);
LINK_MESSAGE_PRIVQ(receiver, mp);
}
else
#endif
{
//这个时候只操作msg_inq
LINK_MESSAGE(receiver, mp);
}
#ifdef USE_VM_PROBES
if (DTRACE_ENABLED(message_queued)) {
DTRACE_CHARBUF(receiver_name, DTRACE_TERM_BUF_SIZE);
Sint tok_label = 0;
Sint tok_lastcnt = 0;
Sint tok_serial = 0;
dtrace_proc_str(receiver, receiver_name);
if (seq_trace_token != NIL && is_tuple(seq_trace_token)) {
tok_label = signed_val(SEQ_TRACE_T_LABEL(seq_trace_token));
tok_lastcnt = signed_val(SEQ_TRACE_T_LASTCNT(seq_trace_token));
tok_serial = signed_val(SEQ_TRACE_T_SERIAL(seq_trace_token));
}
DTRACE6(message_queued,
receiver_name, size_object(message), receiver->msg.len,
tok_label, tok_lastcnt, tok_serial);
}
#endif
if (IS_TRACED_FL(receiver, F_TRACE_RECEIVE)){
trace_receive(receiver, message);
}
if (locked_msgq){
erts_smp_proc_unlock(receiver, ERTS_PROC_LOCK_MSGQ);
}
erts_proc_notify_new_message(receiver,
#ifdef ERTS_SMP
*receiver_locks
#else
0
#endif
);
#ifndef ERTS_SMP
ERTS_HOLE_CHECK(receiver);
#endif
return res;
}
