/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

#pragma ident	"%Z%%M%	%I%	%E% SMI"	/* from SVr4.0 1.74 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/sysmacros.h>

#include <sys/systm.h>

#include <sys/cred.h>

#include <sys/user.h>

#include <sys/errno.h>

#include <sys/proc.h>

#include <sys/ucontext.h>

#include <sys/procfs.h>

#include <sys/vnode.h>

#include <sys/acct.h>

#include <sys/var.h>

#include <sys/cmn_err.h>

#include <sys/debug.h>

#include <sys/wait.h>

#include <sys/siginfo.h>

#include <sys/procset.h>

#include <sys/class.h>

#include <sys/file.h>

#include <sys/session.h>

#include <sys/kmem.h>

#include <sys/vtrace.h>

#include <sys/prsystm.h>

#include <sys/ipc.h>

#include <sys/sem_impl.h>

#include <c2/audit.h>

#include <sys/aio_impl.h>

#include <vm/as.h>

#include <sys/poll.h>

#include <sys/door.h>

#include <sys/lwpchan_impl.h>

#include <sys/utrap.h>

#include <sys/task.h>

#include <sys/exacct.h>

#include <sys/cyclic.h>

#include <sys/schedctl.h>

#include <sys/rctl.h>

#include <sys/contract_impl.h>

#include <sys/contract/process_impl.h>

#include <sys/list.h>

#include <sys/dtrace.h>

#include <sys/pool.h>

#include <sys/sdt.h>

#include <sys/corectl.h>

/*

 * convert code/data pair into old style wait status

 */

int

wstat(int code, int data)

{

	int stat = (data & 0377);

	switch (code) {

	case CLD_EXITED:

		stat <<= 8;

		break;

	case CLD_DUMPED:

		stat |= WCOREFLG;

		break;

	case CLD_KILLED:

		break;

	case CLD_TRAPPED:

	case CLD_STOPPED:

		stat <<= 8;

		stat |= WSTOPFLG;

		break;

	case CLD_CONTINUED:

		stat = WCONTFLG;

		break;

	default:

		cmn_err(CE_PANIC, "wstat: bad code");

		/* NOTREACHED */

	}

	return (stat);

}

static char *

exit_reason(char *buf, size_t bufsz, int what, int why)

{

	switch (why) {

	case CLD_EXITED:

		(void) snprintf(buf, bufsz, "exited with status %d", what);

		break;

	case CLD_KILLED:

		(void) snprintf(buf, bufsz, "exited on fatal signal %d", what);

		break;

	case CLD_DUMPED:

		(void) snprintf(buf, bufsz, "core dumped on signal %d", what);

		break;

	default:

		(void) snprintf(buf, bufsz, "encountered unknown error "

		    "(%d, %d)", why, what);

		break;

	}

	return (buf);

}

/*

 * exit system call: pass back caller's arg.

 */

void

rexit(int rval)

{

	exit(CLD_EXITED, rval);

}

/*

 * Called by proc_exit() when a zone's init exits, presumably because

 * it failed.  As long as the given zone is still in the "running"

 * state, we will re-exec() init, but first we need to reset things

 * which are usually inherited across exec() but will break init's

 * assumption that it is being exec()'d from a virgin process.  Most

 * importantly this includes closing all file descriptors (exec only

 * closes those marked close-on-exec) and resetting signals (exec only

 * resets handled signals, and we need to clear any signals which

 * killed init).  Anything else that exec(2) says would be inherited,

 * but would affect the execution of init, needs to be reset.

 */

static int

restart_init(int what, int why)

