summaryrefslogtreecommitdiff
path: root/sys
diff options
context:
space:
mode:
Diffstat (limited to 'sys')
-rw-r--r--sys/kern/imgact_aout.c3
-rw-r--r--sys/kern/kern_proc.c152
-rw-r--r--sys/kern/sys_process.c8
-rw-r--r--sys/sys/user.h114
4 files changed, 192 insertions, 85 deletions
diff --git a/sys/kern/imgact_aout.c b/sys/kern/imgact_aout.c
index e27a80c6e5b1..6e0edde0e022 100644
--- a/sys/kern/imgact_aout.c
+++ b/sys/kern/imgact_aout.c
@@ -254,8 +254,7 @@ aout_coredump(p, vp, limit)
if (ctob(UPAGES + vm->vm_dsize + vm->vm_ssize) >= limit)
return (EFAULT);
- bcopy(p, &p->p_addr->u_kproc.kp_proc, sizeof(struct proc));
- fill_eproc(p, &p->p_addr->u_kproc.kp_eproc);
+ fill_kinfo_proc(p, &p->p_addr->u_kproc);
error = cpu_coredump(p, vp, cred);
if (error == 0)
error = vn_rdwr(UIO_WRITE, vp, vm->vm_daddr,
diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c
index 4c66e505bf06..793c0689e707 100644
--- a/sys/kern/kern_proc.c
+++ b/sys/kern/kern_proc.c
@@ -90,6 +90,13 @@ procinit()
pgrphashtbl = hashinit(maxproc / 4, M_PROC, &pgrphash);
proc_zone = zinit("PROC", sizeof (struct proc), 0, 0, 5);
uihashinit();
+ /*
+ * This should really be a compile time warning, but I do
+ * not know of any way to do that...
+ */
+ if (sizeof(struct kinfo_proc) != KINFO_PROC_SIZE)
+ printf("WARNING: size of kinfo_proc (%d) should be %d!!!\n",
+ sizeof(struct kinfo_proc), KINFO_PROC_SIZE);
}
/*
@@ -352,64 +359,118 @@ DB_SHOW_COMMAND(pgrpdump, pgrpdump)
#endif /* DDB */
/*
- * Fill in an eproc structure for the specified process.
+ * Fill in an kinfo_proc structure for the specified process.
*/
void
-fill_eproc(p, ep)
- register struct proc *p;
- register struct eproc *ep;
+fill_kinfo_proc(p, kp)
+ struct proc *p;
+ struct kinfo_proc *kp;
{
- register struct tty *tp;
-
- bzero(ep, sizeof(*ep));
-
- ep->e_paddr = p;
+ struct tty *tp;
+ struct session *sp;
+
+ bzero(kp, sizeof(*kp));
+
+ kp->ki_structsize = sizeof(*kp);
+ kp->ki_paddr = p;
+ kp->ki_addr = p->p_addr;
+ kp->ki_args = p->p_args;
+ kp->ki_tracep = p->p_tracep;
+ kp->ki_textvp = p->p_textvp;
+ kp->ki_fd = p->p_fd;
+ kp->ki_vmspace = p->p_vmspace;
if (p->p_cred) {
- ep->e_pcred = *p->p_cred;
- if (p->p_ucred)
- ep->e_ucred = *p->p_ucred;
+ kp->ki_uid = p->p_cred->pc_ucred->cr_uid;
+ kp->ki_ruid = p->p_cred->p_ruid;
+ kp->ki_svuid = p->p_cred->p_svuid;
+ kp->ki_ngroups = p->p_cred->pc_ucred->cr_ngroups;
+ bcopy(p->p_cred->pc_ucred->cr_groups, kp->ki_groups,
+ NGROUPS * sizeof(gid_t));
+ kp->ki_rgid = p->p_cred->p_rgid;
+ kp->ki_svgid = p->p_cred->p_svgid;
}
if (p->p_procsig) {
- ep->e_procsig = *p->p_procsig;
+ kp->ki_sigignore = p->p_procsig->ps_sigignore;
+ kp->ki_sigcatch = p->p_procsig->ps_sigcatch;
}
if (p->p_stat != SIDL && p->p_stat != SZOMB && p->p_vmspace != NULL) {
- register struct vmspace *vm = p->p_vmspace;
- ep->e_vm = *vm;
- ep->e_vm.vm_rssize = vmspace_resident_count(vm); /*XXX*/
+ struct vmspace *vm = p->p_vmspace;
+
+ kp->ki_size = vm->vm_map.size;
+ kp->ki_rssize = vmspace_resident_count(vm); /*XXX*/
+ kp->ki_swrss = vm->vm_swrss;
+ kp->ki_tsize = vm->vm_tsize;
+ kp->ki_dsize = vm->vm_dsize;
+ kp->ki_ssize = vm->vm_ssize;
+ }
+ if ((p->p_flag & P_INMEM) && p->p_stats) {
+ kp->ki_start = p->p_stats->p_start;
+ kp->ki_rusage = p->p_stats->p_ru;
+ kp->ki_childtime.tv_sec = p->p_stats->p_cru.ru_utime.tv_sec +
+ p->p_stats->p_cru.ru_stime.tv_sec;
+ kp->ki_childtime.tv_usec = p->p_stats->p_cru.ru_utime.tv_usec +
+ p->p_stats->p_cru.ru_stime.tv_usec;
}
- if ((p->p_flag & P_INMEM) && p->p_stats)
- ep->e_stats = *p->p_stats;
+ kp->ki_rtprio = p->p_rtprio;
+ kp->ki_runtime = p->p_runtime;
+ kp->ki_pid = p->p_pid;
if (p->p_pptr)
- ep->e_ppid = p->p_pptr->p_pid;
+ kp->ki_ppid = p->p_pptr->p_pid;
+ sp = NULL;
if (p->p_pgrp) {
- ep->e_pgid = p->p_pgrp->pg_id;
- ep->e_jobc = p->p_pgrp->pg_jobc;
- ep->e_sess = p->p_pgrp->pg_session;
-
- if (ep->e_sess) {
- bcopy(ep->e_sess->s_login, ep->e_login, sizeof(ep->e_login));
- if (ep->e_sess->s_ttyvp)
- ep->e_flag = EPROC_CTTY;
- if (p->p_session && SESS_LEADER(p))
- ep->e_flag |= EPROC_SLEADER;
+ kp->ki_pgid = p->p_pgrp->pg_id;
+ kp->ki_jobc = p->p_pgrp->pg_jobc;
+ sp = p->p_pgrp->pg_session;
+
+ if (sp != NULL) {
+ kp->ki_sid = sp->s_sid;
+ bcopy(sp->s_login, kp->ki_login, sizeof(kp->ki_login));
+ if (sp->s_ttyvp)
+ kp->ki_kiflag = KI_CTTY;
+ if (SESS_LEADER(p))
+ kp->ki_kiflag |= KI_SLEADER;
}
}
- if ((p->p_flag & P_CONTROLT) &&
- (ep->e_sess != NULL) &&
- ((tp = ep->e_sess->s_ttyp) != NULL)) {
- ep->e_tdev = dev2udev(tp->t_dev);
- ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
- ep->e_tsess = tp->t_session;
+ if ((p->p_flag & P_CONTROLT) && sp && ((tp = sp->s_ttyp) != NULL)) {
+ kp->ki_tdev = dev2udev(tp->t_dev);
+ kp->ki_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PID;
+ if (tp->t_session)
+ kp->ki_tsid = tp->t_session->s_sid;
} else
- ep->e_tdev = NOUDEV;
+ kp->ki_tdev = NOUDEV;
if (p->p_wmesg) {
- strncpy(ep->e_wmesg, p->p_wmesg, WMESGLEN);
- ep->e_wmesg[WMESGLEN] = 0;
+ strncpy(kp->ki_wmesg, p->p_wmesg, WMESGLEN);
+ kp->ki_wmesg[WMESGLEN] = 0;
+ }
+ if (p->p_comm[0] != 0) {
+ strncpy(kp->ki_comm, p->p_comm, MAXCOMLEN);
+ kp->ki_comm[MAXCOMLEN] = 0;
}
- if (p->p_mtxname) {
- strncpy(ep->e_mtxname, p->p_mtxname, MTXNAMELEN);
- ep->e_mtxname[MTXNAMELEN] = 0;
+ if (p->p_blocked != 0) {
+ kp->ki_kiflag |= KI_MTXBLOCK;
+ strncpy(kp->ki_mtxname, p->p_mtxname, MTXNAMELEN);
+ kp->ki_wmesg[MTXNAMELEN] = 0;
}
+ kp->ki_siglist = p->p_siglist;
+ kp->ki_sigmask = p->p_sigmask;
+ kp->ki_xstat = p->p_xstat;
+ kp->ki_acflag = p->p_acflag;
+ kp->ki_pctcpu = p->p_pctcpu;
+ kp->ki_estcpu = p->p_estcpu;
+ kp->ki_slptime = p->p_slptime;
+ kp->ki_swtime = p->p_swtime;
+ kp->ki_flag = p->p_flag;
+ kp->ki_wchan = p->p_wchan;
+ kp->ki_traceflag = p->p_traceflag;
+ kp->ki_priority = p->p_priority;
+ kp->ki_usrpri = p->p_usrpri;
+ kp->ki_nativepri = p->p_nativepri;
+ kp->ki_stat = p->p_stat;
+ kp->ki_nice = p->p_nice;
+ kp->ki_lock = p->p_lock;
+ kp->ki_rqindex = p->p_rqindex;
+ kp->ki_oncpu = p->p_oncpu;
+ kp->ki_lastcpu = p->p_lastcpu;
}
static struct proc *
@@ -427,15 +488,12 @@ zpfind(pid_t pid)
static int
sysctl_out_proc(struct proc *p, struct sysctl_req *req, int doingzomb)
{
- struct eproc eproc;
+ struct kinfo_proc kinfo_proc;
int error;
pid_t pid = p->p_pid;
- fill_eproc(p, &eproc);
- error = SYSCTL_OUT(req,(caddr_t)p, sizeof(struct proc));
- if (error)
- return (error);
- error = SYSCTL_OUT(req,(caddr_t)&eproc, sizeof(eproc));
+ fill_kinfo_proc(p, &kinfo_proc);
+ error = SYSCTL_OUT(req, (caddr_t)&kinfo_proc, sizeof(kinfo_proc));
if (error)
return (error);
if (!doingzomb && pid && (pfind(pid) != p))
diff --git a/sys/kern/sys_process.c b/sys/kern/sys_process.c
index c9abad45c604..5bdeb78dc11e 100644
--- a/sys/kern/sys_process.c
+++ b/sys/kern/sys_process.c
@@ -339,7 +339,7 @@ ptrace(curp, uap)
}
if (uap->addr != (caddr_t)1) {
- fill_eproc (p, &p->p_addr->u_kproc.kp_eproc);
+ fill_kinfo_proc (p, &p->p_addr->u_kproc);
if ((error = ptrace_set_pc (p,
(u_long)(uintfptr_t)uap->addr))) {
PRELE(p);
@@ -428,8 +428,7 @@ ptrace(curp, uap)
error = 0;
PHOLD(p); /* user had damn well better be incore! */
if (p->p_flag & P_INMEM) {
- p->p_addr->u_kproc.kp_proc = *p;
- fill_eproc (p, &p->p_addr->u_kproc.kp_eproc);
+ fill_kinfo_proc (p, &p->p_addr->u_kproc);
curp->p_retval[0] = *(int *)
((uintptr_t)p->p_addr + (uintptr_t)uap->addr);
} else {
@@ -442,8 +441,7 @@ ptrace(curp, uap)
case PT_WRITE_U:
PHOLD(p); /* user had damn well better be incore! */
if (p->p_flag & P_INMEM) {
- p->p_addr->u_kproc.kp_proc = *p;
- fill_eproc (p, &p->p_addr->u_kproc.kp_eproc);
+ fill_kinfo_proc (p, &p->p_addr->u_kproc);
error = ptrace_write_u(p, (vm_offset_t)uap->addr, uap->data);
} else {
error = EFAULT;
diff --git a/sys/sys/user.h b/sys/sys/user.h
index fd5924a0620e..e2ce5f8e9f73 100644
--- a/sys/sys/user.h
+++ b/sys/sys/user.h
@@ -60,41 +60,93 @@
#endif
/*
- * KERN_PROC subtype ops return arrays of augmented proc structures:
+ * KERN_PROC subtype ops return arrays of selected proc structure entries:
+ *
+ * When adding new fields to this structure, ALWAYS add them at the end
+ * and decrease the size of the spare field by the amount of space that
+ * you are adding. Byte aligned data should be added to the ki_sparestring
+ * space; other entries should be added to the ki_spare space. Always
+ * verify that sizeof(struct kinfo_proc) == KINFO_PROC_SIZE when you are
+ * done. If you change the size of this structure, many programs will stop
+ * working! Once you have added the new field, you will need to add code
+ * to initialize it in two places: kern/kern_proc.c in the function
+ * fill_kinfo_proc and in lib/libkvm/kvm_proc.c in the function kvm_proclist.
*/
+#define KINFO_PROC_SIZE 640 /* the correct size for kinfo_proc */
+#define WMESGLEN 8 /* size of returned wchan message */
+#define MTXNAMELEN 8 /* size of returned mutex name */
+
struct kinfo_proc {
- struct proc kp_proc; /* proc structure */
- struct eproc {
- struct proc *e_paddr; /* address of proc */
- struct session *e_sess; /* session pointer */
- struct pcred e_pcred; /* process credentials */
- struct ucred e_ucred; /* current credentials */
- struct procsig e_procsig; /* shared signal structure */
- struct vmspace e_vm; /* address space */
- struct pstats e_stats; /* process stats */
- pid_t e_ppid; /* parent process id */
- pid_t e_pgid; /* process group id */
- short e_jobc; /* job control counter */
- udev_t e_tdev; /* controlling tty dev */
- pid_t e_tpgid; /* tty process group id */
- struct session *e_tsess; /* tty session pointer */
-#define WMESGLEN 7
- char e_wmesg[WMESGLEN+1]; /* wchan message */
-#define MTXNAMELEN 7
- char e_mtxname[MTXNAMELEN+1];/* blocked mutex */
- segsz_t e_xsize; /* text size */
- short e_xrssize; /* text rss */
- short e_xccount; /* text references */
- short e_xswrss;
- long e_flag;
-#define EPROC_CTTY 0x01 /* controlling tty vnode active */
-#define EPROC_SLEADER 0x02 /* session leader */
- char e_login[roundup(MAXLOGNAME, sizeof(long))]; /* setlogin() name */
- long e_spare[2];
- } kp_eproc;
+ int ki_structsize; /* size of this structure */
+ struct pargs *ki_args; /* address of command arguments */
+ struct proc *ki_paddr; /* address of proc */
+ struct user *ki_addr; /* kernel virtual addr of u-area */
+ struct vnode *ki_tracep; /* pointer to trace file */
+ struct vnode *ki_textvp; /* pointer to executable file */
+ struct filedesc *ki_fd; /* pointer to open file info */
+ struct vmspace *ki_vmspace; /* pointer to kernel vmspace struct */
+ void *ki_wchan; /* sleep address */
+ pid_t ki_pid; /* Process identifier */
+ pid_t ki_ppid; /* parent process id */
+ pid_t ki_pgid; /* process group id */
+ pid_t ki_tpgid; /* tty process group id */
+ pid_t ki_sid; /* Process session ID */
+ pid_t ki_tsid; /* Terminal session ID */
+ short ki_jobc; /* job control counter */
+ udev_t ki_tdev; /* controlling tty dev */
+ sigset_t ki_siglist; /* Signals arrived but not delivered */
+ sigset_t ki_sigmask; /* Current signal mask */
+ sigset_t ki_sigignore; /* Signals being ignored */
+ sigset_t ki_sigcatch; /* Signals being caught by user */
+ uid_t ki_uid; /* effective user id */
+ uid_t ki_ruid; /* Real user id */
+ uid_t ki_svuid; /* Saved effective user id */
+ gid_t ki_rgid; /* Real group id */
+ gid_t ki_svgid; /* Saved effective group id */
+ short ki_ngroups; /* number of groups */
+ gid_t ki_groups[NGROUPS]; /* groups */
+ vm_size_t ki_size; /* virtual size */
+ segsz_t ki_rssize; /* current resident set size in pages */
+ segsz_t ki_swrss; /* resident set size before last swap */
+ segsz_t ki_tsize; /* text size (pages) XXX */
+ segsz_t ki_dsize; /* data size (pages) XXX */
+ segsz_t ki_ssize; /* stack size (pages) */
+ u_short ki_xstat; /* Exit status for wait & stop signal */
+ u_short ki_acflag; /* Accounting flags */
+ fixpt_t ki_pctcpu; /* %cpu for process during ki_swtime */
+ u_int ki_estcpu; /* Time averaged value of ki_cpticks */
+ u_int ki_slptime; /* Time since last blocked */
+ u_int ki_swtime; /* Time swapped in or out */
+ u_int64_t ki_runtime; /* Real time in microsec */
+ struct timeval ki_start; /* starting time */
+ struct timeval ki_childtime; /* time used by process children */
+ long ki_flag; /* P_* flags */
+ long ki_kiflag; /* KI_* flags (below) */
+ int ki_traceflag; /* Kernel trace points */
+ u_char ki_priority; /* Process priority */
+ u_char ki_usrpri; /* User-priority based on p_cpu */
+ u_char ki_nativepri; /* Priority before propogation */
+ char ki_stat; /* S* process status */
+ char ki_nice; /* Process "nice" value */
+ char ki_lock; /* Process lock (prevent swap) count */
+ char ki_rqindex; /* Run queue index */
+ u_char ki_oncpu; /* Which cpu we are on */
+ u_char ki_lastcpu; /* Last cpu we were on */
+ char ki_comm[MAXCOMLEN+1]; /* command name */
+ char ki_wmesg[WMESGLEN+1]; /* wchan message */
+ char ki_login[MAXLOGNAME+1]; /* setlogin name */
+ char ki_mtxname[MTXNAMELEN+1]; /* mutex name */
+ char ki_sparestrings[102]; /* spare string space */
+ struct rtprio ki_rtprio; /* Realtime priority */
+ struct rusage ki_rusage; /* process rusage statistics */
+ long ki_spare[25]; /* spare constants */
};
-void fill_eproc __P((struct proc *, struct eproc *));
+void fill_kinfo_proc __P((struct proc *, struct kinfo_proc *));
+/* ki_sessflag values */
+#define KI_CTTY 0x00000001 /* controlling tty vnode active */
+#define KI_SLEADER 0x00000002 /* session leader */
+#define KI_MTXBLOCK 0x00000004 /* proc blocked on mutex ki_mtxname */
/*
* Per process structure containing data that isn't needed in core
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-29 10:34:39 +0000