Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
process.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3  * Copyright 2003 PathScale, Inc.
4  * Licensed under the GPL
5  */
6 
7 #include <linux/stddef.h>
8 #include <linux/err.h>
9 #include <linux/hardirq.h>
10 #include <linux/mm.h>
11 #include <linux/module.h>
12 #include <linux/personality.h>
13 #include <linux/proc_fs.h>
14 #include <linux/ptrace.h>
15 #include <linux/random.h>
16 #include <linux/slab.h>
17 #include <linux/sched.h>
18 #include <linux/seq_file.h>
19 #include <linux/tick.h>
20 #include <linux/threads.h>
21 #include <linux/tracehook.h>
22 #include <asm/current.h>
23 #include <asm/pgtable.h>
24 #include <asm/mmu_context.h>
25 #include <asm/uaccess.h>
26 #include <as-layout.h>
27 #include <kern_util.h>
28 #include <os.h>
29 #include <skas.h>
30 
31 /*
32  * This is a per-cpu array. A processor only modifies its entry and it only
33  * cares about its entry, so it's OK if another processor is modifying its
34  * entry.
35  */
36 struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
37 
38 static inline int external_pid(void)
39 {
40  /* FIXME: Need to look up userspace_pid by cpu */
41  return userspace_pid[0];
42 }
43 
45 {
46  int i;
47 
48  for (i = 0; i < ncpus; i++) {
49  if (cpu_tasks[i].pid == pid)
50  return i;
51  }
52  return -1;
53 }
54 
55 void free_stack(unsigned long stack, int order)
56 {
57  free_pages(stack, order);
58 }
59 
60 unsigned long alloc_stack(int order, int atomic)
61 {
62  unsigned long page;
64 
65  if (atomic)
66  flags = GFP_ATOMIC;
67  page = __get_free_pages(flags, order);
68 
69  return page;
70 }
71 
72 static inline void set_current(struct task_struct *task)
73 {
74  cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task)
75  { external_pid(), task });
76 }
77 
78 extern void arch_switch_to(struct task_struct *to);
79 
80 void *__switch_to(struct task_struct *from, struct task_struct *to)
81 {
82  to->thread.prev_sched = from;
83  set_current(to);
84 
85  do {
86  current->thread.saved_task = NULL;
87 
88  switch_threads(&from->thread.switch_buf,
89  &to->thread.switch_buf);
90 
92 
93  if (current->thread.saved_task)
94  show_regs(&(current->thread.regs));
95  to = current->thread.saved_task;
96  from = current;
97  } while (current->thread.saved_task);
98 
99  return current->thread.prev_sched;
100 }
101 
102 void interrupt_end(void)
103 {
104  if (need_resched())
105  schedule();
106  if (test_thread_flag(TIF_SIGPENDING))
107  do_signal();
108  if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME))
109  tracehook_notify_resume(&current->thread.regs);
110 }
111 
112 void exit_thread(void)
113 {
114 }
115 
117 {
118  return task_pid_nr(current);
119 }
120 
121 /*
122  * This is called magically, by its address being stuffed in a jmp_buf
123  * and being longjmp-d to.
124  */
126 {
127  int (*fn)(void *), n;
128  void *arg;
129 
130  if (current->thread.prev_sched != NULL)
131  schedule_tail(current->thread.prev_sched);
132  current->thread.prev_sched = NULL;
133 
134  fn = current->thread.request.u.thread.proc;
135  arg = current->thread.request.u.thread.arg;
136 
137  /*
138  * callback returns only if the kernel thread execs a process
139  */
140  n = fn(arg);
141  userspace(&current->thread.regs.regs);
142 }
143 
144 /* Called magically, see new_thread_handler above */
145 void fork_handler(void)
146 {
147  force_flush_all();
148 
149  schedule_tail(current->thread.prev_sched);
150 
151  /*
152  * XXX: if interrupt_end() calls schedule, this call to
153  * arch_switch_to isn't needed. We could want to apply this to
154  * improve performance. -bb
155  */
157 
158  current->thread.prev_sched = NULL;
159 
160  userspace(&current->thread.regs.regs);
161 }
162 
163 int copy_thread(unsigned long clone_flags, unsigned long sp,
164  unsigned long arg, struct task_struct * p,
165  struct pt_regs *regs)
166 {
167  void (*handler)(void);
168  int kthread = current->flags & PF_KTHREAD;
169  int ret = 0;
170 
171  p->thread = (struct thread_struct) INIT_THREAD;
172 
173  if (!kthread) {
174  memcpy(&p->thread.regs.regs, &regs->regs,
175  sizeof(p->thread.regs.regs));
176  PT_REGS_SET_SYSCALL_RETURN(&p->thread.regs, 0);
177  if (sp != 0)
178  REGS_SP(p->thread.regs.regs.gp) = sp;
179 
181 
182  arch_copy_thread(&current->thread.arch, &p->thread.arch);
183  } else {
184  get_safe_registers(p->thread.regs.regs.gp, p->thread.regs.regs.fp);
185  p->thread.request.u.thread.proc = (int (*)(void *))sp;
186  p->thread.request.u.thread.arg = (void *)arg;
188  }
189 
190  new_thread(task_stack_page(p), &p->thread.switch_buf, handler);
191 
192  if (!kthread) {
194 
195  /*
196  * Set a new TLS for the child thread?
197  */
198  if (clone_flags & CLONE_SETTLS)
199  ret = arch_copy_tls(p);
200  }
201 
202  return ret;
203 }
204 
205 void initial_thread_cb(void (*proc)(void *), void *arg)
206 {
207  int save_kmalloc_ok = kmalloc_ok;
208 
209  kmalloc_ok = 0;
211  kmalloc_ok = save_kmalloc_ok;
212 }
213 
214 void default_idle(void)
215 {
216  unsigned long long nsecs;
217 
218  while (1) {
219  /* endless idle loop with no priority at all */
220 
221  /*
222  * although we are an idle CPU, we do not want to
223  * get into the scheduler unnecessarily.
224  */
225  if (need_resched())
226  schedule();
227 
228  tick_nohz_idle_enter();
229  rcu_idle_enter();
230  nsecs = disable_timer();
231  idle_sleep(nsecs);
232  rcu_idle_exit();
233  tick_nohz_idle_exit();
234  }
235 }
236 
237 void cpu_idle(void)
238 {
239  cpu_tasks[current_thread_info()->cpu].pid = os_getpid();
240  default_idle();
241 }
242 
243 int __cant_sleep(void) {
244  return in_atomic() || irqs_disabled() || in_interrupt();
245  /* Is in_interrupt() really needed? */
246 }
247 
248 int user_context(unsigned long sp)
249 {
250  unsigned long stack;
251 
252  stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
253  return stack != (unsigned long) current_thread_info();
254 }
255 
257 
259 {
260  exitcall_t *call;
261 
262  call = &__uml_exitcall_end;
263  while (--call >= &__uml_exitcall_begin)
264  (*call)();
265 }
266 
267 char *uml_strdup(const char *string)
268 {
269  return kstrdup(string, GFP_KERNEL);
270 }
272 
273 int copy_to_user_proc(void __user *to, void *from, int size)
274 {
275  return copy_to_user(to, from, size);
276 }
277 
278 int copy_from_user_proc(void *to, void __user *from, int size)
279 {
280  return copy_from_user(to, from, size);
281 }
282 
283 int clear_user_proc(void __user *buf, int size)
284 {
285  return clear_user(buf, size);
286 }
287 
288 int strlen_user_proc(char __user *str)
289 {
290  return strlen_user(str);
291 }
292 
294 {
295 #ifdef CONFIG_SMP
296  int cpu = current_thread_info()->cpu;
297  IPI_handler(cpu);
298  if (cpu != 0)
299  return 1;
300 #endif
301  return 0;
302 }
303 
304 int cpu(void)
305 {
306  return current_thread_info()->cpu;
307 }
308 
309 static atomic_t using_sysemu = ATOMIC_INIT(0);
311 
313 {
314  if (value > sysemu_supported)
315  return;
316  atomic_set(&using_sysemu, value);
317 }
318 
320 {
321  return atomic_read(&using_sysemu);
322 }
323 
324 static int sysemu_proc_show(struct seq_file *m, void *v)
325 {
326  seq_printf(m, "%d\n", get_using_sysemu());
327  return 0;
328 }
329 
330 static int sysemu_proc_open(struct inode *inode, struct file *file)
331 {
332  return single_open(file, sysemu_proc_show, NULL);
333 }
334 
335 static ssize_t sysemu_proc_write(struct file *file, const char __user *buf,
336  size_t count, loff_t *pos)
337 {
338  char tmp[2];
339 
340  if (copy_from_user(tmp, buf, 1))
341  return -EFAULT;
342 
343  if (tmp[0] >= '0' && tmp[0] <= '2')
344  set_using_sysemu(tmp[0] - '0');
345  /* We use the first char, but pretend to write everything */
346  return count;
347 }
348 
349 static const struct file_operations sysemu_proc_fops = {
350  .owner = THIS_MODULE,
351  .open = sysemu_proc_open,
352  .read = seq_read,
353  .llseek = seq_lseek,
354  .release = single_release,
355  .write = sysemu_proc_write,
356 };
357 
359 {
360  struct proc_dir_entry *ent;
361  if (!sysemu_supported)
362  return 0;
363 
364  ent = proc_create("sysemu", 0600, NULL, &sysemu_proc_fops);
365 
366  if (ent == NULL)
367  {
368  printk(KERN_WARNING "Failed to register /proc/sysemu\n");
369  return 0;
370  }
371 
372  return 0;
373 }
374 
376 
377 int singlestepping(void * t)
378 {
379  struct task_struct *task = t ? t : current;
380 
381  if (!(task->ptrace & PT_DTRACE))
382  return 0;
383 
384  if (task->thread.singlestep_syscall)
385  return 1;
386 
387  return 2;
388 }
389 
390 /*
391  * Only x86 and x86_64 have an arch_align_stack().
392  * All other arches have "#define arch_align_stack(x) (x)"
393  * in their asm/system.h
394  * As this is included in UML from asm-um/system-generic.h,
395  * we can use it to behave as the subarch does.
396  */
397 #ifndef arch_align_stack
398 unsigned long arch_align_stack(unsigned long sp)
399 {
400  if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
401  sp -= get_random_int() % 8192;
402  return sp & ~0xf;
403 }
404 #endif
405 
406 unsigned long get_wchan(struct task_struct *p)
407 {
408  unsigned long stack_page, sp, ip;
409  bool seen_sched = 0;
410 
411  if ((p == NULL) || (p == current) || (p->state == TASK_RUNNING))
412  return 0;
413 
414  stack_page = (unsigned long) task_stack_page(p);
415  /* Bail if the process has no kernel stack for some reason */
416  if (stack_page == 0)
417  return 0;
418 
419  sp = p->thread.switch_buf->JB_SP;
420  /*
421  * Bail if the stack pointer is below the bottom of the kernel
422  * stack for some reason
423  */
424  if (sp < stack_page)
425  return 0;
426 
427  while (sp < stack_page + THREAD_SIZE) {
428  ip = *((unsigned long *) sp);
429  if (in_sched_functions(ip))
430  /* Ignore everything until we're above the scheduler */
431  seen_sched = 1;
432  else if (kernel_text_address(ip) && seen_sched)
433  return ip;
434 
435  sp += sizeof(unsigned long);
436  }
437 
438  return 0;
439 }
440 
442 {
443  int cpu = current_thread_info()->cpu;
444 
445  return save_fp_registers(userspace_pid[cpu], (unsigned long *) fpu);
446 }
447