mom_mach.c

openPBS的开放源代码

		else
			*rtn_limit = udblimit;

	} else {

		/* user specified an actual limit */

		if (zlimit) {
			if ((udblimit != MAXUE_LONG) && (rlimit > udblimit))
				return (PBSE_EXLIMIT);
		} else {
			if (((udblimit != 0) || (udblimit != MAXUE_LONG)) &&
			    (rlimit > udblimit))
				return (PBSE_EXLIMIT);
		}
		*rtn_limit = rlimit;
	}

	return (0);
}

/*
 * Establish system-enforced limits for the tasks of a job.
 *
 *	Run through the resource list, checking the values for all items
 *	we recognize.
 *
 *	If set_mode is SET_LIMIT_SET, then also set hard limits for the
 *	system enforced limits (not-polled).
 *	If anything goes wrong with the process, return a PBS error code
 *	and print a message on standard error.  A zero-length resource list
 *	is not an error.
 *
 *	If set_mode is SET_LIMIT_SET the entry conditions are:
 *	    1.	MOM has already forked, and we are called from the child.
 *	    2.	The child is still running as root.
 *	    3.  Standard error is open to the user's file.
 *
 *	If set_mode is SET_LIMIT_ALTER, we are beening called to modify
 *	existing limits.  Unlike bsd based systems that use setrlimit, the
 *	Cray limit() call can set limits for another session.  Hence all
 *	limits can be adjusted.
 */

