 @@ -1,14 +1,14 @@
-/*	$NetBSD: kern_proc.c,v 1.216 2018/09/04 15:48:44 maxv Exp $	*/
+/*	$NetBSD: kern_proc.c,v 1.217 2018/09/04 16:03:56 maxv Exp $	*/
 /*-
  * Copyright (c) 1999, 2006, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center, and by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -52,27 +52,27 @@
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)kern_proc.c	8.7 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.216 2018/09/04 15:48:44 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: kern_proc.c,v 1.217 2018/09/04 16:03:56 maxv Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_kstack.h"
 #include "opt_maxuprc.h"
 #include "opt_dtrace.h"
 #include "opt_compat_netbsd32.h"
 #endif
 #if defined(__HAVE_COMPAT_NETBSD32) && !defined(COMPAT_NETBSD32) \
     && !defined(_RUMPKERNEL)
 #define COMPAT_NETBSD32
 #endif
 @@ -2150,42 +2150,55 @@ copy_procargs(struct proc *p, int oid, s
 			len += xlen;
 			base += xlen;
+		}
+	}
 	*limit = len;
 done:
 	kmem_free(argv, PAGE_SIZE);
 	kmem_free(arg, PAGE_SIZE);
 	uvmspace_free(vmspace);
 	return error;
+}
 #define SET_KERN_ADDR(dst, src, allow)	\
 	do {				\
 		if (allow)		\
 			dst = src;	\
 	} while (0);
 /*
  * Fill in an eproc structure for the specified process.
  */
 void
 fill_eproc(struct proc *p, struct eproc *ep, bool zombie)
