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

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

Version: ~ [ linux-5.13-rc5 ] ~ [ linux-5.12.9 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.42 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.124 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.193 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.235 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.271 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.271 ] ~ [ 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  * Copyright (C) 2005,2006,2007,2008,2009,2010,2011 Imagination Technologies
  4  *
  5  * This file contains the architecture-dependent parts of process handling.
  6  *
  7  */
  8 
  9 #include <linux/errno.h>
 10 #include <linux/export.h>
 11 #include <linux/sched.h>
 12 #include <linux/sched/debug.h>
 13 #include <linux/sched/task.h>
 14 #include <linux/sched/task_stack.h>
 15 #include <linux/kernel.h>
 16 #include <linux/mm.h>
 17 #include <linux/unistd.h>
 18 #include <linux/ptrace.h>
 19 #include <linux/user.h>
 20 #include <linux/reboot.h>
 21 #include <linux/elfcore.h>
 22 #include <linux/fs.h>
 23 #include <linux/tick.h>
 24 #include <linux/slab.h>
 25 #include <linux/mman.h>
 26 #include <linux/pm.h>
 27 #include <linux/syscalls.h>
 28 #include <linux/uaccess.h>
 29 #include <linux/smp.h>
 30 #include <asm/core_reg.h>
 31 #include <asm/user_gateway.h>
 32 #include <asm/tcm.h>
 33 #include <asm/traps.h>
 34 #include <asm/switch_to.h>
 35 
 36 /*
 37  * Wait for the next interrupt and enable local interrupts
 38  */
 39 void arch_cpu_idle(void)
 40 {
 41         int tmp;
 42 
 43         /*
 44          * Quickly jump straight into the interrupt entry point without actually
 45          * triggering an interrupt. When TXSTATI gets read the processor will
 46          * block until an interrupt is triggered.
 47          */
 48         asm volatile (/* Switch into ISTAT mode */
 49                       "RTH\n\t"
 50                       /* Enable local interrupts */
 51                       "MOV      TXMASKI, %1\n\t"
 52                       /*
 53                        * We can't directly "SWAP PC, PCX", so we swap via a
 54                        * temporary. Essentially we do:
 55                        *  PCX_new = 1f (the place to continue execution)
 56                        *  PC = PCX_old
 57                        */
 58                       "ADD      %0, CPC0, #(1f-.)\n\t"
 59                       "SWAP     PCX, %0\n\t"
 60                       "MOV      PC, %0\n"
 61                       /* Continue execution here with interrupts enabled */
 62                       "1:"
 63                       : "=a" (tmp)
 64                       : "r" (get_trigger_mask()));
 65 }
 66 
 67 #ifdef CONFIG_HOTPLUG_CPU
 68 void arch_cpu_idle_dead(void)
 69 {
 70         cpu_die();
 71 }
 72 #endif
 73 
 74 void (*pm_power_off)(void);
 75 EXPORT_SYMBOL(pm_power_off);
 76 
 77 void (*soc_restart)(char *cmd);
 78 void (*soc_halt)(void);
 79 
 80 void machine_restart(char *cmd)
 81 {
 82         if (soc_restart)
 83                 soc_restart(cmd);
 84         hard_processor_halt(HALT_OK);
 85 }
 86 
 87 void machine_halt(void)
 88 {
 89         if (soc_halt)
 90                 soc_halt();
 91         smp_send_stop();
 92         hard_processor_halt(HALT_OK);
 93 }
 94 
 95 void machine_power_off(void)
 96 {
 97         if (pm_power_off)
 98                 pm_power_off();
 99         smp_send_stop();
100         hard_processor_halt(HALT_OK);
101 }
102 
103 #define FLAG_Z 0x8
104 #define FLAG_N 0x4
105 #define FLAG_O 0x2
106 #define FLAG_C 0x1
107 
108 void show_regs(struct pt_regs *regs)
109 {
110         int i;
111         const char *AX0_names[] = {"A0StP", "A0FrP"};
112         const char *AX1_names[] = {"A1GbP", "A1LbP"};
113 
114         const char *DX0_names[] = {
115                 "D0Re0",
116                 "D0Ar6",
117                 "D0Ar4",
118                 "D0Ar2",
119                 "D0FrT",
120                 "D0.5 ",
121                 "D0.6 ",
122                 "D0.7 "
123         };
124 
125         const char *DX1_names[] = {
126                 "D1Re0",
127                 "D1Ar5",
128                 "D1Ar3",
129                 "D1Ar1",
130                 "D1RtP",
131                 "D1.5 ",
132                 "D1.6 ",
133                 "D1.7 "
134         };
135 
136         show_regs_print_info(KERN_INFO);
137 
138         pr_info(" pt_regs @ %p\n", regs);
139         pr_info(" SaveMask = 0x%04hx\n", regs->ctx.SaveMask);
140         pr_info(" Flags = 0x%04hx (%c%c%c%c)\n", regs->ctx.Flags,
141                 regs->ctx.Flags & FLAG_Z ? 'Z' : 'z',
142                 regs->ctx.Flags & FLAG_N ? 'N' : 'n',
143                 regs->ctx.Flags & FLAG_O ? 'O' : 'o',
144                 regs->ctx.Flags & FLAG_C ? 'C' : 'c');
145         pr_info(" TXRPT = 0x%08x\n", regs->ctx.CurrRPT);
146         pr_info(" PC = 0x%08x\n", regs->ctx.CurrPC);
147 
148         /* AX regs */
149         for (i = 0; i < 2; i++) {
150                 pr_info(" %s = 0x%08x    ",
151                         AX0_names[i],
152                         regs->ctx.AX[i].U0);
153                 printk(" %s = 0x%08x\n",
154                         AX1_names[i],
155                         regs->ctx.AX[i].U1);
156         }
157 
158         if (regs->ctx.SaveMask & TBICTX_XEXT_BIT)
159                 pr_warn(" Extended state present - AX2.[01] will be WRONG\n");
160 
161         /* Special place with AXx.2 */
162         pr_info(" A0.2  = 0x%08x    ",
163                 regs->ctx.Ext.AX2.U0);
164         printk(" A1.2  = 0x%08x\n",
165                 regs->ctx.Ext.AX2.U1);
166 
167         /* 'extended' AX regs (nominally, just AXx.3) */
168         for (i = 0; i < (TBICTX_AX_REGS - 3); i++) {
169                 pr_info(" A0.%d  = 0x%08x    ", i + 3, regs->ctx.AX3[i].U0);
170                 printk(" A1.%d  = 0x%08x\n", i + 3, regs->ctx.AX3[i].U1);
171         }
172 
173         for (i = 0; i < 8; i++) {
174                 pr_info(" %s = 0x%08x    ", DX0_names[i], regs->ctx.DX[i].U0);
175                 printk(" %s = 0x%08x\n", DX1_names[i], regs->ctx.DX[i].U1);
176         }
177 
178         show_trace(NULL, (unsigned long *)regs->ctx.AX[0].U0, regs);
179 }
180 
181 /*
182  * Copy architecture-specific thread state
183  */
184 int copy_thread(unsigned long clone_flags, unsigned long usp,
185                 unsigned long kthread_arg, struct task_struct *tsk)
186 {
187         struct pt_regs *childregs = task_pt_regs(tsk);
188         void *kernel_context = ((void *) childregs +
189                                 sizeof(struct pt_regs));
190         unsigned long global_base;
191 
192         BUG_ON(((unsigned long)childregs) & 0x7);
193         BUG_ON(((unsigned long)kernel_context) & 0x7);
194 
195         memset(&tsk->thread.kernel_context, 0,
196                         sizeof(tsk->thread.kernel_context));
197 
198         tsk->thread.kernel_context = __TBISwitchInit(kernel_context,
199                                                      ret_from_fork,
200                                                      0, 0);
201 
202         if (unlikely(tsk->flags & PF_KTHREAD)) {
203                 /*
204                  * Make sure we don't leak any kernel data to child's regs
205                  * if kernel thread becomes a userspace thread in the future
206                  */
207                 memset(childregs, 0 , sizeof(struct pt_regs));
208 
209                 global_base = __core_reg_get(A1GbP);
210                 childregs->ctx.AX[0].U1 = (unsigned long) global_base;
211                 childregs->ctx.AX[0].U0 = (unsigned long) kernel_context;
212                 /* Set D1Ar1=kthread_arg and D1RtP=usp (fn) */
213                 childregs->ctx.DX[4].U1 = usp;
214                 childregs->ctx.DX[3].U1 = kthread_arg;
215                 tsk->thread.int_depth = 2;
216                 return 0;
217         }
218 
219         /*
220          * Get a pointer to where the new child's register block should have
221          * been pushed.
222          * The Meta's stack grows upwards, and the context is the the first
223          * thing to be pushed by TBX (phew)
224          */
225         *childregs = *current_pt_regs();
226         /* Set the correct stack for the clone mode */
227         if (usp)
228                 childregs->ctx.AX[0].U0 = ALIGN(usp, 8);
229         tsk->thread.int_depth = 1;
230 
231         /* set return value for child process */
232         childregs->ctx.DX[0].U0 = 0;
233 
234         /* The TLS pointer is passed as an argument to sys_clone. */
235         if (clone_flags & CLONE_SETTLS)
236                 tsk->thread.tls_ptr =
237                                 (__force void __user *)childregs->ctx.DX[1].U1;
238 
239 #ifdef CONFIG_METAG_FPU
240         if (tsk->thread.fpu_context) {
241                 struct meta_fpu_context *ctx;
242 
243                 ctx = kmemdup(tsk->thread.fpu_context,
244                               sizeof(struct meta_fpu_context), GFP_ATOMIC);
245                 tsk->thread.fpu_context = ctx;
246         }
247 #endif
248 
249 #ifdef CONFIG_METAG_DSP
250         if (tsk->thread.dsp_context) {
251                 struct meta_ext_context *ctx;
252                 int i;
253 
254                 ctx = kmemdup(tsk->thread.dsp_context,
255                               sizeof(struct meta_ext_context), GFP_ATOMIC);
256                 for (i = 0; i < 2; i++)
257                         ctx->ram[i] = kmemdup(ctx->ram[i], ctx->ram_sz[i],
258                                               GFP_ATOMIC);
259                 tsk->thread.dsp_context = ctx;
260         }
261 #endif
262 
263         return 0;
264 }
265 
266 #ifdef CONFIG_METAG_FPU
267 static void alloc_fpu_context(struct thread_struct *thread)
268 {
269         thread->fpu_context = kzalloc(sizeof(struct meta_fpu_context),
270                                       GFP_ATOMIC);
271 }
272 
273 static void clear_fpu(struct thread_struct *thread)
274 {
275         thread->user_flags &= ~TBICTX_FPAC_BIT;
276         kfree(thread->fpu_context);
277         thread->fpu_context = NULL;
278 }
279 #else
280 static void clear_fpu(struct thread_struct *thread)
281 {
282 }
283 #endif
284 
285 #ifdef CONFIG_METAG_DSP
286 static void clear_dsp(struct thread_struct *thread)
287 {
288         if (thread->dsp_context) {
289                 kfree(thread->dsp_context->ram[0]);
290                 kfree(thread->dsp_context->ram[1]);
291 
292                 kfree(thread->dsp_context);
293 
294                 thread->dsp_context = NULL;
295         }
296 
297         __core_reg_set(D0.8, 0);
298 }
299 #else
300 static void clear_dsp(struct thread_struct *thread)
301 {
302 }
303 #endif
304 
305 struct task_struct *__sched __switch_to(struct task_struct *prev,
306                                         struct task_struct *next)
307 {
308         TBIRES to, from;
309 
310         to.Switch.pCtx = next->thread.kernel_context;
311         to.Switch.pPara = prev;
312 
313 #ifdef CONFIG_METAG_FPU
314         if (prev->thread.user_flags & TBICTX_FPAC_BIT) {
315                 struct pt_regs *regs = task_pt_regs(prev);
316                 TBIRES state;
317 
318                 state.Sig.SaveMask = prev->thread.user_flags;
319                 state.Sig.pCtx = &regs->ctx;
320 
321                 if (!prev->thread.fpu_context)
322                         alloc_fpu_context(&prev->thread);
323                 if (prev->thread.fpu_context)
324                         __TBICtxFPUSave(state, prev->thread.fpu_context);
325         }
326         /*
327          * Force a restore of the FPU context next time this process is
328          * scheduled.
329          */
330         if (prev->thread.fpu_context)
331                 prev->thread.fpu_context->needs_restore = true;
332 #endif
333 
334 
335         from = __TBISwitch(to, &prev->thread.kernel_context);
336 
337         /* Restore TLS pointer for this process. */
338         set_gateway_tls(current->thread.tls_ptr);
339 
340         return (struct task_struct *) from.Switch.pPara;
341 }
342 
343 void flush_thread(void)
344 {
345         clear_fpu(&current->thread);
346         clear_dsp(&current->thread);
347 }
348 
349 /*
350  * Free current thread data structures etc.
351  */
352 void exit_thread(struct task_struct *tsk)
353 {
354         clear_fpu(&tsk->thread);
355         clear_dsp(&tsk->thread);
356 }
357 
358 /* TODO: figure out how to unwind the kernel stack here to figure out
359  * where we went to sleep. */
360 unsigned long get_wchan(struct task_struct *p)
361 {
362         return 0;
363 }
364 
365 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
366 {
367         /* Returning 0 indicates that the FPU state was not stored (as it was
368          * not in use) */
369         return 0;
370 }
371 
372 #ifdef CONFIG_METAG_USER_TCM
373 
374 #define ELF_MIN_ALIGN   PAGE_SIZE
375 
376 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
377 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
378 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
379 
380 #define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
381 
382 unsigned long __metag_elf_map(struct file *filep, unsigned long addr,
383                               struct elf_phdr *eppnt, int prot, int type,
384                               unsigned long total_size)
385 {
386         unsigned long map_addr, size;
387         unsigned long page_off = ELF_PAGEOFFSET(eppnt->p_vaddr);
388         unsigned long raw_size = eppnt->p_filesz + page_off;
389         unsigned long off = eppnt->p_offset - page_off;
390         unsigned int tcm_tag;
391         addr = ELF_PAGESTART(addr);
392         size = ELF_PAGEALIGN(raw_size);
393 
394         /* mmap() will return -EINVAL if given a zero size, but a
395          * segment with zero filesize is perfectly valid */
396         if (!size)
397                 return addr;
398 
399         tcm_tag = tcm_lookup_tag(addr);
400 
401         if (tcm_tag != TCM_INVALID_TAG)
402                 type &= ~MAP_FIXED;
403 
404         /*
405         * total_size is the size of the ELF (interpreter) image.
406         * The _first_ mmap needs to know the full size, otherwise
407         * randomization might put this image into an overlapping
408         * position with the ELF binary image. (since size < total_size)
409         * So we first map the 'big' image - and unmap the remainder at
410         * the end. (which unmap is needed for ELF images with holes.)
411         */
412         if (total_size) {
413                 total_size = ELF_PAGEALIGN(total_size);
414                 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
415                 if (!BAD_ADDR(map_addr))
416                         vm_munmap(map_addr+size, total_size-size);
417         } else
418                 map_addr = vm_mmap(filep, addr, size, prot, type, off);
419 
420         if (!BAD_ADDR(map_addr) && tcm_tag != TCM_INVALID_TAG) {
421                 struct tcm_allocation *tcm;
422                 unsigned long tcm_addr;
423 
424                 tcm = kmalloc(sizeof(*tcm), GFP_KERNEL);
425                 if (!tcm)
426                         return -ENOMEM;
427 
428                 tcm_addr = tcm_alloc(tcm_tag, raw_size);
429                 if (tcm_addr != addr) {
430                         kfree(tcm);
431                         return -ENOMEM;
432                 }
433 
434                 tcm->tag = tcm_tag;
435                 tcm->addr = tcm_addr;
436                 tcm->size = raw_size;
437 
438                 list_add(&tcm->list, &current->mm->context.tcm);
439 
440                 eppnt->p_vaddr = map_addr;
441                 if (copy_from_user((void *) addr, (void __user *) map_addr,
442                                    raw_size))
443                         return -EFAULT;
444         }
445 
446         return map_addr;
447 }
448 #endif
449 

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