/*-
 * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Simon 'corecode' Schubert <corecode@fs.ei.tum.de>
 * by Thomas E. Spanjaard <tgen@netphreax.net>
 *
 * 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
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS 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.
 */

/*
 * This is a source file used by both the kernel and libkvm.
 */

#ifndef _KERNEL
#define _KERNEL_STRUCTURES
#endif

#include <sys/proc.h>
#include <vm/vm_map.h>
#include <sys/kinfo.h>
#include <sys/tty.h>
#include <sys/conf.h>
#include <sys/jail.h>
#include <sys/mplock2.h>
#include <sys/globaldata.h>
#ifdef _KERNEL
#include <sys/systm.h>
#else
#include <string.h>

dev_t devid_from_dev(cdev_t dev);	/* kvm_proc.c */
#endif


#ifndef _KERNEL
/*
 * This is a temporary hack for when libkvm compiles in this file
 * from userland.  These functions don't belong here.
 */
static void
timevalfix(struct timeval *t1)
{

	if (t1->tv_usec < 0) {
		t1->tv_sec--;
		t1->tv_usec += 1000000;
	}
	if (t1->tv_usec >= 1000000) {
		t1->tv_sec++;
		t1->tv_usec -= 1000000;
	}
}

static void
timevaladd(struct timeval *t1, const struct timeval *t2)
{

	t1->tv_sec += t2->tv_sec;
	t1->tv_usec += t2->tv_usec;
	timevalfix(t1);
}

static void
ruadd(struct rusage *ru, struct rusage *ru2)
{
	long *ip, *ip2;
	int i;

	timevaladd(&ru->ru_utime, &ru2->ru_utime);
	timevaladd(&ru->ru_stime, &ru2->ru_stime);
	if (ru->ru_maxrss < ru2->ru_maxrss)
		ru->ru_maxrss = ru2->ru_maxrss;
	ip = &ru->ru_first; ip2 = &ru2->ru_first;
	for (i = &ru->ru_last - &ru->ru_first; i >= 0; i--)
		*ip++ += *ip2++;
}

#endif

/*
 * Fill in a struct kinfo_proc, and zero the lwp fields for a possible
 * fill_kinfo_lwp() aggregation.
 *
 * NOTE!  We may be asked to fill in kinfo_proc for a zombied process, and
 * the process may be in the middle of being deallocated.  Check all pointers
 * for NULL.
 *
 * Caller must hold p->p_token
 */
