/* * VG locking is by VG name. * FIXME This should become VG uuid. */ static int _lock_vol(struct cmd_context *cmd, const char *resource, uint32_t flags, lv_operation_t lv_op, struct logical_volume *lv) { uint32_t lck_type = flags & LCK_TYPE_MASK; uint32_t lck_scope = flags & LCK_SCOPE_MASK; int ret = 0; _block_signals(flags); _lock_memory(cmd, lv_op); assert(resource); if (!*resource) { log_error(INTERNAL_ERROR "Use of P_orphans is deprecated."); return 0; } if ((is_orphan_vg(resource) || is_global_vg(resource)) && (flags & LCK_CACHE)) { log_error(INTERNAL_ERROR "P_%s referenced", resource); return 0; } if (cmd->metadata_read_only && lck_type == LCK_WRITE && strcmp(resource, VG_GLOBAL)) { log_error("Operation prohibited while global/metadata_read_only is set."); return 0; } if ((ret = _locking.lock_resource(cmd, resource, flags, lv))) { if (lck_scope == LCK_VG && !(flags & LCK_CACHE)) { if (lck_type != LCK_UNLOCK) lvmcache_lock_vgname(resource, lck_type == LCK_READ); dev_reset_error_count(cmd); } _update_vg_lock_count(resource, flags); } else stack; /* If unlocking, always remove lock from lvmcache even if operation failed. */ if (lck_scope == LCK_VG && !(flags & LCK_CACHE) && lck_type == LCK_UNLOCK) { lvmcache_unlock_vgname(resource); if (!ret) _update_vg_lock_count(resource, flags); } _unlock_memory(cmd, lv_op); _unblock_signals(); return ret; }
void reset_locking(void) { int was_locked = _vg_lock_count; _vg_lock_count = 0; _vg_write_lock_held = 0; if (_locking.reset_locking) _locking.reset_locking(); if (was_locked) _unblock_signals(); memlock_reset(); }
extern int launch_p_step_launch(srun_job_t *job, slurm_step_io_fds_t *cio_fds, uint32_t *global_rc, slurm_step_launch_callbacks_t *step_callbacks, opt_t *opt_local) { int rc = 0; pthread_t msg_thread = _spawn_msg_handler(job); aprun_pid = fork(); if (aprun_pid < 0) { error("fork: %m"); return 1; } else if (aprun_pid > 0) { if (waitpid(aprun_pid, &rc, 0) < 0) error("Unable to reap aprun child process"); *global_rc = rc; /* Just because waitpid returns something doesn't mean this function failed so always set it back to 0. */ rc = 0; } else { setpgid(0, 0); _unblock_signals(); /* dup stdio onto our open fds */ if ((dup2(cio_fds->input.fd, 0) == -1) || (dup2(cio_fds->out.fd, 1) == -1) || (dup2(cio_fds->err.fd, 2) == -1)) { error("dup2: %m"); return 1; } execvp(opt_local->argv[0], opt_local->argv); error("execv(aprun) error: %m"); return 1; } _send_step_complete_rpc(job, *global_rc); if (msg_thread) { srun_shutdown = true; pthread_cancel(msg_thread); pthread_join(msg_thread, NULL); } return rc; }
extern int launch_p_step_launch( srun_job_t *job, slurm_step_io_fds_t *cio_fds, uint32_t *global_rc, slurm_step_launch_callbacks_t *step_callbacks) { int rc = 0; if (opt.export_env) _build_user_env(); poe_pid = fork(); if (poe_pid < 0) { error("fork: %m"); return 1; } else if (poe_pid > 0) { if (waitpid(poe_pid, &rc, 0) < 0) error("Unable to reap poe child process"); *global_rc = rc; /* Just because waitpid returns something doesn't mean this function failed so always set it back to 0. */ rc = 0; } else { setpgrp(); _unblock_signals(); /* dup stdio onto our open fds */ if ((dup2(cio_fds->input.fd, 0) == -1) || (dup2(cio_fds->out.fd, 1) == -1) || (dup2(cio_fds->err.fd, 2) == -1)) { error("dup2: %m"); return 1; } execvp(opt.argv[0], opt.argv); error("execv(poe) error: %m"); return 1; } return rc; }