[apple/xnu.git] / bsd / kern / kern_shutdown.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *	File:	bsd/kern/kern_shutdown.c
 *
 *	Copyright (C) 1989, NeXT, Inc.
 *
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/vm.h>
#include <sys/proc.h>
#include <sys/user.h>
#include <sys/buf.h>
#include <sys/reboot.h>
#include <sys/conf.h>
#include <sys/vnode.h>
#include <sys/file.h>
#include <sys/clist.h>
#include <sys/callout.h>
#include <sys/mbuf.h>
#include <sys/msgbuf.h>
#include <sys/ioctl.h>
#include <sys/signal.h>
#include <sys/tty.h>
#include <kern/task.h>
#include <ufs/ufs/quota.h>
#include <ufs/ufs/inode.h>
#if	NCPUS > 1
#include <kern/processor.h>
#include <kern/thread.h>
#include <sys/lock.h>
#endif	/* NCPUS > 1 */
#include <vm/vm_kern.h>
#include <mach/vm_param.h>
#include <sys/filedesc.h>
#include <mach/host_reboot.h>

int	waittime = -1;

void
boot(paniced, howto, command)
	int paniced, howto;
	char *command;
{
	register int i;
	int s;
	struct proc *p = current_proc();	/* XXX */
	int hostboot_option=0;
	int funnel_state;

        static void proc_shutdown();

	funnel_state = thread_funnel_set(kernel_flock, TRUE);

	/* md_prepare_for_shutdown(paniced, howto, command); */

	if ((howto&RB_NOSYNC)==0 && waittime < 0) {
		int iter, nbusy;

		waittime = 0;
		
		printf("syncing disks... ");

		/*
		 * Release vnodes held by texts before sync.
		 */

		/* handle live procs (deallocate their root and current directories). */		
		proc_shutdown();

		sync(p, (void *)NULL, (int *)NULL);

		/* Release vnodes from the VM object cache */	 
		ubc_unmountall();

		IOSleep( 1 * 1000 );

		/*
		 * Unmount filesystems
		 */
		if (panicstr == 0)
			vfs_unmountall();

		/* Wait for the buffer cache to clean remaining dirty buffers */
		for (iter = 0; iter < 20; iter++) {
			nbusy = count_busy_buffers();
			if (nbusy == 0)
				break;
			printf("%d ", nbusy);
			IOSleep( 4 * nbusy );
		}
		if (nbusy)
			printf("giving up\n");
		else
			printf("done\n");
	}

	/*
	 * Can't just use an splnet() here to disable the network
	 * because that will lock out softints which the disk
	 * drivers depend on to finish DMAs.
	 */
	if_down_all();

	if (howto & RB_POWERDOWN)
		hostboot_option = HOST_REBOOT_HALT;
	if (howto & RB_HALT)
		hostboot_option = HOST_REBOOT_HALT;
	if (paniced == RB_PANIC)
		hostboot_option = HOST_REBOOT_HALT;

	if (hostboot_option == HOST_REBOOT_HALT)
	        IOSleep( 1 * 1000 );

	host_reboot(host_priv_self(), hostboot_option);

	thread_funnel_set(kernel_flock, FALSE);
}

/*
 * proc_shutdown()
 *
 *	Shutdown down proc system (release references to current and root
 *	dirs for each process).
 *
 * POSIX modifications:
 *
 *	For POSIX fcntl() file locking call vno_lockrelease() on 
 *	the file to release all of its record locks, if any.
 */

