mom_mach.c

openPBS的开放源代码

int mom_set_use(pjob)
    job			*pjob;
{
	char			*id = "mom_set_use";
	resource		*pres;
	attribute		*at;
	resource_def		*rd;
	unsigned long		*lp, lnum;

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

	at->at_flags |= ATR_VFLAG_MODIFY;
	if ((at->at_flags & ATR_VFLAG_SET) == 0) {
		at->at_flags |= ATR_VFLAG_SET;

		rd = find_resc_def(svr_resc_def, "cput", svr_resc_size);
		assert(rd != NULL);
		pres = add_resource_entry(at, rd);
		assert(pres != NULL);
		pres->rs_value.at_flags |= ATR_VFLAG_SET;
		pres->rs_value.at_type = ATR_TYPE_LONG;
		pres->rs_value.at_val.at_long = 0;

		rd = find_resc_def(svr_resc_def, "vmem", svr_resc_size);
		assert(rd != NULL);
		pres = add_resource_entry(at, rd);
		assert(pres != NULL);
		pres->rs_value.at_flags |= ATR_VFLAG_SET;
		pres->rs_value.at_type = ATR_TYPE_SIZE;
		pres->rs_value.at_val.at_size.atsv_shift = 10; /* KB */
		pres->rs_value.at_val.at_size.atsv_units = ATR_SV_BYTESZ;
		pres->rs_value.at_val.at_size.atsv_num = 0;

		rd = find_resc_def(svr_resc_def, "walltime", svr_resc_size);
		assert(rd != NULL);
		pres = add_resource_entry(at, rd);
		assert(pres != NULL);
		pres->rs_value.at_flags |= ATR_VFLAG_SET;
		pres->rs_value.at_type = ATR_TYPE_LONG;
		pres->rs_value.at_val.at_long = 0;

		rd = find_resc_def(svr_resc_def, "mem", svr_resc_size);
		assert(rd != NULL);
		pres = add_resource_entry(at, rd);
		assert(pres != NULL);
		pres->rs_value.at_flags |= ATR_VFLAG_SET;
		pres->rs_value.at_type = ATR_TYPE_SIZE;
		pres->rs_value.at_val.at_size.atsv_shift = 10; /* KB */
		pres->rs_value.at_val.at_size.atsv_units = ATR_SV_BYTESZ;
		pres->rs_value.at_val.at_size.atsv_num = 0;
	}

	rd = find_resc_def(svr_resc_def, "cput", svr_resc_size);
	assert(rd != NULL);
	pres = find_resc_entry(at, rd);
	assert(pres != NULL);
	lp = (unsigned long *)&pres->rs_value.at_val.at_long;
	lnum = cput_sum(pjob);
	*lp = MAX(*lp, lnum);

	rd = find_resc_def(svr_resc_def, "vmem", svr_resc_size);
	assert(rd != NULL);
	pres = find_resc_entry(at, rd);
	assert(pres != NULL);
	lp = &pres->rs_value.at_val.at_size.atsv_num;
	lnum = (mem_sum(pjob) + 1023) >> 10;	/* as KB */
	*lp = MAX(*lp, lnum);

	rd = find_resc_def(svr_resc_def, "walltime", svr_resc_size);
	assert(rd != NULL);
	pres = find_resc_entry(at, rd);
	assert(pres != NULL);
	pres->rs_value.at_val.at_long = (long)((double)(time_now - pjob->ji_qs.ji_stime) * wallfactor);

	rd = find_resc_def(svr_resc_def, "mem", svr_resc_size);
	assert(rd != NULL);
	pres = find_resc_entry(at, rd);
	assert(pres != NULL);
	lp = &pres->rs_value.at_val.at_size.atsv_num;
	lnum = (resi_sum(pjob) + 1023) >> 10;	/* as KB */
	*lp = MAX(*lp, lnum);

	return (PBSE_NONE);
}

/*
 *	Kill a task session.
 *	Call with the job pointer and a signal number.
 */
int kill_task(ptask, sig)
    task	*ptask;
    int  	sig;
{
	int	ct = 0;
	int	i, err;
	int	sesid;

	sesid = ptask->ti_qs.ti_sid;
	if (sesid <= 1)
		return 0;

	if ((err = mom_get_sample()) != PBSE_NONE)
		return 0;

	for (i=0; i<nproc; i++) {
		register struct procsinfo	*pp = &proc_tbl[i];

		if (pp->pi_state == SNONE)
			continue;

		if (sesid != pp->pi_sid)
			continue;

		DBPRT(("kill_task: send signal %d to pid %d\n",
			sig, pp->pi_pid))
		(void)kill(pp->pi_pid, sig);
		++ct;
	}
	return ct;
}

/*
 * Clean up everything related to polling.
 *
 */
int mom_close_poll()
{
	DBPRT(("mom_close_poll entered\n"))

	if (proc_tbl) {
		free(proc_tbl);
		proc_tbl = NULL;
	}

	return (PBSE_NONE);
}

/*
 * mom_does_chkpnt - return 1 if mom supports checkpoint
 *			    0 if not
 */

