mom_mach.c

openPBS的开放源代码

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

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

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

#define	dsecs(val) ( (double)(val) )

char	*
cput_job(jobid)
pid_t	jobid;
{
	char			*id = "cput_job";
	int			found = 0;
	struct dirent		*dent;
	double			cputime, addtime;
	proc_stat_t		*ps;

	cputime = 0.0;
	rewinddir(pdir);
	while ((dent = readdir(pdir)) != NULL) {
		if (!isdigit(dent->d_name[0]))
			continue;

		if ((ps = get_proc_stat(atoi(dent->d_name))) == NULL) {
			if (errno != ENOENT) {
				sprintf(log_buffer,
					"%s: get_proc_stat", dent->d_name);
				log_err(errno, id, log_buffer);
			}
			continue;
		}

		if (jobid != ps->session)
			continue;

		found = 1;
		addtime = dsecs(ps->cutime) + dsecs(ps->cstime);

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

	}
	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_pid";
	double			cputime;
	proc_stat_t		*ps;

	cputime = 0.0;

	if ((ps = get_proc_stat(pid)) == NULL) {
		if (errno != ENOENT) {
			sprintf(log_buffer, "%d: get_proc_stat", pid);
			log_err(errno, id, log_buffer);
		}
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}
	cputime = dsecs(ps->utime) + dsecs(ps->stime);

	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 = 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(sid)
pid_t	sid;
{
	static	char	id[] = "mem_job";
	ulong			memsize;
	struct dirent		*dent;
	char			procname[100];
	int			num, i;
	proc_stat_t		*ps;

	memsize = 0;
	rewinddir(pdir);

	while ((dent = readdir(pdir)) != NULL) {
		if (!isdigit(dent->d_name[0]))
			continue;

		if ((ps = get_proc_stat(atoi(dent->d_name))) == NULL) {
			if (errno != ENOENT) {
				sprintf(log_buffer,
					"%s: get_proc_stat", dent->d_name);
				log_err(errno, id, log_buffer);
			}
			continue;
		}

		if (sid != ps->session)
			continue;
		memsize += ps->vsize;
	}

	if (memsize == 0) {
		rm_errno = RM_ERR_EXIST;
		return NULL;
	}
	else {
		sprintf(ret_string, "%lukb", memsize >> 10); /* KB */
		return ret_string;
	}
}

char	*
mem_proc(pid)
pid_t	pid;
{
	char			*id = "mem_proc";
	proc_stat_t		*ps;

	if ((ps = get_proc_stat(pid)) == NULL) {
		if (errno != ENOENT) {
			sprintf(log_buffer, "%d: get_proc_stat", pid);
			log_err(errno, id, log_buffer);
		}
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}

	sprintf(ret_string, "%lukb", (ulong)ps->vsize >> 10); /* 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 = 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	*
resi_job(jobid)
pid_t	jobid;
{
	char			*id = "resi_job";
	ulong			resisize;
	int			fd;
	int			found = 0;
	char			procname[100];
	struct dirent		*dent;
	proc_stat_t		*ps;

	resisize = 0;
	rewinddir(pdir);
	while ((dent = readdir(pdir)) != NULL) {
		if (!isdigit(dent->d_name[0]))
			continue;

		if ((ps = get_proc_stat(atoi(dent->d_name))) == NULL) {
			if (errno != ENOENT) {
				sprintf(log_buffer,
					"%s: get_proc_stat", dent->d_name);
				log_err(errno, id, log_buffer);
			}
			continue;
		}

		if (jobid != ps->session)
			continue;

		found = 1;
		resisize += ps->rss;
	}
	if (found) {
		/* in KB */
		sprintf(ret_string, "%lukb",(resisize * (ulong)pagesize) >> 10);
		return ret_string;
	}

	rm_errno = RM_ERR_EXIST;
	return NULL;
}