static void
proc_shutdown()
{
	struct proc	*p, *self;
	struct vnode	**cdirp, **rdirp, *vp;
	int		restart, i, TERM_catch;

	/*
	 *	Kill as many procs as we can.  (Except ourself...)
	 */
	self = (struct proc *)(get_bsdtask_info(current_task()));
	
	/*
	 * Suspend /etc/init
	 */
	p = pfind(1);
	if (p && p != self)
		task_suspend(p->task);		/* stop init */

	/*
	 * Suspend mach_init
	 */
	p = pfind(2);
	if (p && p != self)
		task_suspend(p->task);		/* stop mach_init */

	printf("Killing all processes ");

	/*
	 * send SIGTERM to those procs interested in catching one
	 */
	for (p = allproc.lh_first; p; p = p->p_list.le_next) {
	        if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) {
		        if (p->p_sigcatch & sigmask(SIGTERM))
			        psignal(p, SIGTERM);
		}
	}
	/*
	 * now wait for up to 30 seconds to allow those procs catching SIGTERM
	 * to digest it
	 * as soon as these procs have exited, we'll continue on to the next step
	 */
	for (i = 0; i < 300; i++) {
	        /*
		 * sleep for a tenth of a second
		 * and then check to see if the tasks that were sent a
		 * SIGTERM have exited
		 */
	        IOSleep(100);   
		TERM_catch = 0;

	        for (p = allproc.lh_first; p; p = p->p_list.le_next) {
		        if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) {
			        if (p->p_sigcatch & sigmask(SIGTERM))
				        TERM_catch++;
			}
		}
		if (TERM_catch == 0)
		        break;
	}

	/*
	 * send a SIGKILL to all the procs still hanging around
	 */
	for (p = allproc.lh_first; p; p = p->p_list.le_next) {
	        if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self))
		        psignal(p, SIGKILL);
	}
	/*
	 * wait for up to 60 seconds to allow these procs to exit normally
	 */
	for (i = 0; i < 300; i++) {
		IOSleep(200);  /* double the time from 100 to 200 for NFS requests in particular */

	        for (p = allproc.lh_first; p; p = p->p_list.le_next) {
		        if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self))
			        break;
		}
		if (!p)
		        break;
	}

	/*
	 * if we still have procs that haven't exited, then brute force 'em
	 */
	p = allproc.lh_first;
	while (p) {
	        if ((p->p_flag&P_SYSTEM) || (p->p_pptr->p_pid == 0) || (p == self)) {
		        p = p->p_list.le_next;
		}
		else {
		        /*
			 * NOTE: following code ignores sig_lock and plays
			 * with exit_thread correctly.  This is OK unless we
			 * are a multiprocessor, in which case I do not
			 * understand the sig_lock.  This needs to be fixed.
			 * XXX
			 */
		        if (p->exit_thread) {	/* someone already doing it */
			        thread_block(0);/* give him a chance */
			}
			else {
			        p->exit_thread = current_thread();
				printf(".");
				exit1(p, 1);
			}
			p = allproc.lh_first;
		}
	}
	printf("\n");
	/*
	 *	Forcibly free resources of what's left.
	 */
	p = allproc.lh_first;
	while (p) {
	/*
	 * Close open files and release open-file table.
	 * This may block!
	 */
#ifdef notyet
	/* panics on reboot due to "zfree: non-allocated memory in collectable zone" message */
	fdfree(p);
#endif /* notyet */
	p = p->p_list.le_next;
	}
	/* Wait for the reaper thread to run, and clean up what we have done 
	 * before we proceed with the hardcore shutdown. This reduces the race
	 * between kill_tasks and the reaper thread.
	 */
	/* thread_wakeup(&reaper_queue); */
	/*	IOSleep( 1 * 1000);      */
	printf("continuing\n");
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	/*
	23	* File: bsd/kern/kern_shutdown.c
	24	*
	25	* Copyright (C) 1989, NeXT, Inc.
	26	*
	27	*/
	28
	29	#include <sys/param.h>
	30	#include <sys/systm.h>
	31	#include <sys/kernel.h>
	32	#include <sys/vm.h>
	33	#include <sys/proc.h>
	34	#include <sys/user.h>
	35	#include <sys/buf.h>
	36	#include <sys/reboot.h>
	37	#include <sys/conf.h>
	38	#include <sys/vnode.h>
	39	#include <sys/file.h>
	40	#include <sys/clist.h>
	41	#include <sys/callout.h>
	42	#include <sys/mbuf.h>
	43	#include <sys/msgbuf.h>
	44	#include <sys/ioctl.h>
	45	#include <sys/signal.h>
	46	#include <sys/tty.h>
	47	#include <kern/task.h>
	48	#include <ufs/ufs/quota.h>
	49	#include <ufs/ufs/inode.h>
	50	#if NCPUS > 1
	51	#include <kern/processor.h>
	52	#include <kern/thread.h>
	53	#include <sys/lock.h>
	54	#endif /* NCPUS > 1 */
	55	#include <vm/vm_kern.h>
	56	#include <mach/vm_param.h>
	57	#include <sys/filedesc.h>
	58	#include <mach/host_reboot.h>
	59
	60	int waittime = -1;
	61
	62	void
	63	boot(paniced, howto, command)
	64	int paniced, howto;
