mom_mach.c

openPBS的开放源代码

	rewinddir(pdir);
	for (fd = -1; (dent = readdir(pdir)) != NULL; close(fd)) {
		if (!isdigit(dent->d_name[0]))
			continue;

		sprintf(procname, procfmts, dent->d_name);
		if ((fd = open(procname, O_RDONLY)) == -1)
			continue;
		if (ioctl(fd, PIOCPSINFO, &pi) == -1) {
			if (errno != ENOENT) {
				sprintf(log_buffer,
					"%s: ioctl(PIOCPSINFO)", procname);
				log_err(errno, id, log_buffer);
			}
			continue;
		}

		if (sesid == pi.pr_sid) {
			(void)kill(pi.pr_pid, sig);
			++ct;
		}
	}
	return ct;
}

/*
 * Clean up everything related to polling.
 */
int mom_close_poll()
{
	char	*id = "mom_close_poll";
	int	i;

	DBPRT(("%s: entered\n", id))
	if (proc_array) {
#if COMPLEX_MEM_CALC==1
		for(i=0; i<max_proc; i++) {
			struct	proc_info	*pi = &proc_array[i];

			if (pi->map)
				free(pi->map);
		}
#endif	/* COMPLEX_MEM_CALC */
		free(proc_array);
	}
	if (pdir) {
		if (closedir(pdir) != 0) {
			log_err(errno, id, "closedir");
			return (PBSE_SYSTEM);
		}
	}

	return (PBSE_NONE);
}

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

int mom_does_chkpnt()
{
#if MOM_CHECKPOINT == 1
	return (1);
#else /* MOM_CHECKPOINT */
	return (0);
#endif	/* MOM_CHECKPOINT */
}

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

int mach_checkpoint(ptask, file, abort)
    task	*ptask;
    char	*file;
    int		abort;
{
#if MOM_CHECKPOINT == 1
	/* ckpt_setup(0, 0);  Does nothing so why have it */

	if (abort) 
		cpr_flags = CKPT_CHECKPOINT_KILL | CKPT_NQE;
	else
		cpr_flags = CKPT_CHECKPOINT_CONT | CKPT_NQE;
     /* return ( ckpt_create(file, ptask->ti_qs.ti_u.ti_ash, P_ASH, 0, 0) ); */
	return ( ckpt_create(file, ptask->ti_qs.ti_sid, P_SID, 0, 0) );
#else /* MOM_CHECKPOINT */
	return (-1);
#endif /* MOM_CHECKPOINT */
}

/*
 * Restart the task from the checkpoint file.
 *
 *	Return -1 on error or sid if okay.
 */

long mach_restart(ptask, file)
    task	*ptask;
    char	*file;
{
#if MOM_CHECKPOINT == 1
	ckpt_id_t rc;
	cpr_flags = CKPT_NQE;

	/* KLUDGE to work-around SGI problem, for some reason ckpt_restart() */
	/* passes open file descriptor to /proc to restarted process	     */
	if (pdir)
		closedir(pdir);

	rc =  ckpt_restart(file, (struct ckpt_args **)0, 0);

	/* KLUDGE TO work-around SGI problem, ckpt_restart sets the uid of */
	/* the calling process (me) to that of the restarted process       */
	(void)setuid(0);
	if ((pdir = opendir(procfs)) == NULL) {
		log_err(errno, "mach_restart", "opendir");
	}

	return ((int)rc);
#else	/* MOM_CHECKPOINT */
	return (-1);
#endif	/* MOM_CHECKPOINT */
}

/*
**	Return 1 if proc table can be read, 0 otherwise.
*/
int
getprocs()
{
	static	unsigned	int	lastproc = 0;

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

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

	lastproc = reqnum;
	return 1;
}

