static void
release_update_permission(int release_updater)
{
erts_mtx_lock(&update_table_permission_mtx);
ASSERT(updater_process != NULL);
if (release_updater) {
erts_proc_lock(updater_process, ERTS_PROC_LOCK_STATUS);
if (!ERTS_PROC_IS_EXITING(updater_process)) {
erts_resume(updater_process, ERTS_PROC_LOCK_STATUS);
}
erts_proc_unlock(updater_process, ERTS_PROC_LOCK_STATUS);
}
updater_process = NULL;
while (update_queue != NULL) { /* Unleash the entire herd */
struct update_queue_item* qitem = update_queue;
erts_proc_lock(qitem->p, ERTS_PROC_LOCK_STATUS);
if (!ERTS_PROC_IS_EXITING(qitem->p)) {
erts_resume(qitem->p, ERTS_PROC_LOCK_STATUS);
}
erts_proc_unlock(qitem->p, ERTS_PROC_LOCK_STATUS);
update_queue = qitem->next;
erts_proc_dec_refc(qitem->p);
erts_free(ERTS_ALC_T_PERSISTENT_LOCK_Q, qitem);
}
erts_mtx_unlock(&update_table_permission_mtx);
}
static void
resume_purger(void *unused)
{
Process *p = erts_code_purger;
erts_smp_proc_lock(p, ERTS_PROC_LOCK_STATUS);
erts_resume(p, ERTS_PROC_LOCK_STATUS);
erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
}
static void
complete_literal_area_switch(void *literal_area)
{
Process *p = erts_literal_area_collector;
erts_smp_proc_lock(p, ERTS_PROC_LOCK_STATUS);
erts_resume(p, ERTS_PROC_LOCK_STATUS);
erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
if (literal_area)
erts_release_literal_area((ErtsLiteralArea *) literal_area);
}
static void copy_literals_commit(void* null) {
Process* p = committer_state.stager;
#ifdef DEBUG
committer_state.stager = NULL;
#endif
erts_release_code_write_permission();
erts_smp_proc_lock(p, ERTS_PROC_LOCK_STATUS);
if (!ERTS_PROC_IS_EXITING(p)) {
erts_resume(p, ERTS_PROC_LOCK_STATUS);
}
erts_smp_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
erts_proc_dec_refc(p);
}
Eterm
check_process_code_2(BIF_ALIST_2)
{
Process* rp;
Module* modp;
if (is_not_atom(BIF_ARG_2)) {
goto error;
}
if (is_internal_pid(BIF_ARG_1)) {
Eterm res;
if (internal_pid_index(BIF_ARG_1) >= erts_max_processes)
goto error;
modp = erts_get_module(BIF_ARG_2);
if (modp == NULL) { /* Doesn't exist. */
return am_false;
} else if (modp->old_code == NULL) { /* No old code. */
return am_false;
}
#ifdef ERTS_SMP
rp = erts_pid2proc_suspend(BIF_P, ERTS_PROC_LOCK_MAIN,
BIF_ARG_1, ERTS_PROC_LOCK_MAIN);
#else
rp = erts_pid2proc(BIF_P, 0, BIF_ARG_1, 0);
#endif
if (!rp) {
BIF_RET(am_false);
}
if (rp == ERTS_PROC_LOCK_BUSY) {
ERTS_BIF_YIELD2(bif_export[BIF_check_process_code_2], BIF_P,
BIF_ARG_1, BIF_ARG_2);
}
res = check_process_code(rp, modp);
#ifdef ERTS_SMP
if (BIF_P != rp) {
erts_resume(rp, ERTS_PROC_LOCK_MAIN);
erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_MAIN);
}
#endif
BIF_RET(res);
}
else if (is_external_pid(BIF_ARG_1)
&& external_pid_dist_entry(BIF_ARG_1) == erts_this_dist_entry) {
BIF_RET(am_false);
}
error:
BIF_ERROR(BIF_P, BADARG);
}
static void
finalize_purge_operation(Process *c_p, int succeded)
{
Uint ix;
if (c_p)
erts_smp_proc_unlock(c_p, ERTS_PROC_LOCK_MAIN);
erts_smp_mtx_lock(&purge_state.mtx);
ASSERT(purge_state.module != THE_NON_VALUE);
purge_state.module = THE_NON_VALUE;
/*
* Resume all processes that have tried to call
* funs in this code.
*/
for (ix = 0; ix < purge_state.sp_ix; ix++) {
Process *rp = erts_pid2proc(NULL, 0,
purge_state.sprocs[ix],
ERTS_PROC_LOCK_STATUS);
if (rp) {
erts_resume(rp, ERTS_PROC_LOCK_STATUS);
erts_smp_proc_unlock(rp, ERTS_PROC_LOCK_STATUS);
}
}
erts_smp_mtx_unlock(&purge_state.mtx);
if (c_p)
erts_smp_proc_lock(c_p, ERTS_PROC_LOCK_MAIN);
if (purge_state.sprocs != &purge_state.def_sprocs[0]) {
erts_free(ERTS_ALC_T_PURGE_DATA, purge_state.sprocs);
purge_state.sprocs = &purge_state.def_sprocs[0];
purge_state.sp_size = sizeof(purge_state.def_sprocs);
purge_state.sp_size /= sizeof(purge_state.def_sprocs[0]);
}
purge_state.sp_ix = 0;
if (purge_state.funs != &purge_state.def_funs[0]) {
erts_free(ERTS_ALC_T_PURGE_DATA, purge_state.funs);
purge_state.funs = &purge_state.def_funs[0];
purge_state.fe_size = sizeof(purge_state.def_funs);
purge_state.fe_size /= sizeof(purge_state.def_funs[0]);
}
purge_state.fe_ix = 0;
}
static void
thr_prg_wake_up_later(void* bin_p)
{
Binary* bin = bin_p;
ErtsFlxCtrWakeUpLaterInfo* info = ERTS_MAGIC_BIN_DATA(bin);
Process* p = info->process;
/* Resume the requesting process */
erts_proc_lock(p, ERTS_PROC_LOCK_STATUS);
if (!ERTS_PROC_IS_EXITING(p)) {
erts_resume(p, ERTS_PROC_LOCK_STATUS);
}
erts_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
/* Free data */
erts_proc_dec_refc(p);
erts_bin_release(bin);
}
void erts_release_code_write_permission(void)
{
erts_smp_mtx_lock(&the_code_ix_queue_lock);
while (the_code_ix_queue != NULL) { /* unleash the entire herd */
struct code_ix_queue_item* qitem = the_code_ix_queue;
erts_smp_proc_lock(qitem->p, ERTS_PROC_LOCK_STATUS);
if (!ERTS_PROC_IS_EXITING(qitem->p)) {
erts_resume(qitem->p, ERTS_PROC_LOCK_STATUS);
}
erts_smp_proc_unlock(qitem->p, ERTS_PROC_LOCK_STATUS);
the_code_ix_queue = qitem->next;
erts_smp_proc_dec_refc(qitem->p);
erts_free(ERTS_ALC_T_CODE_IX_LOCK_Q, qitem);
}
the_code_ix_lock = 0;
erts_smp_mtx_unlock(&the_code_ix_queue_lock);
}
static void
thr_prg_wake_up_and_count(void* bin_p)
{
Binary* bin = bin_p;
DecentralizedReadSnapshotInfo* info = ERTS_MAGIC_BIN_DATA(bin);
Process* p = info->process;
ErtsFlxCtrDecentralizedCtrArray* array = info->array;
ErtsFlxCtrDecentralizedCtrArray* next = info->next_array;
int i, sched;
/* Reset result array */
for (i = 0; i < info->nr_of_counters; i++) {
info->result[i] = 0;
}
/* Read result from snapshot */
for (sched = 0; sched < ERTS_FLXCTR_DECENTRALIZED_NO_SLOTS; sched++) {
for (i = 0; i < info->nr_of_counters; i++) {
info->result[i] = info->result[i] +
erts_atomic_read_nob(&array->array[sched].counters[i]);
}
}
/* Update the next decentralized counter array */
for (i = 0; i < info->nr_of_counters; i++) {
erts_atomic_add_nob(&next->array[0].counters[i], info->result[i]);
}
/* Announce that the snapshot is done */
{
Sint expected = ERTS_FLXCTR_SNAPSHOT_ONGOING;
if (expected != erts_atomic_cmpxchg_mb(&next->snapshot_status,
ERTS_FLXCTR_SNAPSHOT_NOT_ONGOING,
expected)) {
/* The CAS failed which means that this thread need to free the next array. */
erts_free(info->alloc_type, next->block_start);
}
}
/* Resume the process that requested the snapshot */
erts_proc_lock(p, ERTS_PROC_LOCK_STATUS);
if (!ERTS_PROC_IS_EXITING(p)) {
erts_resume(p, ERTS_PROC_LOCK_STATUS);
}
/* Free the memory that is no longer needed */
erts_free(info->alloc_type, array->block_start);
erts_proc_unlock(p, ERTS_PROC_LOCK_STATUS);
erts_proc_dec_refc(p);
erts_bin_release(bin);
}
void erts_release_code_write_permission(void)
{
erts_smp_mtx_lock(&code_write_permission_mtx);
ERTS_SMP_LC_ASSERT(erts_has_code_write_permission());
while (code_write_queue != NULL) { /* unleash the entire herd */
struct code_write_queue_item* qitem = code_write_queue;
erts_smp_proc_lock(qitem->p, ERTS_PROC_LOCK_STATUS);
if (!ERTS_PROC_IS_EXITING(qitem->p)) {
erts_resume(qitem->p, ERTS_PROC_LOCK_STATUS);
}
erts_smp_proc_unlock(qitem->p, ERTS_PROC_LOCK_STATUS);
code_write_queue = qitem->next;
erts_proc_dec_refc(qitem->p);
erts_free(ERTS_ALC_T_CODE_IX_LOCK_Q, qitem);
}
code_writing_process = NULL;
#ifdef ERTS_ENABLE_LOCK_CHECK
erts_tsd_set(has_code_write_permission, (void *) 0);
#endif
erts_smp_mtx_unlock(&code_write_permission_mtx);
}