65	char *command;
66	{
67	register int i;
68	int s;
69	struct proc p = current_proc(); / XXX */
70	int hostboot_option=0;
71	int funnel_state;
72
73	static void proc_shutdown();
74
75	funnel_state = thread_funnel_set(kernel_flock, TRUE);
76
77	/* md_prepare_for_shutdown(paniced, howto, command); */
78
79	if ((howto&RB_NOSYNC)==0 && waittime < 0) {
80	int iter, nbusy;
81
82	waittime = 0;
83
84	printf("syncing disks... ");
85
86	/*
87	* Release vnodes held by texts before sync.
88	*/
89
90	/* handle live procs (deallocate their root and current directories). */
91	proc_shutdown();
92
93	sync(p, (void )NULL, (int )NULL);
94
95	/* Release vnodes from the VM object cache */
96	ubc_unmountall();
97
98	IOSleep( 1 * 1000 );
99
100	/*
101	* Unmount filesystems
102	*/
103	if (panicstr == 0)
104	vfs_unmountall();
105
106	/* Wait for the buffer cache to clean remaining dirty buffers */
107	for (iter = 0; iter < 20; iter++) {
108	nbusy = count_busy_buffers();
109	if (nbusy == 0)
110	break;
111	printf("%d ", nbusy);
112	IOSleep( 4 * nbusy );
113	}
114	if (nbusy)
115	printf("giving up\n");
116	else
117	printf("done\n");
118	}
119
120	/*
121	* Can't just use an splnet() here to disable the network
122	* because that will lock out softints which the disk
123	* drivers depend on to finish DMAs.
124	*/
125	if_down_all();
126
127	if (howto & RB_POWERDOWN)
128	hostboot_option = HOST_REBOOT_HALT;
129	if (howto & RB_HALT)
130	hostboot_option = HOST_REBOOT_HALT;
131	if (paniced == RB_PANIC)
132	hostboot_option = HOST_REBOOT_HALT;
133
134	if (hostboot_option == HOST_REBOOT_HALT)
135	IOSleep( 1 * 1000 );
136
137	host_reboot(host_priv_self(), hostboot_option);
138
139	thread_funnel_set(kernel_flock, FALSE);
140	}
141
142	/*
143	* proc_shutdown()
144	*
145	* Shutdown down proc system (release references to current and root
146	* dirs for each process).
147	*
148	* POSIX modifications:
149	*
150	* For POSIX fcntl() file locking call vno_lockrelease() on
151	* the file to release all of its record locks, if any.
152	*/
153
154	static void
155	proc_shutdown()
156	{
157	struct proc p, self;
158	struct vnode cdirp, rdirp, *vp;
159	int restart, i, TERM_catch;
160
161	/*
162	* Kill as many procs as we can. (Except ourself...)
163	*/
164	self = (struct proc *)(get_bsdtask_info(current_task()));
165
166	/*
167	* Suspend /etc/init
168	*/
169	p = pfind(1);
170	if (p && p != self)
171	task_suspend(p->task); /* stop init */
172
173	/*
174	* Suspend mach_init
175	*/
176	p = pfind(2);
177	if (p && p != self)
178	task_suspend(p->task); /* stop mach_init */
179
180	printf("Killing all processes ");
181
182	/*
183	* send SIGTERM to those procs interested in catching one
184	*/
185	for (p = allproc.lh_first; p; p = p->p_list.le_next) {
186	if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) {
187	if (p->p_sigcatch & sigmask(SIGTERM))
188	psignal(p, SIGTERM);
189	}
190	}
191	/*
192	* now wait for up to 30 seconds to allow those procs catching SIGTERM
193	* to digest it
194	* as soon as these procs have exited, we'll continue on to the next step
195	*/
196	for (i = 0; i < 300; i++) {
197	/*
198	* sleep for a tenth of a second
199	* and then check to see if the tasks that were sent a
200	* SIGTERM have exited
201	*/
202	IOSleep(100);
203	TERM_catch = 0;
204
205	for (p = allproc.lh_first; p; p = p->p_list.le_next) {
206	if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) {
207	if (p->p_sigcatch & sigmask(SIGTERM))
208	TERM_catch++;
209	}
210	}
211	if (TERM_catch == 0)
212	break;
213	}
214
215	/*
216	* send a SIGKILL to all the procs still hanging around
217	*/
218	for (p = allproc.lh_first; p; p = p->p_list.le_next) {
219	if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self))
220	psignal(p, SIGKILL);
221	}
222	/*
223	* wait for up to 60 seconds to allow these procs to exit normally
224	*/
225	for (i = 0; i < 300; i++) {
226	IOSleep(200); /* double the time from 100 to 200 for NFS requests in particular */
227
228	for (p = allproc.lh_first; p; p = p->p_list.le_next) {
229	if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self))
230	break;
231	}
232	if (!p)
233	break;
234	}
235
236	/*
237	* if we still have procs that haven't exited, then brute force 'em
238	*/
239	p = allproc.lh_first;
240	while (p) {
241	if ((p->p_flag&P_SYSTEM) \|\| (p->p_pptr->p_pid == 0) \|\| (p == self)) {
242	p = p->p_list.le_next;
243	}
244	else {
245	/*
246	* NOTE: following code ignores sig_lock and plays
247	* with exit_thread correctly. This is OK unless we
248	* are a multiprocessor, in which case I do not
249	* understand the sig_lock. This needs to be fixed.
250	* XXX
251	*/
252	if (p->exit_thread) { /* someone already doing it */
253	thread_block(0);/* give him a chance */
254	}
255	else {
256	p->exit_thread = current_thread();
257	printf(".");
258	exit1(p, 1);
259	}
260	p = allproc.lh_first;
261	}
262	}
263	printf("\n");
264	/*
265	* Forcibly free resources of what's left.
266	*/
267	p = allproc.lh_first;
268	while (p) {
269	/*
270	* Close open files and release open-file table.
271	* This may block!
272	*/
273	#ifdef notyet
274	/* panics on reboot due to "zfree: non-allocated memory in collectable zone" message */
275	fdfree(p);
276	#endif /* notyet */
277	p = p->p_list.le_next;
278	}
279	/* Wait for the reaper thread to run, and clean up what we have done
280	* before we proceed with the hardcore shutdown. This reduces the race
281	* between kill_tasks and the reaper thread.
282	*/
283	/* thread_wakeup(&reaper_queue); */
284	/* IOSleep( 1 * 1000); */
285	printf("continuing\n");
286	}
287