![[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 XNU] / XNU / bsd / kern|
Return to kern_shutdown.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 ! root 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: * History: ! 28: * Jan 29, 1992 [email protected] ! 29: * Created by munging machdep/m68k/shutdown.c and ! 30: * machdep/m68k/machdep.c into machine-independence. ! 31: * ! 32: */ ! 33: ! 34: #import <mach_nbc.h> ! 35: ! 36: #import <sys/param.h> ! 37: #import <sys/systm.h> ! 38: #import <sys/kernel.h> ! 39: #import <sys/vm.h> ! 40: #import <sys/proc.h> ! 41: #import <sys/user.h> ! 42: #import <sys/buf.h> ! 43: #import <sys/reboot.h> ! 44: #import <sys/conf.h> ! 45: #import <sys/vnode.h> ! 46: #import <sys/file.h> ! 47: #import <sys/clist.h> ! 48: #import <sys/callout.h> ! 49: #import <sys/mbuf.h> ! 50: #import <sys/msgbuf.h> ! 51: #import <sys/ioctl.h> ! 52: #import <sys/signal.h> ! 53: #import <sys/tty.h> ! 54: #import <kern/task.h> ! 55: #import <ufs/ufs/quota.h> ! 56: #import <ufs/ufs/inode.h> ! 57: #if NCPUS > 1 ! 58: #import <kern/processor.h> ! 59: #import <kern/thread.h> ! 60: #import <sys/lock.h> ! 61: #endif /* NCPUS > 1 */ ! 62: #import <vm/vm_kern.h> ! 63: #import <mach/vm_param.h> ! 64: #import <sys/filedesc.h> ! 65: #import <mach/host_reboot.h> ! 66: ! 67: int waittime = -1; ! 68: ! 69: boot(paniced, howto, command) ! 70: int paniced, howto; ! 71: char *command; ! 72: { ! 73: register int i; ! 74: int s; ! 75: struct proc *p = current_proc(); /* XXX */ ! 76: int hostboot_option=0; ! 77: /* md_prepare_for_shutdown(paniced, howto, command); */ ! 78: ! 79: if ((howto&RB_NOSYNC)==0 && waittime < 0) { ! 80: register struct buf *bp; ! 81: int iter, nbusy; ! 82: ! 83: waittime = 0; ! 84: ! 85: (void) spl0(); ! 86: ! 87: printf("syncing disks... "); ! 88: ! 89: /* ! 90: * Release vnodes held by texts before sync. ! 91: */ ! 92: ! 93: proc_shutdown(); /* handle live procs (deallocate their ! 94: root and current directories). */ ! 95: #if 0 /* [ */ ! 96: /* NOT MY PROBLEM XXX */ ! 97: kill_tasks(); /* get rid of all task memory */ ! 98: #endif /* 0 ] */ ! 99: ! 100: #if MACH_NBC ! 101: mapfs_cache_clear(); ! 102: vm_object_cache_clear(); ! 103: #endif /* MACH_NBC */ ! 104: if (panicstr == 0) ! 105: vnode_pager_shutdown(); /* NO MORE PAGING - release vnodes */ ! 106: ! 107: sync(p, (void *)NULL, (int *)NULL); ! 108: ! 109: /* ! 110: * Unmount filesystems ! 111: */ ! 112: if (panicstr == 0) ! 113: vfs_unmountall(); ! 114: ! 115: for (iter = 0; iter < 20; iter++) { ! 116: nbusy = 0; ! 117: for (bp = &buf[nbuf]; --bp >= buf; ) ! 118: if ((bp->b_flags & (B_BUSY|B_INVAL)) == B_BUSY) ! 119: nbusy++; ! 120: if (nbusy == 0) ! 121: break; ! 122: printf("%d ", nbusy); ! 123: IOSleep( 4 * nbusy ); ! 124: } ! 125: if (nbusy) ! 126: printf("giving up\n"); ! 127: else ! 128: printf("done\n"); ! 129: ! 130: /* ! 131: * If we've been adjusting the clock, the todr ! 132: * will be out of synch; adjust it now. ! 133: */ ! 134: } ! 135: ! 136: /* ! 137: * Can't just use an splnet() here to disable the network ! 138: * because that will lock out softints which the disk ! 139: * drivers depend on to finish DMAs. ! 140: */ ! 141: if_down_all(); ! 142: #define BSD_DUMMY_HOST 1 ! 143: if (howto & RB_POWERDOWN) ! 144: hostboot_option = HOST_REBOOT_HALT; ! 145: if (howto & RB_HALT) ! 146: hostboot_option = HOST_REBOOT_HALT; ! 147: if (paniced == RB_PANIC) ! 148: hostboot_option = HOST_REBOOT_HALT; ! 149: ! 150: if (hostboot_option == HOST_REBOOT_HALT) ! 151: IOSleep( 1 * 1000 ); ! 152: ! 153: host_reboot(BSD_DUMMY_HOST, hostboot_option); ! 154: } ! 155: ! 156: #if 0 /* [ */ ! 157: kill_tasks() ! 158: { ! 159: processor_set_t pset; ! 160: task_t task; ! 161: vm_map_t map, empty_map; ! 162: ! 163: empty_map = vm_map_create(pmap_create(0), 0, 0, TRUE); ! 164: ! 165: /* ! 166: * Destroy all but the default processor_set. ! 167: */ ! 168: simple_lock(&all_psets_lock); ! 169: pset = (processor_set_t) queue_first(&all_psets); ! 170: while (!queue_end(&all_psets, (queue_entry_t) pset)) { ! 171: if (pset == &default_pset) { ! 172: pset = (processor_set_t) queue_next(&pset->all_psets); ! 173: continue; ! 174: } ! 175: simple_unlock(&all_psets_lock); ! 176: processor_set_destroy(pset); ! 177: simple_lock(&all_psets_lock); ! 178: pset = (processor_set_t) queue_first(&all_psets); ! 179: } ! 180: simple_unlock(&all_psets_lock); ! 181: ! 182: /* ! 183: * Kill all the tasks in the default processor set. ! 184: */ ! 185: pset = &default_pset; ! 186: pset_lock(pset); ! 187: task = (task_t) queue_first(&pset->tasks); ! 188: while (pset->task_count) { ! 189: pset_remove_task(pset, task); ! 190: map = task->map; ! 191: if ((map != kernel_map) && (map != empty_map)) { ! 192: task->map = empty_map; ! 193: vm_map_reference(empty_map); ! 194: pset_unlock(pset); ! 195: vm_map_remove(map, vm_map_min(map), vm_map_max(map)); ! 196: pset_lock(pset); ! 197: } ! 198: task = (task_t) queue_first(&pset->tasks); ! 199: } ! 200: pset_unlock(pset); ! 201: } ! 202: #endif /* 0 ] */ ! 203: ! 204: #if NeXT ! 205: extern int reaper_queue; ! 206: #endif ! 207: /* ! 208: * proc_shutdown() ! 209: * ! 210: * Shutdown down proc system (release references to current and root ! 211: * dirs for each process). ! 212: * ! 213: * POSIX modifications: ! 214: * ! 215: * For POSIX fcntl() file locking call vno_lockrelease() on ! 216: * the file to release all of its record locks, if any. ! 217: */ ! 218: ! 219: proc_shutdown() ! 220: { ! 221: struct proc *p, *self; ! 222: struct vnode **cdirp, **rdirp, *vp; ! 223: int restart, i, TERM_catch; ! 224: ! 225: /* ! 226: * Kill as many procs as we can. (Except ourself...) ! 227: */ ! 228: self = (struct proc *)(get_bsdtask_info(current_task())); ! 229: ! 230: /* ! 231: * Suspend /etc/init ! 232: */ ! 233: p = pfind(1); ! 234: if (p && p != self) ! 235: task_suspend(p->task); /* stop init */ ! 236: ! 237: /* ! 238: * Suspend mach_init ! 239: */ ! 240: p = pfind(2); ! 241: if (p && p != self) ! 242: task_suspend(p->task); /* stop mach_init */ ! 243: ! 244: printf("Killing all processes "); ! 245: ! 246: /* ! 247: * send SIGTERM to those procs interested in catching one ! 248: */ ! 249: for (p = allproc.lh_first; p; p = p->p_list.le_next) { ! 250: if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) { ! 251: if (p->p_sigcatch & sigmask(SIGTERM)) ! 252: psignal(p, SIGTERM); ! 253: } ! 254: } ! 255: /* ! 256: * now wait for up to 5 seconds to allow those procs catching SIGTERM ! 257: * to digest it ! 258: * as soon as these procs have exited, we'll continue on to the next step ! 259: */ ! 260: for (i = 0; i < 50; i++) { ! 261: /* ! 262: * sleep for a tenth of a second ! 263: * and then check to see if the tasks that were sent a ! 264: * SIGTERM have exited ! 265: */ ! 266: IOSleep(100); ! 267: TERM_catch = 0; ! 268: ! 269: for (p = allproc.lh_first; p; p = p->p_list.le_next) { ! 270: if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) { ! 271: if (p->p_sigcatch & sigmask(SIGTERM)) ! 272: TERM_catch++; ! 273: } ! 274: } ! 275: if (TERM_catch == 0) ! 276: break; ! 277: } ! 278: ! 279: /* ! 280: * send a SIGKILL to all the procs still hanging around ! 281: */ ! 282: for (p = allproc.lh_first; p; p = p->p_list.le_next) { ! 283: if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) ! 284: psignal(p, SIGKILL); ! 285: } ! 286: /* ! 287: * wait for up to 2 seconds to allow these procs to exit normally ! 288: */ ! 289: for (i = 0; i < 20; i++) { ! 290: IOSleep(100); ! 291: ! 292: for (p = allproc.lh_first; p; p = p->p_list.le_next) { ! 293: if (((p->p_flag&P_SYSTEM) == 0) && (p->p_pptr->p_pid != 0) && (p != self)) ! 294: break; ! 295: } ! 296: if (!p) ! 297: break; ! 298: } ! 299: ! 300: /* ! 301: * if we still have procs that haven't exited, then brute force 'em ! 302: */ ! 303: p = allproc.lh_first; ! 304: while (p) { ! 305: if ((p->p_flag&P_SYSTEM) || (p->p_pptr->p_pid == 0) || (p == self)) { ! 306: p = p->p_list.le_next; ! 307: } ! 308: else { ! 309: /* ! 310: * NOTE: following code ignores sig_lock and plays ! 311: * with exit_thread correctly. This is OK unless we ! 312: * are a multiprocessor, in which case I do not ! 313: * understand the sig_lock. This needs to be fixed. ! 314: * XXX ! 315: */ ! 316: if (p->exit_thread) { /* someone already doing it */ ! 317: thread_block(0);/* give him a chance */ ! 318: } ! 319: else { ! 320: p->exit_thread = current_thread(); ! 321: printf("."); ! 322: exit1(p, 1); ! 323: } ! 324: p = allproc.lh_first; ! 325: } ! 326: } ! 327: printf("\n"); ! 328: /* ! 329: * Forcibly free resources of what's left. ! 330: */ ! 331: p = allproc.lh_first; ! 332: while (p) { ! 333: /* ! 334: * Close open files and release open-file table. ! 335: * This may block! ! 336: */ ! 337: #ifdef notyet ! 338: /* panics on reboot due to "zfree: non-allocated memory in collectable zone" message */ ! 339: fdfree(p); ! 340: #endif /* notyet */ ! 341: p = p->p_list.le_next; ! 342: } ! 343: /* Wait for the reaper thread to run, and clean up what we have done ! 344: * before we proceed with the hardcore shutdown. This reduces the race ! 345: * between kill_tasks and the reaper thread. ! 346: */ ! 347: /* thread_wakeup(&reaper_queue); */ ! 348: /* IOSleep( 1 * 1000); */ ! 349: printf("continuing\n"); ! 350: } ! 351: ! 352: /* ! 353: * Close all file descriptors, called at shutdown time. ! 354: */ ! 355: fd_shutdown() ! 356: { ! 357: register struct file *fp, *nextfp; ! 358: ! 359: for (fp = filehead.lh_first; fp != 0; fp = nextfp) { ! 360: nextfp = fp->f_list.le_next; ! 361: while (fp->f_count > 1) ! 362: closef(fp); ! 363: closef(fp); ! 364: } ! 365: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.