mom_start.c

openPBS的开放源代码

    struct startjob_rtn *sjr;
{
	uid_t	uid = pjob->ji_qs.ji_un.ji_momt.ji_exuid;
	
        if ((sjr->sj_session = setjob(uid, WJSIGNAL)) == -1)
                return (-1);
	if (sesscntl(sjr->sj_session, S_SETFL, S_BATCH) == -1)
		return (-1);
	sjr->sj_pid = getpid();
	return (sjr->sj_session);
}

/*
**	set_globid - set the global id for a machine type.
*/
void
set_globid(pjob, sjr)
	job *pjob;
	struct startjob_rtn *sjr;
{
	char cvtbuf[20];

	(void)sprintf(cvtbuf, "%ld", (long)sjr->sj_pid);
	 if (pjob->ji_globid)
		free(pjob->ji_globid);
	pjob->ji_globid = strdup(cvtbuf);
	(void)decode_str(&pjob->ji_wattr[JOB_ATR_altid],
			  ATTR_altid, NULL, cvtbuf);
}

/*
 * set_mach_vars - setup machine dependent environment variables
 */
int
set_mach_vars(pjob, vtab)
	job   		 *pjob;
	struct var_table *vtab;
{
	int	 ret;

	/* Add names of temp directories to environment */
	ret = mktmpdir(pjob, vtab);
	switch (ret) {
	case 0:
		return 0;
	case 1:			/* old dirs exist, doing remove */
		rmtmpdir(pjob->ji_qs.ji_jobid);
		return JOB_EXEC_RETRY;
	default:
		return JOB_EXEC_FAIL1;
	}
}

char *set_shell(pjob, pwdp)
	job	      *pjob;
	struct passwd *pwdp;
{
	char *cp;
	int   i;
	char *shell;
	struct array_strings *vstrs;
	/*
	 * find which shell to use, one specified or the login shell
	 */

	shell = pwdp->pw_shell;
	if ((pjob->ji_wattr[(int)JOB_ATR_shell].at_flags & ATR_VFLAG_SET) &&
	    (vstrs = pjob->ji_wattr[(int)JOB_ATR_shell].at_val.at_arst)) {
		for (i = 0; i < vstrs->as_usedptr; ++i) {
			cp = strchr(vstrs->as_string[i], '@');
			if (cp) {
				if (!strncmp(mom_host, cp+1, strlen(cp+1))) {
					*cp = '\0';	/* host name matches */
					shell = vstrs->as_string[i];
					break;
				}
			} else {
				shell = vstrs->as_string[i];	/* wildcard */
			}
		}
	}
	return (shell);
}

/* 
 * scan_for_terminated - scan the list of runnings jobs for one whose
 *	session id matched that of a terminated child pid.  Mark that
 *	job as Exiting.
 */

void scan_for_terminated()
{
	static	char	id[] = "scan_for_terminated";
	int		exiteval;
	pid_t		pid;
	int		sid;
	job		*pjob;
	task		*ptask;
	int		statloc;

	/* update the latest intelligence about the running jobs;         */
	/* must be done before we reap the zombies, else we lose the info */

	termin_child = 0;

	if (mom_get_sample() == PBSE_NONE) {
		pjob = (job *)GET_NEXT(svr_alljobs);
		while (pjob) {
			mom_set_use(pjob);
			pjob = (job *)GET_NEXT(pjob->ji_alljobs);
		}
	}

	while ((pid = waitpid(-1, &statloc, WNOHANG)) > 0) {
#ifdef DEBUG
		sprintf(log_buffer, "Waitpid = %d", pid);
		LOG_EVENT(PBSEVENT_DEBUG, PBS_EVENTCLASS_SERVER,
				"PBS_MOM", log_buffer);
#endif
	    	/*
		** see if process was a child doing a special function for MOM
		*/
		pjob = (job *)GET_NEXT(svr_alljobs);
		while (pjob) {
			if (pid == pjob->ji_momsubt) {
				if (WIFEXITED(statloc))
					statloc = WEXITSTATUS(statloc);
				else
					statloc = -1;

				if (pjob->ji_mompost) {
					pjob->ji_mompost(pjob, statloc);
					pjob->ji_mompost = 0;
				}
				pjob->ji_momsubt = 0;
				(void)job_save(pjob, SAVEJOB_QUICK);
				break;
			}
	   		pjob = (job *)GET_NEXT(pjob->ji_alljobs);
		}
	}

	/* Now figure out which task(s) have terminated (are zombies) */

	while ( (sid = waitjob(NULL)) > 0 ) {
		sprintf(log_buffer, "Waitjob = %d", sid);
		LOG_EVENT(PBSEVENT_DEBUG, PBS_EVENTCLASS_SERVER,
				"PBS_MOM", log_buffer);

		pjob = (job *)GET_NEXT(svr_alljobs);
		while (pjob) {
			ptask = (task *)GET_NEXT(pjob->ji_tasks);
			while (ptask) {
				if (ptask->ti_qs.ti_sid == sid)
					break;
				ptask = (task *)GET_NEXT(ptask->ti_jobtask);
			}
			if (ptask != NULL)
				break;
			pjob = (job *)GET_NEXT(pjob->ji_alljobs);
		}
		if (pjob == NULL) {
			DBPRT(("%s: sid %d not a task\n", id, sid))
			continue;
		}
		/*
		** We found task within the job which has exited.
		*/
		if (WIFEXITED(statloc))
			exiteval = WEXITSTATUS(statloc);
		else if (WIFSIGNALED(statloc))
			exiteval = WTERMSIG(statloc) + 10000;
		else 
			exiteval = 1;
		DBPRT(("%s: task %d sid %d exit value %d\n", id,
				ptask->ti_qs.ti_task, sid, exiteval))
		kill_task(ptask, SIGKILL);
		ptask->ti_qs.ti_exitstat = exiteval;
		ptask->ti_qs.ti_status = TI_STATE_EXITED;
		task_save(ptask);
		sprintf(log_buffer, "task %d terminated", ptask->ti_qs.ti_task);
		LOG_EVENT(PBSEVENT_DEBUG, PBS_EVENTCLASS_JOB,
				pjob->ji_qs.ji_jobid, log_buffer);
		exiting_tasks = 1;
	}
}