{

	kthread_t *t = curthread;

	klwp_t *lwp = ttolwp(t);

	proc_t *p = ttoproc(t);

	user_t *up = PTOU(p);

	vnode_t *oldcd, *oldrd;

	sess_t *sp;

	int i, err;

	char reason_buf[64];

	const char *ipath;

	/*

	 * Let zone admin (and global zone admin if this is for a non-global

	 * zone) know that init has failed and will be restarted.

	 */

	zcmn_err(p->p_zone->zone_id, CE_WARN,

	    "init(1M) %s: restarting automatically",

	    exit_reason(reason_buf, sizeof (reason_buf), what, why));

	if (!INGLOBALZONE(p)) {

		cmn_err(CE_WARN, "init(1M) for zone %s (pid %d) %s: "

		    "restarting automatically",

		    p->p_zone->zone_name, p->p_pid, reason_buf);

	}

	/*

	 * Remove any fpollinfo_t's for this (last) thread from our file

	 * descriptors so closeall() can ASSERT() that they're all gone.

	 * Then close all open file descriptors in the process.

	 */

	pollcleanup();

	closeall(P_FINFO(p));

	/*

	 * Grab p_lock and begin clearing miscellaneous global process

	 * state that needs to be reset before we exec the new init(1M).

	 */

	mutex_enter(&p->p_lock);

	prbarrier(p);

	p->p_flag &= ~(SKILLED | SEXTKILLED | SEXITING | SDOCORE);

	up->u_cmask = CMASK;

	sigemptyset(&t->t_hold);

	sigemptyset(&t->t_sig);

	sigemptyset(&t->t_extsig);

	sigemptyset(&p->p_sig);

	sigemptyset(&p->p_extsig);

	sigdelq(p, t, 0);

	sigdelq(p, NULL, 0);

	if (p->p_killsqp) {

		siginfofree(p->p_killsqp);

		p->p_killsqp = NULL;

	}

	/*

	 * Reset any signals that are ignored back to the default disposition.

	 * Other u_signal members will be cleared when exec calls sigdefault().

	 */

	for (i = 1; i < NSIG; i++) {

		if (up->u_signal[i - 1] == SIG_IGN) {

			up->u_signal[i - 1] = SIG_DFL;

			sigemptyset(&up->u_sigmask[i - 1]);

		}

	}

	/*

	 * Clear the current signal, any signal info associated with it, and

	 * any signal information from contracts and/or contract templates.

	 */

	lwp->lwp_cursig = 0;

	lwp->lwp_extsig = 0;

	if (lwp->lwp_curinfo != NULL) {

		siginfofree(lwp->lwp_curinfo);

		lwp->lwp_curinfo = NULL;

	}

	lwp_ctmpl_clear(lwp);

	/*

	 * Reset both the process root directory and the current working

	 * directory to the root of the zone just as we do during boot.

	 */

	VN_HOLD(p->p_zone->zone_rootvp);

	oldrd = up->u_rdir;

	up->u_rdir = p->p_zone->zone_rootvp;

	VN_HOLD(p->p_zone->zone_rootvp);

	oldcd = up->u_cdir;

	up->u_cdir = p->p_zone->zone_rootvp;

	if (up->u_cwd != NULL) {

		refstr_rele(up->u_cwd);

		up->u_cwd = NULL;

	}

	mutex_exit(&p->p_lock);

	if (oldrd != NULL)

		VN_RELE(oldrd);

	if (oldcd != NULL)

		VN_RELE(oldcd);

	/*

	 * Free the controlling tty.

	 */

	mutex_enter(&pidlock);

	sp = p->p_sessp;

	if (sp->s_sidp == p->p_pidp && sp->s_vp != NULL) {

		mutex_exit(&pidlock);

		freectty(sp);

	} else {

		mutex_exit(&pidlock);

	}

	/*

	 * Now exec() the new init(1M) on top of the current process.  If we

	 * succeed, the caller will treat this like a successful system call.

	 * If we fail, we issue messages and the caller will proceed with exit.

	 */

	ipath = INGLOBALZONE(p) ? initname : zone_initname;

	err = exec_init(ipath, 0, NULL);

	if (err == 0)

		return (0);

	zcmn_err(p->p_zone->zone_id, CE_WARN,

	    "failed to restart init(1M) (err=%d): system reboot required", err);

	if (!INGLOBALZONE(p)) {

		cmn_err(CE_WARN, "failed to restart init(1M) for zone %s "

		    "(pid %d, err=%d): zoneadm(1M) boot required",

		    p->p_zone->zone_name, p->p_pid, err);

	}

	return (-1);

}

/*

 * Release resources.

 * Enter zombie state.

 * Wake up parent and init processes,

 * and dispose of children.

 */

void

exit(int why, int what)

{

	/*

	 * If proc_exit() fails, then some other lwp in the process

	 * got there first.  We just have to call lwp_exit() to allow

	 * the other lwp to finish exiting the process.  Otherwise we're

	 * restarting init, and should return.

	 */

	if (proc_exit(why, what) != 0) {

		mutex_enter(&curproc->p_lock);

		ASSERT(curproc->p_flag & SEXITLWPS);

		lwp_exit();

		/* NOTREACHED */

	}

}

/*

 * Set the SEXITING flag on the process, after making sure /proc does

 * not have it locked.  This is done in more places than proc_exit(),

 * so it is a separate function.

 */

void

proc_is_exiting(proc_t *p)

{

	mutex_enter(&p->p_lock);

	prbarrier(p);

	p->p_flag |= SEXITING;

	mutex_exit(&p->p_lock);

}

/*

 * Return value:

 *   1 - exitlwps() failed, call (or continue) lwp_exit()

 *   0 - restarting init.  Return through system call path

 */

int

proc_exit(int why, int what)