int mom_does_chkpnt()
{
	return (0);
}

/*
 * Checkpoint the job.
 *
 *	If abort is true, kill it too.
 */

int mach_checkpoint(ptask, file, abort)
    task	*ptask;
    char	*file;
    int		abort;
{
       	return (-1);
}

/*
 * Restart the job from the checkpoint file.
 *
 *	Return a -1 on error or sid.
 */

long mach_restart(ptask, file)
    task	*ptask;
    char	*file;
{
	return (-1);
}

int
kvm_read(fd, addr, buf, size)
    int		fd;
    long	addr;
    char	*buf;
    int		size;
{
	int	ret;

	if (lseek(fd, addr, SEEK_SET) != addr)
		return -1;
	if ((ret = read(fd, buf, size)) == -1)
		return -1;
	return ret;
}

int
getproctab()
{
	static	uint	lastproc = 0;
	char		*id = "getproctab";

	if (lastproc == reqnum)		/* don't need new proc table */
		return nproc;

	if (mom_get_sample() != PBSE_NONE)
		return 0;

	lastproc = reqnum;
	return(nproc);
}

double
dsecs(val)
struct	timeval	*val;
{
        return ( (double)val->tv_sec + (double)val->tv_usec*1e-6 );
}

char	*
cput_job(jobid)
pid_t	jobid;
{
	char		*id = "cput_job";
	int		i, nproc;
	int		found = 0;
	double		cputime, addtime;

	if ((nproc = getproctab()) == 0) {
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}
	cputime = 0;
	for (i=0; i<nproc; i++) {
		register struct procsinfo	*pp = &proc_tbl[i];

		if (pp->pi_state == SNONE)
			continue;

		if (jobid != pp->pi_sid)
			continue;

		found = 1;
		DBPRT(("%s: pid=%d", id, pp->pi_pid))
		if (pp->pi_state == SZOMB) {
			DBPRT((" (zombie)"))
			addtime = dsecs(&pp->pi_utime) +
				dsecs(&pp->pi_stime);
		}
		else {
			DBPRT((" (active)"))
			addtime = dsecs(&pp->pi_ru.ru_utime) +
				dsecs(&pp->pi_ru.ru_stime) +
				dsecs(&pp->pi_cru.ru_utime) +
				dsecs(&pp->pi_cru.ru_stime);
		}
		cputime += addtime;
		DBPRT((" %.2f total=%.2f\n", addtime, cputime))

	}
	if (found) {
		sprintf(ret_string, "%.2f", cputime * cputfactor);
		return ret_string;
	}

	rm_errno = RM_ERR_EXIST;
	return NULL;
}

char	*
cput_proc(pid)
pid_t	pid;
{
	char			*id = "cput_proc";
	int			i, nproc;
	int			found = 0;
	double			cputime;

	if ((nproc = getproctab()) == 0) {
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}
	for (i=0; i<nproc; i++) {
		register struct procsinfo	*pp = &proc_tbl[i];

		if (pp->pi_state == SNONE)
			continue;

		if (pid != pp->pi_pid)
			continue;

		DBPRT(("%s: pid=%d", id, pp->pi_pid))
		if (pp->pi_state == SZOMB) {
			DBPRT((" (zombie)"))
			cputime = dsecs(&pp->pi_utime) +
				dsecs(&pp->pi_stime);
		}
		else {
			DBPRT((" (active)"))
			cputime = dsecs(&pp->pi_ru.ru_utime) +
				dsecs(&pp->pi_ru.ru_stime) +
				dsecs(&pp->pi_cru.ru_utime) +
				dsecs(&pp->pi_cru.ru_stime);
		}
		DBPRT((" %.2f\n", cputime))
		found = 1;
		break;
	}
	if (found) {
		sprintf(ret_string, "%.2f", cputime * cputfactor);
		return ret_string;
	}

	rm_errno = RM_ERR_EXIST;
	return NULL;
}

char	*
cput(attrib)
struct	rm_attribute	*attrib;
{
	char			*id = "cput";
	int			value;

