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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
process.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：22k
源码类别：

Linux/Unix编程

开发平台：

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_alt_power_off(void)
  132. {
  133. sti();
  134. mdelay(8);
  135. cli();
  136. #ifdef CONFIG_SUN_CONSOLE
  137. if (!serial_console && prom_palette)
  138. prom_palette(1);
  139. #endif
  140. if (prom_keyboard)
  141. prom_keyboard();
  142. prom_halt_power_off();
  143. panic("Power-off failed!");
  144. }
  146. void machine_restart(char * cmd)
  147. {
  148. char *p;
  150. sti();
  151. mdelay(8);
  152. cli();
  154. p = strchr (reboot_command, 'n');
  155. if (p) *p = 0;
  156. #ifdef CONFIG_SUN_CONSOLE
  157. if (!serial_console && prom_palette)
  158. prom_palette (1);
  159. #endif
  160. if (prom_keyboard)
  161. prom_keyboard();
  162. if (cmd)
  163. prom_reboot(cmd);
  164. if (*reboot_command)
  165. prom_reboot(reboot_command);
  166. prom_reboot("");
  167. panic("Reboot failed!");
  168. }
  170. static void show_regwindow32(struct pt_regs *regs)
  171. {
  172. struct reg_window32 *rw;
  173. struct reg_window32 r_w;
  174. mm_segment_t old_fs;
  176. __asm__ __volatile__ ("flushw");
  177. rw = (struct reg_window32 *)((long)(unsigned)regs->u_regs[14]);
  178. old_fs = get_fs();
  179. set_fs (USER_DS);
  180. if (copy_from_user (&r_w, rw, sizeof(r_w))) {
  181. set_fs (old_fs);
  182. return;
  183. }
  184. rw = &r_w;
  185. set_fs (old_fs);
  186. printk("l0: %08x l1: %08x l2: %08x l3: %08x "
  187.        "l4: %08x l5: %08x l6: %08x l7: %08xn",
  188.        rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3],
  189.        rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]);
  190. printk("i0: %08x i1: %08x i2: %08x i3: %08x "
  191.        "i4: %08x i5: %08x i6: %08x i7: %08xn",
  192.        rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3],
  193.        rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]);
  194. }
  196. static void show_regwindow(struct pt_regs *regs)
  197. {
  198. struct reg_window *rw;
  199. struct reg_window r_w;
  200. mm_segment_t old_fs;
  202. if ((regs->tstate & TSTATE_PRIV) || !(current->thread.flags & SPARC_FLAG_32BIT)) {
  203. __asm__ __volatile__ ("flushw");
  204. rw = (struct reg_window *)(regs->u_regs[14] + STACK_BIAS);
  205. if (!(regs->tstate & TSTATE_PRIV)) {
  206. old_fs = get_fs();
  207. set_fs (USER_DS);
  208. if (copy_from_user (&r_w, rw, sizeof(r_w))) {
  209. set_fs (old_fs);
  210. return;
  211. }
  212. rw = &r_w;
  213. set_fs (old_fs);
  214. }
  215. } else {
  216. show_regwindow32(regs);
  217. return;
  218. }
  219. printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lxn",
  220.        rw->locals[0], rw->locals[1], rw->locals[2], rw->locals[3]);
  221. printk("l4: %016lx l5: %016lx l6: %016lx l7: %016lxn",
  222.        rw->locals[4], rw->locals[5], rw->locals[6], rw->locals[7]);
  223. printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lxn",
  224.        rw->ins[0], rw->ins[1], rw->ins[2], rw->ins[3]);
  225. printk("i4: %016lx i5: %016lx i6: %016lx i7: %016lxn",
  226.        rw->ins[4], rw->ins[5], rw->ins[6], rw->ins[7]);
  227. }
  229. void show_stackframe(struct sparc_stackf *sf)
  230. {
  231. unsigned long size;
  232. unsigned long *stk;
  233. int i;
  235. printk("l0: %016lx l1: %016lx l2: %016lx l3: %016lxn"
  236.        "l4: %016lx l5: %016lx l6: %016lx l7: %016lxn",
  237.        sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3],
  238.        sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
  239. printk("i0: %016lx i1: %016lx i2: %016lx i3: %016lxn"
  240.        "i4: %016lx i5: %016lx fp: %016lx ret_pc: %016lxn",
  241.        sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3],
  242.        sf->ins[4], sf->ins[5], (unsigned long)sf->fp, sf->callers_pc);
  243. printk("sp: %016lx x0: %016lx x1: %016lx x2: %016lxn"
  244.        "x3: %016lx x4: %016lx x5: %016lx xx: %016lxn",
  245.        (unsigned long)sf->structptr, sf->xargs[0], sf->xargs[1],
  246.        sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
  247.        sf->xxargs[0]);
  248. size = ((unsigned long)sf->fp) - ((unsigned long)sf);
  249. size -= STACKFRAME_SZ;
  250. stk = (unsigned long *)((unsigned long)sf + STACKFRAME_SZ);
  251. i = 0;
  252. do {
  253. printk("s%d: %016lxn", i++, *stk++);
  254. } while ((size -= sizeof(unsigned long)));
  255. }
  257. void show_stackframe32(struct sparc_stackf32 *sf)
  258. {
  259. unsigned long size;
  260. unsigned *stk;
  261. int i;
  263. printk("l0: %08x l1: %08x l2: %08x l3: %08xn",
  264.        sf->locals[0], sf->locals[1], sf->locals[2], sf->locals[3]);
  265. printk("l4: %08x l5: %08x l6: %08x l7: %08xn",
  266.        sf->locals[4], sf->locals[5], sf->locals[6], sf->locals[7]);
  267. printk("i0: %08x i1: %08x i2: %08x i3: %08xn",
  268.        sf->ins[0], sf->ins[1], sf->ins[2], sf->ins[3]);
  269. printk("i4: %08x i5: %08x fp: %08x ret_pc: %08xn",
  270.        sf->ins[4], sf->ins[5], sf->fp, sf->callers_pc);
  271. printk("sp: %08x x0: %08x x1: %08x x2: %08xn"
  272.        "x3: %08x x4: %08x x5: %08x xx: %08xn",
  273.        sf->structptr, sf->xargs[0], sf->xargs[1],
  274.        sf->xargs[2], sf->xargs[3], sf->xargs[4], sf->xargs[5],
  275.        sf->xxargs[0]);
  276. size = ((unsigned long)sf->fp) - ((unsigned long)sf);
  277. size -= STACKFRAME32_SZ;
  278. stk = (unsigned *)((unsigned long)sf + STACKFRAME32_SZ);
  279. i = 0;
  280. do {
  281. printk("s%d: %08xn", i++, *stk++);
  282. } while ((size -= sizeof(unsigned)));
  283. }
  285. #ifdef CONFIG_SMP
  286. static spinlock_t regdump_lock = SPIN_LOCK_UNLOCKED;
  287. #endif
  289. void __show_regs(struct pt_regs * regs)
  290. {
  291. #ifdef CONFIG_SMP
  292. unsigned long flags;
  294. /* Protect against xcall ipis which might lead to livelock on the lock */
  295. __asm__ __volatile__("rdpr      %%pstate, %0nt"
  296.      "wrpr      %0, %1, %%pstate"
  297.      : "=r" (flags)
  298.      : "i" (PSTATE_IE));
  299. spin_lock(&regdump_lock);
  300. printk("CPU[%d]: local_irq_count[%u] irqs_running[%d]n",
  301.        smp_processor_id(),
  302.        local_irq_count(smp_processor_id()),
  303.        irqs_running());
  304. #endif
  305. printk("TSTATE: %016lx TPC: %016lx TNPC: %016lx Y: %08x    %sn", regs->tstate,
  306.        regs->tpc, regs->tnpc, regs->y, print_tainted());
  307. printk("g0: %016lx g1: %016lx g2: %016lx g3: %016lxn",
  308.        regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
  309.        regs->u_regs[3]);
  310. printk("g4: %016lx g5: %016lx g6: %016lx g7: %016lxn",
  311.        regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
  312.        regs->u_regs[7]);
  313. printk("o0: %016lx o1: %016lx o2: %016lx o3: %016lxn",
  314.        regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
  315.        regs->u_regs[11]);
  316. printk("o4: %016lx o5: %016lx sp: %016lx ret_pc: %016lxn",
  317.        regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
  318.        regs->u_regs[15]);
  319. show_regwindow(regs);
  320. #ifdef CONFIG_SMP
  321. spin_unlock(&regdump_lock);
  322. __asm__ __volatile__("wrpr %0, 0, %%pstate"
  323.      : : "r" (flags));
  324. #endif
  325. }
  327. #ifdef VERBOSE_SHOWREGS
  328. static void idump_from_user (unsigned int *pc)
  329. {
  330. int i;
  331. int code;
  333. if((((unsigned long) pc) & 3))
  334. return;
  336. pc -= 3;
  337. for(i = -3; i < 6; i++) {
  338. get_user(code, pc);
  339. printk("%c%08x%c",i?' ':'<',code,i?' ':'>');
  340. pc++;
  341. }
  342. printk("n");
  343. }
  344. #endif
  346. void show_regs(struct pt_regs *regs)
  347. {
  348. #ifdef VERBOSE_SHOWREGS
  349. extern long etrap, etraptl1;
  350. #endif
  351. __show_regs(regs);
  352. #ifdef CONFIG_SMP
  353. {
  354. extern void smp_report_regs(void);
  356. smp_report_regs();
  357. }
  358. #endif
  360. #ifdef VERBOSE_SHOWREGS
  361. if (regs->tpc >= &etrap && regs->tpc < &etraptl1 &&
  362.     regs->u_regs[14] >= (long)current - PAGE_SIZE &&
  363.     regs->u_regs[14] < (long)current + 6 * PAGE_SIZE) {
  364. printk ("*********parent**********n");
  365. __show_regs((struct pt_regs *)(regs->u_regs[14] + STACK_BIAS + REGWIN_SZ));
  366. idump_from_user(((struct pt_regs *)(regs->u_regs[14] + STACK_BIAS + REGWIN_SZ))->tpc);
  367. printk ("*********endpar**********n");
  368. }
  369. #endif
  370. }
  372. void show_regs32(struct pt_regs32 *regs)
  373. {
  374. printk("PSR: %08x PC: %08x NPC: %08x Y: %08x    %sn", regs->psr,
  375.        regs->pc, regs->npc, regs->y, print_tainted());
  376. printk("g0: %08x g1: %08x g2: %08x g3: %08x ",
  377.        regs->u_regs[0], regs->u_regs[1], regs->u_regs[2],
  378.        regs->u_regs[3]);
  379. printk("g4: %08x g5: %08x g6: %08x g7: %08xn",
  380.        regs->u_regs[4], regs->u_regs[5], regs->u_regs[6],
  381.        regs->u_regs[7]);
  382. printk("o0: %08x o1: %08x o2: %08x o3: %08x ",
  383.        regs->u_regs[8], regs->u_regs[9], regs->u_regs[10],
  384.        regs->u_regs[11]);
  385. printk("o4: %08x o5: %08x sp: %08x ret_pc: %08xn",
  386.        regs->u_regs[12], regs->u_regs[13], regs->u_regs[14],
  387.        regs->u_regs[15]);
  388. }
  390. void show_thread(struct thread_struct *thread)
  391. {
  392. int i;
  394. #if 0
  395. printk("kregs:             0x%016lxn", (unsigned long)thread->kregs);
  396. show_regs(thread->kregs);
  397. #endif
  398. printk("ksp:               0x%016lxn", thread->ksp);
  400. if (thread->w_saved) {
  401. for (i = 0; i < NSWINS; i++) {
  402. if (!thread->rwbuf_stkptrs[i])
  403. continue;
  404. printk("reg_window[%d]:n", i);
  405. printk("stack ptr:         0x%016lxn", thread->rwbuf_stkptrs[i]);
  406. }
  407. printk("w_saved:           0x%04xn", thread->w_saved);
  408. }
  410. printk("flags:             0x%08xn", thread->flags);
  411. printk("current_ds:        0x%xn", thread->current_ds.seg);
  412. }
  414. /* Free current thread data structures etc.. */
  415. void exit_thread(void)
  416. {
  417. struct thread_struct *t = &current->thread;
  419. if (t->utraps) {
  420. if (t->utraps[0] < 2)
  421. kfree (t->utraps);
  422. else
  423. t->utraps[0]--;
  424. }
  426. /* Turn off performance counters if on. */
  427. if (t->flags & SPARC_FLAG_PERFCTR) {
  428. t->user_cntd0 = t->user_cntd1 = NULL;
  429. t->pcr_reg = 0;
  430. t->flags &= ~(SPARC_FLAG_PERFCTR);
  431. write_pcr(0);
  432. }
  433. }
  435. void flush_thread(void)
  436. {
  437. struct thread_struct *t = &current->thread;
  439. if (t->flags & SPARC_FLAG_ABI_PENDING)
  440. t->flags ^= (SPARC_FLAG_ABI_PENDING |
  441.      SPARC_FLAG_32BIT);
  442. if (current->mm) {
  443. unsigned long pgd_cache = 0UL;
  445. if (t->flags & SPARC_FLAG_32BIT) {
  446. struct mm_struct *mm = current->mm;
  447. pgd_t *pgd0 = &mm->pgd[0];
  449. if (pgd_none(*pgd0)) {
  450. pmd_t *page = pmd_alloc_one_fast(NULL, 0);
  451. if (!page)
  452. page = pmd_alloc_one(NULL, 0);
  453. pgd_set(pgd0, page);
  454. }
  455. pgd_cache = pgd_val(*pgd0) << 11UL;
  456. }
  457. __asm__ __volatile__("stxa %0, [%1] %2nt"
  458.      "membar #Sync"
  459.      : /* no outputs */
  460.      : "r" (pgd_cache),
  461.      "r" (TSB_REG),
  462.      "i" (ASI_DMMU));
  463. }
  464. t->w_saved = 0;
  466. /* Turn off performance counters if on. */
  467. if (t->flags & SPARC_FLAG_PERFCTR) {
  468. t->user_cntd0 = t->user_cntd1 = NULL;
  469. t->pcr_reg = 0;
  470. t->flags &= ~(SPARC_FLAG_PERFCTR);
  471. write_pcr(0);
  472. }
  474. /* Clear FPU register state. */
  475. t->fpsaved[0] = 0;
  477. if (t->current_ds.seg != ASI_AIUS)
  478. set_fs(USER_DS);
  480. /* Init new signal delivery disposition. */
  481. t->flags &= ~SPARC_FLAG_NEWSIGNALS;
  482. }
  484. /* It's a bit more tricky when 64-bit tasks are involved... */
  485. static unsigned long clone_stackframe(unsigned long csp, unsigned long psp)
  486. {
  487. unsigned long fp, distance, rval;
  489. if (!(current->thread.flags & SPARC_FLAG_32BIT)) {
  490. csp += STACK_BIAS;
  491. psp += STACK_BIAS;
  492. __get_user(fp, &(((struct reg_window *)psp)->ins[6]));
  493. fp += STACK_BIAS;
  494. } else
  495. __get_user(fp, &(((struct reg_window32 *)psp)->ins[6]));
  497. /* Now 8-byte align the stack as this is mandatory in the
  498.  * Sparc ABI due to how register windows work.  This hides
  499.  * the restriction from thread libraries etc.  -DaveM
  500.  */
  501. csp &= ~7UL;
  503. distance = fp - psp;
  504. rval = (csp - distance);
  505. if (copy_in_user(rval, psp, distance))
  506. rval = 0;
  507. else if (current->thread.flags & SPARC_FLAG_32BIT) {
  508. if (put_user(((u32)csp), &(((struct reg_window32 *)rval)->ins[6])))
  509. rval = 0;
  510. } else {
  511. if (put_user(((u64)csp - STACK_BIAS),
  512.      &(((struct reg_window *)rval)->ins[6])))
  513. rval = 0;
  514. else
  515. rval = rval - STACK_BIAS;
  516. }
  518. return rval;
  519. }
  521. /* Standard stuff. */
  522. static inline void shift_window_buffer(int first_win, int last_win,
  523.        struct thread_struct *t)
  524. {
  525. int i;
  527. for (i = first_win; i < last_win; i++) {
  528. t->rwbuf_stkptrs[i] = t->rwbuf_stkptrs[i+1];
  529. memcpy(&t->reg_window[i], &t->reg_window[i+1],
  530.        sizeof(struct reg_window));
  531. }
  532. }
  534. void synchronize_user_stack(void)
  535. {
  536. struct thread_struct *t = &current->thread;
  537. unsigned long window;
  539. flush_user_windows();
  540. if ((window = t->w_saved) != 0) {
  541. int winsize = REGWIN_SZ;
  542. int bias = 0;
  544. if (t->flags & SPARC_FLAG_32BIT)
  545. winsize = REGWIN32_SZ;
  546. else
  547. bias = STACK_BIAS;
  549. window -= 1;
  550. do {
  551. unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
  552. struct reg_window *rwin = &t->reg_window[window];
  554. if (!copy_to_user((char *)sp, rwin, winsize)) {
  555. shift_window_buffer(window, t->w_saved - 1, t);
  556. t->w_saved--;
  557. }
  558. } while (window--);
  559. }
  560. }
  562. void fault_in_user_windows(void)
  563. {
  564. struct thread_struct *t = &current->thread;
  565. unsigned long window;
  566. int winsize = REGWIN_SZ;
  567. int bias = 0;
  569. if (t->flags & SPARC_FLAG_32BIT)
  570. winsize = REGWIN32_SZ;
  571. else
  572. bias = STACK_BIAS;
  574. flush_user_windows();
  575. window = t->w_saved;
  577. if (window != 0) {
  578. window -= 1;
  579. do {
  580. unsigned long sp = (t->rwbuf_stkptrs[window] + bias);
  581. struct reg_window *rwin = &t->reg_window[window];
  583. if (copy_to_user((char *)sp, rwin, winsize))
  584. goto barf;
  585. } while (window--);
  586. }
  587. t->w_saved = 0;
  588. return;
  590. barf:
  591. t->w_saved = window + 1;
  592. do_exit(SIGILL);
  593. }
  595. /* Copy a Sparc thread.  The fork() return value conventions
  596.  * under SunOS are nothing short of bletcherous:
  597.  * Parent -->  %o0 == childs  pid, %o1 == 0
  598.  * Child  -->  %o0 == parents pid, %o1 == 1
  599.  */
  600. int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
  601. unsigned long unused,
  602. struct task_struct *p, struct pt_regs *regs)
  603. {
  604. struct thread_struct *t = &p->thread;
  605. char *child_trap_frame;
  607. #ifdef CONFIG_DEBUG_SPINLOCK
  608. t->smp_lock_count = 0;
  609. t->smp_lock_pc = 0;
  610. #endif
  612. /* Calculate offset to stack_frame & pt_regs */
  613. child_trap_frame = ((char *)p) + (THREAD_SIZE - (TRACEREG_SZ+REGWIN_SZ));
  614. memcpy(child_trap_frame, (((struct reg_window *)regs)-1), (TRACEREG_SZ+REGWIN_SZ));
  615. t->ksp = ((unsigned long) child_trap_frame) - STACK_BIAS;
  616. t->flags |= SPARC_FLAG_NEWCHILD;
  617. t->kregs = (struct pt_regs *)(child_trap_frame+sizeof(struct reg_window));
  618. t->cwp = (regs->tstate + 1) & TSTATE_CWP;
  619. t->fpsaved[0] = 0;
  621. if (regs->tstate & TSTATE_PRIV) {
  622. /* Special case, if we are spawning a kernel thread from
  623.  * a userspace task (via KMOD, NFS, or similar) we must
  624.  * disable performance counters in the child because the
  625.  * address space and protection realm are changing.
  626.  */
  627. if (t->flags & SPARC_FLAG_PERFCTR) {
  628. t->user_cntd0 = t->user_cntd1 = NULL;
  629. t->pcr_reg = 0;
  630. t->flags &= ~(SPARC_FLAG_PERFCTR);
  631. }
  632. t->kregs->u_regs[UREG_FP] = p->thread.ksp;
  633. t->current_ds = KERNEL_DS;
  634. flush_register_windows();
  635. memcpy((void *)(t->ksp + STACK_BIAS),
  636.        (void *)(regs->u_regs[UREG_FP] + STACK_BIAS),
  637.        sizeof(struct reg_window));
  638. t->kregs->u_regs[UREG_G6] = (unsigned long) p;
  639. } else {
  640. if (t->flags & SPARC_FLAG_32BIT) {
  641. sp &= 0x00000000ffffffffUL;
  642. regs->u_regs[UREG_FP] &= 0x00000000ffffffffUL;
  643. }
  644. t->kregs->u_regs[UREG_FP] = sp;
  645. t->current_ds = USER_DS;
  646. if (sp != regs->u_regs[UREG_FP]) {
  647. unsigned long csp;
  649. csp = clone_stackframe(sp, regs->u_regs[UREG_FP]);
  650. if (!csp)
  651. return -EFAULT;
  652. t->kregs->u_regs[UREG_FP] = csp;
  653. }
  654. if (t->utraps)
  655. t->utraps[0]++;
  656. }
  658. /* Set the return value for the child. */
  659. t->kregs->u_regs[UREG_I0] = current->pid;
  660. t->kregs->u_regs[UREG_I1] = 1;
  662. /* Set the second return value for the parent. */
  663. regs->u_regs[UREG_I1] = 0;
  665. return 0;
  666. }
  668. /*
  669.  * This is the mechanism for creating a new kernel thread.
  670.  *
  671.  * NOTE! Only a kernel-only process(ie the swapper or direct descendants
  672.  * who haven't done an "execve()") should use this: it will work within
  673.  * a system call from a "real" process, but the process memory space will
  674.  * not be free'd until both the parent and the child have exited.
  675.  */
  676. pid_t kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
  677. {
  678. long retval;
  680. /* If the parent runs before fn(arg) is called by the child,
  681.  * the input registers of this function can be clobbered.
  682.  * So we stash 'fn' and 'arg' into global registers which
  683.  * will not be modified by the parent.
  684.  */
  685. __asm__ __volatile("mov %4, %%g2nt"    /* Save FN into global */
  686.    "mov %5, %%g3nt"    /* Save ARG into global */
  687.    "mov %1, %%g1nt"    /* Clone syscall nr. */
  688.    "mov %2, %%o0nt"    /* Clone flags. */
  689.    "mov 0, %%o1nt"    /* usp arg == 0 */
  690.    "t 0x6dnt"    /* Linux/Sparc clone(). */
  691.    "brz,a,pn %%o1, 1fnt" /* Parent, just return. */
  692.    " mov %%o0, %0nt"
  693.    "jmpl %%g2, %%o7nt"   /* Call the function. */
  694.    " mov %%g3, %%o0nt"   /* Set arg in delay. */
  695.    "mov %3, %%g1nt"
  696.    "t 0x6dnt"    /* Linux/Sparc exit(). */
  697.    /* Notreached by child. */
  698.    "1:" :
  699.    "=r" (retval) :
  700.    "i" (__NR_clone), "r" (flags | CLONE_VM),
  701.    "i" (__NR_exit),  "r" (fn), "r" (arg) :
  702.    "g1", "g2", "g3", "o0", "o1", "memory", "cc");
  703. return retval;
  704. }
  706. /*
  707.  * fill in the user structure for a core dump..
  708.  */
  709. void dump_thread(struct pt_regs * regs, struct user * dump)
  710. {
  711. #if 1
  712. /* Only should be used for SunOS and ancient a.out
  713.  * SparcLinux binaries...  Fixme some day when bored.
  714.  * But for now at least plug the security hole :-)
  715.  */
  716. memset(dump, 0, sizeof(struct user));
  717. #else
  718. unsigned long first_stack_page;
  719. dump->magic = SUNOS_CORE_MAGIC;
  720. dump->len = sizeof(struct user);
  721. dump->regs.psr = regs->psr;
  722. dump->regs.pc = regs->pc;
  723. dump->regs.npc = regs->npc;
  724. dump->regs.y = regs->y;
  725. /* fuck me plenty */
  726. memcpy(&dump->regs.regs[0], &regs->u_regs[1], (sizeof(unsigned long) * 15));
  727. dump->u_tsize = (((unsigned long) current->mm->end_code) -
  728. ((unsigned long) current->mm->start_code)) & ~(PAGE_SIZE - 1);
  729. dump->u_dsize = ((unsigned long) (current->mm->brk + (PAGE_SIZE-1)));
  730. dump->u_dsize -= dump->u_tsize;
  731. dump->u_dsize &= ~(PAGE_SIZE - 1);
  732. first_stack_page = (regs->u_regs[UREG_FP] & ~(PAGE_SIZE - 1));
  733. dump->u_ssize = (TASK_SIZE - first_stack_page) & ~(PAGE_SIZE - 1);
  734. memcpy(&dump->fpu.fpstatus.fregs.regs[0], &current->thread.float_regs[0], (sizeof(unsigned long) * 32));
  735. dump->fpu.fpstatus.fsr = current->thread.fsr;
  736. dump->fpu.fpstatus.flags = dump->fpu.fpstatus.extra = 0;
  737. #endif
  738. }
  740. typedef struct {
  741. union {
  742. unsigned int pr_regs[32];
  743. unsigned long pr_dregs[16];
  744. } pr_fr;
  745. unsigned int __unused;
  746. unsigned int pr_fsr;
  747. unsigned char pr_qcnt;
  748. unsigned char pr_q_entrysize;
  749. unsigned char pr_en;
  750. unsigned int pr_q[64];
  751. } elf_fpregset_t32;
  753. /*
  754.  * fill in the fpu structure for a core dump.
  755.  */
  756. int dump_fpu (struct pt_regs * regs, elf_fpregset_t * fpregs)
  757. {
  758. unsigned long *kfpregs = (unsigned long *)(((char *)current) + AOFF_task_fpregs);
  759. unsigned long fprs = current->thread.fpsaved[0];
  761. if ((current->thread.flags & SPARC_FLAG_32BIT) != 0) {
  762. elf_fpregset_t32 *fpregs32 = (elf_fpregset_t32 *)fpregs;
  764. if (fprs & FPRS_DL)
  765. memcpy(&fpregs32->pr_fr.pr_regs[0], kfpregs,
  766.        sizeof(unsigned int) * 32);
  767. else
  768. memset(&fpregs32->pr_fr.pr_regs[0], 0,
  769.        sizeof(unsigned int) * 32);
  770. fpregs32->pr_qcnt = 0;
  771. fpregs32->pr_q_entrysize = 8;
  772. memset(&fpregs32->pr_q[0], 0,
  773.        (sizeof(unsigned int) * 64));
  774. if (fprs & FPRS_FEF) {
  775. fpregs32->pr_fsr = (unsigned int) current->thread.xfsr[0];
  776. fpregs32->pr_en = 1;
  777. } else {
  778. fpregs32->pr_fsr = 0;
  779. fpregs32->pr_en = 0;
  780. }
  781. } else {
  782. if(fprs & FPRS_DL)
  783. memcpy(&fpregs->pr_regs[0], kfpregs,
  784.        sizeof(unsigned int) * 32);
  785. else
  786. memset(&fpregs->pr_regs[0], 0,
  787.        sizeof(unsigned int) * 32);
  788. if(fprs & FPRS_DU)
  789. memcpy(&fpregs->pr_regs[16], kfpregs+16,
  790.        sizeof(unsigned int) * 32);
  791. else
  792. memset(&fpregs->pr_regs[16], 0,
  793.        sizeof(unsigned int) * 32);
  794. if(fprs & FPRS_FEF) {
  795. fpregs->pr_fsr = current->thread.xfsr[0];
  796. fpregs->pr_gsr = current->thread.gsr[0];
  797. } else {
  798. fpregs->pr_fsr = fpregs->pr_gsr = 0;
  799. }
  800. fpregs->pr_fprs = fprs;
  801. }
  802. return 1;
  803. }
  805. /*
  806.  * sparc_execve() executes a new program after the asm stub has set
  807.  * things up for us.  This should basically do what I want it to.
  808.  */
  809. asmlinkage int sparc_execve(struct pt_regs *regs)
  810. {
  811. int error, base = 0;
  812. char *filename;
  814. /* User register window flush is done by entry.S */
  816. /* Check for indirect call. */
  817. if (regs->u_regs[UREG_G1] == 0)
  818. base = 1;
  820. filename = getname((char *)regs->u_regs[base + UREG_I0]);
  821. error = PTR_ERR(filename);
  822. if (IS_ERR(filename))
  823. goto out;
  824. error = do_execve(filename, (char **) regs->u_regs[base + UREG_I1],
  825.   (char **) regs->u_regs[base + UREG_I2], regs);
  826. putname(filename);
  827. if (!error) {
  828. fprs_write(0);
  829. current->thread.xfsr[0] = 0;
  830. current->thread.fpsaved[0] = 0;
  831. regs->tstate &= ~TSTATE_PEF;
  832. }
  833. out:
  834. return error;
  835. }