char *
renice_procs(char *str)
{
register char negate;
int prio;
int procnum;
int uid;
ERR_RESET;
uid = getuid();
/* allow for negative priority values */
if ((negate = (*str == '-')) != 0)
{
/* move past the minus sign */
str++;
}
/* use procnum as a temporary holding place and get the number */
procnum = scanint(str, &prio);
/* negate if necessary */
if (negate)
{
prio = -prio;
}
#if defined(PRIO_MIN) && defined(PRIO_MAX)
/* check for validity */
if (procnum == -1 || prio < PRIO_MIN || prio > PRIO_MAX)
{
return (" bad priority value");
}
#endif
/* move to the first process number */
if ((str = next_field(str)) == NULL)
{
return (" no processes specified");
}
#ifdef HAVE_SETPRIORITY
/* loop thru the process numbers, renicing each one */
do
{
if (scanint(str, &procnum) == -1)
{
ERROR(str, 0);
}
/* check process owner if we're not root */
else if (uid && (uid != proc_owner(procnum)))
{
ERROR(str, EACCES);
}
else if (setpriority(PRIO_PROCESS, procnum, prio) == -1)
{
ERROR(str, errno);
}
} while ((str = next_field(str)) != NULL);
/* return appropriate error string */
return (err_string());
#else
return (" operation not supported");
#endif
}
static void
kill_procs(char *str)
{
register char *nptr;
int signum = SIGTERM; /* default */
int procnum;
int uid;
int owner;
#ifndef USE_SYS_SIGLIST
struct sigdesc *sigp;
#endif
/* reset error array */
ERR_RESET;
/* remember our uid */
uid = getuid();
/* skip over leading white space */
while (isspace((int)*str)) str++;
if (str[0] == '-')
{
/* explicit signal specified */
if ((nptr = next_field(str)) == NULL)
{
message_error(" kill: no processes specified");
return;
}
str++;
if (isdigit((int)str[0]))
{
(void) scanint(str, &signum);
if (signum <= 0 || signum >= NSIG)
{
message_error(" kill: invalid signal number");
return;
}
}
else
{
/* translate the name into a number */
#ifdef USE_SYS_SIGLIST
for (signum = 1; signum < NSIG; signum++)
{
if (strcasecmp(sys_signame[signum], str) == 0)
{
break;
}
}
if (signum == NSIG)
{
message_error(" kill: bad signal name");
return;
}
#else
for (sigp = sigdesc; sigp->name != NULL; sigp++)
{
#ifdef HAVE_STRCASECMP
if (strcasecmp(sigp->name, str) == 0)
#else
if (strcmp(sigp->name, str) == 0)
#endif
{
signum = sigp->number;
break;
}
}
/* was it ever found */
if (sigp->name == NULL)
{
message_error(" kill: bad signal name");
return;
}
#endif
}
/* put the new pointer in place */
str = nptr;
}
/* loop thru the string, killing processes */
do
{
if (scanint(str, &procnum) == -1)
{
ERROR(str, 0);
}
else
{
/* check process owner if we're not root */
owner = proc_owner(procnum);
if (uid && (uid != owner))
{
ERROR(str, owner == -1 ? ESRCH : EACCES);
}
/* go in for the kill */
else if (kill(procnum, signum) == -1)
{
/* chalk up an error */
ERROR(str, errno);
}
}
} while ((str = next_field(str)) != NULL);
/* process errors */
err_string();
}
char *
kill_procs(char *str)
{
register char *nptr;
int signum = SIGTERM; /* default */
int procnum;
struct sigdesc *sigp;
int uid;
/* reset error array */
ERR_RESET;
/* remember our uid */
uid = getuid();
/* skip over leading white space */
while (isspace(*str))
str++;
if (str[0] == '-')
{
/* explicit signal specified */
if ((nptr = next_field(str)) == NULL)
{
return (" kill: no processes specified");
}
if (isdigit(str[1]))
{
(void) scanint(str + 1, &signum);
if (signum <= 0 || signum >= NSIG)
{
return (" invalid signal number");
}
}
else
{
/* translate the name into a number */
for (sigp = sigdesc; sigp->name != NULL; sigp++)
{
if (strcmp(sigp->name, str + 1) == 0)
{
signum = sigp->number;
break;
}
}
/* was it ever found */
if (sigp->name == NULL)
{
return (" bad signal name");
}
}
/* put the new pointer in place */
str = nptr;
}
/* loop thru the string, killing processes */
do
{
if (scanint(str, &procnum) == -1)
{
ERROR(str, 0);
}
else
{
/* check process owner if we're not root */
if (uid && (uid != proc_owner(procnum)))
{
ERROR(str, EACCES);
}
/* go in for the kill */
else if (kill(procnum, signum) == -1)
{
/* chalk up an error */
ERROR(str, errno);
}
}
} while ((str = next_field(str)) != NULL);
/* return appropriate error string */
return (err_string());
}
static void
read_one_proc_stat(pid_t pid, struct top_proc * proc, struct process_select * sel)
{
char buffer[4096],
*p,
*q;
int fd,
len;
int fullcmd;
char value[BUFFERLEN + 1];
/* if anything goes wrong, we return with proc->state == 0 */
proc->state = 0;
/* full cmd handling */
fullcmd = sel->fullcmd;
if (fullcmd == 1)
{
sprintf(buffer, "%d/cmdline", pid);
if ((fd = open(buffer, O_RDONLY)) != -1)
{
/* read command line data */
/* (theres no sense in reading more than we can fit) */
if ((len = read(fd, buffer, MAX_COLS)) > 1)
{
buffer[len] = '\0';
xfrm_cmdline(buffer, len);
update_procname(proc, buffer);
}
else
{
fullcmd = 0;
}
close(fd);
}
else
{
fullcmd = 0;
}
}
/* grab the proc stat info in one go */
sprintf(buffer, "%d/stat", pid);
fd = open(buffer, O_RDONLY);
len = read(fd, buffer, sizeof(buffer) - 1);
close(fd);
buffer[len] = '\0';
proc->uid = (uid_t) proc_owner((int) pid);
/* parse out the status, described in 'man proc' */
/* skip pid and locate command, which is in parentheses */
if ((p = strchr(buffer, '(')) == NULL)
{
return;
}
if ((q = strrchr(++p, ')')) == NULL)
{
return;
}
/* set the procname */
*q = '\0';
if (!fullcmd)
{
update_procname(proc, p);
}
/* scan the rest of the line */
p = q + 1;
p = skip_ws(p);
switch (*p++) /* state */
{
case 'R':
proc->state = 1;
break;
case 'S':
proc->state = 2;
break;
case 'D':
proc->state = 3;
break;
case 'Z':
proc->state = 4;
break;
case 'T':
proc->state = 5;
break;
case 'W':
proc->state = 6;
break;
case '\0':
return;
}
p = skip_token(p); /* skip ppid */
p = skip_token(p); /* skip pgrp */
p = skip_token(p); /* skip session */
p = skip_token(p); /* skip tty nr */
p = skip_token(p); /* skip tty pgrp */
p = skip_token(p); /* skip flags */
p = skip_token(p); /* skip min flt */
p = skip_token(p); /* skip cmin flt */
p = skip_token(p); /* skip maj flt */
p = skip_token(p); /* skip cmaj flt */
proc->time = strtoul(p, &p, 10); /* utime */
proc->time += strtoul(p, &p, 10); /* stime */
p = skip_token(p); /* skip cutime */
p = skip_token(p); /* skip cstime */
proc->pri = strtol(p, &p, 10); /* priority */
proc->nice = strtol(p, &p, 10); /* nice */
p = skip_token(p); /* skip num_threads */
p = skip_token(p); /* skip itrealvalue, 0 */
proc->start_time = strtoul(p, &p, 10); /* start_time */
proc->size = bytetok(strtoul(p, &p, 10)); /* vsize */
proc->rss = pagetok(strtoul(p, &p, 10)); /* rss */
#if 0
/* for the record, here are the rest of the fields */
p = skip_token(p); /* skip rlim */
p = skip_token(p); /* skip start_code */
p = skip_token(p); /* skip end_code */
p = skip_token(p); /* skip start_stack */
p = skip_token(p); /* skip esp */
p = skip_token(p); /* skip eip */
p = skip_token(p); /* skip signal */
p = skip_token(p); /* skip sigblocked */
p = skip_token(p); /* skip sigignore */
p = skip_token(p); /* skip sigcatch */
p = skip_token(p); /* skip wchan */
p = skip_token(p); /* skip nswap, not maintained */
p = skip_token(p); /* exit signal */
p = skip_token(p); /* processor */
p = skip_token(p); /* rt_priority */
p = skip_token(p); /* policy */
p = skip_token(p); /* delayacct_blkio_ticks */
#endif
/* Get the io stats. */
sprintf(buffer, "%d/io", pid);
fd = open(buffer, O_RDONLY);
if (fd == -1)
{
/*
* CONFIG_TASK_IO_ACCOUNTING is not enabled in the Linux kernel or
* this version of Linux may not support collecting i/o statistics
* per pid. Report 0's.
*/
proc->rchar = 0;
proc->wchar = 0;
proc->syscr = 0;
proc->syscw = 0;
proc->read_bytes = 0;
proc->write_bytes = 0;
proc->cancelled_write_bytes = 0;
return;
}
len = read(fd, buffer, sizeof(buffer) - 1);
close(fd);
buffer[len] = '\0';
p = buffer;
GET_VALUE(proc->rchar);
GET_VALUE(proc->wchar);
GET_VALUE(proc->syscr);
GET_VALUE(proc->syscw);
GET_VALUE(proc->read_bytes);
GET_VALUE(proc->write_bytes);
GET_VALUE(proc->cancelled_write_bytes);
}