	if (attrib == NULL) {
		log_err(-1, id, no_parm);
		rm_errno = RM_ERR_NOPARAM;
		return NULL;
	}
	if ((value = atoi(attrib->a_value)) == 0) {
		sprintf(log_buffer, "bad param: %s", attrib->a_value);
		log_err(-1, id, log_buffer);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
	if (momgetattr(NULL)) {
		log_err(-1, id, extra_parm);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}

	if (strcmp(attrib->a_qualifier, "session") == 0)
		return (cput_job((pid_t)value));
	else if (strcmp(attrib->a_qualifier, "proc") == 0)
		return (cput_proc((pid_t)value));
	else {
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
}

char	*
mem_job(jobid)
pid_t	jobid;
{
	char			*id = "mem_job";
	int			i, nproc;
	int			memsize;
	int			found = 0;

	if ((nproc = getproctab()) == 0) {
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}
	memsize = 0;
	for (i=0; i<nproc; i++) {
		register struct procsinfo	*pp = &proc_tbl[i];

		if (pp->pi_state == SNONE)
			continue;

		if (jobid != pp->pi_sid)
			continue;

		found = 1;
		memsize += pp->pi_size;
		DBPRT(("%s: pid %d memsize %d pi_size %d\n", id, pp->pi_pid,
				memsize, pp->pi_size))
	}
	if (found) {
		sprintf(ret_string, "%ukb", ctob(memsize) >> 10); /* KB */
		return ret_string;
	}

	rm_errno = RM_ERR_EXIST;
	return NULL;
}

char	*
mem_proc(pid)
pid_t	pid;
{
	char			*id = "mem_proc";
	int			i, nproc;
	int			memsize;
	int			found = 0;

	if ((nproc = getproctab()) == 0) {
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}
	memsize = 0;
	for (i=0; i<nproc; i++) {
		register struct procsinfo	*pp = &proc_tbl[i];

		if (pp->pi_state == SNONE)
			continue;

		if (pid != pp->pi_pid)
			continue;

		found = 1;
		memsize = pp->pi_size;
		break;
	}
	if (found) {
		sprintf(ret_string, "%ukb", ctob(memsize) >> 10); /* KB */
		return ret_string;
	}

	rm_errno = RM_ERR_EXIST;
	return NULL;
}

char	*
mem(attrib)
struct	rm_attribute	*attrib;
{
	char			*id = "mem";
	int			value;

	if (attrib == NULL) {
		log_err(-1, id, no_parm);
		rm_errno = RM_ERR_NOPARAM;
		return NULL;
	}
	if ((value = atoi(attrib->a_value)) == 0) {
		sprintf(log_buffer, "bad param: %s", attrib->a_value);
		log_err(-1, id, log_buffer);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
	if (momgetattr(NULL)) {
		log_err(-1, id, extra_parm);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}

	if (strcmp(attrib->a_qualifier, "session") == 0)
		return (mem_job((pid_t)value));
	else if (strcmp(attrib->a_qualifier, "proc") == 0)
		return (mem_proc((pid_t)value));
	else {
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
}

static char	*
ncpus(attrib)
struct rm_attribute	*attrib;
{
	if (attrib) {
		log_err(-1, "ncpus", extra_parm);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
	sprintf(ret_string, "%d", nncpus);
	return ret_string;
}

static char	*
resi_job(jobid)
pid_t	jobid;
{
	char			*id = "resi_job";
	int			i, nproc;
	int			resisize;
	int			found = 0;

	if ((nproc = getproctab()) == 0) {
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}
	resisize = 0;
	for (i=0; i<nproc; i++) {
		struct	procsinfo	*pp = &proc_tbl[i];

		if (pp->pi_state == SNONE)
			continue;

		if (jobid != pp->pi_sid)
			continue;

		found = 1;
		if (pp->pi_state == SZOMB)
			continue;

		resisize += pp->pi_drss + pp->pi_trss;
		DBPRT(("%s: pid=%d size=%d\n", id, pp->pi_pid, resisize))
	}
	if (found) {
		sprintf(ret_string, "%ukb", ctob(resisize) >> 10);  /* KB */
		return ret_string;
	}

	rm_errno = RM_ERR_EXIST;
	return NULL;
}

static char	*
resi_proc(pid)
pid_t	pid;
{
	char			*id = "resi_proc";
	int			i, nproc;
	int			resisize;
	int			found = 0;

	if ((nproc = getproctab()) == 0) {
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}
	resisize = 0;
	for (i=0; i<nproc; i++) {
		struct	procsinfo	*pp = &proc_tbl[i];

		if (pp->pi_state == SNONE)
			continue;

		if (pid != pp->pi_pid)
			continue;

		found = 1;
		if (pp->pi_state == SZOMB)
			break;

		resisize = pp->pi_drss + pp->pi_trss;
		DBPRT(("%s: pid=%d size=%d\n", id, pp->pi_pid, resisize))
		break;
	}
	if (found) {
		sprintf(ret_string, "%ukb", ctob(resisize) >> 10); /* KB */
		return ret_string;
	}

	rm_errno = RM_ERR_EXIST;
	return NULL;
}

static char	*
resi(attrib)
struct	rm_attribute	*attrib;
{
	char			*id = "resi";
	int			value;

	if (attrib == NULL) {
		log_err(-1, id, no_parm);
		rm_errno = RM_ERR_NOPARAM;
		return NULL;
	}
	if ((value = atoi(attrib->a_value)) == 0) {
		sprintf(log_buffer, "bad param: %s", attrib->a_value);
		log_err(-1, id, log_buffer);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
	if (momgetattr(NULL)) {
		log_err(-1, id, extra_parm);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}

	if (strcmp(attrib->a_qualifier, "session") == 0)
		return (resi_job((pid_t)value));
	else if (strcmp(attrib->a_qualifier, "proc") == 0)
		return (resi_proc((pid_t)value));
	else {
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
}

char	*
sessions(attrib)
struct	rm_attribute	*attrib;
{
	char			*id = "sessions";
	int			nproc;
	int			i, j;
	char			*fmt;
	int			njids = 0;
	pid_t			*jids, jobid;

	if (attrib) {