#define	dsecs(val) ( (double)(val).tv_sec + ((double)(val).tv_nsec * 1.0e-9) )

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

	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	cputime = 0.0;
	for (i=0; i<nproc; i++) {

		pi = &proc_array[i].info;
		if (jobid != pi->pr_sid)
			continue;

		found = 1;
		addtime = dsecs(pi->pr_time) + dsecs(pi->pr_ctime);

		cputime += addtime;
		DBPRT(("%s: total %.2f pid %d %.2f\n", id, cputime,
				pi->pr_pid, addtime))

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

	rm_errno = PBSE_RMEXIST;
	return NULL;
}

char	*
cput_proc(pid)
pid_t	pid;
{
	double			cputime;
	int			i;
	prpsinfo_t		*pi;

	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	cputime = 0.0;
	for (i=0; i<nproc; i++) {
		pi = &proc_array[i].info;

		if (pid == pi->pr_pid)
			break;
	}
	if (i == nproc) {
		rm_errno = PBSE_RMEXIST;
		return NULL;
	}
	cputime = dsecs(pi->pr_time) + dsecs(pi->pr_ctime);

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


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

	if (attrib == NULL) {
		log_err(-1, id, no_parm);
		rm_errno = PBSE_RMNOPARAM;
		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 = PBSE_RMBADPARAM;
		return NULL;
	}
	if (momgetattr(NULL)) {
		log_err(-1, id, extra_parm);
		rm_errno = PBSE_RMBADPARAM;
		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 = PBSE_RMBADPARAM;
		return NULL;
	}
}

/*
 * mem_job() - return memory in KB used by job as a numerical string
 */

char	*
mem_job(sid)
pid_t	sid;
{
	rlim64_t memsize;
	static  list_head       taskhead;
	static  task            onetask;
	static  int             first = 1;

	if (first) {
		CLEAR_HEAD(taskhead);
		CLEAR_LINK(onetask.ti_jobtask);
		append_link(&taskhead, &onetask.ti_jobtask, &onetask);
		first = 0;
	}
	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	onetask.ti_qs.ti_sid = sid;
	memsize = mem_sum(&taskhead);
	if (memsize == 0) {
		rm_errno = PBSE_RMEXIST;
		return NULL;
	}
	else {
		sprintf(ret_string, "%llukb", memsize>>10);	/* in KB */
		return ret_string;
	}
}

char	*
mem_proc(pid)
pid_t	pid;
{
	prpsinfo_t	*pi;
	int		i;

	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	for (i=0; i<nproc; i++) {
		pi = &proc_array[i].info;

		if (pid == pi->pr_pid)
			break;
	}
	if (i == nproc) {
		rm_errno = PBSE_RMEXIST;
		return NULL;
	}

	sprintf(ret_string, "%llukb",
		((rlim64_t)pi->pr_size * (rlim64_t)pagesize) >> 10); /* in KB */

	return ret_string;
}

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

	if (attrib == NULL) {
		log_err(-1, id, no_parm);
		rm_errno = PBSE_RMNOPARAM;
		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 = PBSE_RMBADPARAM;
		return NULL;
	}
	if (momgetattr(NULL)) {
		log_err(-1, id, extra_parm);
		rm_errno = PBSE_RMBADPARAM;
		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 = PBSE_RMBADPARAM;
		return NULL;
	}
}

static char	*
resi_job(jobid)
pid_t	jobid;
{
	rlim64_t memsize;
	static  list_head       taskhead;
	static  task            onetask;
	static  int             first = 1;

	if (first) {
		CLEAR_HEAD(taskhead);
		CLEAR_LINK(onetask.ti_jobtask);
		append_link(&taskhead, &onetask.ti_jobtask, &onetask);
		first = 0;
	}
	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	onetask.ti_qs.ti_sid = jobid;
	memsize = resi_sum(&taskhead);
	sprintf(ret_string, "%llukb", memsize>>10);	/* in KB */
	return ret_string;
}

