FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_shutdown.c

     /*-
      * Copyright (c) 1986, 1988, 1991, 1993
      *      The Regents of the University of California.  All rights reserved.
      * (c) UNIX System Laboratories, Inc.
      * All or some portions of this file are derived from material licensed
      * to the University of California by American Telephone and Telegraph
      * Co. or Unix System Laboratories, Inc. and are reproduced herein with
      * the permission of UNIX System Laboratories, Inc.
      *
     * 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. All advertising materials mentioning features or use of this software
     *    must display the following acknowledgement:
     *      This product includes software developed by the University of
     *      California, Berkeley and its contributors.
     * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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.
     *
     *      @(#)kern_shutdown.c     8.3 (Berkeley) 1/21/94
     * $FreeBSD$
     */
    
    #include "opt_ddb.h"
    #include "opt_hw_wdog.h"
    #include "opt_panic.h"
    #include "opt_show_busybufs.h"
    
    #include <sys/param.h>
    #include <sys/systm.h>
    #include <sys/buf.h>
    #include <sys/reboot.h>
    #include <sys/proc.h>
    #include <sys/vnode.h>
    #include <sys/malloc.h>
    #include <sys/kernel.h>
    #include <sys/mount.h>
    #include <sys/queue.h>
    #include <sys/sysctl.h>
    #include <sys/conf.h>
    #include <sys/sysproto.h>
    
    #include <machine/pcb.h>
    #include <machine/clock.h>
    #include <machine/cons.h>
    #include <machine/md_var.h>
    #ifdef SMP
    #include <machine/smp.h>                /* smp_active, cpuid */
    #endif
    
    #include <sys/signalvar.h>
    
    #ifndef PANIC_REBOOT_WAIT_TIME
    #define PANIC_REBOOT_WAIT_TIME 15 /* default to 15 seconds */
    #endif
    
    /*
     * Note that stdarg.h and the ANSI style va_start macro is used for both
     * ANSI and traditional C compilers.
     */
    #include <machine/stdarg.h>
    
    #ifdef DDB
    #ifdef DDB_UNATTENDED
    int debugger_on_panic = 0;
    #else
    int debugger_on_panic = 1;
    #endif
    SYSCTL_INT(_debug, OID_AUTO, debugger_on_panic, CTLFLAG_RW,
            &debugger_on_panic, 0, "");
    #endif
    
    #ifdef  HW_WDOG
    /*
     * If there is a hardware watchdog, point this at the function needed to
     * hold it off.
     * It's needed when the kernel needs to do some lengthy operations.
     * e.g. in wd.c when dumping core.. It's most annoying to have
     * your precious core-dump only half written because the wdog kicked in.
     */
    watchdog_tickle_fn wdog_tickler = NULL;
   #endif  /* HW_WDOG */
   
   /*
    * Variable panicstr contains argument to first call to panic; used as flag
    * to indicate that the kernel has already called panic.
    */
   const char *panicstr;
   
   /*
    * callout list for things to do a shutdown
    */
   typedef struct shutdown_list_element {
           LIST_ENTRY(shutdown_list_element) links;
           bootlist_fn function;
           void *arg;
           int priority;
   } *sle_p;
   
   /*
    * There are three shutdown lists. Some things need to be shut down
    * earlier than others.
    */
   LIST_HEAD(shutdown_list, shutdown_list_element);
   
   static struct shutdown_list shutdown_lists[SHUTDOWN_FINAL + 1];
   
   static void boot __P((int)) __dead2;
   static void dumpsys __P((void));
   static void print_uptime __P((void));
   
   #ifndef _SYS_SYSPROTO_H_
   struct reboot_args {
           int     opt;
   };
   #endif
   /* ARGSUSED */
   
   /*
    * The system call that results in a reboot
    */
   int
   reboot(p, uap)
           struct proc *p;
           struct reboot_args *uap;
   {
           int error;
   
           if ((error = suser(p->p_ucred, &p->p_acflag)))
                   return (error);
   
           boot(uap->opt);
           return (0);
   }
   
   /*
    * Called by events that want to shut down.. e.g  <CTL><ALT><DEL> on a PC
    */
   void
   shutdown_nice()
   {
           /* Send a signal to init(8) and have it shutdown the world */
           if (initproc != NULL) {
                   psignal(initproc, SIGINT);
           } else {
                   /* No init(8) running, so simply reboot */
                   boot(RB_NOSYNC);
           }
           return;
   }
   static int      waittime = -1;
   static struct pcb dumppcb;
   
   static void
   print_uptime()
   {
           int f;
           struct timespec ts;
   
           getnanouptime(&ts);
           printf("Uptime: ");
           f = 0;
           if (ts.tv_sec >= 86400) {
                   printf("%ldd", ts.tv_sec / 86400);
                   ts.tv_sec %= 86400;
                   f = 1;
           }
           if (f || ts.tv_sec >= 3600) {
                   printf("%ldh", ts.tv_sec / 3600);
                   ts.tv_sec %= 3600;
                   f = 1;
           }
           if (f || ts.tv_sec >= 60) {
                   printf("%ldm", ts.tv_sec / 60);
                   ts.tv_sec %= 60;
                   f = 1;
           }
           printf("%lds\n", ts.tv_sec);
   }
   
   /*
    *  Go through the rigmarole of shutting down..
    * this used to be in machdep.c but I'll be dammned if I could see
    * anything machine dependant in it.
    */
   static void
   boot(howto)
           int howto;
   {
           sle_p ep;
   
   #ifdef SMP
           if (smp_active) {
                   printf("boot() called on cpu#%d\n", cpuid);
           }
   #endif
           /*
            * Do any callouts that should be done BEFORE syncing the filesystems.
            */
           LIST_FOREACH(ep, &shutdown_lists[SHUTDOWN_PRE_SYNC], links)
                   (*ep->function)(howto, ep->arg);
   
           /* 
            * Now sync filesystems
            */
           if (!cold && (howto & RB_NOSYNC) == 0 && waittime < 0) {
                   register struct buf *bp;
                   int iter, nbusy;
   
                   waittime = 0;
                   printf("\nsyncing disks... ");
   
                   sync(&proc0, NULL);
   
                   /*
                    * With soft updates, some buffers that are
                    * written will be remarked as dirty until other
                    * buffers are written.
                    */
                   for (iter = 0; iter < 20; iter++) {
                           nbusy = 0;
                           for (bp = &buf[nbuf]; --bp >= buf; ) {
                                   if ((bp->b_flags & (B_BUSY | B_INVAL))
                                                   == B_BUSY) {
                                           nbusy++;
                                   } else if ((bp->b_flags & (B_DELWRI | B_INVAL))
                                                   == B_DELWRI) {
                                           /* bawrite(bp);*/
                                           nbusy++;
                                   }
                           }
                           if (nbusy == 0)
                                   break;
                           printf("%d ", nbusy);
                           sync(&proc0, NULL);
                           DELAY(50000 * iter);
                   }
                   /*
                    * Count only busy local buffers to prevent forcing 
                    * a fsck if we're just a client of a wedged NFS server
                    */
                   nbusy = 0;
                   for (bp = &buf[nbuf]; --bp >= buf; ) {
                           if (((bp->b_flags & (B_BUSY | B_INVAL)) == B_BUSY) 
                               ||((bp->b_flags & (B_DELWRI | B_INVAL))== B_DELWRI))
                                   if(bp->b_dev == NODEV)
                                           CIRCLEQ_REMOVE(&mountlist, bp->b_vp->v_mount, mnt_list);
                                   else
                                           nbusy++;
   
   
                   }
                   if (nbusy) {
                           /*
                            * Failed to sync all blocks. Indicate this and don't
                            * unmount filesystems (thus forcing an fsck on reboot).
                            */
                           printf("giving up\n");
   #ifdef SHOW_BUSYBUFS
                           nbusy = 0;
                           for (bp = &buf[nbuf]; --bp >= buf; ) {
                                   if ((bp->b_flags & (B_BUSY | B_INVAL))
                                                   == B_BUSY) {
                                           nbusy++;
                                           printf(
                           "%d: dev:%08lx, flags:%08lx, blkno:%ld, lblkno:%ld\n",
                                               nbusy, (u_long)bp->b_dev,
                                               bp->b_flags, (long)bp->b_blkno,
                                               (long)bp->b_lblkno);
                                   }
                           }
                           DELAY(5000000); /* 5 seconds */
   #endif
                   } else {
                           printf("done\n");
                           /*
                            * Unmount filesystems
                            */
                           if (panicstr == 0)
                                   vfs_unmountall();
                   }
                   DELAY(100000);          /* wait for console output to finish */
           }
   
           print_uptime();
   
           /*
            * Ok, now do things that assume all filesystem activity has
            * been completed.
            */
           LIST_FOREACH(ep, &shutdown_lists[SHUTDOWN_POST_SYNC], links)
                   (*ep->function)(howto, ep->arg);
           splhigh();
           if ((howto & (RB_HALT|RB_DUMP)) == RB_DUMP && !cold) {
                   savectx(&dumppcb);
   #ifdef __i386__
                   dumppcb.pcb_cr3 = rcr3();
   #endif
                   dumpsys();
           }
   
           /* Now that we're going to really halt the system... */
           LIST_FOREACH(ep, &shutdown_lists[SHUTDOWN_FINAL], links)
                   (*ep->function)(howto, ep->arg);
   
           if (howto & RB_HALT) {
                   printf("\n");
                   printf("The operating system has halted.\n");
                   printf("Please press any key to reboot.\n\n");
                   switch (cngetc()) {
                   case -1:                /* No console, just die */
                           cpu_halt();
                           /* NOTREACHED */
                   default:
                           howto &= ~RB_HALT;
                           break;
                   }
           } else if (howto & RB_DUMP) {
                   /* System Paniced */
   
                   if (PANIC_REBOOT_WAIT_TIME != 0) {
                           if (PANIC_REBOOT_WAIT_TIME != -1) {
                                   int loop;
                                   printf("Automatic reboot in %d seconds - "
                                          "press a key on the console to abort\n",
                                           PANIC_REBOOT_WAIT_TIME);
                                   for (loop = PANIC_REBOOT_WAIT_TIME * 10;
                                        loop > 0; --loop) {
                                           DELAY(1000 * 100); /* 1/10th second */
                                           /* Did user type a key? */
                                           if (cncheckc() != -1)
                                                   break;
                                   }
                                   if (!loop)
                                           goto die;
                           }
                   } else { /* zero time specified - reboot NOW */
                           goto die;
                   }
                   printf("--> Press a key on the console to reboot <--\n");
                   cngetc();
           }
   die:
           printf("Rebooting...\n");
           DELAY(1000000); /* wait 1 sec for printf's to complete and be read */
           /* cpu_boot(howto); */ /* doesn't do anything at the moment */
           cpu_reset();
           for(;;) ;
           /* NOTREACHED */
   }
   
   /*
    * Magic number for savecore
    *
    * exported (symorder) and used at least by savecore(8)
    *
    */
   static u_long const     dumpmag = 0x8fca0101UL; 
   
   static int      dumpsize = 0;           /* also for savecore */
   
   static int      dodump = 1;
   SYSCTL_INT(_machdep, OID_AUTO, do_dump, CTLFLAG_RW, &dodump, 0, "");
   
   /* ARGSUSED */
   static void dump_conf __P((void *dummy));
   static void
   dump_conf(dummy)
           void *dummy;
   {
           cpu_dumpconf();
   }
   SYSINIT(dump_conf, SI_SUB_DUMP_CONF, SI_ORDER_FIRST, dump_conf, NULL)
   
   /*
    * Doadump comes here after turning off memory management and
    * getting on the dump stack, either when called above, or by
    * the auto-restart code.
    */
   static void
   dumpsys(void)
   {
   
           if (!dodump)
                   return;
           if (dumpdev == NODEV)
                   return;
           if (!(bdevsw[major(dumpdev)]))
                   return;
           if (!(bdevsw[major(dumpdev)]->d_dump))
                   return;
           dumpsize = Maxmem;
           printf("\ndumping to dev %lx, offset %ld\n", (u_long)dumpdev, dumplo);
           printf("dump ");
           switch ((*bdevsw[major(dumpdev)]->d_dump)(dumpdev)) {
   
           case ENXIO:
                   printf("device bad\n");
                   break;
   
           case EFAULT:
                   printf("device not ready\n");
                   break;
   
           case EINVAL:
                   printf("area improper\n");
                   break;
   
           case EIO:
                   printf("i/o error\n");
                   break;
   
           case EINTR:
                   printf("aborted from console\n");
                   break;
   
           default:
                   printf("succeeded\n");
                   break;
           }
   }
   
   /*
    * Panic is called on unresolvable fatal errors.  It prints "panic: mesg",
    * and then reboots.  If we are called twice, then we avoid trying to sync
    * the disks as this often leads to recursive panics.
    */
   void
   panic(const char *fmt, ...)
   {
           int bootopt;
           va_list ap;
           static char buf[256];
   
           bootopt = RB_AUTOBOOT | RB_DUMP;
           if (panicstr)
                   bootopt |= RB_NOSYNC;
           else
                   panicstr = fmt;
   
           va_start(ap, fmt);
           (void)vsnprintf(buf, sizeof(buf), fmt, ap);
           if (panicstr == fmt)
                   panicstr = buf;
           va_end(ap);
           printf("panic: %s\n", buf);
   #ifdef SMP
           /* three seperate prints in case of an unmapped page and trap */
           printf("mp_lock = %08x; ", mp_lock);
           printf("cpuid = %d; ", cpuid);
           printf("lapic.id = %08x\n", lapic.id);
   #endif
   
   #if defined(DDB)
           if (debugger_on_panic)
                   Debugger ("panic");
   #endif
           boot(bootopt);
   }
   
   /*
    * Three routines to handle adding/deleting items on the
    * shutdown callout lists
    *
    * at_shutdown():
    * Take the arguments given and put them onto the shutdown callout list.
    * However first make sure that it's not already there.
    * returns 0 on success.
    */
   int
   at_shutdown(bootlist_fn function, void *arg, int queue)
   {
           return(at_shutdown_pri(function, arg, queue, SHUTDOWN_PRI_DEFAULT));
   }
   
   /*
    * at_shutdown_pri():
    * Take the arguments given and put them onto the shutdown callout list
    * with the given execution priority.
    * returns 0 on success.
    */
   int
   at_shutdown_pri(bootlist_fn function, void *arg, int queue, int pri)
   {
           sle_p ep, ip;
   
           if (queue < SHUTDOWN_PRE_SYNC
            || queue > SHUTDOWN_FINAL) {
                   printf("at_shutdown: bad exit callout queue %d specified\n",
                          queue);
                   return (EINVAL);
           }
           if (rm_at_shutdown(function, arg))
                   printf("at_shutdown: exit callout entry was already present\n");
           ep = malloc(sizeof(*ep), M_TEMP, M_NOWAIT);
           if (ep == NULL)
                   return (ENOMEM);
           ep->function = function;
           ep->arg = arg;
           ep->priority = pri;
   
           /* Sort into list of items on this queue */
           ip = LIST_FIRST(&shutdown_lists[queue]);
           if (ip == NULL) {
                   LIST_INSERT_HEAD(&shutdown_lists[queue], ep, links);
           } else {
                   for (; LIST_NEXT(ip, links) != NULL; ip = LIST_NEXT(ip, links)) {
                           if (ep->priority < ip->priority) {
                                   LIST_INSERT_BEFORE(ip, ep, links);
                                   ep = NULL;
                                   break;
                           }
                   }
                   if (ep != NULL)
                           LIST_INSERT_AFTER(ip, ep, links);
           }
           return (0);
   }
   
   /*
    * Scan the exit callout lists for the given items and remove them.
    * Returns the number of items removed.
    */
   int
   rm_at_shutdown(bootlist_fn function, void *arg)
   {
           sle_p ep;
           int   count;
           int   queue;
   
           count = 0;
           for (queue = SHUTDOWN_PRE_SYNC; queue < SHUTDOWN_FINAL; queue++) {
                   LIST_FOREACH(ep, &shutdown_lists[queue], links) {
                           if ((ep->function == function) && (ep->arg == arg)) {
                                   LIST_REMOVE(ep, links);
                                   free(ep, M_TEMP);
                                   count++;
                           }
                   }
           }
           return (count);
   }

Cache object: 1f27576b6be01f142143cb86e1c49fa8