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

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

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ 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 /*
  2  * Process creation support for Hexagon
  3  *
  4  * Copyright (c) 2010-2012, The Linux Foundation. All rights reserved.
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 and
  8  * only version 2 as published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it will be useful,
 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13  * GNU General Public License for more details.
 14  *
 15  * You should have received a copy of the GNU General Public License
 16  * along with this program; if not, write to the Free Software
 17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 18  * 02110-1301, USA.
 19  */
 20 
 21 #include <linux/sched.h>
 22 #include <linux/sched/debug.h>
 23 #include <linux/sched/task.h>
 24 #include <linux/sched/task_stack.h>
 25 #include <linux/types.h>
 26 #include <linux/module.h>
 27 #include <linux/tick.h>
 28 #include <linux/uaccess.h>
 29 #include <linux/slab.h>
 30 #include <linux/tracehook.h>
 31 
 32 /*
 33  * Program thread launch.  Often defined as a macro in processor.h,
 34  * but we're shooting for a small footprint and it's not an inner-loop
 35  * performance-critical operation.
 36  *
 37  * The Hexagon ABI specifies that R28 is zero'ed before program launch,
 38  * so that gets automatically done here.  If we ever stop doing that here,
 39  * we'll probably want to define the ELF_PLAT_INIT macro.
 40  */
 41 void start_thread(struct pt_regs *regs, unsigned long pc, unsigned long sp)
 42 {
 43         /* We want to zero all data-containing registers. Is this overkill? */
 44         memset(regs, 0, sizeof(*regs));
 45         /* We might want to also zero all Processor registers here */
 46         pt_set_usermode(regs);
 47         pt_set_elr(regs, pc);
 48         pt_set_rte_sp(regs, sp);
 49 }
 50 
 51 /*
 52  *  Spin, or better still, do a hardware or VM wait instruction
 53  *  If hardware or VM offer wait termination even though interrupts
 54  *  are disabled.
 55  */
 56 void arch_cpu_idle(void)
 57 {
 58         __vmwait();
 59         /*  interrupts wake us up, but irqs are still disabled */
 60         local_irq_enable();
 61 }
 62 
 63 /*
 64  * Copy architecture-specific thread state
 65  */
 66 int copy_thread(unsigned long clone_flags, unsigned long usp,
 67                 unsigned long arg, struct task_struct *p)
 68 {
 69         struct thread_info *ti = task_thread_info(p);
 70         struct hexagon_switch_stack *ss;
 71         struct pt_regs *childregs;
 72         asmlinkage void ret_from_fork(void);
 73 
 74         childregs = (struct pt_regs *) (((unsigned long) ti + THREAD_SIZE) -
 75                                         sizeof(*childregs));
 76 
 77         ti->regs = childregs;
 78 
 79         /*
 80          * Establish kernel stack pointer and initial PC for new thread
 81          * Note that unlike the usual situation, we do not copy the
 82          * parent's callee-saved here; those are in pt_regs and whatever
 83          * we leave here will be overridden on return to userland.
 84          */
 85         ss = (struct hexagon_switch_stack *) ((unsigned long) childregs -
 86                                                     sizeof(*ss));
 87         ss->lr = (unsigned long)ret_from_fork;
 88         p->thread.switch_sp = ss;
 89         if (unlikely(p->flags & PF_KTHREAD)) {
 90                 memset(childregs, 0, sizeof(struct pt_regs));
 91                 /* r24 <- fn, r25 <- arg */
 92                 ss->r24 = usp;
 93                 ss->r25 = arg;
 94                 pt_set_kmode(childregs);
 95                 return 0;
 96         }
 97         memcpy(childregs, current_pt_regs(), sizeof(*childregs));
 98         ss->r2524 = 0;
 99 
100         if (usp)
101                 pt_set_rte_sp(childregs, usp);
102 
103         /* Child sees zero return value */
104         childregs->r00 = 0;
105 
106         /*
107          * The clone syscall has the C signature:
108          * int [r0] clone(int flags [r0],
109          *           void *child_frame [r1],
110          *           void *parent_tid [r2],
111          *           void *child_tid [r3],
112          *           void *thread_control_block [r4]);
113          * ugp is used to provide TLS support.
114          */
115         if (clone_flags & CLONE_SETTLS)
116                 childregs->ugp = childregs->r04;
117 
118         /*
119          * Parent sees new pid -- not necessary, not even possible at
120          * this point in the fork process
121          * Might also want to set things like ti->addr_limit
122          */
123 
124         return 0;
125 }
126 
127 /*
128  * Release any architecture-specific resources locked by thread
129  */
130 void release_thread(struct task_struct *dead_task)
131 {
132 }
133 
134 /*
135  * Some archs flush debug and FPU info here
136  */
137 void flush_thread(void)
138 {
139 }
140 
141 /*
142  * The "wait channel" terminology is archaic, but what we want
143  * is an identification of the point at which the scheduler
144  * was invoked by a blocked thread.
145  */
146 unsigned long get_wchan(struct task_struct *p)
147 {
148         unsigned long fp, pc;
149         unsigned long stack_page;
150         int count = 0;
151         if (!p || p == current || p->state == TASK_RUNNING)
152                 return 0;
153 
154         stack_page = (unsigned long)task_stack_page(p);
155         fp = ((struct hexagon_switch_stack *)p->thread.switch_sp)->fp;
156         do {
157                 if (fp < (stack_page + sizeof(struct thread_info)) ||
158                         fp >= (THREAD_SIZE - 8 + stack_page))
159                         return 0;
160                 pc = ((unsigned long *)fp)[1];
161                 if (!in_sched_functions(pc))
162                         return pc;
163                 fp = *(unsigned long *) fp;
164         } while (count++ < 16);
165 
166         return 0;
167 }
168 
169 /*
170  * Required placeholder.
171  */
172 int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fpu)
173 {
174         return 0;
175 }
176 
177 
178 /*
179  * Called on the exit path of event entry; see vm_entry.S
180  *
181  * Interrupts will already be disabled.
182  *
183  * Returns 0 if there's no need to re-check for more work.
184  */
185 
186 int do_work_pending(struct pt_regs *regs, u32 thread_info_flags)
187 {
188         if (!(thread_info_flags & _TIF_WORK_MASK)) {
189                 return 0;
190         }  /* shortcut -- no work to be done */
191 
192         local_irq_enable();
193 
194         if (thread_info_flags & _TIF_NEED_RESCHED) {
195                 schedule();
196                 return 1;
197         }
198 
199         if (thread_info_flags & _TIF_SIGPENDING) {
200                 do_signal(regs);
201                 return 1;
202         }
203 
204         if (thread_info_flags & _TIF_NOTIFY_RESUME) {
205                 clear_thread_flag(TIF_NOTIFY_RESUME);
206                 tracehook_notify_resume(regs);
207                 return 1;
208         }
209 
210         /* Should not even reach here */
211         panic("%s: bad thread_info flags 0x%08x\n", __func__,
212                 thread_info_flags);
213 }
214 

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