static char	*
resi_proc(pid)
pid_t	pid;
{
	prpsinfo_t	*pi;
	int		i;

	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	for (i=0; i<nproc; i++) {
		pi = &proc_array[i].info;

		if (pid == pi->pr_pid)
			break;
	}
	if (i == nproc) {
		rm_errno = PBSE_RMEXIST;
		return NULL;
	}

	sprintf(ret_string, "%llukb", ((rlim64_t)pi->pr_rssize * pagesize)>>10);
	return ret_string;
}

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

	if (attrib == NULL) {
		log_err(-1, id, no_parm);
		rm_errno = PBSE_RMNOPARAM;
		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 = PBSE_RMBADPARAM;
		return NULL;
	}
	if (momgetattr(NULL)) {
		log_err(-1, id, extra_parm);
		rm_errno = PBSE_RMBADPARAM;
		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 = PBSE_RMBADPARAM;
		return NULL;
	}
}

char	*
sessions(attrib)
struct	rm_attribute	*attrib;
{
	char			*id = "sessions";
	int			i, j;
	prpsinfo_t		*pi;
	char			*fmt;
	int			njids = 0;
	pid_t			*jids, *hold;
	static		int	maxjid = 200;
	register	pid_t	jobid;

	if (attrib) {
		log_err(-1, id, extra_parm);
		rm_errno = PBSE_RMBADPARAM;
		return NULL;
	}
	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	if ((jids = (pid_t *)calloc(maxjid, sizeof(pid_t))) == NULL) {
		log_err(errno, id, "no memory");
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	/*
	** Search for members of session
	*/
	for (i=0; i<nproc; i++) {
		pi = &proc_array[i].info;

		if (pi->pr_uid == 0)
			continue;
		if ((jobid = pi->pr_sid) == 0)
			continue;
		DBPRT(("%s[%d]: pid %d sid %d\n",
		       id, njids, pi->pr_pid, jobid))

		for (j=0; j<njids; j++) {
			if (jids[j] == jobid)
				break;
		}
		if (j == njids) {		/* not found */
			if (njids == maxjid) {	/* need more space */
				maxjid += 100;
				hold = (pid_t *)realloc(jids, maxjid);
				if (hold == NULL) {
					log_err(errno, id, "realloc");
					rm_errno = PBSE_RMSYSTEM;
					free(jids);
					return NULL;
				}
				jids = hold;
			}
			jids[njids++] = jobid;	/* add jobid to list */
		}
	}

	fmt = ret_string;
	for (j=0; j<njids; j++) {
		checkret(&fmt, 100);
		sprintf(fmt, " %d", (int)jids[j]);
		fmt += strlen(fmt);
	}
	free(jids);
	return ret_string;
}

char	*
nsessions(attrib)
struct	rm_attribute	*attrib;
{
	char	*result, *ch;
	int	num = 0;

	if ((result = sessions(attrib)) == NULL)
		return result;

	for (ch=result; *ch; ch++) {
		if (*ch == ' ')		/* count blanks */
			num++;
	}
	sprintf(ret_string, "%d", num);
	return ret_string;
}

char	*
pids(attrib)
struct	rm_attribute	*attrib;
{
	char		*id = "pids";
	pid_t		jobid;
	prpsinfo_t	*pi;
	int		i;
	char		*fmt;
	int		num_pids;

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

	if (strcmp(attrib->a_qualifier, "session") != 0) {
		rm_errno = PBSE_RMBADPARAM;
		return NULL;
	}
	if (getprocs() == 0) {
		rm_errno = PBSE_RMSYSTEM;
		return NULL;
	}

	/*
	** Search for members of session
	*/
	fmt = ret_string;
	num_pids = 0;
	for (i=0; i<nproc; i++) {
		pi = &proc_array[i].info;

		DBPRT(("%s[%d]: pid: %d sid %d\n",
		       id, num_pids, pi->pr_pid, pi->pr_sid))
		if (jobid != pi->pr_sid)
			continue;

		sprintf(fmt, "%d ", pi->pr_pid);
		fmt += strlen(fmt);
		num_pids++;
	}
	if (num_pids == 0) {
		rm_errno = PBSE_RMEXIST;
		return NULL;
	}
	return ret_string;
}

char	*
nusers(attrib)
struct	rm_attribute	*attrib;
{
	char			*id = "nusers";
	int			i, j;
	prpsinfo_t		*pi;