static int init_global_snapshot_directory(orte_sstore_central_global_snapshot_info_t *handle_info)
{
int ret, exit_status = ORTE_SUCCESS;
char * dir_name = NULL;
mode_t my_mode = S_IRWXU;
/*
* Make the snapshot directory from the uniq_global_snapshot_name
*/
asprintf(&dir_name, "%s/%s",
handle_info->base_location,
handle_info->local_location);
if(OPAL_SUCCESS != (ret = opal_os_dirpath_create(dir_name, my_mode)) ) {
ORTE_ERROR_LOG(ret);
exit_status = ret;
goto cleanup;
}
/*
* Open up the metadata file
*/
if( ORTE_SUCCESS != (ret = metadata_open(handle_info)) ) {
ORTE_ERROR_LOG(ret);
exit_status = ret;
goto cleanup;
}
cleanup:
if(NULL != dir_name) {
free(dir_name);
dir_name = NULL;
}
return exit_status;
}
static bool test3(void)
{
char *out;
struct stat buf;
char *a[] = { "aaa", "bbb", "ccc", NULL };
if (NULL == path_sep) {
printf("test3 cannot be run\n");
return(false);
}
out = opal_os_path(true, a[0], a[1], a[2], NULL);
if (OPAL_SUCCESS != opal_os_dirpath_create(out, S_IRWXU)) {
out = opal_os_path(true, a[0], a[1], a[2], NULL);
if (0 == stat(out, &buf))
rmdir(out);
out = opal_os_path(true, a[0], a[1], NULL);
if (0 == stat(out, &buf))
rmdir(out);
out = opal_os_path(true, a[0], NULL);
if (0 == stat(out, &buf))
rmdir(out);
return(false);
}
free(out);
return(true);
}
/*
* Check and create the directory requested
*/
static int orte_create_dir(char *directory)
{
mode_t my_mode = S_IRWXU; /* I'm looking for full rights */
int ret;
/* Sanity check before creating the directory with the proper mode,
* Make sure it doesn't exist already */
if( ORTE_ERR_NOT_FOUND !=
(ret = opal_os_dirpath_access(directory, my_mode)) ) {
/* Failure because opal_os_dirpath_access() indicated that either:
* - The directory exists and we can access it (no need to create it again),
* return OPAL_SUCCESS, or
* - don't have access rights, return OPAL_ERROR
*/
if (ORTE_SUCCESS != ret) {
ORTE_ERROR_LOG(ret);
}
return(ret);
}
/* Get here if the directory doesn't exist, so create it */
if (ORTE_SUCCESS != (ret = opal_os_dirpath_create(directory, my_mode))) {
ORTE_ERROR_LOG(ret);
}
return ret;
}
static bool test1(void)
{
/* Test trivial functionality. Program should return OPAL_ERROR when called with NULL path. */
if (OPAL_SUCCESS == opal_os_dirpath_create(NULL, S_IRWXU))
return(false);
return true;
}
/**
* Creates the passed directory. If the directory already exists, it and its
* contents will be deleted then the directory will be created.
* @param directory The directory to be created.
* @retval ORTE_SUCCESS
* @retval error
*/
static int
odls_bproc_make_dir(char *directory)
{
struct stat buf;
mode_t my_mode = S_IRWXU; /* at the least, I need to be able to do anything */
if (0 == stat(directory, &buf)) { /* exists - delete it and its contents */
odls_bproc_delete_dir_tree(directory);
}
/* try to create it with proper mode */
return(opal_os_dirpath_create(directory, my_mode));
}
int opal_crs_base_init_snapshot_directory(opal_crs_base_snapshot_t *snapshot)
{
int ret, exit_status = OPAL_SUCCESS;
mode_t my_mode = S_IRWXU;
char * pid_str = NULL;
/*
* Make the snapshot directory from the uniq_snapshot_name
*/
if(OPAL_SUCCESS != (ret = opal_os_dirpath_create(snapshot->local_location, my_mode)) ) {
opal_output(opal_crs_base_output,
"opal:crs:base: init_snapshot_directory: Error: Unable to create directory (%s)\n",
snapshot->local_location);
exit_status = ret;
goto cleanup;
}
/*
* Initialize the metadata file at the top of that directory.
* Add 'BASE' and 'PID'
*/
if( NULL != last_metadata_file ) {
free(last_metadata_file);
last_metadata_file = NULL;
}
last_metadata_file = strdup(snapshot->local_location);
if( OPAL_SUCCESS != (ret = opal_crs_base_metadata_write_token(NULL, CRS_METADATA_BASE, "") ) ) {
opal_output(opal_crs_base_output,
"opal:crs:base: init_snapshot_directory: Error: Unable to write BASE to the file (%s/%s)\n",
snapshot->local_location, opal_crs_base_metadata_filename);
exit_status = ret;
goto cleanup;
}
asprintf(&pid_str, "%d", getpid());
if( OPAL_SUCCESS != (ret = opal_crs_base_metadata_write_token(NULL, CRS_METADATA_PID, pid_str) ) ) {
opal_output(opal_crs_base_output,
"opal:crs:base: init_snapshot_directory: Error: Unable to write PID (%s) to the file (%s/%s)\n",
pid_str, snapshot->local_location, opal_crs_base_metadata_filename);
exit_status = ret;
goto cleanup;
}
cleanup:
if( NULL != pid_str) {
free(pid_str);
pid_str = NULL;
}
return OPAL_SUCCESS;
}
static int init_local_snapshot_directory(orte_sstore_central_app_snapshot_info_t *handle_info)
{
int ret, exit_status = ORTE_SUCCESS;
mode_t my_mode = S_IRWXU;
/*
* Make the snapshot directory from the uniq_global_snapshot_name
*/
if(OPAL_SUCCESS != (ret = opal_os_dirpath_create(handle_info->local_location, my_mode)) ) {
opal_show_help("help-orte-sstore-central.txt", "fail_path_create", true,
ORTE_NAME_PRINT(ORTE_PROC_MY_NAME),
orte_process_info.nodename,
handle_info->local_location);
ORTE_ERROR_LOG(ret);
exit_status = ret;
goto cleanup;
}
/*
* Open up the metadata file
*/
if( ORTE_SUCCESS != (ret = metadata_open(handle_info)) ) {
ORTE_ERROR_LOG(ret);
exit_status = ret;
goto cleanup;
}
/*
* Add a timestamp and the PID of this process
*/
if( ORTE_SUCCESS != (ret = metadata_write_timestamp(handle_info)) ) {
ORTE_ERROR_LOG(ret);
exit_status = ret;
goto cleanup;
}
if( ORTE_SUCCESS != (ret = metadata_write_int(handle_info, SSTORE_METADATA_LOCAL_PID_STR, (int)getpid())) ) {
ORTE_ERROR_LOG(ret);
exit_status = ret;
goto cleanup;
}
if( ORTE_SUCCESS != (ret = metadata_close(handle_info)) ) {
ORTE_ERROR_LOG(ret);
exit_status = ret;
goto cleanup;
}
cleanup:
return exit_status;
}
static bool test2(void)
{
char *tmp;
struct stat buf;
if (NULL == path_sep) {
printf("test2 cannot be run\n");
return(false);
}
tmp = opal_os_path(true, "tmp", NULL);
if (0 != mkdir(tmp, S_IRWXU)) {
printf("test2 could not be run - directory could not be made\n");
return(false);
}
if (OPAL_SUCCESS != opal_os_dirpath_create(tmp, S_IRWXU)) {
rmdir(tmp);
return(false);
}
chmod(tmp, S_IRUSR);
if (OPAL_SUCCESS != opal_os_dirpath_create(tmp, S_IRWXU)) {
rmdir(tmp);
return(false);
}
stat(tmp, &buf);
if (S_IRWXU != (S_IRWXU & buf.st_mode)) {
rmdir(tmp);
return(false);
}
rmdir(tmp);
free(tmp);
return true;
}
/*
* Check and create the directory requested
*/
static int orte_create_dir(char *directory)
{
#ifndef __WINDOWS__
mode_t my_mode = S_IRWXU; /* at the least, I need to be able to do anything */
#else
mode_t my_mode = _S_IREAD | _S_IWRITE | _S_IEXEC;
#endif
int ret;
/* Sanity check before creating the directory with the proper mode,
* Make sure it doesn't exist already */
if( OPAL_ERR_NOT_FOUND != (ret = opal_os_dirpath_access(directory, my_mode)) ) {
/* Failure because opal_os_dirpath_access() indicated that either:
* - The directory exists and we can access it (no need to create it again),
* return OPAL_SUCCESS, or
* - don't have access rights, return OPAL_ERROR
*/
return(ret);
}
/* The directory doesn't exist so create it */
else {
return(opal_os_dirpath_create(directory, my_mode));
}
}
static int setup_child(orte_job_t *jdata,
orte_proc_t *child,
orte_app_context_t *app)
{
char *param, *value;
int rc, i;
int32_t nrestarts=0, *nrptr;
bool takeus = false;
/* see if we are included */
for (i=0; NULL != jdata->personality[i]; i++) {
if (0 == strcmp(jdata->personality[i], "ompi")) {
takeus = true;
break;
}
}
if (!takeus) {
return ORTE_ERR_TAKE_NEXT_OPTION;
}
/* setup the jobid */
if (ORTE_SUCCESS != (rc = orte_util_convert_jobid_to_string(&value, child->name.jobid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
opal_setenv("OMPI_MCA_ess_base_jobid", value, true, &app->env);
free(value);
/* setup the vpid */
if (ORTE_SUCCESS != (rc = orte_util_convert_vpid_to_string(&value, child->name.vpid))) {
ORTE_ERROR_LOG(rc);
return rc;
}
opal_setenv("OMPI_MCA_ess_base_vpid", value, true, &app->env);
/* although the vpid IS the process' rank within the job, users
* would appreciate being given a public environmental variable
* that also represents this value - something MPI specific - so
* do that here.
*
* AND YES - THIS BREAKS THE ABSTRACTION BARRIER TO SOME EXTENT.
* We know - just live with it
*/
opal_setenv("OMPI_COMM_WORLD_RANK", value, true, &app->env);
free(value); /* done with this now */
/* users would appreciate being given a public environmental variable
* that also represents the local rank value - something MPI specific - so
* do that here.
*
* AND YES - THIS BREAKS THE ABSTRACTION BARRIER TO SOME EXTENT.
* We know - just live with it
*/
if (ORTE_LOCAL_RANK_INVALID == child->local_rank) {
ORTE_ERROR_LOG(ORTE_ERR_VALUE_OUT_OF_BOUNDS);
rc = ORTE_ERR_VALUE_OUT_OF_BOUNDS;
return rc;
}
asprintf(&value, "%lu", (unsigned long) child->local_rank);
opal_setenv("OMPI_COMM_WORLD_LOCAL_RANK", value, true, &app->env);
free(value);
/* users would appreciate being given a public environmental variable
* that also represents the node rank value - something MPI specific - so
* do that here.
*
* AND YES - THIS BREAKS THE ABSTRACTION BARRIER TO SOME EXTENT.
* We know - just live with it
*/
if (ORTE_NODE_RANK_INVALID == child->node_rank) {
ORTE_ERROR_LOG(ORTE_ERR_VALUE_OUT_OF_BOUNDS);
rc = ORTE_ERR_VALUE_OUT_OF_BOUNDS;
return rc;
}
asprintf(&value, "%lu", (unsigned long) child->node_rank);
opal_setenv("OMPI_COMM_WORLD_NODE_RANK", value, true, &app->env);
/* set an mca param for it too */
opal_setenv("OMPI_MCA_orte_ess_node_rank", value, true, &app->env);
free(value);
/* provide the identifier for the PMIx connection - the
* PMIx connection is made prior to setting the process
* name itself. Although in most cases the ID and the
* process name are the same, it isn't necessarily
* required */
orte_util_convert_process_name_to_string(&value, &child->name);
opal_setenv("PMIX_ID", value, true, &app->env);
free(value);
nrptr = &nrestarts;
if (orte_get_attribute(&child->attributes, ORTE_PROC_NRESTARTS, (void**)&nrptr, OPAL_INT32)) {
/* pass the number of restarts for this proc - will be zero for
* an initial start, but procs would like to know if they are being
* restarted so they can take appropriate action
*/
asprintf(&value, "%d", nrestarts);
opal_setenv("OMPI_MCA_orte_num_restarts", value, true, &app->env);
free(value);
}
/* if the proc should not barrier in orte_init, tell it */
if (orte_get_attribute(&child->attributes, ORTE_PROC_NOBARRIER, NULL, OPAL_BOOL)
|| 0 < nrestarts) {
opal_setenv("OMPI_MCA_orte_do_not_barrier", "1", true, &app->env);
}
/* if we are using staged execution, tell it */
if (orte_staged_execution) {
opal_setenv("OMPI_MCA_orte_staged_execution", "1", true, &app->env);
}
/* if the proc isn't going to forward IO, then we need to flag that
* it has "completed" iof termination as otherwise it will never fire
*/
if (!ORTE_FLAG_TEST(jdata, ORTE_JOB_FLAG_FORWARD_OUTPUT)) {
ORTE_FLAG_SET(child, ORTE_PROC_FLAG_IOF_COMPLETE);
}
/* construct the proc's session dir name */
if (NULL != orte_process_info.tmpdir_base) {
value = strdup(orte_process_info.tmpdir_base);
} else {
value = NULL;
}
param = NULL;
if (ORTE_SUCCESS != (rc = orte_session_dir_get_name(¶m, &value, NULL,
orte_process_info.nodename,
NULL, &child->name))) {
ORTE_ERROR_LOG(rc);
if (NULL != value) {
free(value);
}
return rc;
}
free(value);
/* pass an envar so the proc can find any files it had prepositioned */
opal_setenv("OMPI_FILE_LOCATION", param, true, &app->env);
/* if the user wanted the cwd to be the proc's session dir, then
* switch to that location now
*/
if (orte_get_attribute(&app->attributes, ORTE_APP_SSNDIR_CWD, NULL, OPAL_BOOL)) {
/* create the session dir - may not exist */
if (OPAL_SUCCESS != (rc = opal_os_dirpath_create(param, S_IRWXU))) {
ORTE_ERROR_LOG(rc);
/* doesn't exist with correct permissions, and/or we can't
* create it - either way, we are done
*/
free(param);
return rc;
}
/* change to it */
if (0 != chdir(param)) {
free(param);
return ORTE_ERROR;
}
/* It seems that chdir doesn't
* adjust the $PWD enviro variable when it changes the directory. This
* can cause a user to get a different response when doing getcwd vs
* looking at the enviro variable. To keep this consistent, we explicitly
* ensure that the PWD enviro variable matches the CWD we moved to.
*
* NOTE: if a user's program does a chdir(), then $PWD will once
* again not match getcwd! This is beyond our control - we are only
* ensuring they start out matching.
*/
opal_setenv("PWD", param, true, &app->env);
/* update the initial wdir value too */
opal_setenv("OMPI_MCA_initial_wdir", param, true, &app->env);
}
free(param);
return ORTE_SUCCESS;
}
/**
* Function for finding and opening either all MCA components, or the one
* that was specifically requested via a MCA parameter.
*/
static int orte_iof_base_open(mca_base_open_flag_t flags)
{
int rc, xmlfd;
/* did the user request we print output to files? */
if (NULL != orte_output_filename) {
/* we will setup the files themselves as needed in the iof
* module. For now, let's see if the filename contains a
* path, or just a name
*/
char *path;
path = opal_dirname(orte_output_filename);
if (NULL == path) {
return ORTE_ERR_OUT_OF_RESOURCE;
}
if (0 != strcmp(path, orte_output_filename)) {
/* there is a path in this name - ensure that the directory
* exists, and create it if not
*/
if (ORTE_SUCCESS != (rc = opal_os_dirpath_create(path, S_IRWXU))) {
free(path);
return rc;
}
}
free(path);
}
/* daemons do not need to do this as they do not write out stdout/err */
if (!ORTE_PROC_IS_DAEMON ||
(ORTE_PROC_IS_DAEMON && ORTE_PROC_IS_CM)) {
if (orte_xml_output) {
if (NULL != orte_xml_fp) {
/* user wants all xml-formatted output sent to file */
xmlfd = fileno(orte_xml_fp);
} else {
xmlfd = 1;
}
/* setup the stdout event */
ORTE_IOF_SINK_DEFINE(&orte_iof_base.iof_write_stdout, ORTE_PROC_MY_NAME,
xmlfd, ORTE_IOF_STDOUT, orte_iof_base_write_handler);
/* don't create a stderr event - all output will go to
* the stdout channel
*/
} else {
/* setup the stdout event */
ORTE_IOF_SINK_DEFINE(&orte_iof_base.iof_write_stdout, ORTE_PROC_MY_NAME,
1, ORTE_IOF_STDOUT, orte_iof_base_write_handler);
/* setup the stderr event */
ORTE_IOF_SINK_DEFINE(&orte_iof_base.iof_write_stderr, ORTE_PROC_MY_NAME,
2, ORTE_IOF_STDERR, orte_iof_base_write_handler);
}
/* do NOT set these file descriptors to non-blocking. If we do so,
* we set the file descriptor to non-blocking for everyone that has
* that file descriptor, which includes everyone else in our shell
* pipeline chain. (See
* http://lists.freebsd.org/pipermail/freebsd-hackers/2005-January/009742.html).
* This causes things like "mpirun -np 1 big_app | cat" to lose
* output, because cat's stdout is then ALSO non-blocking and cat
* isn't built to deal with that case (same with almost all other
* unix text utils).
*/
}
/* Open up all available components */
return mca_base_framework_components_open(&orte_iof_base_framework, flags);
}
int orte_iof_base_setup_output_files(const orte_process_name_t* dst_name,
orte_job_t *jobdat,
orte_iof_proc_t *proct)
{
int rc;
char *dirname, *outdir, *outfile;
int np, numdigs, fdout, i;
char *p, **s;
bool usejobid = true;
/* see if we are to output to a file */
dirname = NULL;
if (orte_get_attribute(&jobdat->attributes, ORTE_JOB_OUTPUT_TO_FILE, (void**)&dirname, OPAL_STRING) &&
NULL != dirname) {
np = jobdat->num_procs / 10;
/* determine the number of digits required for max vpid */
numdigs = 1;
while (np > 0) {
numdigs++;
np = np / 10;
}
/* check for a conditional in the directory name */
if (NULL != (p = strchr(dirname, ':'))) {
*p = '\0';
++p;
/* could me more than one directive */
s = opal_argv_split(p, ',');
for (i=0; NULL != s[i]; i++) {
if (0 == strcasecmp(s[i], "nojobid")) {
usejobid = false;
} else if (0 == strcasecmp(s[i], "nocopy")) {
proct->copy = false;
}
}
}
/* construct the directory where the output files will go */
if (usejobid) {
asprintf(&outdir, "%s/%d/rank.%0*lu", dirname,
(int)ORTE_LOCAL_JOBID(proct->name.jobid),
numdigs, (unsigned long)proct->name.vpid);
} else {
asprintf(&outdir, "%s/rank.%0*lu", dirname,
numdigs, (unsigned long)proct->name.vpid);
}
/* ensure the directory exists */
if (OPAL_SUCCESS != (rc = opal_os_dirpath_create(outdir, S_IRWXU|S_IRGRP|S_IXGRP))) {
ORTE_ERROR_LOG(rc);
free(outdir);
return rc;
}
if (NULL != proct->revstdout && NULL == proct->revstdout->sink) {
/* setup the stdout sink */
asprintf(&outfile, "%s/stdout", outdir);
fdout = open(outfile, O_CREAT|O_RDWR|O_TRUNC, 0644);
free(outfile);
if (fdout < 0) {
/* couldn't be opened */
ORTE_ERROR_LOG(ORTE_ERR_FILE_OPEN_FAILURE);
return ORTE_ERR_FILE_OPEN_FAILURE;
}
/* define a sink to that file descriptor */
ORTE_IOF_SINK_DEFINE(&proct->revstdout->sink, dst_name,
fdout, ORTE_IOF_STDOUT,
orte_iof_base_write_handler);
}
if (NULL != proct->revstderr && NULL == proct->revstderr->sink) {
/* if they asked for stderr to be combined with stdout, then we
* only create one file and tell the IOF to put both streams
* into it. Otherwise, we create separate files for each stream */
if (orte_get_attribute(&jobdat->attributes, ORTE_JOB_MERGE_STDERR_STDOUT, NULL, OPAL_BOOL)) {
/* just use the stdout sink */
OBJ_RETAIN(proct->revstdout->sink);
proct->revstdout->sink->tag = ORTE_IOF_STDMERGE; // show that it is merged
proct->revstderr->sink = proct->revstdout->sink;
} else {
asprintf(&outfile, "%s/stderr", outdir);
fdout = open(outfile, O_CREAT|O_RDWR|O_TRUNC, 0644);
free(outfile);
if (fdout < 0) {
/* couldn't be opened */
ORTE_ERROR_LOG(ORTE_ERR_FILE_OPEN_FAILURE);
return ORTE_ERR_FILE_OPEN_FAILURE;
}
/* define a sink to that file descriptor */
ORTE_IOF_SINK_DEFINE(&proct->revstderr->sink, dst_name,
fdout, ORTE_IOF_STDERR,
orte_iof_base_write_handler);
}
}
#if OPAL_PMIX_V1
if (NULL != proct->revstddiag && NULL == proct->revstddiag->sink) {
/* always tie the sink for stddiag to stderr */
OBJ_RETAIN(proct->revstderr->sink);
proct->revstddiag->sink = proct->revstderr->sink;
}
#endif
}
return ORTE_SUCCESS;
}
