1 /* $OpenBSD: kern_xxx.c,v 1.33 2017/01/21 05:42:03 guenther Exp $ */ 2 /* $NetBSD: kern_xxx.c,v 1.32 1996/04/22 01:38:41 christos Exp $ */ 3 4 /* 5 * Copyright (c) 1982, 1986, 1989, 1993 6 * The Regents of the University of California. All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. Neither the name of the University nor the names of its contributors 17 * may be used to endorse or promote products derived from this software 18 * without specific prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 23 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 30 * SUCH DAMAGE. 31 * 32 * @(#)kern_xxx.c 8.2 (Berkeley) 11/14/93 33 */ 34 35 #include <sys/param.h> 36 #include <sys/systm.h> 37 #include <sys/kernel.h> 38 #include <sys/reboot.h> 39 #include <sys/sysctl.h> 40 #include <sys/mount.h> 41 #include <sys/syscallargs.h> 42 43 int 44 sys_reboot(struct proc *p, void *v, register_t *retval) 45 { 46 struct sys_reboot_args /* { 47 syscallarg(int) opt; 48 } */ *uap = v; 49 int error; 50 51 if ((error = suser(p, 0)) != 0) 52 return (error); 53 54 #ifdef MULTIPROCESSOR 55 sched_stop_secondary_cpus(); 56 KASSERT(CPU_IS_PRIMARY(curcpu())); 57 #endif 58 reboot(SCARG(uap, opt)); 59 /* NOTREACHED */ 60 return (0); 61 } 62 63 __dead void 64 reboot(int howto) 65 { 66 KASSERT((howto & RB_NOSYNC) || curproc != NULL); 67 68 stop_periodic_resettodr(); 69 70 boot(howto); 71 /* NOTREACHED */ 72 } 73 74 #if !defined(NO_PROPOLICE) 75 void __stack_smash_handler(char [], int __attribute__((unused))); 76 77 void 78 __stack_smash_handler(char func[], int damaged) 79 { 80 panic("smashed stack in %s", func); 81 } 82 #endif 83 84 #ifdef SYSCALL_DEBUG 85 #include <sys/proc.h> 86 87 #define SCDEBUG_CALLS 0x0001 /* show calls */ 88 #define SCDEBUG_RETURNS 0x0002 /* show returns */ 89 #define SCDEBUG_ALL 0x0004 /* even syscalls that are implemented */ 90 #define SCDEBUG_SHOWARGS 0x0008 /* show arguments to calls */ 91 92 int scdebug = SCDEBUG_CALLS|SCDEBUG_RETURNS|SCDEBUG_SHOWARGS; 93 94 void 95 scdebug_call(struct proc *p, register_t code, const register_t args[]) 96 { 97 struct process *pr; 98 struct sysent *sy; 99 struct emul *em; 100 int i; 101 102 if (!(scdebug & SCDEBUG_CALLS)) 103 return; 104 105 pr = p->p_p; 106 em = pr->ps_emul; 107 sy = &em->e_sysent[code]; 108 if (!(scdebug & SCDEBUG_ALL || code < 0 || code >= em->e_nsysent || 109 sy->sy_call == sys_nosys)) 110 return; 111 112 printf("proc %d (%s): %s num ", pr->ps_pid, pr->ps_comm, em->e_name); 113 if (code < 0 || code >= em->e_nsysent) 114 printf("OUT OF RANGE (%ld)", code); 115 else { 116 printf("%ld call: %s", code, em->e_syscallnames[code]); 117 if (scdebug & SCDEBUG_SHOWARGS) { 118 printf("("); 119 for (i = 0; i < sy->sy_argsize / sizeof(register_t); 120 i++) 121 printf("%s0x%lx", i == 0 ? "" : ", ", args[i]); 122 printf(")"); 123 } 124 } 125 printf("\n"); 126 } 127 128 void 129 scdebug_ret(struct proc *p, register_t code, int error, 130 const register_t retval[]) 131 { 132 struct process *pr; 133 struct sysent *sy; 134 struct emul *em; 135 136 if (!(scdebug & SCDEBUG_RETURNS)) 137 return; 138 139 pr = p->p_p; 140 em = pr->ps_emul; 141 sy = &em->e_sysent[code]; 142 if (!(scdebug & SCDEBUG_ALL || code < 0 || code >= em->e_nsysent || 143 sy->sy_call == sys_nosys)) 144 return; 145 146 printf("proc %d (%s): %s num ", pr->ps_pid, pr->ps_comm, em->e_name); 147 if (code < 0 || code >= em->e_nsysent) 148 printf("OUT OF RANGE (%ld)", code); 149 else 150 printf("%ld ret: err = %d, rv = 0x%lx,0x%lx", code, 151 error, retval[0], retval[1]); 152 printf("\n"); 153 } 154 #endif /* SYSCALL_DEBUG */ 155