~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/powerpc/kernel/signal.c

Version: ~ [ linux-5.19-rc8 ] ~ [ linux-5.18.14 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.57 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.133 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.207 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.253 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.289 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.324 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Common signal handling code for both 32 and 64 bits
  3  *
  4  *    Copyright (c) 2007 Benjamin Herrenschmidt, IBM Corporation
  5  *    Extracted from signal_32.c and signal_64.c
  6  *
  7  * This file is subject to the terms and conditions of the GNU General
  8  * Public License.  See the file README.legal in the main directory of
  9  * this archive for more details.
 10  */
 11 
 12 #include <linux/tracehook.h>
 13 #include <linux/signal.h>
 14 #include <linux/uprobes.h>
 15 #include <linux/key.h>
 16 #include <linux/context_tracking.h>
 17 #include <asm/hw_breakpoint.h>
 18 #include <asm/uaccess.h>
 19 #include <asm/unistd.h>
 20 #include <asm/debug.h>
 21 #include <asm/tm.h>
 22 
 23 #include "signal.h"
 24 
 25 /* Log an error when sending an unhandled signal to a process. Controlled
 26  * through debug.exception-trace sysctl.
 27  */
 28 
 29 int show_unhandled_signals = 1;
 30 
 31 /*
 32  * Allocate space for the signal frame
 33  */
 34 void __user *get_sigframe(struct ksignal *ksig, unsigned long sp,
 35                            size_t frame_size, int is_32)
 36 {
 37         unsigned long oldsp, newsp;
 38 
 39         /* Default to using normal stack */
 40         oldsp = get_clean_sp(sp, is_32);
 41         oldsp = sigsp(oldsp, ksig);
 42         newsp = (oldsp - frame_size) & ~0xFUL;
 43 
 44         /* Check access */
 45         if (!access_ok(VERIFY_WRITE, (void __user *)newsp, oldsp - newsp))
 46                 return NULL;
 47 
 48         return (void __user *)newsp;
 49 }
 50 
 51 static void check_syscall_restart(struct pt_regs *regs, struct k_sigaction *ka,
 52                                   int has_handler)
 53 {
 54         unsigned long ret = regs->gpr[3];
 55         int restart = 1;
 56 
 57         /* syscall ? */
 58         if (TRAP(regs) != 0x0C00)
 59                 return;
 60 
 61         /* error signalled ? */
 62         if (!(regs->ccr & 0x10000000))
 63                 return;
 64 
 65         switch (ret) {
 66         case ERESTART_RESTARTBLOCK:
 67         case ERESTARTNOHAND:
 68                 /* ERESTARTNOHAND means that the syscall should only be
 69                  * restarted if there was no handler for the signal, and since
 70                  * we only get here if there is a handler, we dont restart.
 71                  */
 72                 restart = !has_handler;
 73                 break;
 74         case ERESTARTSYS:
 75                 /* ERESTARTSYS means to restart the syscall if there is no
 76                  * handler or the handler was registered with SA_RESTART
 77                  */
 78                 restart = !has_handler || (ka->sa.sa_flags & SA_RESTART) != 0;
 79                 break;
 80         case ERESTARTNOINTR:
 81                 /* ERESTARTNOINTR means that the syscall should be
 82                  * called again after the signal handler returns.
 83                  */
 84                 break;
 85         default:
 86                 return;
 87         }
 88         if (restart) {
 89                 if (ret == ERESTART_RESTARTBLOCK)
 90                         regs->gpr[0] = __NR_restart_syscall;
 91                 else
 92                         regs->gpr[3] = regs->orig_gpr3;
 93                 regs->nip -= 4;
 94                 regs->result = 0;
 95         } else {
 96                 regs->result = -EINTR;
 97                 regs->gpr[3] = EINTR;
 98                 regs->ccr |= 0x10000000;
 99         }
100 }
101 
102 static void do_signal(struct pt_regs *regs)
103 {
104         sigset_t *oldset = sigmask_to_save();
105         struct ksignal ksig;
106         int ret;
107         int is32 = is_32bit_task();
108 
109         get_signal(&ksig);
110 
111         /* Is there any syscall restart business here ? */
112         check_syscall_restart(regs, &ksig.ka, ksig.sig > 0);
113 
114         if (ksig.sig <= 0) {
115                 /* No signal to deliver -- put the saved sigmask back */
116                 restore_saved_sigmask();
117                 regs->trap = 0;
118                 return;               /* no signals delivered */
119         }
120 
121 #ifndef CONFIG_PPC_ADV_DEBUG_REGS
122         /*
123          * Reenable the DABR before delivering the signal to
124          * user space. The DABR will have been cleared if it
125          * triggered inside the kernel.
126          */
127         if (current->thread.hw_brk.address &&
128                 current->thread.hw_brk.type)
129                 __set_breakpoint(&current->thread.hw_brk);
130 #endif
131         /* Re-enable the breakpoints for the signal stack */
132         thread_change_pc(current, regs);
133 
134         if (is32) {
135                 if (ksig.ka.sa.sa_flags & SA_SIGINFO)
136                         ret = handle_rt_signal32(&ksig, oldset, regs);
137                 else
138                         ret = handle_signal32(&ksig, oldset, regs);
139         } else {
140                 ret = handle_rt_signal64(&ksig, oldset, regs);
141         }
142 
143         regs->trap = 0;
144         signal_setup_done(ret, &ksig, test_thread_flag(TIF_SINGLESTEP));
145 }
146 
147 void do_notify_resume(struct pt_regs *regs, unsigned long thread_info_flags)
148 {
149         user_exit();
150 
151         if (thread_info_flags & _TIF_UPROBE)
152                 uprobe_notify_resume(regs);
153 
154         if (thread_info_flags & _TIF_SIGPENDING)
155                 do_signal(regs);
156 
157         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
158                 clear_thread_flag(TIF_NOTIFY_RESUME);
159                 tracehook_notify_resume(regs);
160         }
161 
162         user_enter();
163 }
164 
165 unsigned long get_tm_stackpointer(struct pt_regs *regs)
166 {
167         /* When in an active transaction that takes a signal, we need to be
168          * careful with the stack.  It's possible that the stack has moved back
169          * up after the tbegin.  The obvious case here is when the tbegin is
170          * called inside a function that returns before a tend.  In this case,
171          * the stack is part of the checkpointed transactional memory state.
172          * If we write over this non transactionally or in suspend, we are in
173          * trouble because if we get a tm abort, the program counter and stack
174          * pointer will be back at the tbegin but our in memory stack won't be
175          * valid anymore.
176          *
177          * To avoid this, when taking a signal in an active transaction, we
178          * need to use the stack pointer from the checkpointed state, rather
179          * than the speculated state.  This ensures that the signal context
180          * (written tm suspended) will be written below the stack required for
181          * the rollback.  The transaction is aborted because of the treclaim,
182          * so any memory written between the tbegin and the signal will be
183          * rolled back anyway.
184          *
185          * For signals taken in non-TM or suspended mode, we use the
186          * normal/non-checkpointed stack pointer.
187          */
188 
189 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
190         if (MSR_TM_ACTIVE(regs->msr)) {
191                 tm_reclaim_current(TM_CAUSE_SIGNAL);
192                 if (MSR_TM_TRANSACTIONAL(regs->msr))
193                         return current->thread.ckpt_regs.gpr[1];
194         }
195 #endif
196         return regs->gpr[1];
197 }
198 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp