![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_shutdown.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / kern|
Return to kern_shutdown.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * File: bsd/kern/kern_shutdown.c
27: *
28: * Copyright (C) 1989, NeXT, Inc.
29: *
30: * History:
31: * Jan 29, 1992 [email protected]
32: * Created by munging machdep/m68k/shutdown.c and
33: * machdep/m68k/machdep.c into machine-independence.
34: *
35: */
36:
37: #import <cpus.h>
38: #import <quota.h>
39: #import <mach_nbc.h>
40:
41: #import <sys/param.h>
42: #import <sys/systm.h>
43: #import <sys/kernel.h>
44: // #import <sys/dnlc.h>
45: #import <sys/vm.h>
46: #import <sys/proc.h>
47: #import <sys/user.h>
48: #import <sys/buf.h>
49: #import <sys/reboot.h>
50: #import <sys/conf.h>
51: #import <sys/vnode.h>
52: #import <sys/file.h>
53: #import <sys/clist.h>
54: #import <sys/callout.h>
55: #import <sys/mbuf.h>
56: #import <sys/msgbuf.h>
57: #import <sys/ioctl.h>
58: #import <sys/signal.h>
59: #import <sys/tty.h>
60: #import <kern/task.h>
61: #import <ufs/ufs/quota.h>
62: #import <ufs/ufs/inode.h>
63: #if NCPUS > 1
64: #import <kern/processor.h>
65: #import <kern/thread.h>
66: #import <kern/lock.h>
67: #endif /* NCPUS > 1 */
68: #import <kern/xpr.h>
69: #import <vm/vm_kern.h>
70: #import <mach/vm_param.h>
71: #import <vm/vm_page.h>
72: #import <kernserv/ns_timer.h>
73: #import <bsd/sys/filedesc.h>
74:
75: int waittime = -1;
76:
77: boot(paniced, howto, command)
78: int paniced, howto;
79: char *command;
80: {
81: register int i;
82: int s;
83: struct proc *p = current_proc(); /* XXX */
84:
85: md_prepare_for_shutdown(paniced, howto, command);
86:
87: if ((howto&RB_NOSYNC)==0 && waittime < 0) {
88: register struct buf *bp;
89: int iter, nbusy;
90:
91: waittime = 0;
92:
93: (void) spl0();
94:
95: printf("syncing disks... ");
96:
97: /*
98: * Release vnodes held by texts before sync.
99: */
100:
101: proc_shutdown(); /* handle live procs (deallocate their
102: root and current directories). */
103: kill_tasks(); /* get rid of all task memory */
104:
105: #if MACH_NBC
106: mapfs_cache_clear();
107: vm_object_cache_clear();
108: #endif /* MACH_NBC */
109: if (panicstr == 0)
110: vnode_pager_shutdown(); /* NO MORE PAGING - release vnodes */
111:
112: sync(p, (void *)NULL, (int *)NULL);
113:
114: /*
115: * Unmount filesystems
116: */
117: if (panicstr == 0)
118: vfs_unmountall();
119:
120: for (iter = 0; iter < 20; iter++) {
121: nbusy = 0;
122: for (bp = &buf[nbuf]; --bp >= buf; )
123: if ((bp->b_flags & (B_BUSY|B_INVAL)) == B_BUSY)
124: nbusy++;
125: if (nbusy == 0)
126: break;
127: printf("%d ", nbusy);
128: DELAY(40000 * iter);
129: }
130: if (nbusy)
131: printf("giving up\n");
132: else
133: printf("done\n");
134:
135: /*
136: * If we've been adjusting the clock, the todr
137: * will be out of synch; adjust it now.
138: */
139: // resettodr();
140: }
141:
142: /*
143: * Can't just use an splnet() here to disable the network
144: * because that will lock out softints which the disk
145: * drivers depend on to finish DMAs.
146: */
147: if_down_all();
148:
149: md_shutdown_devices(paniced, howto, command);
150:
151: #if NCPUS > 1
152: #define LOOPCOUNT 1000
153: #define WAITCOUNT 1000
154:
155: for (i = 0; i < NCPUS; i++) {
156: processor_t thisprocessor;
157:
158: thisprocessor = cpu_to_processor(i);
159: if (thisprocessor->state != PROCESSOR_OFF_LINE &&
160: thisprocessor != current_processor()) {
161: register int j,k;
162:
163: processor_shutdown(thisprocessor);
164:
165: j = 0;
166: while ( machine_slot[i].running && j < LOOPCOUNT) {
167: for (k=0; k< WAITCOUNT; k++) DELAY(1);
168: j++;
169: }
170:
171: if (!machine_slot[i].running)
172: printf("Processor %d Halted.\n", i);
173: else
174: printf("Processor %d won't halt.\n", i);
175: }
176: }
177: #endif /* NCPUS > 1 */
178:
179: md_do_shutdown(paniced, howto, command);
180: }
181:
182: kill_tasks()
183: {
184: processor_set_t pset;
185: task_t task;
186: vm_map_t map, empty_map;
187:
188: empty_map = vm_map_create(pmap_create(0), 0, 0, TRUE);
189:
190: /*
191: * Destroy all but the default processor_set.
192: */
193: simple_lock(&all_psets_lock);
194: pset = (processor_set_t) queue_first(&all_psets);
195: while (!queue_end(&all_psets, (queue_entry_t) pset)) {
196: if (pset == &default_pset) {
197: pset = (processor_set_t) queue_next(&pset->all_psets);
198: continue;
199: }
200: simple_unlock(&all_psets_lock);
201: processor_set_destroy(pset);
202: simple_lock(&all_psets_lock);
203: pset = (processor_set_t) queue_first(&all_psets);
204: }
205: simple_unlock(&all_psets_lock);
206:
207: /*
208: * Kill all the tasks in the default processor set.
209: */
210: pset = &default_pset;
211: pset_lock(pset);
212: task = (task_t) queue_first(&pset->tasks);
213: while (pset->task_count) {
214: pset_remove_task(pset, task);
215: map = task->map;
216: if ((map != kernel_map) && (map != empty_map)) {
217: task->map = empty_map;
218: vm_map_reference(empty_map);
219: pset_unlock(pset);
220: vm_map_remove(map, vm_map_min(map), vm_map_max(map));
221: pset_lock(pset);
222: }
223: task = (task_t) queue_first(&pset->tasks);
224: }
225: pset_unlock(pset);
226: }
227:
228: #if NeXT
229: extern int reaper_queue;
230: #endif
231: /*
232: * proc_shutdown()
233: *
234: * Shutdown down proc system (release references to current and root
235: * dirs for each process).
236: *
237: * POSIX modifications:
238: *
239: * For POSIX fcntl() file locking call vno_lockrelease() on
240: * the file to release all of its record locks, if any.
241: */
242:
243: proc_shutdown()
244: {
245: struct proc *p, *self;
246: struct vnode **cdirp, **rdirp, *vp;
247: int restart, i;
248:
249: /*
250: * Kill as many procs as we can. (Except ourself...)
251: */
252: self = current_task()->proc;
253:
254: /*
255: * Suspend /etc/init
256: */
257: p = pfind(1);
258: if (p && p != self)
259: task_suspend(p->task); /* stop init */
260:
261: /*
262: * Suspend mach_init
263: */
264: p = pfind(2);
265: if (p && p != self)
266: task_suspend(p->task); /* stop mach_init */
267:
268: printf("Killing all processes ");
269: /* SIGTERM and ns_sleep to allow process to clean-up */
270: for (p = allproc.lh_first; p; p = p->p_list.le_next) {
271: if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self))
272: psignal(p, SIGTERM);
273: }
274: ns_sleep(2 * 1000000000);
275: ns_sleep(2 * 1000000000);
276: /* SIGKILL in case the TERM wasn't heard */
277: for (p = allproc.lh_first; p; p = p->p_list.le_next) {
278: if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self))
279: psignal(p, SIGKILL);
280: }
281: ns_sleep(1000000000);
282: /* Brute force 'em, if necessary */
283: p = allproc.lh_first;
284: while (p) {
285: if ((p->p_flag&P_SYSTEM) || (p->p_pptr->p_pid == 0) || (p == self)) {
286: p = p->p_list.le_next;
287: }
288: else {
289: /*
290: * NOTE: following code ignores sig_lock and plays
291: * with exit_thread correctly. This is OK unless we
292: * are a multiprocessor, in which case I do not
293: * understand the sig_lock. This needs to be fixed.
294: * XXX
295: */
296: if (p->exit_thread) { /* someone already doing it */
297: thread_block(); /* give him a chance */
298: }
299: else {
300: p->exit_thread = current_thread();
301: printf(".");
302: exit1(p, 1);
303: }
304: p = allproc.lh_first;
305: }
306: }
307: printf("\n");
308: /*
309: * Forcibly free resources of what's left.
310: */
311: p = allproc.lh_first;
312: while (p) {
313: /*
314: * Close open files and release open-file table.
315: * This may block!
316: */
317: fdfree(p);
318: p = p->p_list.le_next;
319: }
320: /* Wait for the reaper thread to run, and clean up what we have done
321: * before we proceed with the hardcore shutdown. This reduces the race
322: * between kill_tasks and the reaper thread.
323: */
324: thread_wakeup(&reaper_queue);
325: ns_sleep(2 * 1000000000);
326: printf("continuing\n");
327:
328: }
329:
330: /*
331: * Close all file descriptors, called at shutdown time.
332: */
333: fd_shutdown()
334: {
335: register struct file *fp, *nextfp;
336:
337: for (fp = filehead.lh_first; fp != 0; fp = nextfp) {
338: nextfp = fp->f_list.le_next;
339: while (fp->f_count > 1)
340: closef(fp);
341: closef(fp);
342: }
343: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.