static char	*
resi_proc(pid)
pid_t	pid;
{
	char			*id = "resi_proc";
	proc_stat_t		*ps;


	if ((ps = get_proc_stat(pid)) == NULL) {
		if (errno != ENOENT) {
			sprintf(log_buffer,
				"%d: get_proc_stat(PIOCPSINFO)", pid);
			log_err(errno, id, log_buffer);
		}
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}

	/* in KB */
	sprintf(ret_string, "%lukb", ((ulong)ps->rss * (ulong)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 = 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			j;
	struct dirent		*dent;
	proc_stat_t		*ps;
	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 = RM_ERR_BADPARAM;
		return NULL;
	}
	if ((jids = (pid_t *)calloc(maxjid, sizeof(pid_t))) == NULL) {
		log_err(errno, id, "no memory");
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}

	/*
	** Search for members of session
	*/
	rewinddir(pdir);
	while ((dent = readdir(pdir)) != NULL) {
		if (!isdigit(dent->d_name[0]))
			continue;

		if ((ps = get_proc_stat(atoi(dent->d_name))) == NULL) {
			if (errno != ENOENT) {
				sprintf(log_buffer,
					"%s: get_proc_stat", dent->d_name);
				log_err(errno, id, log_buffer);
			}
			continue;
		}

		if (ps->uid == 0)
			continue;
		if ((jobid = ps->session) == 0)
			continue;
		DBPRT(("%s[%d]: pid %d sid %d\n",
		       id, njids, ps->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 = RM_ERR_SYSTEM;
					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;
	struct	dirent	*dent;
	proc_stat_t	*ps;
	int		i;
	char		*fmt;
	int		num_pids;

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

	/*
	** Search for members of session
	*/
	rewinddir(pdir);
	fmt = ret_string;
	while ((dent = readdir(pdir)) != NULL) {
		if (!isdigit(dent->d_name[0]))
			continue;

		if ((ps = get_proc_stat(atoi(dent->d_name))) == NULL) {
			if (errno != ENOENT) {
				sprintf(log_buffer,
					"%s: get_proc_stat", dent->d_name);
				log_err(errno, id, log_buffer);
			}
			continue;
		}

		DBPRT(("%s[%d]: pid: %s sid %d\n",
		       id, num_pids, dent->d_name, ps->session))
		if (jobid != ps->session)
			continue;

		sprintf(fmt, "%s ", dent->d_name);
		fmt += strlen(fmt);
		num_pids++;
	}
	if (num_pids == 0) {
		rm_errno = RM_ERR_EXIST;
		return NULL;
	}
	return ret_string;
}

char	*
nusers(attrib)
struct	rm_attribute	*attrib;
{
	char			*id = "nusers";
	int			j;
	struct dirent		*dent;
	proc_stat_t		*ps;
	int			nuids = 0;
	uid_t			*uids, *hold;
	static		int	maxuid = 200;
	register	uid_t	uid;

	if (attrib) {
		log_err(-1, id, extra_parm);
		rm_errno = RM_ERR_BADPARAM;
		return NULL;
	}
	if ((uids = (uid_t *)calloc(maxuid, sizeof(uid_t))) == NULL) {
		log_err(errno, id, "no memory");
		rm_errno = RM_ERR_SYSTEM;
		return NULL;
	}

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

		if ((ps = get_proc_stat(atoi(dent->d_name))) == NULL) {
			if (errno != ENOENT) {
				sprintf(log_buffer,
					"%s: get_proc_stat", dent->d_name);
				log_err(errno, id, log_buffer);
			}
			continue;
		}
		if ((uid = ps->uid) == 0)
			continue;

		DBPRT(("%s[%d]: pid %d uid %d\n",
		       id, nuids, ps->pid, uid))

		for (j=0; j<nuids; j++) {
			if (uids[j] == uid)
				break;
		}
		if (j == nuids) {		/* not found */
			if (nuids == maxuid) {	/* need more space */
				maxuid += 100;
				hold = (uid_t *)realloc(uids, maxuid);
				if (hold == NULL) {
					log_err(errno, id, "realloc");
					rm_errno = RM_ERR_SYSTEM;
					free(uids);
					return NULL;
				}
				uids = hold;
			}