1/*- 2 * Copyright (C) 1994, David Greenman 3 * Copyright (c) 1990, 1993 4 * The Regents of the University of California. All rights reserved. 5 * Copyright (c) 2007 The FreeBSD Foundation 6 * 7 * This code is derived from software contributed to Berkeley by 8 * the University of Utah, and William Jolitz. 9 * 10 * Portions of this software were developed by A. Joseph Koshy under 11 * sponsorship from the FreeBSD Foundation and Google, Inc. 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 3. All advertising materials mentioning features or use of this software 22 * must display the following acknowledgement: 23 * This product includes software developed by the University of 24 * California, Berkeley and its contributors. 25 * 4. Neither the name of the University nor the names of its contributors 26 * may be used to endorse or promote products derived from this software 27 * without specific prior written permission. 28 * 29 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 30 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 31 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 32 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 33 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 34 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 35 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 36 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 37 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 38 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 39 * SUCH DAMAGE. 40 * 41 * from: @(#)trap.c 7.4 (Berkeley) 5/13/91 42 */ 43 44#include <sys/cdefs.h> 45__FBSDID("$FreeBSD: stable/11/sys/kern/subr_trap.c 351809 2019-09-04 09:54:21Z avg $"); 46 47#include "opt_hwpmc_hooks.h" 48#include "opt_ktrace.h" 49#include "opt_sched.h" 50 51#include <sys/param.h> 52#include <sys/bus.h> 53#include <sys/capsicum.h> 54#include <sys/kernel.h> 55#include <sys/lock.h> 56#include <sys/mutex.h> 57#include <sys/pmckern.h> 58#include <sys/proc.h> 59#include <sys/ktr.h> 60#include <sys/pioctl.h> 61#include <sys/ptrace.h> 62#include <sys/racct.h> 63#include <sys/resourcevar.h> 64#include <sys/sched.h> 65#include <sys/signalvar.h> 66#include <sys/syscall.h> 67#include <sys/syscallsubr.h> 68#include <sys/sysent.h> 69#include <sys/systm.h> 70#include <sys/vmmeter.h> 71#ifdef KTRACE 72#include <sys/uio.h> 73#include <sys/ktrace.h> 74#endif 75#include <security/audit/audit.h> 76 77#include <machine/cpu.h> 78 79#ifdef VIMAGE 80#include <net/vnet.h> 81#endif 82 83#ifdef HWPMC_HOOKS 84#include <sys/pmckern.h> 85#endif 86 87#include <security/mac/mac_framework.h> 88 89void (*softdep_ast_cleanup)(struct thread *); 90 91/* 92 * Define the code needed before returning to user mode, for trap and 93 * syscall. 94 */ 95void 96userret(struct thread *td, struct trapframe *frame) 97{ 98 struct proc *p = td->td_proc; 99 100 CTR3(KTR_SYSC, "userret: thread %p (pid %d, %s)", td, p->p_pid, 101 td->td_name); 102 KASSERT((p->p_flag & P_WEXIT) == 0, 103 ("Exiting process returns to usermode")); 104#ifdef DIAGNOSTIC 105 /* 106 * Check that we called signotify() enough. For 107 * multi-threaded processes, where signal distribution might 108 * change due to other threads changing sigmask, the check is 109 * racy and cannot be performed reliably. 110 * If current process is vfork child, indicated by P_PPWAIT, then 111 * issignal() ignores stops, so we block the check to avoid 112 * classifying pending signals. 113 */ 114 if (p->p_numthreads == 1) { 115 PROC_LOCK(p); 116 thread_lock(td); 117 if ((p->p_flag & P_PPWAIT) == 0) { 118 KASSERT(!SIGPENDING(td) || (td->td_flags & 119 (TDF_NEEDSIGCHK | TDF_ASTPENDING)) == 120 (TDF_NEEDSIGCHK | TDF_ASTPENDING), 121 ("failed to set signal flags for ast p %p " 122 "td %p fl %x", p, td, td->td_flags)); 123 } 124 thread_unlock(td); 125 PROC_UNLOCK(p); 126 } 127#endif 128#ifdef KTRACE 129 KTRUSERRET(td); 130#endif 131 td_softdep_cleanup(td); 132 MPASS(td->td_su == NULL); 133 134 /* 135 * If this thread tickled GEOM, we need to wait for the giggling to 136 * stop before we return to userland 137 */ 138 if (td->td_pflags & TDP_GEOM) 139 g_waitidle(); 140 141 /* 142 * Charge system time if profiling. 143 */ 144 if (p->p_flag & P_PROFIL) 145 addupc_task(td, TRAPF_PC(frame), td->td_pticks * psratio); 146 /* 147 * Let the scheduler adjust our priority etc. 148 */ 149 sched_userret(td); 150 151 /* 152 * Check for misbehavior. 153 * 154 * In case there is a callchain tracing ongoing because of 155 * hwpmc(4), skip the scheduler pinning check. 156 * hwpmc(4) subsystem, infact, will collect callchain informations 157 * at ast() checkpoint, which is past userret(). 158 */ 159 WITNESS_WARN(WARN_PANIC, NULL, "userret: returning"); 160 KASSERT(td->td_critnest == 0, 161 ("userret: Returning in a critical section")); 162 KASSERT(td->td_locks == 0, 163 ("userret: Returning with %d locks held", td->td_locks)); 164 KASSERT(td->td_rw_rlocks == 0, 165 ("userret: Returning with %d rwlocks held in read mode", 166 td->td_rw_rlocks)); 167 KASSERT(td->td_lk_slocks == 0, 168 ("userret: Returning with %d lockmanager locks held in shared mode", 169 td->td_lk_slocks)); 170 KASSERT((td->td_pflags & TDP_NOFAULTING) == 0, 171 ("userret: Returning with pagefaults disabled")); 172 KASSERT(td->td_no_sleeping == 0, 173 ("userret: Returning with sleep disabled")); 174 KASSERT(td->td_pinned == 0 || (td->td_pflags & TDP_CALLCHAIN) != 0, 175 ("userret: Returning with with pinned thread")); 176 KASSERT(td->td_vp_reserv == 0, 177 ("userret: Returning while holding vnode reservation")); 178 KASSERT((td->td_flags & (TDF_SBDRY | TDF_SEINTR | TDF_SERESTART)) == 0, 179 ("userret: Returning with stop signals deferred")); 180 KASSERT(td->td_su == NULL, 181 ("userret: Returning with SU cleanup request not handled")); 182 KASSERT(td->td_vslock_sz == 0, 183 ("userret: Returning with vslock-wired space")); 184#ifdef VIMAGE 185 /* Unfortunately td_vnet_lpush needs VNET_DEBUG. */ 186 VNET_ASSERT(curvnet == NULL, 187 ("%s: Returning on td %p (pid %d, %s) with vnet %p set in %s", 188 __func__, td, p->p_pid, td->td_name, curvnet, 189 (td->td_vnet_lpush != NULL) ? td->td_vnet_lpush : "N/A")); 190#endif 191#ifdef RACCT 192 if (racct_enable && p->p_throttled != 0) { 193 PROC_LOCK(p); 194 while (p->p_throttled != 0) { 195 msleep(p->p_racct, &p->p_mtx, 0, "racct", 196 p->p_throttled < 0 ? 0 : p->p_throttled); 197 if (p->p_throttled > 0) 198 p->p_throttled = 0; 199 } 200 PROC_UNLOCK(p); 201 } 202#endif 203} 204 205/* 206 * Process an asynchronous software trap. 207 * This is relatively easy. 208 * This function will return with preemption disabled. 209 */ 210void 211ast(struct trapframe *framep) 212{ 213 struct thread *td; 214 struct proc *p; 215 int flags; 216 int sig; 217 218 td = curthread; 219 p = td->td_proc; 220 221 CTR3(KTR_SYSC, "ast: thread %p (pid %d, %s)", td, p->p_pid, 222 p->p_comm); 223 KASSERT(TRAPF_USERMODE(framep), ("ast in kernel mode")); 224 WITNESS_WARN(WARN_PANIC, NULL, "Returning to user mode"); 225 mtx_assert(&Giant, MA_NOTOWNED); 226 THREAD_LOCK_ASSERT(td, MA_NOTOWNED); 227 td->td_frame = framep; 228 td->td_pticks = 0; 229 230 /* 231 * This updates the td_flag's for the checks below in one 232 * "atomic" operation with turning off the astpending flag. 233 * If another AST is triggered while we are handling the 234 * AST's saved in flags, the astpending flag will be set and 235 * ast() will be called again. 236 */ 237 thread_lock(td); 238 flags = td->td_flags; 239 td->td_flags &= ~(TDF_ASTPENDING | TDF_NEEDSIGCHK | TDF_NEEDSUSPCHK | 240 TDF_NEEDRESCHED | TDF_ALRMPEND | TDF_PROFPEND | TDF_MACPEND); 241 thread_unlock(td); 242 PCPU_INC(cnt.v_trap); 243 244 if (td->td_cowgen != p->p_cowgen) 245 thread_cow_update(td); 246 if (td->td_pflags & TDP_OWEUPC && p->p_flag & P_PROFIL) { 247 addupc_task(td, td->td_profil_addr, td->td_profil_ticks); 248 td->td_profil_ticks = 0; 249 td->td_pflags &= ~TDP_OWEUPC; 250 } 251#ifdef HWPMC_HOOKS 252 /* Handle Software PMC callchain capture. */ 253 if (PMC_IS_PENDING_CALLCHAIN(td)) 254 PMC_CALL_HOOK_UNLOCKED(td, PMC_FN_USER_CALLCHAIN_SOFT, (void *) framep); 255#endif 256 if (flags & TDF_ALRMPEND) { 257 PROC_LOCK(p); 258 kern_psignal(p, SIGVTALRM); 259 PROC_UNLOCK(p); 260 } 261 if (flags & TDF_PROFPEND) { 262 PROC_LOCK(p); 263 kern_psignal(p, SIGPROF); 264 PROC_UNLOCK(p); 265 } 266#ifdef MAC 267 if (flags & TDF_MACPEND) 268 mac_thread_userret(td); 269#endif 270 if (flags & TDF_NEEDRESCHED) { 271#ifdef KTRACE 272 if (KTRPOINT(td, KTR_CSW)) 273 ktrcsw(1, 1, __func__); 274#endif 275 thread_lock(td); 276 sched_prio(td, td->td_user_pri); 277 mi_switch(SW_INVOL | SWT_NEEDRESCHED, NULL); 278 thread_unlock(td); 279#ifdef KTRACE 280 if (KTRPOINT(td, KTR_CSW)) 281 ktrcsw(0, 1, __func__); 282#endif 283 } 284 285#ifdef DIAGNOSTIC 286 if (p->p_numthreads == 1 && (flags & TDF_NEEDSIGCHK) == 0) { 287 PROC_LOCK(p); 288 thread_lock(td); 289 /* 290 * Note that TDF_NEEDSIGCHK should be re-read from 291 * td_flags, since signal might have been delivered 292 * after we cleared td_flags above. This is one of 293 * the reason for looping check for AST condition. 294 * See comment in userret() about P_PPWAIT. 295 */ 296 if ((p->p_flag & P_PPWAIT) == 0) { 297 KASSERT(!SIGPENDING(td) || (td->td_flags & 298 (TDF_NEEDSIGCHK | TDF_ASTPENDING)) == 299 (TDF_NEEDSIGCHK | TDF_ASTPENDING), 300 ("failed2 to set signal flags for ast p %p td %p " 301 "fl %x %x", p, td, flags, td->td_flags)); 302 } 303 thread_unlock(td); 304 PROC_UNLOCK(p); 305 } 306#endif 307 308 /* 309 * Check for signals. Unlocked reads of p_pendingcnt or 310 * p_siglist might cause process-directed signal to be handled 311 * later. 312 */ 313 if (flags & TDF_NEEDSIGCHK || p->p_pendingcnt > 0 || 314 !SIGISEMPTY(p->p_siglist)) { 315 PROC_LOCK(p); 316 mtx_lock(&p->p_sigacts->ps_mtx); 317 while ((sig = cursig(td)) != 0) 318 postsig(sig); 319 mtx_unlock(&p->p_sigacts->ps_mtx); 320 PROC_UNLOCK(p); 321 } 322 /* 323 * We need to check to see if we have to exit or wait due to a 324 * single threading requirement or some other STOP condition. 325 */ 326 if (flags & TDF_NEEDSUSPCHK) { 327 PROC_LOCK(p); 328 thread_suspend_check(0); 329 PROC_UNLOCK(p); 330 } 331 332 if (td->td_pflags & TDP_OLDMASK) { 333 td->td_pflags &= ~TDP_OLDMASK; 334 kern_sigprocmask(td, SIG_SETMASK, &td->td_oldsigmask, NULL, 0); 335 } 336 337 userret(td, framep); 338} 339 340const char * 341syscallname(struct proc *p, u_int code) 342{ 343 static const char unknown[] = "unknown"; 344 struct sysentvec *sv; 345 346 sv = p->p_sysent; 347 if (sv->sv_syscallnames == NULL || code >= sv->sv_size) 348 return (unknown); 349 return (sv->sv_syscallnames[code]); 350} 351