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

TOMOYO Linux Cross Reference
Linux/arch/x86/kernel/step.c

Version: ~ [ linux-6.12-rc7 ] ~ [ linux-6.11.7 ] ~ [ linux-6.10.14 ] ~ [ linux-6.9.12 ] ~ [ linux-6.8.12 ] ~ [ linux-6.7.12 ] ~ [ linux-6.6.60 ] ~ [ linux-6.5.13 ] ~ [ linux-6.4.16 ] ~ [ linux-6.3.13 ] ~ [ linux-6.2.16 ] ~ [ linux-6.1.116 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.171 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.229 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.285 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.323 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.336 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.4.302 ] ~ [ 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.12 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

Diff markup

Differences between /arch/x86/kernel/step.c (Version linux-6.12-rc7) and /arch/ppc/kernel/step.c (Version linux-6.0.19)


  1 // SPDX-License-Identifier: GPL-2.0                 1 
  2 /*                                                
  3  * x86 single-step support code, common to 32-    
  4  */                                               
  5 #include <linux/sched.h>                          
  6 #include <linux/sched/task_stack.h>               
  7 #include <linux/mm.h>                             
  8 #include <linux/ptrace.h>                         
  9                                                   
 10 #include <asm/desc.h>                             
 11 #include <asm/debugreg.h>                         
 12 #include <asm/mmu_context.h>                      
 13                                                   
 14 unsigned long convert_ip_to_linear(struct task    
 15 {                                                 
 16         unsigned long addr, seg;                  
 17                                                   
 18         addr = regs->ip;                          
 19         seg = regs->cs;                           
 20         if (v8086_mode(regs)) {                   
 21                 addr = (addr & 0xffff) + (seg     
 22                 return addr;                      
 23         }                                         
 24                                                   
 25 #ifdef CONFIG_MODIFY_LDT_SYSCALL                  
 26         /*                                        
 27          * We'll assume that the code segments    
 28          * are all zero-based. That is largely    
 29          * TLS segments are used for data, and    
 30          * and APM bios ones we just ignore he    
 31          */                                       
 32         if ((seg & SEGMENT_TI_MASK) == SEGMENT    
 33                 struct desc_struct *desc;         
 34                 unsigned long base;               
 35                                                   
 36                 seg >>= 3;                        
 37                                                   
 38                 mutex_lock(&child->mm->context    
 39                 if (unlikely(!child->mm->conte    
 40                              seg >= child->mm-    
 41                         addr = -1L; /* bogus s    
 42                 else {                            
 43                         desc = &child->mm->con    
 44                         base = get_desc_base(d    
 45                                                   
 46                         /* 16-bit code segment    
 47                         if (!desc->d)             
 48                                 addr &= 0xffff    
 49                         addr += base;             
 50                 }                                 
 51                 mutex_unlock(&child->mm->conte    
 52         }                                         
 53 #endif                                            
 54                                                   
 55         return addr;                              
 56 }                                                 
 57                                                   
 58 static int is_setting_trap_flag(struct task_st    
 59 {                                                 
 60         int i, copied;                            
 61         unsigned char opcode[15];                 
 62         unsigned long addr = convert_ip_to_lin    
 63                                                   
 64         copied = access_process_vm(child, addr    
 65                         FOLL_FORCE);              
 66         for (i = 0; i < copied; i++) {            
 67                 switch (opcode[i]) {              
 68                 /* popf and iret */               
 69                 case 0x9d: case 0xcf:             
 70                         return 1;                 
 71                                                   
 72                         /* CHECKME: 64 65 */      
 73                                                   
 74                 /* opcode and address size pre    
 75                 case 0x66: case 0x67:             
 76                         continue;                 
 77                 /* irrelevant prefixes (segmen    
 78                 case 0x26: case 0x2e:             
 79                 case 0x36: case 0x3e:             
 80                 case 0x64: case 0x65:             
 81                 case 0xf0: case 0xf2: case 0xf    
 82                         continue;                 
 83                                                   
 84 #ifdef CONFIG_X86_64                              
 85                 case 0x40 ... 0x4f:               
 86                         if (!user_64bit_mode(r    
 87                                 /* 32-bit mode    
 88                                 return 0;         
 89                         /* 64-bit mode: REX pr    
 90                         continue;                 
 91 #endif                                            
 92                                                   
 93                         /* CHECKME: f2, f3 */     
 94                                                   
 95                 /*                                
 96                  * pushf: NOTE! We should prob    
 97                  * the user see the TF bit bei    
 98                  * it's more pain than it's wo    
 99                  * it, and a debugger could em    
100                  * all in user space if it _re    
101                  */                               
102                 case 0x9c:                        
103                 default:                          
104                         return 0;                 
105                 }                                 
106         }                                         
107         return 0;                                 
108 }                                                 
109                                                   
110 /*                                                
111  * Enable single-stepping.  Return nonzero if     
112  */                                               
113 static int enable_single_step(struct task_stru    
114 {                                                 
115         struct pt_regs *regs = task_pt_regs(ch    
116         unsigned long oflags;                     
117                                                   
118         /*                                        
119          * If we stepped into a sysenter/sysca    
120          * kernel mode; do_debug() cleared TF     
121          * If user-mode had set TF itself, the    
122          * do_debug() and we need to set it ag    
123          * state so we don't wrongly set TIF_F    
124          * If enable_single_step() was used la    
125          * set TIF_SINGLESTEP, then both TF an    
126          * already set and our bookkeeping is     
127          */                                       
128         if (unlikely(test_tsk_thread_flag(chil    
129                 regs->flags |= X86_EFLAGS_TF;     
130                                                   
131         /*                                        
132          * Always set TIF_SINGLESTEP.  This wi    
133          * cause us to set TF when returning t    
134          */                                       
135         set_tsk_thread_flag(child, TIF_SINGLES    
136                                                   
137         /*                                        
138          * Ensure that a trap is triggered onc    
139          * call prior to executing any user in    
140          */                                       
141         set_task_syscall_work(child, SYSCALL_E    
142                                                   
143         oflags = regs->flags;                     
144                                                   
145         /* Set TF on the kernel stack.. */        
146         regs->flags |= X86_EFLAGS_TF;             
147                                                   
148         /*                                        
149          * ..but if TF is changed by the instr    
150          * don't mark it as being "us" that se    
151          * won't clear it by hand later.          
152          *                                        
153          * Note that if we don't actually exec    
154          * of a signal arriving right now or s    
155          * track of the fact that it really wa    
156          */                                       
157         if (is_setting_trap_flag(child, regs))    
158                 clear_tsk_thread_flag(child, T    
159                 return 0;                         
160         }                                         
161                                                   
162         /*                                        
163          * If TF was already set, check whethe    
164          * If not, we should never attempt a b    
165          */                                       
166         if (oflags & X86_EFLAGS_TF)               
167                 return test_tsk_thread_flag(ch    
168                                                   
169         set_tsk_thread_flag(child, TIF_FORCED_    
170                                                   
171         return 1;                                 
172 }                                                 
173                                                   
174 void set_task_blockstep(struct task_struct *ta    
175 {                                                 
176         unsigned long debugctl;                   
177                                                   
178         /*                                        
179          * Ensure irq/preemption can't change     
180          * Note also that both TIF_BLOCKSTEP a    
181          * be changed atomically wrt preemptio    
182          *                                        
183          * NOTE: this means that set/clear TIF    
184          * task is current or it can't be runn    
185          * with __switch_to_xtra(). We rely on    
186          */                                       
187         local_irq_disable();                      
188         debugctl = get_debugctlmsr();             
189         if (on) {                                 
190                 debugctl |= DEBUGCTLMSR_BTF;      
191                 set_tsk_thread_flag(task, TIF_    
192         } else {                                  
193                 debugctl &= ~DEBUGCTLMSR_BTF;     
194                 clear_tsk_thread_flag(task, TI    
195         }                                         
196         if (task == current)                      
197                 update_debugctlmsr(debugctl);     
198         local_irq_enable();                       
199 }                                                 
200                                                   
201 /*                                                
202  * Enable single or block step.                   
203  */                                               
204 static void enable_step(struct task_struct *ch    
205 {                                                 
206         /*                                        
207          * Make sure block stepping (BTF) is n    
208          * Note that we don't try to worry abo    
209          * instructions after the first when u    
210          * So no one should try to use debugge    
211          * that uses user-mode single stepping    
212          */                                       
213         if (enable_single_step(child) && block    
214                 set_task_blockstep(child, true    
215         else if (test_tsk_thread_flag(child, T    
216                 set_task_blockstep(child, fals    
217 }                                                 
218                                                   
219 void user_enable_single_step(struct task_struc    
220 {                                                 
221         enable_step(child, 0);                    
222 }                                                 
223                                                   
224 void user_enable_block_step(struct task_struct    
225 {                                                 
226         enable_step(child, 1);                    
227 }                                                 
228                                                   
229 void user_disable_single_step(struct task_stru    
230 {                                                 
231         /*                                        
232          * Make sure block stepping (BTF) is d    
233          */                                       
234         if (test_tsk_thread_flag(child, TIF_BL    
235                 set_task_blockstep(child, fals    
236                                                   
237         /* Always clear TIF_SINGLESTEP... */      
238         clear_tsk_thread_flag(child, TIF_SINGL    
239         clear_task_syscall_work(child, SYSCALL    
240                                                   
241         /* But touch TF only if it was set by     
242         if (test_and_clear_tsk_thread_flag(chi    
243                 task_pt_regs(child)->flags &=     
244 }                                                 
245                                                   

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

kernel.org | git.kernel.org | LWN.net | Project Home | 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.

sflogo.php