开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
process.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：22k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

process.c：源码内容
  1. /*  $Id: process.c,v 1.125.2.1 2001/12/18 19:40:17 davem Exp $
  2.  *  arch/sparc64/kernel/process.c
  3.  *
  4.  *  Copyright (C) 1995, 1996 David S. Miller (davem@caip.rutgers.edu)
  5.  *  Copyright (C) 1996       Eddie C. Dost   (ecd@skynet.be)
  6.  *  Copyright (C) 1997, 1998 Jakub Jelinek   (jj@sunsite.mff.cuni.cz)
  7.  */
  9. /*
  10.  * This file handles the architecture-dependent parts of process handling..
  11.  */
  13. #define __KERNEL_SYSCALLS__
  14. #include <stdarg.h>
  16. #include <linux/errno.h>
  17. #include <linux/sched.h>
  18. #include <linux/kernel.h>
  19. #include <linux/mm.h>
  20. #include <linux/smp.h>
  21. #include <linux/smp_lock.h>
  22. #include <linux/stddef.h>
  23. #include <linux/unistd.h>
  24. #include <linux/ptrace.h>
  25. #include <linux/slab.h>
  26. #include <linux/user.h>
  27. #include <linux/a.out.h>
  28. #include <linux/config.h>
  29. #include <linux/reboot.h>
  30. #include <linux/delay.h>
  32. #include <asm/oplib.h>
  33. #include <asm/uaccess.h>
  34. #include <asm/system.h>
  35. #include <asm/page.h>
  36. #include <asm/pgalloc.h>
  37. #include <asm/pgtable.h>
  38. #include <asm/processor.h>
  39. #include <asm/pstate.h>
  40. #include <asm/elf.h>
  41. #include <asm/fpumacro.h>
  43. /* #define VERBOSE_SHOWREGS */
  45. #ifndef CONFIG_SMP
  47. /*
  48.  * the idle loop on a Sparc... ;)
  49.  */
  50. int cpu_idle(void)
  51. {
  52. if (current->pid != 0)
  53. return -EPERM;
  55. /* endless idle loop with no priority at all */
  56. current->nice = 20;
  57. current->counter = -100;
  58. init_idle();
  60. for (;;) {
  61. /* If current->need_resched is zero we should really
  62.  * setup for a system wakup event and execute a shutdown
  63.  * instruction.
  64.  *
  65.  * But this requires writing back the contents of the
  66.  * L2 cache etc. so implement this later. -DaveM
  67.  */
  68. while (!current->need_resched)
  69. barrier();
  71. schedule();
  72. check_pgt_cache();
  73. }
  74. return 0;
  75. }
  77. #else
  79. /*
  80.  * the idle loop on a UltraMultiPenguin...
  81.  */
  82. #define idle_me_harder() (cpu_data[current->processor].idle_volume += 1)
  83. #define unidle_me() (cpu_data[current->processor].idle_volume = 0)
  84. int cpu_idle(void)
  85. {
  86. current->nice = 20;
  87. current->counter = -100;
  88. init_idle();
  90. while(1) {
  91. if (current->need_resched != 0) {
  92. unidle_me();
  93. schedule();
  94. check_pgt_cache();
  95. }
  96. idle_me_harder();
  98. /* The store ordering is so that IRQ handlers on
  99.  * other cpus see our increasing idleness for the buddy
  100.  * redistribution algorithm.  -DaveM
  101.  */
  102. membar("#StoreStore | #StoreLoad");
  103. }
  104. }
  106. #endif
  108. extern char reboot_command [];
  110. #ifdef CONFIG_SUN_CONSOLE
  111. extern void (*prom_palette)(int);
  112. extern int serial_console;
  113. #endif
  114. extern void (*prom_keyboard)(void);
  116. void machine_halt(void)
  117. {
  118. sti();
  119. mdelay(8);
  120. cli();
  121. #ifdef CONFIG_SUN_CONSOLE
  122. if (!serial_console && prom_palette)
  123. prom_palette (1);
  124. #endif
  125. if (prom_keyboard)
  126. prom_keyboard();
  127. prom_halt();
  128. panic("Halt failed!");
  129. }
  131. void machine_restart(char * cmd)
  132. {
  133. char *p;
  135. sti();
  136. mdelay(8);
  137. cli();
  139. p = strchr (reboot_command, 'n');
  140. if (p) *p = 0;
  141. #ifdef CONFIG_SUN_CONSOLE
  142. if (!serial_console && prom_palette)
  143. prom_palette (1);
  144. #endif
  145. if (prom_keyboard)
  146. prom_keyboard();
  147. if (cmd)
  148. prom_reboot(cmd);
  149. if (*reboot_command)
  150. prom_reboot(reboot_command);
  151. prom_reboot("");
  152. panic("Reboot failed!");
  153. }
  155. static void show_regwindow32(struct pt_regs *regs)
  156. {
  157. struct reg_window32 *rw;
  158. struct reg_window32 r_w;
  159. mm_segment_t old_fs;
  161. __asm__ __volatile__ ("flushw");
  162. rw = (struct reg_window32 *)((long)(unsigned)regs->u_regs[14]);
  163. old_fs = get_fs();
  164. set_fs (USER_DS);
  165. if (copy_from_user (&r_w, rw, sizeof(r_w))) {
  166. set_fs (old_fs);
  167. return;
  168. }
  169. rw = &r_w;
  170. set_fs (old_fs);
  171. printk("l0: %08x l1: %08x l2: %08x l3: %08x "
  172.        "l4: %08x l5: %08x l6: %08x l7: %08xn",
  173.        rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3],
  174.        rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]);
  175. printk("i0: %08x i1: %08x i2: %08x i3: %08x "
  176.        "i4: %08x i5: %08x i6: %08x i7: %08xn",
  177.        rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
  178.        rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]);
  179. }
  181. static void show_regwindow(struct pt_regs *regs)
  182. {
  183. struct reg_window *rw;
  184. struct reg_window r_w;
  185. mm_segment_t old_fs;
  187. if ((regs->tstate & TSTATE_PRIV) || !(current->thread.flags & SPARC_FLAG_32BIT)) {
  188. __asm__ __volatile__ ("flushw");
  189. rw = (struct reg_window *)(regs->u_regs[14] + STACK_BIAS);
  190. if (!(regs->tstate & TSTATE_PRIV)) {
  191. old_fs = get_fs();
  192. set_fs (USER_DS);
  193. if (copy_from_user (&r_w, rw, sizeof(r_w))) {
  194. set_fs (old_fs);
  195. return;
  196. }
  197. rw = &r_w;
  198. set_fs (old_fs);
  199. }
  200. } else {
  201. show_regwindow32(regs);
  202. return;
  203. }
  204. printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lxn",
  205.        rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3]);
  206. printk("l4: %016lx l5: %016lx l6: %016lx l7: %016lxn",
  207.        rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]);
  208. printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lxn",
  209.        rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3]);
  210. printk("i4: %016lx i5: %016lx i6: %016lx i7: %016lxn",
  211.        rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]);
  212. }
  214. void show_stackframe(struct sparc_stackf *sf)
  215. {
  216. unsigned long size;
  217. unsigned long *stk;
  218. int i;
  220. printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lxn"
  221.        "l4: %016lx l5: %016lx l6: %016lx l7: %016lxn",
  222.        sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3],
  223.        sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
  224. printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lxn"
  225.        "i4: %016lx i5: %016lx fp: %016lx ret_pc: %016lxn",
  226.        sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3],
  227.        sf->ins[4], sf->ins[5], (unsigned long)sf->fp, sf->callers_pc);
  228. printk("sp: %016lx x0: %016lx x1: %016lx x2: %016lxn"
  229.        "x3: %016lx x4: %016lx x5: %016lx xx: %016lxn",
  230.        (unsigned long)sf->structptr, sf->xargs[0], sf->xargs[1],
  231.        sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
  232.        sf->xxargs[0]);
  233. size = ((unsigned long)sf->fp) - ((unsigned long)sf);
  234. size -= STACKFRAME_SZ;
  235. stk = (unsigned long *)((unsigned long)sf + STACKFRAME_SZ);
  236. i = 0;
  237. do {
  238. printk("s%d: %016lxn", i++, *stk++);
  239. } while ((size -= sizeof(unsigned long)));
  240. }
  242. void show_stackframe32(struct sparc_stackf32 *sf)
  243. {
  244. unsigned long size;
  245. unsigned *stk;
  246. int i;
  248. printk("l0: %08x l1: %08x l2: %08x l3: %08xn",
  249.        sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3]);
  250. printk("l4: %08x l5: %08x l6: %08x l7: %08xn",
  251.        sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
  252. printk("i0: %08x i1: %08x i2: %08x i3: %08xn",
  253.        sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3]);
  254. printk("i4: %08x i5: %08x fp: %08x ret_pc: %08xn",
  255.        sf->ins[4], sf->ins[5], sf->fp, sf->callers_pc);
  256. printk("sp: %08x x0: %08x x1: %08x x2: %08xn"
  257.        "x3: %08x x4: %08x x5: %08x xx: %08xn",
  258.        sf->structptr, sf->xargs[0], sf->xargs[1],
  259.        sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
  260.        sf->xxargs[0]);
  261. size = ((unsigned long)sf->fp) - ((unsigned long)sf);
  262. size -= STACKFRAME32_SZ;
  263. stk = (unsigned *)((unsigned long)sf + STACKFRAME32_SZ);
  264. i = 0;
  265. do {
  266. printk("s%d: %08xn", i++, *stk++);
  267. } while ((size -= sizeof(unsigned)));
  268. }
  270. #ifdef CONFIG_SMP
  271. static spinlock_t regdump_lock = SPIN_LOCK_UNLOCKED;
  272. #endif
  274. void __show_regs(struct pt_regs * regs)
  275. {
  276. #ifdef CONFIG_SMP
  277. unsigned long flags;
  279. /* Protect against xcall ipis which might lead to livelock on the lock */
  280. __asm__ __volatile__("rdpr      %%pstate, %0nt"
  281.      "wrpr      %0, %1, %%pstate"
  282.      : "=r" (flags)
  283.      : "i" (PSTATE_IE));
  284. spin_lock(&regdump_lock);
  285. printk("CPU[%d]: local_irq_count[%u] irqs_running[%d]n",
  286.        smp_processor_id(),
  287.        local_irq_count(smp_processor_id()),
  288.        irqs_running());
  289. #endif
  290. printk("TSTATE: %016lx TPC: %016lx TNPC: %016lx Y: %08x    %sn", regs->tstate,
  291.        regs->tpc, regs->tnpc, regs->y, print_tainted());
  292. printk("g0: %016lx g1: %016lx g2: %016lx g3: %016lxn",
  293.        regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
  294.        regs->u_regs[3]);
  295. printk("g4: %016lx g5: %016lx g6: %016lx g7: %016lxn",
  296.        regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
  297.        regs->u_regs[7]);
  298. printk("o0: %016lx o1: %016lx o2: %016lx o3: %016lxn",
  299.        regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
  300.        regs->u_regs[11]);
  301. printk("o4: %016lx o5: %016lx sp: %016lx ret_pc: %016lxn",
  302.        regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
  303.        regs->u_regs[15]);
  304. show_regwindow(regs);
  305. #ifdef CONFIG_SMP
  306. spin_unlock(&regdump_lock);
  307. __asm__ __volatile__("wrpr %0, 0, %%pstate"
  308.      : : "r" (flags));
  309. #endif
  310. }
  312. #ifdef VERBOSE_SHOWREGS
  313. static void idump_from_user (unsigned int *pc)
  314. {
  315. int i;
  316. int code;
  318. if((((unsigned long) pc) & 3))
  319. return;
  321. pc -= 3;
  322. for(i = -3; i < 6; i++) {
  323. get_user(code, pc);
  324. printk("%c%08x%c",i?' ':'<',code,i?' ':'>');
  325. pc++;
  326. }
  327. printk("n");
  328. }
  329. #endif
  331. void show_regs(struct pt_regs *regs)
  332. {
  333. #ifdef VERBOSE_SHOWREGS
  334. extern long etrap, etraptl1;
  335. #endif
  336. __show_regs(regs);
  337. #ifdef CONFIG_SMP
  338. {
  339. extern void smp_report_regs(void);
  341. smp_report_regs();
  342. }
  343. #endif
  345. #ifdef VERBOSE_SHOWREGS
  346. if (regs->tpc >= &etrap && regs->tpc < &etraptl1 &&
  347.     regs->u_regs[14] >= (long)current - PAGE_SIZE &&
  348.     regs->u_regs[14] < (long)current + 6 * PAGE_SIZE) {
  349. printk ("*********parent**********n");
  350. __show_regs((struct pt_regs *)(regs->u_regs[14] + STACK_BIAS + REGWIN_SZ));
  351. idump_from_user(((struct pt_regs *)(regs->u_regs[14] + STACK_BIAS + REGWIN_SZ))->tpc);
  352. printk ("*********endpar**********n");
  353. }
  354. #endif
  355. }
  357. void show_regs32(struct pt_regs32 *regs)
  358. {
  359. printk("PSR: %08x PC: %08x NPC: %08x Y: %08x    %sn", regs->psr,
  360.        regs->pc, regs->npc, regs->y, print_tainted());
  361. printk("g0: %08x g1: %08x g2: %08x g3: %08x ",
  362.        regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
  363.        regs->u_regs[3]);
  364. printk("g4: %08x g5: %08x g6: %08x g7: %08xn",
  365.        regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
  366.        regs->u_regs[7]);
  367. printk("o0: %08x o1: %08x o2: %08x o3: %08x ",
  368.        regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
  369.        regs->u_regs[11]);
  370. printk("o4: %08x o5: %08x sp: %08x ret_pc: %08xn",
  371.        regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
  372.        regs->u_regs[15]);
  373. }
  375. void show_thread(struct thread_struct *thread)
  376. {
  377. int i;
  379. #if 0
  380. printk("kregs:             0x%016lxn", (unsigned long)thread->kregs);
  381. show_regs(thread->kregs);
  382. #endif
  383. printk("ksp:               0x%016lxn", thread->ksp);
  385. if (thread->w_saved) {
  386. for (i = 0; i < NSWINS; i++) {
  387. if (!thread->rwbuf_stkptrs[i])
  388. continue;
  389. printk("reg_window[%d]:n", i);
  390. printk("stack ptr:         0x%016lxn", thread->rwbuf_stkptrs[i]);
  391. }
  392. printk("w_saved:           0x%04xn", thread->w_saved);
  393. }
  395. printk("flags:             0x%08xn", thread->flags);
  396. printk("current_ds:        0x%xn", thread->current_ds.seg);
  397. }
  399. /* Free current thread data structures etc.. */
  400. void exit_thread(void)
  401. {
  402. struct thread_struct *t = &current->thread;
  404. if (t->utraps) {
  405. if (t->utraps[0] < 2)
  406. kfree (t->utraps);
  407. else
  408. t->utraps[0]--;
  409. }
  411. /* Turn off performance counters if on. */
  412. if (t->flags & SPARC_FLAG_PERFCTR) {
  413. t->user_cntd0 = t->user_cntd1 = NULL;
  414. t->pcr_reg = 0;
  415. t->flags &= ~(SPARC_FLAG_PERFCTR);
  416. write_pcr(0);
  417. }
  418. }
  420. void flush_thread(void)
  421. {
  422. struct thread_struct *t = &current->thread;
  424. if (current->mm) {
  425. if (t->flags & SPARC_FLAG_32BIT) {
  426. struct mm_struct *mm = current->mm;
  427. pgd_t *pgd0 = &mm->pgd[0];
  428. unsigned long pgd_cache;
  430. if (pgd_none(*pgd0)) {
  431. pmd_t *page = pmd_alloc_one_fast(NULL, 0);
  432. if (!page)
  433. page = pmd_alloc_one(NULL, 0);
  434. pgd_set(pgd0, page);
  435. }
  436. pgd_cache = pgd_val(*pgd0) << 11UL;
  437. __asm__ __volatile__("stxa %0, [%1] %2nt"
  438.      "membar #Sync"
  439.      : /* no outputs */
  440.      : "r" (pgd_cache),
  441.        "r" (TSB_REG),
  442.        "i" (ASI_DMMU));
  443. }
  444. }
  445. t->w_saved = 0;
  447. /* Turn off performance counters if on. */
  448. if (t->flags & SPARC_FLAG_PERFCTR) {
  449. t->user_cntd0 = t->user_cntd1 = NULL;
  450. t->pcr_reg = 0;
  451. t->flags &= ~(SPARC_FLAG_PERFCTR);
  452. write_pcr(0);
  453. }
  455. /* Clear FPU register state. */
  456. t->fpsaved[0] = 0;
  458. if (t->current_ds.seg != ASI_AIUS)
  459. set_fs(USER_DS);
  461. /* Init new signal delivery disposition. */
  462. t->flags &= ~SPARC_FLAG_NEWSIGNALS;
  463. }
  465. /* It's a bit more tricky when 64-bit tasks are involved... */
  466. static unsigned long clone_stackframe(unsigned long csp, unsigned long psp)
  467. {
  468. unsigned long fp, distance, rval;
  470. if (!(current->thread.flags & SPARC_FLAG_32BIT)) {
  471. csp += STACK_BIAS;
  472. psp += STACK_BIAS;
  473. __get_user(fp, &(((struct reg_window *)psp)->ins[6]));
  474. fp += STACK_BIAS;
  475. } else
  476. __get_user(fp, &(((struct reg_window32 *)psp)->ins[6]));
  478. /* Now 8-byte align the stack as this is mandatory in the
  479.  * Sparc ABI due to how register windows work.  This hides
  480.  * the restriction from thread libraries etc.  -DaveM
  481.  */
  482. csp &= ~7UL;
  484. distance = fp - psp;
  485. rval = (csp - distance);
  486. if (copy_in_user(rval, psp, distance))
  487. rval = 0;
  488. else if (current->thread.flags & SPARC_FLAG_32BIT) {
  489. if (put_user(((u32)csp), &(((struct reg_window32 *)rval)->ins[6])))
  490. rval = 0;
  491. } else {
  492. if (put_user(((u64)csp - STACK_BIAS),
  493.      &(((struct reg_window *)rval)->ins[6])))
  494. rval = 0;
  495. else
  496. rval = rval - STACK_BIAS;
  497. }
  499. return rval;
  500. }
  502. /* Standard stuff. */
  503. static inline void shift_window_buffer(int first_win, int last_win,
  504.        struct thread_struct *t)
  505. {
  506. int i;
  508. for (i = first_win; i < last_win; i++) {
  509. t->rwbuf_stkptrs[i] = t->rwbuf_stkptrs[i+1];
  510. memcpy(&t->reg_window[i], &t->reg_window[i+1],
  511.        sizeof(struct reg_window));
  512. }
  513. }
  515. void synchronize_user_stack(void)
  516. {
  517. struct thread_struct *t = &current->thread;
  518. unsigned long window;
  520. flush_user_windows();
  521. if ((window = t->w_saved) != 0) {
  522. int winsize = REGWIN_SZ;
  523. int bias = 0;
  525. if (t->flags & SPARC_FLAG_32BIT)
  526. winsize = REGWIN32_SZ;
  527. else
  528. bias = STACK_BIAS;
  530. window -= 1;
  531. do {
  532. unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
  533. struct reg_window *rwin = &t->reg_window[window];
  535. if (!copy_to_user((char *)sp, rwin, winsize)) {
  536. shift_window_buffer(window, t->w_saved - 1, t);
  537. t->w_saved--;
  538. }
  539. } while (window--);
  540. }
  541. }
  543. void fault_in_user_windows(void)
  544. {
  545. struct thread_struct *t = &current->thread;
  546. unsigned long window;
  547. int winsize = REGWIN_SZ;
  548. int bias = 0;
  550. if (t->flags & SPARC_FLAG_32BIT)
  551. winsize = REGWIN32_SZ;
  552. else
  553. bias = STACK_BIAS;
  555. flush_user_windows();
  556. window = t->w_saved;
  558. if (window != 0) {
  559. window -= 1;
  560. do {
  561. unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
  562. struct reg_window *rwin = &t->reg_window[window];
  564. if (copy_to_user((char *)sp, rwin, winsize))
  565. goto barf;
  566. } while (window--);
  567. }
  568. t->w_saved = 0;
  569. return;
  571. barf:
  572. t->w_saved = window + 1;
  573. do_exit(SIGILL);
  574. }
  576. /* Copy a Sparc thread.  The fork() return value conventions
  577.  * under SunOS are nothing short of bletcherous:
  578.  * Parent -->  %o0 == childs  pid, %o1 == 0
  579.  * Child  -->  %o0 == parents pid, %o1 == 1
  580.  *
  581.  * NOTE: We have a separate fork kpsr/kwim because
  582.  *       the parent could change these values between
  583.  *       sys_fork invocation and when we reach here
  584.  *       if the parent should sleep while trying to
  585.  *       allocate the task_struct and kernel stack in
  586.  *       do_fork().
  587.  */
  588. int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
  589. unsigned long unused,
  590. struct task_struct *p, struct pt_regs *regs)
  591. {
  592. struct thread_struct *t = &p->thread;
  593. char *child_trap_frame;
  595. #ifdef CONFIG_DEBUG_SPINLOCK
  596. t->smp_lock_count = 0;
  597. t->smp_lock_pc = 0;
  598. #endif
  600. /* Calculate offset to stack_frame & pt_regs */
  601. child_trap_frame = ((char *)p) + (THREAD_SIZE - (TRACEREG_SZ+REGWIN_SZ));
  602. memcpy(child_trap_frame, (((struct reg_window *)regs)-1), (TRACEREG_SZ+REGWIN_SZ));
  603. t->ksp = ((unsigned long) child_trap_frame) - STACK_BIAS;
  604. t->flags |= SPARC_FLAG_NEWCHILD;
  605. t->kregs = (struct pt_regs *)(child_trap_frame+sizeof(struct reg_window));
  606. t->cwp = (regs->tstate + 1) & TSTATE_CWP;
  607. t->fpsaved[0] = 0;
  609. if (regs->tstate & TSTATE_PRIV) {
  610. /* Special case, if we are spawning a kernel thread from
  611.  * a userspace task (via KMOD, NFS, or similar) we must
  612.  * disable performance counters in the child because the
  613.  * address space and protection realm are changing.
  614.  */
  615. if (t->flags & SPARC_FLAG_PERFCTR) {
  616. t->user_cntd0 = t->user_cntd1 = NULL;
  617. t->pcr_reg = 0;
  618. t->flags &= ~(SPARC_FLAG_PERFCTR);
  619. }
  620. t->kregs->u_regs[UREG_FP] = p->thread.ksp;
  621. t->current_ds = KERNEL_DS;
  622. flush_register_windows();
  623. memcpy((void *)(t->ksp + STACK_BIAS),
  624.        (void *)(regs->u_regs[UREG_FP] + STACK_BIAS),
  625.        sizeof(struct reg_window));
  626. t->kregs->u_regs[UREG_G6] = (unsigned long) p;
  627. } else {
  628. if (t->flags & SPARC_FLAG_32BIT) {
  629. sp &= 0x00000000ffffffffUL;
  630. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  631. }
  632. t->kregs->u_regs[UREG_FP] = sp;
  633. t->current_ds = USER_DS;
  634. if (sp != regs->u_regs[UREG_FP]) {
  635. unsigned long csp;
  637. csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
  638. if (!csp)
  639. return -EFAULT;
  640. t->kregs->u_regs[UREG_FP] = csp;
  641. }
  642. if (t->utraps)
  643. t->utraps[0]++;
  644. }
  646. /* Set the return value for the child. */
  647. t->kregs->u_regs[UREG_I0] = current->pid;
  648. t->kregs->u_regs[UREG_I1] = 1;
  650. /* Set the second return value for the parent. */
  651. regs->u_regs[UREG_I1] = 0;
  653. return 0;
  654. }
  656. /*
  657.  * This is the mechanism for creating a new kernel thread.
  658.  *
  659.  * NOTE! Only a kernel-only process(ie the swapper or direct descendants
  660.  * who haven't done an "execve()") should use this: it will work within
  661.  * a system call from a "real" process, but the process memory space will
  662.  * not be free'd until both the parent and the child have exited.
  663.  */
  664. pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
  665. {
  666. long retval;
  668. /* If the parent runs before fn(arg) is called by the child,
  669.  * the input registers of this function can be clobbered.
  670.  * So we stash 'fn' and 'arg' into global registers which
  671.  * will not be modified by the parent.
  672.  */
  673. __asm__ __volatile("mov %4, %%g2nt"    /* Save FN into global */
  674.    "mov %5, %%g3nt"    /* Save ARG into global */
  675.    "mov %1, %%g1nt"    /* Clone syscall nr. */
  676.    "mov %2, %%o0nt"    /* Clone flags. */
  677.    "mov 0, %%o1nt"    /* usp arg == 0 */
  678.    "t 0x6dnt"    /* Linux/Sparc clone(). */
  679.    "brz,a,pn %%o1, 1fnt" /* Parent, just return. */
  680.    " mov %%o0, %0nt"
  681.    "jmpl %%g2, %%o7nt"   /* Call the function. */
  682.    " mov %%g3, %%o0nt"   /* Set arg in delay. */
  683.    "mov %3, %%g1nt"
  684.    "t 0x6dnt"    /* Linux/Sparc exit(). */
  685.    /* Notreached by child. */
  686.    "1:" :
  687.    "=r" (retval) :
  688.    "i" (__NR_clone), "r" (flags | CLONE_VM),
  689.    "i" (__NR_exit),  "r" (fn), "r" (arg) :
  690.    "g1", "g2", "g3", "o0", "o1", "memory", "cc");
  691. return retval;
  692. }
  694. /*
  695.  * fill in the user structure for a core dump..
  696.  */
  697. void dump_thread(struct pt_regs * regs, struct user * dump)
  698. {
  699. #if 1
  700. /* Only should be used for SunOS and ancient a.out
  701.  * SparcLinux binaries...  Fixme some day when bored.
  702.  * But for now at least plug the security hole :-)
  703.  */
  704. memset(dump, 0, sizeof(struct user));
  705. #else
  706. unsigned long first_stack_page;
  707. dump->magic = SUNOS_CORE_MAGIC;
  708. dump->len = sizeof(struct user);
  709. dump->regs.psr = regs->psr;
  710. dump->regs.pc = regs->pc;
  711. dump->regs.npc = regs->npc;
  712. dump->regs.y = regs->y;
  713. /* fuck me plenty */
  714. memcpy(&dump->regs.regs[0], &regs->u_regs[1], (sizeof(unsigned long) * 15));
  715. dump->u_tsize = (((unsigned long) current->mm->end_code) -
  716. ((unsigned long) current->mm->start_code)) & ~(PAGE_SIZE - 1);
  717. dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1)));
  718. dump->u_dsize -= dump->u_tsize;
  719. dump->u_dsize &= ~(PAGE_SIZE - 1);
  720. first_stack_page = (regs->u_regs[UREG_FP] & ~(PAGE_SIZE - 1));
  721. dump->u_ssize = (TASK_SIZE - first_stack_page) & ~(PAGE_SIZE - 1);
  722. memcpy(&dump->fpu.fpstatus.fregs.regs[0], &current->thread.float_regs[0], (sizeof(unsigned long) * 32));
  723. dump->fpu.fpstatus.fsr = current->thread.fsr;
  724. dump->fpu.fpstatus.flags = dump->fpu.fpstatus.extra = 0;
  725. #endif
  726. }
  728. typedef struct {
  729. union {
  730. unsigned int pr_regs[32];
  731. unsigned long pr_dregs[16];
  732. } pr_fr;
  733. unsigned int __unused;
  734. unsigned int pr_fsr;
  735. unsigned char pr_qcnt;
  736. unsigned char pr_q_entrysize;
  737. unsigned char pr_en;
  738. unsigned int pr_q[64];
  739. } elf_fpregset_t32;
  741. /*
  742.  * fill in the fpu structure for a core dump.
  743.  */
  744. int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
  745. {
  746. unsigned long *kfpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
  747. unsigned long fprs = current->thread.fpsaved[0];
  749. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  750. elf_fpregset_t32 *fpregs32 = (elf_fpregset_t32 *)fpregs;
  752. if (fprs & FPRS_DL)
  753. memcpy(&fpregs32->pr_fr.pr_regs[0], kfpregs,
  754.        sizeof(unsigned int) * 32);
  755. else
  756. memset(&fpregs32->pr_fr.pr_regs[0], 0,
  757.        sizeof(unsigned int) * 32);
  758. fpregs32->pr_qcnt = 0;
  759. fpregs32->pr_q_entrysize = 8;
  760. memset(&fpregs32->pr_q[0], 0,
  761.        (sizeof(unsigned int) * 64));
  762. if (fprs & FPRS_FEF) {
  763. fpregs32->pr_fsr = (unsigned int) current->thread.xfsr[0];
  764. fpregs32->pr_en = 1;
  765. } else {
  766. fpregs32->pr_fsr = 0;
  767. fpregs32->pr_en = 0;
  768. }
  769. } else {
  770. if(fprs & FPRS_DL)
  771. memcpy(&fpregs->pr_regs[0], kfpregs,
  772.        sizeof(unsigned int) * 32);
  773. else
  774. memset(&fpregs->pr_regs[0], 0,
  775.        sizeof(unsigned int) * 32);
  776. if(fprs & FPRS_DU)
  777. memcpy(&fpregs->pr_regs[16], kfpregs+16,
  778.        sizeof(unsigned int) * 32);
  779. else
  780. memset(&fpregs->pr_regs[16], 0,
  781.        sizeof(unsigned int) * 32);
  782. if(fprs & FPRS_FEF) {
  783. fpregs->pr_fsr = current->thread.xfsr[0];
  784. fpregs->pr_gsr = current->thread.gsr[0];
  785. } else {
  786. fpregs->pr_fsr = fpregs->pr_gsr = 0;
  787. }
  788. fpregs->pr_fprs = fprs;
  789. }
  790. return 1;
  791. }
  793. /*
  794.  * sparc_execve() executes a new program after the asm stub has set
  795.  * things up for us.  This should basically do what I want it to.
  796.  */
  797. asmlinkage int sparc_execve(struct pt_regs *regs)
  798. {
  799. int error, base = 0;
  800. char *filename;
  802. /* User register window flush is done by entry.S */
  804. /* Check for indirect call. */
  805. if (regs->u_regs[UREG_G1] == 0)
  806. base = 1;
  808. filename = getname((char *)regs->u_regs[base + UREG_I0]);
  809. error = PTR_ERR(filename);
  810. if (IS_ERR(filename))
  811. goto out;
  812. error = do_execve(filename, (char **) regs->u_regs[base + UREG_I1],
  813.   (char **) regs->u_regs[base + UREG_I2], regs);
  814. putname(filename);
  815. if (!error) {
  816. fprs_write(0);
  817. current->thread.xfsr[0] = 0;
  818. current->thread.fpsaved[0] = 0;
  819. regs->tstate &= ~TSTATE_PEF;
  820. }
  821. out:
  822. return error;
  823. }