/*
* 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;
}
