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

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/process.c

Version: ~ [ linux-5.12-rc7 ] ~ [ linux-5.11.13 ] ~ [ linux-5.10.29 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.111 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.186 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.230 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.266 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.266 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ 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.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * This file handles the architecture dependent parts of process handling.
  4  *
  5  *    Copyright IBM Corp. 1999, 2009
  6  *    Author(s): Martin Schwidefsky <schwidefsky@de.ibm.com>,
  7  *               Hartmut Penner <hp@de.ibm.com>,
  8  *               Denis Joseph Barrow,
  9  */
 10 
 11 #include <linux/elf-randomize.h>
 12 #include <linux/compiler.h>
 13 #include <linux/cpu.h>
 14 #include <linux/sched.h>
 15 #include <linux/sched/debug.h>
 16 #include <linux/sched/task.h>
 17 #include <linux/sched/task_stack.h>
 18 #include <linux/kernel.h>
 19 #include <linux/mm.h>
 20 #include <linux/elfcore.h>
 21 #include <linux/smp.h>
 22 #include <linux/slab.h>
 23 #include <linux/interrupt.h>
 24 #include <linux/tick.h>
 25 #include <linux/personality.h>
 26 #include <linux/syscalls.h>
 27 #include <linux/compat.h>
 28 #include <linux/kprobes.h>
 29 #include <linux/random.h>
 30 #include <linux/export.h>
 31 #include <linux/init_task.h>
 32 #include <asm/cpu_mf.h>
 33 #include <asm/io.h>
 34 #include <asm/processor.h>
 35 #include <asm/vtimer.h>
 36 #include <asm/exec.h>
 37 #include <asm/irq.h>
 38 #include <asm/nmi.h>
 39 #include <asm/smp.h>
 40 #include <asm/stacktrace.h>
 41 #include <asm/switch_to.h>
 42 #include <asm/runtime_instr.h>
 43 #include <asm/unwind.h>
 44 #include "entry.h"
 45 
 46 asmlinkage void ret_from_fork(void) asm ("ret_from_fork");
 47 
 48 extern void kernel_thread_starter(void);
 49 
 50 void flush_thread(void)
 51 {
 52 }
 53 
 54 void arch_setup_new_exec(void)
 55 {
 56         if (S390_lowcore.current_pid != current->pid) {
 57                 S390_lowcore.current_pid = current->pid;
 58                 if (test_facility(40))
 59                         lpp(&S390_lowcore.lpp);
 60         }
 61 }
 62 
 63 void arch_release_task_struct(struct task_struct *tsk)
 64 {
 65         runtime_instr_release(tsk);
 66         guarded_storage_release(tsk);
 67 }
 68 
 69 int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src)
 70 {
 71         /*
 72          * Save the floating-point or vector register state of the current
 73          * task and set the CIF_FPU flag to lazy restore the FPU register
 74          * state when returning to user space.
 75          */
 76         save_fpu_regs();
 77 
 78         memcpy(dst, src, arch_task_struct_size);
 79         dst->thread.fpu.regs = dst->thread.fpu.fprs;
 80         return 0;
 81 }
 82 
 83 int copy_thread_tls(unsigned long clone_flags, unsigned long new_stackp,
 84                     unsigned long arg, struct task_struct *p, unsigned long tls)
 85 {
 86         struct fake_frame
 87         {
 88                 struct stack_frame sf;
 89                 struct pt_regs childregs;
 90         } *frame;
 91 
 92         frame = container_of(task_pt_regs(p), struct fake_frame, childregs);
 93         p->thread.ksp = (unsigned long) frame;
 94         /* Save access registers to new thread structure. */
 95         save_access_regs(&p->thread.acrs[0]);
 96         /* start new process with ar4 pointing to the correct address space */
 97         p->thread.mm_segment = get_fs();
 98         /* Don't copy debug registers */
 99         memset(&p->thread.per_user, 0, sizeof(p->thread.per_user));
100         memset(&p->thread.per_event, 0, sizeof(p->thread.per_event));
101         clear_tsk_thread_flag(p, TIF_SINGLE_STEP);
102         p->thread.per_flags = 0;
103         /* Initialize per thread user and system timer values */
104         p->thread.user_timer = 0;
105         p->thread.guest_timer = 0;
106         p->thread.system_timer = 0;
107         p->thread.hardirq_timer = 0;
108         p->thread.softirq_timer = 0;
109         p->thread.last_break = 1;
110 
111         frame->sf.back_chain = 0;
112         /* new return point is ret_from_fork */
113         frame->sf.gprs[8] = (unsigned long) ret_from_fork;
114         /* fake return stack for resume(), don't go back to schedule */
115         frame->sf.gprs[9] = (unsigned long) frame;
116 
117         /* Store access registers to kernel stack of new process. */
118         if (unlikely(p->flags & PF_KTHREAD)) {
119                 /* kernel thread */
120                 memset(&frame->childregs, 0, sizeof(struct pt_regs));
121                 frame->childregs.psw.mask = PSW_KERNEL_BITS | PSW_MASK_DAT |
122                                 PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK;
123                 frame->childregs.psw.addr =
124                                 (unsigned long) kernel_thread_starter;
125                 frame->childregs.gprs[9] = new_stackp; /* function */
126                 frame->childregs.gprs[10] = arg;
127                 frame->childregs.gprs[11] = (unsigned long) do_exit;
128                 frame->childregs.orig_gpr2 = -1;
129 
130                 return 0;
131         }
132         frame->childregs = *current_pt_regs();
133         frame->childregs.gprs[2] = 0;   /* child returns 0 on fork. */
134         frame->childregs.flags = 0;
135         if (new_stackp)
136                 frame->childregs.gprs[15] = new_stackp;
137 
138         /* Don't copy runtime instrumentation info */
139         p->thread.ri_cb = NULL;
140         frame->childregs.psw.mask &= ~PSW_MASK_RI;
141         /* Don't copy guarded storage control block */
142         p->thread.gs_cb = NULL;
143         p->thread.gs_bc_cb = NULL;
144 
145         /* Set a new TLS ?  */
146         if (clone_flags & CLONE_SETTLS) {
147                 if (is_compat_task()) {
148                         p->thread.acrs[0] = (unsigned int)tls;
149                 } else {
150                         p->thread.acrs[0] = (unsigned int)(tls >> 32);
151                         p->thread.acrs[1] = (unsigned int)tls;
152                 }
153         }
154         return 0;
155 }
156 
157 asmlinkage void execve_tail(void)
158 {
159         current->thread.fpu.fpc = 0;
160         asm volatile("sfpc %0" : : "d" (0));
161 }
162 
163 /*
164  * fill in the FPU structure for a core dump.
165  */
166 int dump_fpu (struct pt_regs * regs, s390_fp_regs *fpregs)
167 {
168         save_fpu_regs();
169         fpregs->fpc = current->thread.fpu.fpc;
170         fpregs->pad = 0;
171         if (MACHINE_HAS_VX)
172                 convert_vx_to_fp((freg_t *)&fpregs->fprs,
173                                  current->thread.fpu.vxrs);
174         else
175                 memcpy(&fpregs->fprs, current->thread.fpu.fprs,
176                        sizeof(fpregs->fprs));
177         return 1;
178 }
179 EXPORT_SYMBOL(dump_fpu);
180 
181 unsigned long get_wchan(struct task_struct *p)
182 {
183         struct unwind_state state;
184         unsigned long ip = 0;
185 
186         if (!p || p == current || p->state == TASK_RUNNING || !task_stack_page(p))
187                 return 0;
188 
189         if (!try_get_task_stack(p))
190                 return 0;
191 
192         unwind_for_each_frame(&state, p, NULL, 0) {
193                 if (state.stack_info.type != STACK_TYPE_TASK) {
194                         ip = 0;
195                         break;
196                 }
197 
198                 ip = unwind_get_return_address(&state);
199                 if (!ip)
200                         break;
201 
202                 if (!in_sched_functions(ip))
203                         break;
204         }
205 
206         put_task_stack(p);
207         return ip;
208 }
209 
210 unsigned long arch_align_stack(unsigned long sp)
211 {
212         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
213                 sp -= get_random_int() & ~PAGE_MASK;
214         return sp & ~0xf;
215 }
216 
217 static inline unsigned long brk_rnd(void)
218 {
219         return (get_random_int() & BRK_RND_MASK) << PAGE_SHIFT;
220 }
221 
222 unsigned long arch_randomize_brk(struct mm_struct *mm)
223 {
224         unsigned long ret;
225 
226         ret = PAGE_ALIGN(mm->brk + brk_rnd());
227         return (ret > mm->brk) ? ret : mm->brk;
228 }
229 
230 void set_fs_fixup(void)
231 {
232         struct pt_regs *regs = current_pt_regs();
233         static bool warned;
234 
235         set_fs(USER_DS);
236         if (warned)
237                 return;
238         WARN(1, "Unbalanced set_fs - int code: 0x%x\n", regs->int_code);
239         show_registers(regs);
240         warned = true;
241 }
242 

~ [ 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