process.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682
  1. /*
  2. * Architecture-specific setup.
  3. *
  4. * Copyright (C) 1998-2003 Hewlett-Packard Co
  5. * David Mosberger-Tang <davidm@hpl.hp.com>
  6. * 04/11/17 Ashok Raj <ashok.raj@intel.com> Added CPU Hotplug Support
  7. *
  8. * 2005-10-07 Keith Owens <kaos@sgi.com>
  9. * Add notify_die() hooks.
  10. */
  11. #include <linux/cpu.h>
  12. #include <linux/pm.h>
  13. #include <linux/elf.h>
  14. #include <linux/errno.h>
  15. #include <linux/kallsyms.h>
  16. #include <linux/kernel.h>
  17. #include <linux/mm.h>
  18. #include <linux/slab.h>
  19. #include <linux/module.h>
  20. #include <linux/notifier.h>
  21. #include <linux/personality.h>
  22. #include <linux/sched.h>
  23. #include <linux/stddef.h>
  24. #include <linux/thread_info.h>
  25. #include <linux/unistd.h>
  26. #include <linux/efi.h>
  27. #include <linux/interrupt.h>
  28. #include <linux/delay.h>
  29. #include <linux/kdebug.h>
  30. #include <linux/utsname.h>
  31. #include <linux/tracehook.h>
  32. #include <linux/rcupdate.h>
  33. #include <asm/cpu.h>
  34. #include <asm/delay.h>
  35. #include <asm/elf.h>
  36. #include <asm/irq.h>
  37. #include <asm/kexec.h>
  38. #include <asm/pgalloc.h>
  39. #include <asm/processor.h>
  40. #include <asm/sal.h>
  41. #include <asm/switch_to.h>
  42. #include <asm/tlbflush.h>
  43. #include <asm/uaccess.h>
  44. #include <asm/unwind.h>
  45. #include <asm/user.h>
  46. #include "entry.h"
  47. #ifdef CONFIG_PERFMON
  48. # include <asm/perfmon.h>
  49. #endif
  50. #include "sigframe.h"
  51. void (*ia64_mark_idle)(int);
  52. unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
  53. EXPORT_SYMBOL(boot_option_idle_override);
  54. void (*pm_power_off) (void);
  55. EXPORT_SYMBOL(pm_power_off);
  56. void
  57. ia64_do_show_stack (struct unw_frame_info *info, void *arg)
  58. {
  59. unsigned long ip, sp, bsp;
  60. char buf[128]; /* don't make it so big that it overflows the stack! */
  61. printk("\nCall Trace:\n");
  62. do {
  63. unw_get_ip(info, &ip);
  64. if (ip == 0)
  65. break;
  66. unw_get_sp(info, &sp);
  67. unw_get_bsp(info, &bsp);
  68. snprintf(buf, sizeof(buf),
  69. " [<%016lx>] %%s\n"
  70. " sp=%016lx bsp=%016lx\n",
  71. ip, sp, bsp);
  72. print_symbol(buf, ip);
  73. } while (unw_unwind(info) >= 0);
  74. }
  75. void
  76. show_stack (struct task_struct *task, unsigned long *sp)
  77. {
  78. if (!task)
  79. unw_init_running(ia64_do_show_stack, NULL);
  80. else {
  81. struct unw_frame_info info;
  82. unw_init_from_blocked_task(&info, task);
  83. ia64_do_show_stack(&info, NULL);
  84. }
  85. }
  86. void
  87. show_regs (struct pt_regs *regs)
  88. {
  89. unsigned long ip = regs->cr_iip + ia64_psr(regs)->ri;
  90. print_modules();
  91. printk("\n");
  92. show_regs_print_info(KERN_DEFAULT);
  93. printk("psr : %016lx ifs : %016lx ip : [<%016lx>] %s (%s)\n",
  94. regs->cr_ipsr, regs->cr_ifs, ip, print_tainted(),
  95. init_utsname()->release);
  96. print_symbol("ip is at %s\n", ip);
  97. printk("unat: %016lx pfs : %016lx rsc : %016lx\n",
  98. regs->ar_unat, regs->ar_pfs, regs->ar_rsc);
  99. printk("rnat: %016lx bsps: %016lx pr : %016lx\n",
  100. regs->ar_rnat, regs->ar_bspstore, regs->pr);
  101. printk("ldrs: %016lx ccv : %016lx fpsr: %016lx\n",
  102. regs->loadrs, regs->ar_ccv, regs->ar_fpsr);
  103. printk("csd : %016lx ssd : %016lx\n", regs->ar_csd, regs->ar_ssd);
  104. printk("b0 : %016lx b6 : %016lx b7 : %016lx\n", regs->b0, regs->b6, regs->b7);
  105. printk("f6 : %05lx%016lx f7 : %05lx%016lx\n",
  106. regs->f6.u.bits[1], regs->f6.u.bits[0],
  107. regs->f7.u.bits[1], regs->f7.u.bits[0]);
  108. printk("f8 : %05lx%016lx f9 : %05lx%016lx\n",
  109. regs->f8.u.bits[1], regs->f8.u.bits[0],
  110. regs->f9.u.bits[1], regs->f9.u.bits[0]);
  111. printk("f10 : %05lx%016lx f11 : %05lx%016lx\n",
  112. regs->f10.u.bits[1], regs->f10.u.bits[0],
  113. regs->f11.u.bits[1], regs->f11.u.bits[0]);
  114. printk("r1 : %016lx r2 : %016lx r3 : %016lx\n", regs->r1, regs->r2, regs->r3);
  115. printk("r8 : %016lx r9 : %016lx r10 : %016lx\n", regs->r8, regs->r9, regs->r10);
  116. printk("r11 : %016lx r12 : %016lx r13 : %016lx\n", regs->r11, regs->r12, regs->r13);
  117. printk("r14 : %016lx r15 : %016lx r16 : %016lx\n", regs->r14, regs->r15, regs->r16);
  118. printk("r17 : %016lx r18 : %016lx r19 : %016lx\n", regs->r17, regs->r18, regs->r19);
  119. printk("r20 : %016lx r21 : %016lx r22 : %016lx\n", regs->r20, regs->r21, regs->r22);
  120. printk("r23 : %016lx r24 : %016lx r25 : %016lx\n", regs->r23, regs->r24, regs->r25);
  121. printk("r26 : %016lx r27 : %016lx r28 : %016lx\n", regs->r26, regs->r27, regs->r28);
  122. printk("r29 : %016lx r30 : %016lx r31 : %016lx\n", regs->r29, regs->r30, regs->r31);
  123. if (user_mode(regs)) {
  124. /* print the stacked registers */
  125. unsigned long val, *bsp, ndirty;
  126. int i, sof, is_nat = 0;
  127. sof = regs->cr_ifs & 0x7f; /* size of frame */
  128. ndirty = (regs->loadrs >> 19);
  129. bsp = ia64_rse_skip_regs((unsigned long *) regs->ar_bspstore, ndirty);
  130. for (i = 0; i < sof; ++i) {
  131. get_user(val, (unsigned long __user *) ia64_rse_skip_regs(bsp, i));
  132. printk("r%-3u:%c%016lx%s", 32 + i, is_nat ? '*' : ' ', val,
  133. ((i == sof - 1) || (i % 3) == 2) ? "\n" : " ");
  134. }
  135. } else
  136. show_stack(NULL, NULL);
  137. }
  138. /* local support for deprecated console_print */
  139. void
  140. console_print(const char *s)
  141. {
  142. printk(KERN_EMERG "%s", s);
  143. }
  144. void
  145. do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
  146. {
  147. if (fsys_mode(current, &scr->pt)) {
  148. /*
  149. * defer signal-handling etc. until we return to
  150. * privilege-level 0.
  151. */
  152. if (!ia64_psr(&scr->pt)->lp)
  153. ia64_psr(&scr->pt)->lp = 1;
  154. return;
  155. }
  156. #ifdef CONFIG_PERFMON
  157. if (current->thread.pfm_needs_checking)
  158. /*
  159. * Note: pfm_handle_work() allow us to call it with interrupts
  160. * disabled, and may enable interrupts within the function.
  161. */
  162. pfm_handle_work();
  163. #endif
  164. /* deal with pending signal delivery */
  165. if (test_thread_flag(TIF_SIGPENDING)) {
  166. local_irq_enable(); /* force interrupt enable */
  167. ia64_do_signal(scr, in_syscall);
  168. }
  169. if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME)) {
  170. local_irq_enable(); /* force interrupt enable */
  171. tracehook_notify_resume(&scr->pt);
  172. }
  173. /* copy user rbs to kernel rbs */
  174. if (unlikely(test_thread_flag(TIF_RESTORE_RSE))) {
  175. local_irq_enable(); /* force interrupt enable */
  176. ia64_sync_krbs();
  177. }
  178. local_irq_disable(); /* force interrupt disable */
  179. }
  180. static int __init nohalt_setup(char * str)
  181. {
  182. cpu_idle_poll_ctrl(true);
  183. return 1;
  184. }
  185. __setup("nohalt", nohalt_setup);
  186. #ifdef CONFIG_HOTPLUG_CPU
  187. /* We don't actually take CPU down, just spin without interrupts. */
  188. static inline void play_dead(void)
  189. {
  190. unsigned int this_cpu = smp_processor_id();
  191. /* Ack it */
  192. __this_cpu_write(cpu_state, CPU_DEAD);
  193. max_xtp();
  194. local_irq_disable();
  195. idle_task_exit();
  196. ia64_jump_to_sal(&sal_boot_rendez_state[this_cpu]);
  197. /*
  198. * The above is a point of no-return, the processor is
  199. * expected to be in SAL loop now.
  200. */
  201. BUG();
  202. }
  203. #else
  204. static inline void play_dead(void)
  205. {
  206. BUG();
  207. }
  208. #endif /* CONFIG_HOTPLUG_CPU */
  209. void arch_cpu_idle_dead(void)
  210. {
  211. play_dead();
  212. }
  213. void arch_cpu_idle(void)
  214. {
  215. void (*mark_idle)(int) = ia64_mark_idle;
  216. #ifdef CONFIG_SMP
  217. min_xtp();
  218. #endif
  219. rmb();
  220. if (mark_idle)
  221. (*mark_idle)(1);
  222. safe_halt();
  223. if (mark_idle)
  224. (*mark_idle)(0);
  225. #ifdef CONFIG_SMP
  226. normal_xtp();
  227. #endif
  228. }
  229. void
  230. ia64_save_extra (struct task_struct *task)
  231. {
  232. #ifdef CONFIG_PERFMON
  233. unsigned long info;
  234. #endif
  235. if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
  236. ia64_save_debug_regs(&task->thread.dbr[0]);
  237. #ifdef CONFIG_PERFMON
  238. if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
  239. pfm_save_regs(task);
  240. info = __this_cpu_read(pfm_syst_info);
  241. if (info & PFM_CPUINFO_SYST_WIDE)
  242. pfm_syst_wide_update_task(task, info, 0);
  243. #endif
  244. }
  245. void
  246. ia64_load_extra (struct task_struct *task)
  247. {
  248. #ifdef CONFIG_PERFMON
  249. unsigned long info;
  250. #endif
  251. if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
  252. ia64_load_debug_regs(&task->thread.dbr[0]);
  253. #ifdef CONFIG_PERFMON
  254. if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
  255. pfm_load_regs(task);
  256. info = __this_cpu_read(pfm_syst_info);
  257. if (info & PFM_CPUINFO_SYST_WIDE)
  258. pfm_syst_wide_update_task(task, info, 1);
  259. #endif
  260. }
  261. /*
  262. * Copy the state of an ia-64 thread.
  263. *
  264. * We get here through the following call chain:
  265. *
  266. * from user-level: from kernel:
  267. *
  268. * <clone syscall> <some kernel call frames>
  269. * sys_clone :
  270. * do_fork do_fork
  271. * copy_thread copy_thread
  272. *
  273. * This means that the stack layout is as follows:
  274. *
  275. * +---------------------+ (highest addr)
  276. * | struct pt_regs |
  277. * +---------------------+
  278. * | struct switch_stack |
  279. * +---------------------+
  280. * | |
  281. * | memory stack |
  282. * | | <-- sp (lowest addr)
  283. * +---------------------+
  284. *
  285. * Observe that we copy the unat values that are in pt_regs and switch_stack. Spilling an
  286. * integer to address X causes bit N in ar.unat to be set to the NaT bit of the register,
  287. * with N=(X & 0x1ff)/8. Thus, copying the unat value preserves the NaT bits ONLY if the
  288. * pt_regs structure in the parent is congruent to that of the child, modulo 512. Since
  289. * the stack is page aligned and the page size is at least 4KB, this is always the case,
  290. * so there is nothing to worry about.
  291. */
  292. int
  293. copy_thread(unsigned long clone_flags,
  294. unsigned long user_stack_base, unsigned long user_stack_size,
  295. struct task_struct *p)
  296. {
  297. extern char ia64_ret_from_clone;
  298. struct switch_stack *child_stack, *stack;
  299. unsigned long rbs, child_rbs, rbs_size;
  300. struct pt_regs *child_ptregs;
  301. struct pt_regs *regs = current_pt_regs();
  302. int retval = 0;
  303. child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
  304. child_stack = (struct switch_stack *) child_ptregs - 1;
  305. rbs = (unsigned long) current + IA64_RBS_OFFSET;
  306. child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
  307. /* copy parts of thread_struct: */
  308. p->thread.ksp = (unsigned long) child_stack - 16;
  309. /*
  310. * NOTE: The calling convention considers all floating point
  311. * registers in the high partition (fph) to be scratch. Since
  312. * the only way to get to this point is through a system call,
  313. * we know that the values in fph are all dead. Hence, there
  314. * is no need to inherit the fph state from the parent to the
  315. * child and all we have to do is to make sure that
  316. * IA64_THREAD_FPH_VALID is cleared in the child.
  317. *
  318. * XXX We could push this optimization a bit further by
  319. * clearing IA64_THREAD_FPH_VALID on ANY system call.
  320. * However, it's not clear this is worth doing. Also, it
  321. * would be a slight deviation from the normal Linux system
  322. * call behavior where scratch registers are preserved across
  323. * system calls (unless used by the system call itself).
  324. */
  325. # define THREAD_FLAGS_TO_CLEAR (IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
  326. | IA64_THREAD_PM_VALID)
  327. # define THREAD_FLAGS_TO_SET 0
  328. p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
  329. | THREAD_FLAGS_TO_SET);
  330. ia64_drop_fpu(p); /* don't pick up stale state from a CPU's fph */
  331. if (unlikely(p->flags & PF_KTHREAD)) {
  332. if (unlikely(!user_stack_base)) {
  333. /* fork_idle() called us */
  334. return 0;
  335. }
  336. memset(child_stack, 0, sizeof(*child_ptregs) + sizeof(*child_stack));
  337. child_stack->r4 = user_stack_base; /* payload */
  338. child_stack->r5 = user_stack_size; /* argument */
  339. /*
  340. * Preserve PSR bits, except for bits 32-34 and 37-45,
  341. * which we can't read.
  342. */
  343. child_ptregs->cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
  344. /* mark as valid, empty frame */
  345. child_ptregs->cr_ifs = 1UL << 63;
  346. child_stack->ar_fpsr = child_ptregs->ar_fpsr
  347. = ia64_getreg(_IA64_REG_AR_FPSR);
  348. child_stack->pr = (1 << PRED_KERNEL_STACK);
  349. child_stack->ar_bspstore = child_rbs;
  350. child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
  351. /* stop some PSR bits from being inherited.
  352. * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
  353. * therefore we must specify them explicitly here and not include them in
  354. * IA64_PSR_BITS_TO_CLEAR.
  355. */
  356. child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
  357. & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
  358. return 0;
  359. }
  360. stack = ((struct switch_stack *) regs) - 1;
  361. /* copy parent's switch_stack & pt_regs to child: */
  362. memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
  363. /* copy the parent's register backing store to the child: */
  364. rbs_size = stack->ar_bspstore - rbs;
  365. memcpy((void *) child_rbs, (void *) rbs, rbs_size);
  366. if (clone_flags & CLONE_SETTLS)
  367. child_ptregs->r13 = regs->r16; /* see sys_clone2() in entry.S */
  368. if (user_stack_base) {
  369. child_ptregs->r12 = user_stack_base + user_stack_size - 16;
  370. child_ptregs->ar_bspstore = user_stack_base;
  371. child_ptregs->ar_rnat = 0;
  372. child_ptregs->loadrs = 0;
  373. }
  374. child_stack->ar_bspstore = child_rbs + rbs_size;
  375. child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
  376. /* stop some PSR bits from being inherited.
  377. * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
  378. * therefore we must specify them explicitly here and not include them in
  379. * IA64_PSR_BITS_TO_CLEAR.
  380. */
  381. child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
  382. & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
  383. #ifdef CONFIG_PERFMON
  384. if (current->thread.pfm_context)
  385. pfm_inherit(p, child_ptregs);
  386. #endif
  387. return retval;
  388. }
  389. static void
  390. do_copy_task_regs (struct task_struct *task, struct unw_frame_info *info, void *arg)
  391. {
  392. unsigned long mask, sp, nat_bits = 0, ar_rnat, urbs_end, cfm;
  393. unsigned long uninitialized_var(ip); /* GCC be quiet */
  394. elf_greg_t *dst = arg;
  395. struct pt_regs *pt;
  396. char nat;
  397. int i;
  398. memset(dst, 0, sizeof(elf_gregset_t)); /* don't leak any kernel bits to user-level */
  399. if (unw_unwind_to_user(info) < 0)
  400. return;
  401. unw_get_sp(info, &sp);
  402. pt = (struct pt_regs *) (sp + 16);
  403. urbs_end = ia64_get_user_rbs_end(task, pt, &cfm);
  404. if (ia64_sync_user_rbs(task, info->sw, pt->ar_bspstore, urbs_end) < 0)
  405. return;
  406. ia64_peek(task, info->sw, urbs_end, (long) ia64_rse_rnat_addr((long *) urbs_end),
  407. &ar_rnat);
  408. /*
  409. * coredump format:
  410. * r0-r31
  411. * NaT bits (for r0-r31; bit N == 1 iff rN is a NaT)
  412. * predicate registers (p0-p63)
  413. * b0-b7
  414. * ip cfm user-mask
  415. * ar.rsc ar.bsp ar.bspstore ar.rnat
  416. * ar.ccv ar.unat ar.fpsr ar.pfs ar.lc ar.ec
  417. */
  418. /* r0 is zero */
  419. for (i = 1, mask = (1UL << i); i < 32; ++i) {
  420. unw_get_gr(info, i, &dst[i], &nat);
  421. if (nat)
  422. nat_bits |= mask;
  423. mask <<= 1;
  424. }
  425. dst[32] = nat_bits;
  426. unw_get_pr(info, &dst[33]);
  427. for (i = 0; i < 8; ++i)
  428. unw_get_br(info, i, &dst[34 + i]);
  429. unw_get_rp(info, &ip);
  430. dst[42] = ip + ia64_psr(pt)->ri;
  431. dst[43] = cfm;
  432. dst[44] = pt->cr_ipsr & IA64_PSR_UM;
  433. unw_get_ar(info, UNW_AR_RSC, &dst[45]);
  434. /*
  435. * For bsp and bspstore, unw_get_ar() would return the kernel
  436. * addresses, but we need the user-level addresses instead:
  437. */
  438. dst[46] = urbs_end; /* note: by convention PT_AR_BSP points to the end of the urbs! */
  439. dst[47] = pt->ar_bspstore;
  440. dst[48] = ar_rnat;
  441. unw_get_ar(info, UNW_AR_CCV, &dst[49]);
  442. unw_get_ar(info, UNW_AR_UNAT, &dst[50]);
  443. unw_get_ar(info, UNW_AR_FPSR, &dst[51]);
  444. dst[52] = pt->ar_pfs; /* UNW_AR_PFS is == to pt->cr_ifs for interrupt frames */
  445. unw_get_ar(info, UNW_AR_LC, &dst[53]);
  446. unw_get_ar(info, UNW_AR_EC, &dst[54]);
  447. unw_get_ar(info, UNW_AR_CSD, &dst[55]);
  448. unw_get_ar(info, UNW_AR_SSD, &dst[56]);
  449. }
  450. void
  451. do_dump_task_fpu (struct task_struct *task, struct unw_frame_info *info, void *arg)
  452. {
  453. elf_fpreg_t *dst = arg;
  454. int i;
  455. memset(dst, 0, sizeof(elf_fpregset_t)); /* don't leak any "random" bits */
  456. if (unw_unwind_to_user(info) < 0)
  457. return;
  458. /* f0 is 0.0, f1 is 1.0 */
  459. for (i = 2; i < 32; ++i)
  460. unw_get_fr(info, i, dst + i);
  461. ia64_flush_fph(task);
  462. if ((task->thread.flags & IA64_THREAD_FPH_VALID) != 0)
  463. memcpy(dst + 32, task->thread.fph, 96*16);
  464. }
  465. void
  466. do_copy_regs (struct unw_frame_info *info, void *arg)
  467. {
  468. do_copy_task_regs(current, info, arg);
  469. }
  470. void
  471. do_dump_fpu (struct unw_frame_info *info, void *arg)
  472. {
  473. do_dump_task_fpu(current, info, arg);
  474. }
  475. void
  476. ia64_elf_core_copy_regs (struct pt_regs *pt, elf_gregset_t dst)
  477. {
  478. unw_init_running(do_copy_regs, dst);
  479. }
  480. int
  481. dump_fpu (struct pt_regs *pt, elf_fpregset_t dst)
  482. {
  483. unw_init_running(do_dump_fpu, dst);
  484. return 1; /* f0-f31 are always valid so we always return 1 */
  485. }
  486. /*
  487. * Flush thread state. This is called when a thread does an execve().
  488. */
  489. void
  490. flush_thread (void)
  491. {
  492. /* drop floating-point and debug-register state if it exists: */
  493. current->thread.flags &= ~(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID);
  494. ia64_drop_fpu(current);
  495. }
  496. /*
  497. * Clean up state associated with current thread. This is called when
  498. * the thread calls exit().
  499. */
  500. void
  501. exit_thread (void)
  502. {
  503. ia64_drop_fpu(current);
  504. #ifdef CONFIG_PERFMON
  505. /* if needed, stop monitoring and flush state to perfmon context */
  506. if (current->thread.pfm_context)
  507. pfm_exit_thread(current);
  508. /* free debug register resources */
  509. if (current->thread.flags & IA64_THREAD_DBG_VALID)
  510. pfm_release_debug_registers(current);
  511. #endif
  512. }
  513. unsigned long
  514. get_wchan (struct task_struct *p)
  515. {
  516. struct unw_frame_info info;
  517. unsigned long ip;
  518. int count = 0;
  519. if (!p || p == current || p->state == TASK_RUNNING)
  520. return 0;
  521. /*
  522. * Note: p may not be a blocked task (it could be current or
  523. * another process running on some other CPU. Rather than
  524. * trying to determine if p is really blocked, we just assume
  525. * it's blocked and rely on the unwind routines to fail
  526. * gracefully if the process wasn't really blocked after all.
  527. * --davidm 99/12/15
  528. */
  529. unw_init_from_blocked_task(&info, p);
  530. do {
  531. if (p->state == TASK_RUNNING)
  532. return 0;
  533. if (unw_unwind(&info) < 0)
  534. return 0;
  535. unw_get_ip(&info, &ip);
  536. if (!in_sched_functions(ip))
  537. return ip;
  538. } while (count++ < 16);
  539. return 0;
  540. }
  541. void
  542. cpu_halt (void)
  543. {
  544. pal_power_mgmt_info_u_t power_info[8];
  545. unsigned long min_power;
  546. int i, min_power_state;
  547. if (ia64_pal_halt_info(power_info) != 0)
  548. return;
  549. min_power_state = 0;
  550. min_power = power_info[0].pal_power_mgmt_info_s.power_consumption;
  551. for (i = 1; i < 8; ++i)
  552. if (power_info[i].pal_power_mgmt_info_s.im
  553. && power_info[i].pal_power_mgmt_info_s.power_consumption < min_power) {
  554. min_power = power_info[i].pal_power_mgmt_info_s.power_consumption;
  555. min_power_state = i;
  556. }
  557. while (1)
  558. ia64_pal_halt(min_power_state);
  559. }
  560. void machine_shutdown(void)
  561. {
  562. #ifdef CONFIG_HOTPLUG_CPU
  563. int cpu;
  564. for_each_online_cpu(cpu) {
  565. if (cpu != smp_processor_id())
  566. cpu_down(cpu);
  567. }
  568. #endif
  569. #ifdef CONFIG_KEXEC
  570. kexec_disable_iosapic();
  571. #endif
  572. }
  573. void
  574. machine_restart (char *restart_cmd)
  575. {
  576. (void) notify_die(DIE_MACHINE_RESTART, restart_cmd, NULL, 0, 0, 0);
  577. efi_reboot(REBOOT_WARM, NULL);
  578. }
  579. void
  580. machine_halt (void)
  581. {
  582. (void) notify_die(DIE_MACHINE_HALT, "", NULL, 0, 0, 0);
  583. cpu_halt();
  584. }
  585. void
  586. machine_power_off (void)
  587. {
  588. if (pm_power_off)
  589. pm_power_off();
  590. machine_halt();
  591. }