#define PTY_SIZE 12

/*
 * creat the master pty, this particular
 * piece of code does it the hard way, it searches
 */

int open_master(rtn_name)
	char **rtn_name;	/* RETURN name of slave pts */
{
	int		i = 0;
	int		ptc;	/* master file descriptor */
	static char	pty_name[PTY_SIZE+1];	/* "/dev/[pt]tyXY" */

	while (1) {
		(void)sprintf(pty_name, "/dev/pty/%03d", i++);
		if ((ptc = open(pty_name, O_RDWR | O_NOCTTY, 0)) >= 0) {
		    /* Got a master, fix name to matching slave */
		    pty_name[5] = 't';	
		    pty_name[6] = 't';	
		    pty_name[7] = 'y';	
		    pty_name[8] = 'p';	
		    *rtn_name = pty_name;
		    return (ptc);
		
		} else if (errno == ENOENT)
			return (-1);	/* tried all entries, give up */
	}
}

/*
 * struct sig_tbl = map of signal names to numbers,
 * see req_signal() in ../requests.c
 */

struct sig_tbl sig_tbl[] = {
	{ "NULL", 0 },
	{ "HUP", SIGHUP },
	{ "INT", SIGINT },
	{ "QUIT", SIGQUIT },
	{ "ILL", SIGILL },
	{ "TRAP", SIGTRAP },
	{ "ABRT", SIGABRT },
	{ "IOT", SIGIOT },
	{ "HWE", SIGHWE },
	{ "ERR", SIGERR },
	{ "EMT", SIGEMT },
	{ "FPE", SIGFPE },
	{ "KILL", SIGKILL },
	{ "PRE", SIGPRE },
	{ "BUS", SIGBUS },
	{ "ORE", SIGORE },
	{ "SEGV", SIGSEGV },
	{ "SYS", SIGSYS },
	{ "PIPE", SIGPIPE },
	{ "ALRM", SIGALRM },
	{ "TERM", SIGTERM },
	{ "IO", SIGIO },
	{ "URG", SIGURG },
	{ "CHLD", SIGCHLD },
	{ "PWR", SIGPWR },
	{ "MT", SIGMT },
	{ "MTKILL", SIGMTKILL },
	{ "BUFIO", SIGBUFIO },
	{ "RECOVERY", SIGRECOVERY },
	{ "UME", SIGUME },
	{ "DLK", SIGDLK },
	{ "CPULIM", SIGCPULIM },
	{ "SHUTDN", SIGSHUTDN },
	{ "STOP", SIGSTOP },
	{ "TSTP", SIGTSTP },
	{ "CONT", SIGCONT },
	{ "TTIN", SIGTTIN },
	{ "TTOU", SIGTTOU },
	{ "WINCH", SIGWINCH },
	{ "RPE", SIGRPE },
	{ "WRBKPT", SIGWRBKPT },
	{ "NOBDM", SIGNOBDM },
/* On older Unicoses (before 10.x) SIGAPTEAM was CRI reserved SIGCRAY6 */
#if defined(SIGAPTEAM)
	{ "APTEAM", SIGAPTEAM },
#else
	{ "CRAY6", SIGCRAY6 },
#endif /* SIGAPTEAM */

/* On older Unicoses (before 10.x)  SIGCANCEL was CRI reserved SIGCRAY7 */
#if defined(SIGCANCEL)
	{ "CANCEL", SIGCANCEL },
#else
	{ "CRAY7", SIGCRAY7 },
#endif /* SIGCANCEL */

	{ "CRAY8", SIGCRAY8 },
	{ "CRAY9", SIGCRAY9 },
	{ "CRAY10", SIGCRAY10 },
	{ "CRAY11", SIGCRAY11 },
	{ "CRAY12", SIGCRAY12 },
	{ "CRAY13", SIGCRAY13 },
	{ "CRAY14", SIGCRAY14 },
	{ "INFO", SIGINFO },
	{ "USR1", SIGUSR1 },
	{ "USR2", SIGUSR2 },
	{ (char *)0, -1 }
};

/*
 * post_suspend - post exit of child for suspending a job
 */

void post_suspend(pjob, err)
	job *pjob;
	int  err;
{
	if (err == 0) {
		pjob->ji_qs.ji_substate = JOB_SUBSTATE_SUSPEND;
		pjob->ji_qs.ji_svrflags |= JOB_SVFLG_Suspend;
	}
}

/*
 * post_resume - post exit of child for suspending a job
 */

void post_resume(pjob, err)
	job *pjob;
	int  err;
{
	if (err == 0) {
		/*
		 * adjust walltime for time suspended, ji_momstat contains
	 	 * time when suspended, ji_stime when job started; adjust
		 * stime to current time minus (back to) amount of time
		 * used before suspended.
		 */
		if (pjob->ji_qs.ji_svrflags & JOB_SVFLG_Suspend) {
			pjob->ji_qs.ji_stime = time_now -
				(pjob->ji_momstat - pjob->ji_qs.ji_stime);
		}
		pjob->ji_qs.ji_substate = JOB_SUBSTATE_RUNNING;
		pjob->ji_qs.ji_svrflags &= ~JOB_SVFLG_Suspend;

	}
}