+{
 	bool allowaddr;
 	struct tty *tp;
 	struct lwp *l;
 	int error;
 	KASSERT(mutex_owned(proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	memset(ep, 0, sizeof(*ep));
-	ep->e_paddr = p;
+	/* If not privileged, don't expose kernel addresses. */
-	ep->e_sess = p->p_session;
+	error = kauth_authorize_process(kauth_cred_get(), KAUTH_PROCESS_CANSEE,
 	    curproc, KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_KPTR), NULL, NULL);
 	allowaddr = (error == 0);
 	SET_KERN_ADDR(ep->e_paddr, p, allowaddr);
 	SET_KERN_ADDR(ep->e_sess, p->p_session, allowaddr);
 	if (p->p_cred) {
 		kauth_cred_topcred(p->p_cred, &ep->e_pcred);
 		kauth_cred_toucred(p->p_cred, &ep->e_ucred);
+	}
 	if (p->p_stat != SIDL && !P_ZOMBIE(p) && !zombie) {
 		struct vmspace *vm = p->p_vmspace;
 		ep->e_vm.vm_rssize = vm_resident_count(vm);
 		ep->e_vm.vm_tsize = vm->vm_tsize;
 		ep->e_vm.vm_dsize = vm->vm_dsize;
 		ep->e_vm.vm_ssize = vm->vm_ssize;
 		ep->e_vm.vm_map.size = vm->vm_map.size;
 @@ -2196,94 +2209,101 @@ fill_eproc(struct proc *p, struct eproc
 		if (l->l_wchan)
 			strncpy(ep->e_wmesg, l->l_wmesg, WMESGLEN);
 		lwp_unlock(l);
+	}
 	ep->e_ppid = p->p_ppid;
 	if (p->p_pgrp && p->p_session) {
 		ep->e_pgid = p->p_pgrp->pg_id;
 		ep->e_jobc = p->p_pgrp->pg_jobc;
 		ep->e_sid = p->p_session->s_sid;
 		if ((p->p_lflag & PL_CONTROLT) &&
 		    (tp = p->p_session->s_ttyp)) {
 			ep->e_tdev = tp->t_dev;
 			ep->e_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID;
-			ep->e_tsess = tp->t_session;
+			SET_KERN_ADDR(ep->e_tsess, tp->t_session, allowaddr);
 		} else
 			ep->e_tdev = (uint32_t)NODEV;
 		ep->e_flag = p->p_session->s_ttyvp ? EPROC_CTTY : 0;
 		if (SESS_LEADER(p))
 			ep->e_flag |= EPROC_SLEADER;
 		strncpy(ep->e_login, p->p_session->s_login, MAXLOGNAME);
+	}
 	ep->e_xsize = ep->e_xrssize = 0;
 	ep->e_xccount = ep->e_xswrss = 0;
+}
 /*
  * Fill in a kinfo_proc2 structure for the specified process.
  */
 void
 fill_kproc2(struct proc *p, struct kinfo_proc2 *ki, bool zombie)
+{
 	struct tty *tp;
 	struct lwp *l, *l2;
 	struct timeval ut, st, rt;
 	sigset_t ss1, ss2;
 	struct rusage ru;
 	struct vmspace *vm;
 	bool allowaddr;
 	int error;
 	KASSERT(mutex_owned(proc_lock));
 	KASSERT(mutex_owned(p->p_lock));
 	/* If not privileged, don't expose kernel addresses. */
 	error = kauth_authorize_process(kauth_cred_get(), KAUTH_PROCESS_CANSEE,
 	    curproc, KAUTH_ARG(KAUTH_REQ_PROCESS_CANSEE_KPTR), NULL, NULL);
 	allowaddr = (error == 0);
 	sigemptyset(&ss1);
 	sigemptyset(&ss2);
 	memset(ki, 0, sizeof(*ki));
-	ki->p_paddr = PTRTOUINT64(p);
+	SET_KERN_ADDR(ki->p_paddr, PTRTOUINT64(p), allowaddr);
-	ki->p_fd = PTRTOUINT64(p->p_fd);
+	SET_KERN_ADDR(ki->p_fd, PTRTOUINT64(p->p_fd), allowaddr);
-	ki->p_cwdi = PTRTOUINT64(p->p_cwdi);
+	SET_KERN_ADDR(ki->p_cwdi, PTRTOUINT64(p->p_cwdi), allowaddr);
-	ki->p_stats = PTRTOUINT64(p->p_stats);
+	SET_KERN_ADDR(ki->p_stats, PTRTOUINT64(p->p_stats), allowaddr);
-	ki->p_limit = PTRTOUINT64(p->p_limit);
+	SET_KERN_ADDR(ki->p_limit, PTRTOUINT64(p->p_limit), allowaddr);
-	ki->p_vmspace = PTRTOUINT64(p->p_vmspace);
+	SET_KERN_ADDR(ki->p_vmspace, PTRTOUINT64(p->p_vmspace), allowaddr);
-	ki->p_sigacts = PTRTOUINT64(p->p_sigacts);
+	SET_KERN_ADDR(ki->p_sigacts, PTRTOUINT64(p->p_sigacts), allowaddr);
-	ki->p_sess = PTRTOUINT64(p->p_session);
+	SET_KERN_ADDR(ki->p_sess, PTRTOUINT64(p->p_session), allowaddr);
 	ki->p_tsess = 0;	/* may be changed if controlling tty below */
-	ki->p_ru = PTRTOUINT64(&p->p_stats->p_ru);
+	SET_KERN_ADDR(ki->p_ru, PTRTOUINT64(&p->p_stats->p_ru), allowaddr);
 	ki->p_eflag = 0;
 	ki->p_exitsig = p->p_exitsig;
 	ki->p_flag = L_INMEM;   /* Process never swapped out */
 	ki->p_flag |= sysctl_map_flags(sysctl_flagmap, p->p_flag);
 	ki->p_flag |= sysctl_map_flags(sysctl_sflagmap, p->p_sflag);
 	ki->p_flag |= sysctl_map_flags(sysctl_slflagmap, p->p_slflag);
 	ki->p_flag |= sysctl_map_flags(sysctl_lflagmap, p->p_lflag);
 	ki->p_flag |= sysctl_map_flags(sysctl_stflagmap, p->p_stflag);
 	ki->p_pid = p->p_pid;
 	ki->p_ppid = p->p_ppid;
 	ki->p_uid = kauth_cred_geteuid(p->p_cred);
 	ki->p_ruid = kauth_cred_getuid(p->p_cred);
 	ki->p_gid = kauth_cred_getegid(p->p_cred);
 	ki->p_rgid = kauth_cred_getgid(p->p_cred);
 	ki->p_svuid = kauth_cred_getsvuid(p->p_cred);
 	ki->p_svgid = kauth_cred_getsvgid(p->p_cred);
 	ki->p_ngroups = kauth_cred_ngroups(p->p_cred);
 	kauth_cred_getgroups(p->p_cred, ki->p_groups,
 	    uimin(ki->p_ngroups, sizeof(ki->p_groups) / sizeof(ki->p_groups[0])),
 	    UIO_SYSSPACE);
 	ki->p_uticks = p->p_uticks;
 	ki->p_sticks = p->p_sticks;
 	ki->p_iticks = p->p_iticks;
 	ki->p_tpgid = NO_PGID;	/* may be changed if controlling tty below */
-	ki->p_tracep = PTRTOUINT64(p->p_tracep);
+	SET_KERN_ADDR(ki->p_tracep, PTRTOUINT64(p->p_tracep), allowaddr);
 	ki->p_traceflag = p->p_traceflag;
 	memcpy(&ki->p_sigignore, &p->p_sigctx.ps_sigignore,sizeof(ki_sigset_t));
 	memcpy(&ki->p_sigcatch, &p->p_sigctx.ps_sigcatch, sizeof(ki_sigset_t));
 	ki->p_cpticks = 0;
 	ki->p_pctcpu = p->p_pctcpu;
 	ki->p_estcpu = 0;
 	ki->p_stat = p->p_stat; /* Will likely be overridden by LWP status */
 	ki->p_realstat = p->p_stat;
 	ki->p_nice = p->p_nice;
 	ki->p_xstat = P_WAITSTATUS(p);
 	ki->p_acflag = p->p_acflag;
 @@ -2307,40 +2327,40 @@ fill_kproc2(struct proc *p, struct kinfo
 		 * PROT_NONE and grown as needed, adjust the "mapped size"
 		 * to skip the unused stack portion.
 		 */
 		ki->p_vm_msize =
 		    atop(vm->vm_map.size) - vm->vm_issize + vm->vm_ssize;
 		/* Pick the primary (first) LWP */
 		l = proc_active_lwp(p);
 		KASSERT(l != NULL);
 		lwp_lock(l);
 		ki->p_nrlwps = p->p_nrlwps;
 		ki->p_forw = 0;
 		ki->p_back = 0;
-		ki->p_addr = PTRTOUINT64(l->l_addr);
+		SET_KERN_ADDR(ki->p_addr, PTRTOUINT64(l->l_addr), allowaddr);
 		ki->p_stat = l->l_stat;
 		ki->p_flag |= sysctl_map_flags(sysctl_lwpflagmap, l->l_flag);
 		ki->p_swtime = l->l_swtime;
 		ki->p_slptime = l->l_slptime;
 		if (l->l_stat == LSONPROC)
 			ki->p_schedflags = l->l_cpu->ci_schedstate.spc_flags;
 		else
 			ki->p_schedflags = 0;
 		ki->p_priority = lwp_eprio(l);
 		ki->p_usrpri = l->l_priority;
 		if (l->l_wchan)
 			strncpy(ki->p_wmesg, l->l_wmesg, sizeof(ki->p_wmesg));
-		ki->p_wchan = PTRTOUINT64(l->l_wchan);
+		SET_KERN_ADDR(ki->p_wchan, PTRTOUINT64(l->l_wchan), allowaddr);
 		ki->p_cpuid = cpu_index(l->l_cpu);
 		lwp_unlock(l);
 		LIST_FOREACH(l, &p->p_lwps, l_sibling) {
 			/* This is hardly correct, but... */
 			sigplusset(&l->l_sigpend.sp_set, &ss1);
 			sigplusset(&l->l_sigmask, &ss2);
 			ki->p_cpticks += l->l_cpticks;
 			ki->p_pctcpu += l->l_pctcpu;
 			ki->p_estcpu += l->l_estcpu;
+		}
+	}
 	sigplusset(&p->p_sigpend.sp_set, &ss2);
 	memcpy(&ki->p_siglist, &ss1, sizeof(ki_sigset_t));
 @@ -2349,27 +2369,28 @@ fill_kproc2(struct proc *p, struct kinfo
 	if (p->p_session != NULL) {
 		ki->p_sid = p->p_session->s_sid;
 		ki->p__pgid = p->p_pgrp->pg_id;
 		if (p->p_session->s_ttyvp)
 			ki->p_eflag |= EPROC_CTTY;
 		if (SESS_LEADER(p))
 			ki->p_eflag |= EPROC_SLEADER;
 		strncpy(ki->p_login, p->p_session->s_login,
 		    uimin(sizeof ki->p_login - 1, sizeof p->p_session->s_login));
 		ki->p_jobc = p->p_pgrp->pg_jobc;
 		if ((p->p_lflag & PL_CONTROLT) && (tp = p->p_session->s_ttyp)) {
 			ki->p_tdev = tp->t_dev;
 			ki->p_tpgid = tp->t_pgrp ? tp->t_pgrp->pg_id : NO_PGID;
-			ki->p_tsess = PTRTOUINT64(tp->t_session);
+			SET_KERN_ADDR(ki->p_tsess, PTRTOUINT64(tp->t_session),
 			    allowaddr);
 		} else {
 			ki->p_tdev = (int32_t)NODEV;
+		}
+	}
 	if (!P_ZOMBIE(p) && !zombie) {
 		ki->p_uvalid = 1;
 		ki->p_ustart_sec = p->p_stats->p_start.tv_sec;
 		ki->p_ustart_usec = p->p_stats->p_start.tv_usec;
 		calcru(p, &ut, &st, NULL, &rt);
 		ki->p_rtime_sec = rt.tv_sec;
 		ki->p_rtime_usec = rt.tv_usec;