void
fill_kinfo_proc(struct proc *p, struct kinfo_proc *kp)
{
	struct session *sess;
	struct pgrp *pgrp;
	struct vmspace *vm;

	pgrp = p->p_pgrp;
	sess = pgrp ? pgrp->pg_session : NULL;

	bzero(kp, sizeof(*kp));

	kp->kp_paddr = (uintptr_t)p;
	kp->kp_fd = (uintptr_t)p->p_fd;

	kp->kp_flags = p->p_flags;
	kp->kp_stat = p->p_stat;
	kp->kp_lock = p->p_lock;
	kp->kp_acflag = p->p_acflag;
	kp->kp_traceflag = p->p_traceflag;
	kp->kp_siglist = p->p_siglist;
	if (p->p_sigacts) {
		kp->kp_sigignore = p->p_sigignore;	/* p_sigacts-> */
		kp->kp_sigcatch = p->p_sigcatch;	/* p_sigacts-> */
		kp->kp_sigflag = p->p_sigacts->ps_flag;
	}
	kp->kp_start = p->p_start;

	strncpy(kp->kp_comm, p->p_comm, sizeof(kp->kp_comm) - 1);
	kp->kp_comm[sizeof(kp->kp_comm) - 1] = 0;

	if (p->p_ucred) {
		kp->kp_uid = p->p_ucred->cr_uid;
		kp->kp_ngroups = p->p_ucred->cr_ngroups;
		bcopy(p->p_ucred->cr_groups, kp->kp_groups,
		      NGROUPS * sizeof(kp->kp_groups[0]));
		kp->kp_ruid = p->p_ucred->cr_ruid;
		kp->kp_svuid = p->p_ucred->cr_svuid;
		kp->kp_rgid = p->p_ucred->cr_rgid;
		kp->kp_svgid = p->p_ucred->cr_svgid;

		/*
		 * Copy just some of the capabilities for now to avoid
		 * changing the size of the kp structure.
		 */
		bcopy(p->p_ucred->cr_caps.caps, kp->kp_syscaps,
		      sizeof(kp->kp_syscaps));
	}

	kp->kp_pid = p->p_pid;
	if (p->p_oppid != 0)
		kp->kp_ppid = p->p_oppid;
	else
		kp->kp_ppid = p->p_pptr != NULL ? p->p_pptr->p_pid : -1;
	if (pgrp) {
		kp->kp_pgid = pgrp->pg_id;
		kp->kp_jobc = pgrp->pg_jobc;
	}
	if (sess) {
		kp->kp_sid = sess->s_sid;
		bcopy(sess->s_login, kp->kp_login, MAXLOGNAME);
		if (sess->s_ttyvp != NULL)
			kp->kp_auxflags |= KI_CTTY;
		if ((p->p_session != NULL) && SESS_LEADER(p))
			kp->kp_auxflags |= KI_SLEADER;
	}
	if (sess && (p->p_flags & P_CONTROLT) != 0 && sess->s_ttyp != NULL) {
		kp->kp_tdev = devid_from_dev(sess->s_ttyp->t_dev);
		if (sess->s_ttyp->t_pgrp != NULL)
			kp->kp_tpgid = sess->s_ttyp->t_pgrp->pg_id;
		else
			kp->kp_tpgid = -1;
		if (sess->s_ttyp->t_session != NULL)
			kp->kp_tsid = sess->s_ttyp->t_session->s_sid;
		else
			kp->kp_tsid = -1;
	} else {
		kp->kp_tdev = NOUDEV;
	}
	kp->kp_exitstat = p->p_xstat;
	kp->kp_nthreads = p->p_nthreads;
	kp->kp_nice = p->p_nice;
	kp->kp_swtime = p->p_swtime;

	if ((vm = p->p_vmspace) != NULL) {
		kp->kp_vm_map_size = vm->vm_map.size;
		kp->kp_vm_rssize = vmspace_resident_count(vm);
		kp->kp_vm_swrss = vm->vm_swrss;
		kp->kp_vm_tsize = btoc(vm->vm_tsize);
		kp->kp_vm_dsize = btoc(vm->vm_dsize);
		kp->kp_vm_ssize = btoc(vm->vm_ssize);
	}

	if (p->p_ucred && jailed(p->p_ucred))
		kp->kp_jailid = p->p_ucred->cr_prison->pr_id;

	kp->kp_ru = p->p_ru;
	kp->kp_cru = p->p_cru;
}

/*
 * Fill in a struct kinfo_lwp.  This routine also doubles as an aggregator
 * of lwps for the proc.
 *
 * The kl structure must be initially zerod by the caller.  Note that
 * fill_kinfo_proc() will do this for us.
 */