int mom_set_limits(pjob, set_mode)
    job			*pjob;
    int			 set_mode;	/* unused here */
{
	static char	*id = "mom_set_limits";
	int	        acid;
	int		maxcput;
	int		maxpcput;
	int		maxmem;
	int		maxmt[MAXUE_TAPETYPE];
	int		maxpmem;
	int		maxpf;
	int		maxppf;
	int		maxsds;
	int		maxpsds;
	int		maxnproc;
	int		maxmppe;
	int		maxmppt;
	int		maxpmppt;
	int		niceval;
	int		num;
	char		*pc;
	char		*phost;
	char		*pname;
	struct udb	*pudb;
	int		sessid;
	int		retval;
	attribute	*pat;
	resource	*pres;
	task		*ptask;
	unsigned long	value;	/* place in which to build resource value */

	DBPRT(("%s: entered\n", id))
	assert(pjob != NULL);
	assert(pjob->ji_wattr[(int)JOB_ATR_resource].at_type == ATR_TYPE_RESC);

	/* initialize limits to values from user's UDB */

	if (set_mode == SET_LIMIT_SET) {
		getsysudb();	/* get the priviled (locked) udb */
	}

	pudb = getudbuid(pjob->ji_qs.ji_un.ji_momt.ji_exuid);
	if (pudb == UDB_NULL)
		return (PBSE_BADUSER);

	if (set_mode == SET_LIMIT_SET) {

		/* can this user run batch jobs */

		if (pudb->ue_permbits & PERMBITS_NOBATCH) {
			endudb();
			return (PBSE_QACESS);
		}

		/* set Account ID: 1 - if supplied and is valid acid, */
		/* or 2 - default acid from UDB 		      */

		pat = &pjob->ji_wattr[(int)JOB_ATR_account];
		if (pat->at_flags & ATR_VFLAG_SET) {
			pname = pat->at_val.at_str;
			if ((acid = nam2acid(pname)) == -1)  {
			    for (pc = pname; *pc; ++pc) {
				if ( !isdigit((int)*pc))
				    return (error(pname, PBSE_BADACCT));
			    }
			    if (acid2nam(acid = atoi(pname)) == (char *)0)
				    return (error(pname, PBSE_BADACCT));
			}
			for (num=0; num<MAXVIDS; ++num) {
				if (pudb->ue_acids[num] == acid)
					break;
			}
			if (num == MAXVIDS)
				return (error(pname, PBSE_BADACCT));
		} else {
			acid = pudb->ue_acids[0];
		}
		if (acctid(0, acid) == -1) 
			return (error("Account", PBSE_BADACCT));
			 
			 

		/* lock and update the UDB with the batch host/time */

		if (lockudb() < 0) {
			log_err(udb_errno, id, "Unable to lock UDB");
		} else {
			pudb->ue_batchtime = time_now;

			phost = arst_string("PBS_O_HOST",
				     &pjob->ji_wattr[(int)JOB_ATR_variables]);
			if ( (phost == (char *)0) ||
			     ((phost=strchr(phost, (int)'=')) == (char *)0) ) 
				log_err(-1, id, "PBS_O_HOST not set");
			strncpy(pudb->ue_batchhost, phost+1, MAXUE_HOSTNAME);
			pudb->ue_batchhost[MAXUE_HOSTNAME] = '\0';
			if (rewriteudb(pudb) < 0)
				log_err(udb_errno, id, "UDB Update failed");
		}
	}
	endudb();
/*
 *	set basic limits to values from the user's UDB entry;  later
 *	we have to check for values == MAXUE_LONG, meaning unlimited,
 *	where in the limit() call it must be changed to 0.
 *	A click is 512 words = 4096 bytes
 */

	maxcput  = pudb->ue_jcpulim[UDBRC_BATCH];	/* seconds */
	maxpcput = pudb->ue_pcpulim[UDBRC_BATCH];	/* seconds */
	maxmem   = pudb->ue_jmemlim[UDBRC_BATCH];	/* clicks */
	maxpmem  = pudb->ue_pmemlim[UDBRC_BATCH];	/* clicks */
	maxpf    = pudb->ue_jfilelim[UDBRC_BATCH];	/* clicks */
	maxppf   = pudb->ue_pfilelim[UDBRC_BATCH];	/* clicks */
	maxsds   = pudb->ue_jsdslim[UDBRC_BATCH];	/* clicks */
	maxpsds  = pudb->ue_psdslim[UDBRC_BATCH];	/* clicks */
	maxnproc = pudb->ue_jproclim[UDBRC_BATCH];
	maxmppe  = pudb->ue_jpelimit[UDBRC_BATCH];
	maxmppt  = pudb->ue_jmpptime[UDBRC_BATCH];
	maxpmppt = pudb->ue_pmpptime[UDBRC_BATCH];
	niceval  = pudb->ue_nice[UDBRC_BATCH];
	for (num = 0; num < MAXUE_TAPETYPE; ++num)
		maxmt[num] = pudb->ue_jtapelim[UDBRC_BATCH][num];

	pres = (resource *)
	    GET_NEXT(pjob->ji_wattr[(int)JOB_ATR_resource].at_val.at_list);
/*
 * Cycle through all the resource specifications,
 * setting limits appropriately.
 */

	while (pres != NULL) {
		assert(pres->rs_defin != NULL);
		pname = pres->rs_defin->rs_name;
		assert(pname != NULL);
		assert(*pname != '\0');

		if (strcmp(pname, "cput") == 0) {
			retval = gettime(pres, &value);
			value = (unsigned long)((double)value / cputfactor);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit(value, maxcput,
					pres->rs_value.at_flags, 0, &maxcput);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "pcput") == 0) {
			retval = gettime(pres, &value);
			value = (unsigned long)((double)value / cputfactor);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit(value, maxpcput,
					pres->rs_value.at_flags, 0, &maxpcput);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "mem") == 0) {
			retval = getsize(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit((value+4095)/4096, maxmem,
					pres->rs_value.at_flags, 0, &maxmem);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "pmem") == 0) {
			retval = getsize(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit((value+4095)/4096, maxpmem,
					pres->rs_value.at_flags, 0, &maxpmem);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "vmem")  == 0) {	/* ignore */
		} else if (strcmp(pname, "pvmem") == 0) {	/* ignore */
		} else if (strcmp(pname, "file")  == 0) {	/* ignore */
		} else if ( (strcmp(pname, "mta") == 0) ||
			    (strcmp(pname, "mtb") == 0) ||
			    (strcmp(pname, "mtc") == 0) ||
			    (strcmp(pname, "mtd") == 0) ||
			    (strcmp(pname, "mte") == 0) ||
			    (strcmp(pname, "mtf") == 0) ||
			    (strcmp(pname, "mtg") == 0) ||
			    (strcmp(pname, "mth") == 0) ) {
			num = (int)*(pname+2) - (int)'a';
			maxmt[num] = pres->rs_value.at_val.at_long;
			retval = which_limit(pres->rs_value.at_val.at_long,
					maxmt[num], 
					pres->rs_value.at_flags,
					0,
					&maxmt[num]);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "pf") == 0) {
			retval = getsize(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit((value+4095)/4096, maxpf,
					pres->rs_value.at_flags,
					0,
					&maxpf);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "ppf") == 0) {
			retval = getsize(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit((value+4095)/4096, maxppf,
					pres->rs_value.at_flags,
					0,
					&maxppf);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "sds") == 0) {
			retval = getsize(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit((value+4095)/4096, maxsds,
					pres->rs_value.at_flags, 1, &maxsds);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "psds") == 0) {
			retval = getsize(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit((value+4095)/4096, maxpsds,
					pres->rs_value.at_flags, 1, &maxpsds);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "procs") == 0) {
			retval = getlong(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit(value, maxnproc,
					pres->rs_value.at_flags, 0, &maxnproc);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "mppe") == 0) {
			retval = getlong(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit(value, maxmppe,
					pres->rs_value.at_flags, 1, &maxmppe);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "mppt") == 0) {
			retval = gettime(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit(value, maxmppt,
					pres->rs_value.at_flags, 1, &maxmppt);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "pmppt") == 0) {
			retval = gettime(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
			if (value > INT_MAX)
				return (error(pname, PBSE_BADATVAL));
			retval = which_limit(value, maxpmppt,
					pres->rs_value.at_flags, 1, &maxpmppt);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "walltime") == 0) {
			retval = gettime(pres, &value);
			if (retval != PBSE_NONE)
				return (error(pname, retval));
		} else if (strcmp(pname, "nice") == 0) {
			if (set_mode == SET_LIMIT_SET) {
				niceval = (int)pres->rs_value.at_val.at_long;
			}
		} else if ((pres->rs_defin->rs_flags & ATR_DFLAG_RMOMIG) == 0)
			/* don't recognize and nor marked as ignore by mom */
			return (error(pname, PBSE_UNKRESC));

		pres = (resource *)GET_NEXT(pres->rs_link);
	}

	/*
	 * Set the limits
	 *
	 * If pcput, pmem, or ppf is unlimited but the corresponding session
	 * limit is not, use the session limit for the process limit.
	 */

	for (ptask = (task *)GET_NEXT(pjob->ji_tasks);
			ptask != NULL;
			ptask = (task *)GET_NEXT(ptask->ti_jobtask)) {
		sessid = ptask->ti_qs.ti_sid;

		if (maxcput == MAXUE_LONG)	/* if unlimited */
			maxcput = 0;
		if (limit(C_JOB, sessid, L_CPU, maxcput) < 0)
			return (error("cput", PBSE_SYSTEM));

		if ((maxpcput == MAXUE_LONG) ||
				(maxpcput == 0)) {	/* if unlimited */
			if (maxcput != 0)
				maxpcput = maxcput;
			else
				maxpcput = 0;
		} else if ((maxpcput > maxcput) && (maxcput != 0)) {
			maxpcput = maxcput;
		}
		if (limit(C_JOBPROCS, sessid, L_CPU, maxpcput) < 0)
			return (error("pcput", PBSE_SYSTEM));

		if (maxmem == MAXUE_LONG)	/* if unlimited */
			maxmem = 0;
		if (limit(C_JOB, sessid, L_MEM, maxmem) < 0)
			return (error("mem", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_MPPM, maxmem) < 0)
			return (error("mppm", PBSE_SYSTEM));

		if ((maxpmem == MAXUE_LONG) ||
				(maxpmem == 0)) {	/* if unlimited */
			if (maxmem != 0)
				maxpmem = maxmem;
			else
				maxpmem = 0;
		} else if ((maxpmem > maxmem) && (maxmem != 0)) {
			maxpmem = maxmem;
		}
		if (limit(C_JOBPROCS, sessid, L_MEM, maxpmem) < 0)
			return (error("pmem", PBSE_SYSTEM));

		if (maxpf == MAXUE_LONG)	/* if unlimited */
			maxpf = 0;
		if (limit(C_JOB, sessid, L_FSBLK, maxpf) < 0)
			return (error("pf", PBSE_SYSTEM));

		if ((maxppf == MAXUE_LONG) ||
				(maxppf == 0)) {	/* if unlimited */
			if (maxpf != 0)
				maxppf = maxpf;
			else
				maxppf = 0;
		} else if ((maxppf > maxpf) && (maxpf != 0)) {
			maxppf = maxpf;
		}
		if (limit(C_JOBPROCS, sessid, L_FSBLK, maxppf) < 0)
			return (error("ppf", PBSE_SYSTEM));

		if (limit(C_JOB, sessid, L_SDS, maxsds) < 0)
			return (error("sds", PBSE_SYSTEM));
		if (limit(C_JOBPROCS, sessid, L_SDS, maxpsds) < 0)
			return (error("psds", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_CPROC, maxnproc) < 0)
			return (error("procs", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE0, maxmt[0]) < 0)
			return (error("mta", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE1, maxmt[1]) < 0)
			return (error("mtb", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE2, maxmt[2]) < 0)
			return (error("mtc", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE3, maxmt[3]) < 0)
			return (error("mtd", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE4, maxmt[4]) < 0)
			return (error("mte", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE5, maxmt[5]) < 0)
			return (error("mtf", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE6, maxmt[6]) < 0)
			return (error("mtg", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_TAPE7, maxmt[7]) < 0)
			return (error("mth", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_MPPE, maxmppe) < 0)
			return (error("mppe", PBSE_SYSTEM));
		if (limit(C_JOB, sessid, L_MPPT, maxmppt) < 0)
			return (error("mppt", PBSE_SYSTEM));
		if (limit(C_JOBPROCS, sessid, L_MPPT, maxpmppt) < 0)
			return (error("pmppt", PBSE_SYSTEM));

		if (set_mode == SET_LIMIT_SET) {
			errno = 0;
			if ((nice(niceval) == -1) && (errno != 0))
				return (error("nice", PBSE_SYSTEM));
		}
	}

	return (PBSE_NONE);
}

/*
 * State whether MOM main loop has to poll this job to determine if some
 * limits are being exceeded.
 *
 *	Sets flag TRUE if polling is necessary, FALSE otherwise.  Actual
 *	polling is done using the mom_over_limit machine-dependent function.
 */

int mom_do_poll(pjob)
    job			*pjob;
{
	static char	*id = "mom_do_poll";
	char		*pname;
	resource	*pres;

	DBPRT(("%s: entered\n", id))
	assert(pjob != NULL);
	assert(pjob->ji_wattr[(int)JOB_ATR_resource].at_type == ATR_TYPE_RESC);
	pres = (resource *)
	    GET_NEXT(pjob->ji_wattr[(int)JOB_ATR_resource].at_val.at_list);

	while (pres != NULL) {
		assert(pres->rs_defin != NULL);
		pname = pres->rs_defin->rs_name;
		assert(pname != NULL);
		assert(*pname != '\0');