{

	kthread_t *t = curthread;

	klwp_t *lwp = ttolwp(t);

	proc_t *p = ttoproc(t);

	zone_t *z = p->p_zone;

	timeout_id_t tmp_id;

	int rv;

	proc_t *q;

	sess_t *sp;

	task_t *tk;

	vnode_t *exec_vp, *execdir_vp, *cdir, *rdir;

	sigqueue_t *sqp;

	lwpdir_t *lwpdir;

	uint_t lwpdir_sz;

	lwpdir_t **tidhash;

	uint_t tidhash_sz;

	refstr_t *cwd;

	hrtime_t hrutime, hrstime;

	/*

	 * Stop and discard the process's lwps except for the current one,

	 * unless some other lwp beat us to it.  If exitlwps() fails then

	 * return and the calling lwp will call (or continue in) lwp_exit().

	 */

	proc_is_exiting(p);

	if (exitlwps(0) != 0)

		return (1);

	DTRACE_PROC(lwp__exit);

	DTRACE_PROC1(exit, int, why);

	/*

	 * Don't let init exit unless zone_icode() failed its exec, or

	 * we are shutting down the zone or the machine.

	 *

	 * Since we are single threaded, we don't need to lock the

	 * following accesses to zone_proc_initpid.

	 */

	if (p->p_pid == z->zone_proc_initpid) {

		if (z->zone_boot_err == 0 &&

		    zone_status_get(z) < ZONE_IS_SHUTTING_DOWN &&

		    zone_status_get(global_zone) < ZONE_IS_SHUTTING_DOWN &&

		    restart_init(what, why) == 0)

			return (0);

		/*

		 * Since we didn't or couldn't restart init, we clear

		 * the zone's init state and proceed with exit

		 * processing.

		 */

		z->zone_proc_initpid = -1;

	}

	/*

	 * Allocate a sigqueue now, before we grab locks.

	 * It will be given to sigcld(), below.

	 */

	sqp = kmem_zalloc(sizeof (sigqueue_t), KM_SLEEP);

	/*

	 * revoke any doors created by the process.

	 */

	if (p->p_door_list)

		door_exit();

	/*

	 * Release schedctl data structures.

	 */

	if (p->p_pagep)

		schedctl_proc_cleanup();

	/*

	 * make sure all pending kaio has completed.

	 */

	if (p->p_aio)

		aio_cleanup_exit();

	/*

	 * discard the lwpchan cache.

	 */

	if (p->p_lcp != NULL)

		lwpchan_destroy_cache(0);

	/*

	 * Clean up any DTrace helper actions or probes for the process.

	 */

	if (p->p_dtrace_helpers != NULL) {

		ASSERT(dtrace_helpers_cleanup != NULL);

		(*dtrace_helpers_cleanup)();

	}

	/* untimeout the realtime timers */

	if (p->p_itimer != NULL)

		timer_exit();

	if ((tmp_id = p->p_alarmid) != 0) {

		p->p_alarmid = 0;

		(void) untimeout(tmp_id);

	}

	/*

	 * Remove any fpollinfo_t's for this (last) thread from our file

	 * descriptors so closeall() can ASSERT() that they're all gone.

	 */

	pollcleanup();

	if (p->p_rprof_cyclic != CYCLIC_NONE) {

		mutex_enter(&cpu_lock);

		cyclic_remove(p->p_rprof_cyclic);

		mutex_exit(&cpu_lock);

	}

	mutex_enter(&p->p_lock);

	/*

	 * Clean up any DTrace probes associated with this process.

	 */

	if (p->p_dtrace_probes) {

		ASSERT(dtrace_fasttrap_exit_ptr != NULL);

		dtrace_fasttrap_exit_ptr(p);

	}

	while ((tmp_id = p->p_itimerid) != 0) {

		p->p_itimerid = 0;

		mutex_exit(&p->p_lock);

		(void) untimeout(tmp_id);

		mutex_enter(&p->p_lock);

	}

	lwp_cleanup();

	/*

	 * We are about to exit; prevent our resource associations from

	 * being changed.

	 */

	pool_barrier_enter();

	/*

	 * Block the process against /proc now that we have really

	 * acquired p->p_lock (to manipulate p_tlist at least).

	 */

	prbarrier(p);

#ifdef	SUN_SRC_COMPAT

	if (code == CLD_KILLED)

		u.u_acflag |= AXSIG;

#endif

	sigfillset(&p->p_ignore);

	sigemptyset(&p->p_siginfo);

	sigemptyset(&p->p_sig);

	sigemptyset(&p->p_extsig);

	sigemptyset(&t->t_sig);

	sigemptyset(&t->t_extsig);

	sigemptyset(&p->p_sigmask);

	sigdelq(p, t, 0);

	lwp->lwp_cursig = 0;

	lwp->lwp_extsig = 0;

	p->p_flag &= ~(SKILLED | SEXTKILLED);

	if (lwp->lwp_curinfo) {

		siginfofree(lwp->lwp_curinfo);

		lwp->lwp_curinfo = NULL;

	}

	t->t_proc_flag |= TP_LWPEXIT;

	ASSERT(p->p_lwpcnt == 1 && p->p_zombcnt == 0);

	prlwpexit(t);		/* notify /proc */

	lwp_hash_out(p, t->t_tid);

	prexit(p);

	p->p_lwpcnt = 0;

	p->p_tlist = NULL;

	sigqfree(p);

	term_mstate(t);

	p->p_mterm = gethrtime();

	exec_vp = p->p_exec;

	execdir_vp = p->p_execdir;

	p->p_exec = NULLVP;

	p->p_execdir = NULLVP;

	mutex_exit(&p->p_lock);

	if (exec_vp)

		VN_RELE(exec_vp);

	if (execdir_vp)

		VN_RELE(execdir_vp);

	pr_free_watched_pages(p);