void
fill_kinfo_lwp(struct lwp *lwp, struct kinfo_lwp *kl)
{
	kl->kl_pid = lwp->lwp_proc->p_pid;
	kl->kl_tid = lwp->lwp_tid;

	kl->kl_flags = lwp->lwp_flags;
	kl->kl_stat = lwp->lwp_stat;
	kl->kl_lock = lwp->lwp_lock;
	kl->kl_tdflags = lwp->lwp_thread->td_flags;

	/*
	 * The process/lwp stat may not reflect whether the process is
	 * actually sleeping or not if the related thread was directly
	 * descheduled by LWKT.  Adjust the stat if the thread is not
	 * runnable and not waiting to be scheduled on a cpu by the
	 * user process scheduler.
	 */
	if (kl->kl_stat == LSRUN) {
		if ((kl->kl_tdflags & TDF_RUNQ) == 0 &&
		    (lwp->lwp_mpflags & LWP_MP_ONRUNQ) == 0) {
			kl->kl_stat = LSSLEEP;
		}
	}
#ifdef _KERNEL
	kl->kl_mpcount = get_mplock_count(lwp->lwp_thread);
#else
	kl->kl_mpcount = 0;
#endif

	kl->kl_prio = lwp->lwp_usdata.bsd4.priority;	/* XXX TGEN dangerous assumption */
	kl->kl_tdprio = lwp->lwp_thread->td_pri;
	kl->kl_rtprio = lwp->lwp_rtprio;

	kl->kl_uticks += lwp->lwp_thread->td_uticks;
	kl->kl_sticks += lwp->lwp_thread->td_sticks;
	kl->kl_iticks += lwp->lwp_thread->td_iticks;
	kl->kl_cpticks += lwp->lwp_cpticks;
	kl->kl_pctcpu += lwp->lwp_proc->p_stat == SZOMB ? 0 : lwp->lwp_pctcpu;
	kl->kl_slptime += lwp->lwp_slptime;
	kl->kl_origcpu = lwp->lwp_usdata.bsd4.batch;
	kl->kl_estcpu = lwp->lwp_usdata.bsd4.estcpu;
	kl->kl_cpuid = lwp->lwp_thread->td_gd->gd_cpuid;

	ruadd(&kl->kl_ru, &lwp->lwp_ru);

	kl->kl_siglist = lwp->lwp_siglist;
	kl->kl_sigmask = lwp->lwp_sigmask;

	kl->kl_wchan = (uintptr_t)lwp->lwp_thread->td_wchan;
	if (lwp->lwp_thread->td_wmesg) {
		strncpy(kl->kl_wmesg, lwp->lwp_thread->td_wmesg, WMESGLEN);
		kl->kl_wmesg[WMESGLEN] = 0;
	}
	strlcpy(kl->kl_comm, lwp->lwp_thread->td_comm, sizeof(kl->kl_comm));
}

/*
 * Fill in a struct kinfo_proc for kernel threads (i.e. those without proc).
 */
void
fill_kinfo_proc_kthread(struct thread *td, struct kinfo_proc *kp)
{
	bzero(kp, sizeof(*kp));

	/*
	 * Fill in fake proc information and semi-fake lwp info.
	 */
	kp->kp_pid = -1;
	kp->kp_tdev = NOUDEV;
	strncpy(kp->kp_comm, td->td_comm, sizeof(kp->kp_comm) - 1);
	kp->kp_comm[sizeof(kp->kp_comm) - 1] = 0;
	kp->kp_flags = P_SYSTEM;
	if (td != &td->td_gd->gd_idlethread)
		kp->kp_stat = SACTIVE;
	else
		kp->kp_stat = SIDL;
	kp->kp_nthreads = 1;
	kp->kp_ktaddr = (uintptr_t)td;

	kp->kp_lwp.kl_pid = -1;
	kp->kp_lwp.kl_tid = -1;
	kp->kp_lwp.kl_tdflags = td->td_flags;
#ifdef _KERNEL
	kp->kp_lwp.kl_mpcount = get_mplock_count(td);
#else
	kp->kp_lwp.kl_mpcount = 0;
#endif

	kp->kp_lwp.kl_tdprio = td->td_pri;
	kp->kp_lwp.kl_rtprio.type = RTP_PRIO_THREAD;
	kp->kp_lwp.kl_rtprio.prio = td->td_pri;

	kp->kp_lwp.kl_uticks = td->td_uticks;
	kp->kp_lwp.kl_sticks = td->td_sticks;
	kp->kp_lwp.kl_iticks = td->td_iticks;
	kp->kp_lwp.kl_cpuid = td->td_gd->gd_cpuid;

	kp->kp_lwp.kl_wchan = (uintptr_t)td->td_wchan;
	if (td->td_flags & TDF_RUNQ)
		kp->kp_lwp.kl_stat = LSRUN;
	else
		kp->kp_lwp.kl_stat = LSSLEEP;
	if (td->td_wmesg) {
		strncpy(kp->kp_lwp.kl_wmesg, td->td_wmesg, WMESGLEN);
		kp->kp_lwp.kl_wmesg[WMESGLEN] = 0;
	}
	strlcpy(kp->kp_lwp.kl_comm, td->td_comm, sizeof(kp->kp_lwp.kl_comm));
}