2 * Architecture-specific setup.
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
8 * 2005-10-07 Keith Owens <kaos@sgi.com>
9 * Add notify_die() hooks.
11 #include <linux/cpu.h>
13 #include <linux/elf.h>
14 #include <linux/errno.h>
15 #include <linux/kallsyms.h>
16 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/notifier.h>
20 #include <linux/personality.h>
21 #include <linux/sched.h>
22 #include <linux/slab.h>
23 #include <linux/smp_lock.h>
24 #include <linux/stddef.h>
25 #include <linux/thread_info.h>
26 #include <linux/unistd.h>
27 #include <linux/efi.h>
28 #include <linux/interrupt.h>
29 #include <linux/delay.h>
32 #include <asm/delay.h>
36 #include <asm/kdebug.h>
37 #include <asm/kexec.h>
38 #include <asm/pgalloc.h>
39 #include <asm/processor.h>
41 #include <asm/tlbflush.h>
42 #include <asm/uaccess.h>
43 #include <asm/unwind.h>
49 # include <asm/perfmon.h>
54 void (*ia64_mark_idle
)(int);
55 static DEFINE_PER_CPU(unsigned int, cpu_idle_state
);
57 unsigned long boot_option_idle_override
= 0;
58 EXPORT_SYMBOL(boot_option_idle_override
);
61 ia64_do_show_stack (struct unw_frame_info
*info
, void *arg
)
63 unsigned long ip
, sp
, bsp
;
64 char buf
[128]; /* don't make it so big that it overflows the stack! */
66 printk("\nCall Trace:\n");
68 unw_get_ip(info
, &ip
);
72 unw_get_sp(info
, &sp
);
73 unw_get_bsp(info
, &bsp
);
74 snprintf(buf
, sizeof(buf
),
76 " sp=%016lx bsp=%016lx\n",
78 print_symbol(buf
, ip
);
79 } while (unw_unwind(info
) >= 0);
83 show_stack (struct task_struct
*task
, unsigned long *sp
)
86 unw_init_running(ia64_do_show_stack
, NULL
);
88 struct unw_frame_info info
;
90 unw_init_from_blocked_task(&info
, task
);
91 ia64_do_show_stack(&info
, NULL
);
98 show_stack(NULL
, NULL
);
101 EXPORT_SYMBOL(dump_stack
);
104 show_regs (struct pt_regs
*regs
)
106 unsigned long ip
= regs
->cr_iip
+ ia64_psr(regs
)->ri
;
109 printk("\nPid: %d, CPU %d, comm: %20s\n", current
->pid
, smp_processor_id(), current
->comm
);
110 printk("psr : %016lx ifs : %016lx ip : [<%016lx>] %s\n",
111 regs
->cr_ipsr
, regs
->cr_ifs
, ip
, print_tainted());
112 print_symbol("ip is at %s\n", ip
);
113 printk("unat: %016lx pfs : %016lx rsc : %016lx\n",
114 regs
->ar_unat
, regs
->ar_pfs
, regs
->ar_rsc
);
115 printk("rnat: %016lx bsps: %016lx pr : %016lx\n",
116 regs
->ar_rnat
, regs
->ar_bspstore
, regs
->pr
);
117 printk("ldrs: %016lx ccv : %016lx fpsr: %016lx\n",
118 regs
->loadrs
, regs
->ar_ccv
, regs
->ar_fpsr
);
119 printk("csd : %016lx ssd : %016lx\n", regs
->ar_csd
, regs
->ar_ssd
);
120 printk("b0 : %016lx b6 : %016lx b7 : %016lx\n", regs
->b0
, regs
->b6
, regs
->b7
);
121 printk("f6 : %05lx%016lx f7 : %05lx%016lx\n",
122 regs
->f6
.u
.bits
[1], regs
->f6
.u
.bits
[0],
123 regs
->f7
.u
.bits
[1], regs
->f7
.u
.bits
[0]);
124 printk("f8 : %05lx%016lx f9 : %05lx%016lx\n",
125 regs
->f8
.u
.bits
[1], regs
->f8
.u
.bits
[0],
126 regs
->f9
.u
.bits
[1], regs
->f9
.u
.bits
[0]);
127 printk("f10 : %05lx%016lx f11 : %05lx%016lx\n",
128 regs
->f10
.u
.bits
[1], regs
->f10
.u
.bits
[0],
129 regs
->f11
.u
.bits
[1], regs
->f11
.u
.bits
[0]);
131 printk("r1 : %016lx r2 : %016lx r3 : %016lx\n", regs
->r1
, regs
->r2
, regs
->r3
);
132 printk("r8 : %016lx r9 : %016lx r10 : %016lx\n", regs
->r8
, regs
->r9
, regs
->r10
);
133 printk("r11 : %016lx r12 : %016lx r13 : %016lx\n", regs
->r11
, regs
->r12
, regs
->r13
);
134 printk("r14 : %016lx r15 : %016lx r16 : %016lx\n", regs
->r14
, regs
->r15
, regs
->r16
);
135 printk("r17 : %016lx r18 : %016lx r19 : %016lx\n", regs
->r17
, regs
->r18
, regs
->r19
);
136 printk("r20 : %016lx r21 : %016lx r22 : %016lx\n", regs
->r20
, regs
->r21
, regs
->r22
);
137 printk("r23 : %016lx r24 : %016lx r25 : %016lx\n", regs
->r23
, regs
->r24
, regs
->r25
);
138 printk("r26 : %016lx r27 : %016lx r28 : %016lx\n", regs
->r26
, regs
->r27
, regs
->r28
);
139 printk("r29 : %016lx r30 : %016lx r31 : %016lx\n", regs
->r29
, regs
->r30
, regs
->r31
);
141 if (user_mode(regs
)) {
142 /* print the stacked registers */
143 unsigned long val
, *bsp
, ndirty
;
144 int i
, sof
, is_nat
= 0;
146 sof
= regs
->cr_ifs
& 0x7f; /* size of frame */
147 ndirty
= (regs
->loadrs
>> 19);
148 bsp
= ia64_rse_skip_regs((unsigned long *) regs
->ar_bspstore
, ndirty
);
149 for (i
= 0; i
< sof
; ++i
) {
150 get_user(val
, (unsigned long __user
*) ia64_rse_skip_regs(bsp
, i
));
151 printk("r%-3u:%c%016lx%s", 32 + i
, is_nat
? '*' : ' ', val
,
152 ((i
== sof
- 1) || (i
% 3) == 2) ? "\n" : " ");
155 show_stack(NULL
, NULL
);
159 do_notify_resume_user (sigset_t
*oldset
, struct sigscratch
*scr
, long in_syscall
)
161 if (fsys_mode(current
, &scr
->pt
)) {
162 /* defer signal-handling etc. until we return to privilege-level 0. */
163 if (!ia64_psr(&scr
->pt
)->lp
)
164 ia64_psr(&scr
->pt
)->lp
= 1;
168 #ifdef CONFIG_PERFMON
169 if (current
->thread
.pfm_needs_checking
)
173 /* deal with pending signal delivery */
174 if (test_thread_flag(TIF_SIGPENDING
))
175 ia64_do_signal(oldset
, scr
, in_syscall
);
178 static int pal_halt
= 1;
179 static int can_do_pal_halt
= 1;
181 static int __init
nohalt_setup(char * str
)
183 pal_halt
= can_do_pal_halt
= 0;
186 __setup("nohalt", nohalt_setup
);
189 update_pal_halt_status(int status
)
191 can_do_pal_halt
= pal_halt
&& status
;
195 * We use this if we don't have any better idle routine..
201 while (!need_resched()) {
209 #ifdef CONFIG_HOTPLUG_CPU
210 /* We don't actually take CPU down, just spin without interrupts. */
211 static inline void play_dead(void)
213 extern void ia64_cpu_local_tick (void);
214 unsigned int this_cpu
= smp_processor_id();
217 __get_cpu_var(cpu_state
) = CPU_DEAD
;
222 ia64_jump_to_sal(&sal_boot_rendez_state
[this_cpu
]);
224 * The above is a point of no-return, the processor is
225 * expected to be in SAL loop now.
230 static inline void play_dead(void)
234 #endif /* CONFIG_HOTPLUG_CPU */
236 void cpu_idle_wait(void)
238 unsigned int cpu
, this_cpu
= get_cpu();
241 set_cpus_allowed(current
, cpumask_of_cpu(this_cpu
));
245 for_each_online_cpu(cpu
) {
246 per_cpu(cpu_idle_state
, cpu
) = 1;
250 __get_cpu_var(cpu_idle_state
) = 0;
255 for_each_online_cpu(cpu
) {
256 if (cpu_isset(cpu
, map
) && !per_cpu(cpu_idle_state
, cpu
))
259 cpus_and(map
, map
, cpu_online_map
);
260 } while (!cpus_empty(map
));
262 EXPORT_SYMBOL_GPL(cpu_idle_wait
);
264 void __attribute__((noreturn
))
267 void (*mark_idle
)(int) = ia64_mark_idle
;
268 int cpu
= smp_processor_id();
270 /* endless idle loop with no priority at all */
272 if (can_do_pal_halt
) {
273 current_thread_info()->status
&= ~TS_POLLING
;
275 * TS_POLLING-cleared state must be visible before we
280 current_thread_info()->status
|= TS_POLLING
;
283 if (!need_resched()) {
288 if (__get_cpu_var(cpu_idle_state
))
289 __get_cpu_var(cpu_idle_state
) = 0;
305 preempt_enable_no_resched();
309 if (cpu_is_offline(cpu
))
315 ia64_save_extra (struct task_struct
*task
)
317 #ifdef CONFIG_PERFMON
321 if ((task
->thread
.flags
& IA64_THREAD_DBG_VALID
) != 0)
322 ia64_save_debug_regs(&task
->thread
.dbr
[0]);
324 #ifdef CONFIG_PERFMON
325 if ((task
->thread
.flags
& IA64_THREAD_PM_VALID
) != 0)
328 info
= __get_cpu_var(pfm_syst_info
);
329 if (info
& PFM_CPUINFO_SYST_WIDE
)
330 pfm_syst_wide_update_task(task
, info
, 0);
333 #ifdef CONFIG_IA32_SUPPORT
334 if (IS_IA32_PROCESS(task_pt_regs(task
)))
335 ia32_save_state(task
);
340 ia64_load_extra (struct task_struct
*task
)
342 #ifdef CONFIG_PERFMON
346 if ((task
->thread
.flags
& IA64_THREAD_DBG_VALID
) != 0)
347 ia64_load_debug_regs(&task
->thread
.dbr
[0]);
349 #ifdef CONFIG_PERFMON
350 if ((task
->thread
.flags
& IA64_THREAD_PM_VALID
) != 0)
353 info
= __get_cpu_var(pfm_syst_info
);
354 if (info
& PFM_CPUINFO_SYST_WIDE
)
355 pfm_syst_wide_update_task(task
, info
, 1);
358 #ifdef CONFIG_IA32_SUPPORT
359 if (IS_IA32_PROCESS(task_pt_regs(task
)))
360 ia32_load_state(task
);
365 * Copy the state of an ia-64 thread.
367 * We get here through the following call chain:
369 * from user-level: from kernel:
371 * <clone syscall> <some kernel call frames>
374 * copy_thread copy_thread
376 * This means that the stack layout is as follows:
378 * +---------------------+ (highest addr)
380 * +---------------------+
381 * | struct switch_stack |
382 * +---------------------+
385 * | | <-- sp (lowest addr)
386 * +---------------------+
388 * Observe that we copy the unat values that are in pt_regs and switch_stack. Spilling an
389 * integer to address X causes bit N in ar.unat to be set to the NaT bit of the register,
390 * with N=(X & 0x1ff)/8. Thus, copying the unat value preserves the NaT bits ONLY if the
391 * pt_regs structure in the parent is congruent to that of the child, modulo 512. Since
392 * the stack is page aligned and the page size is at least 4KB, this is always the case,
393 * so there is nothing to worry about.
396 copy_thread (int nr
, unsigned long clone_flags
,
397 unsigned long user_stack_base
, unsigned long user_stack_size
,
398 struct task_struct
*p
, struct pt_regs
*regs
)
400 extern char ia64_ret_from_clone
, ia32_ret_from_clone
;
401 struct switch_stack
*child_stack
, *stack
;
402 unsigned long rbs
, child_rbs
, rbs_size
;
403 struct pt_regs
*child_ptregs
;
408 * For SMP idle threads, fork_by_hand() calls do_fork with
415 stack
= ((struct switch_stack
*) regs
) - 1;
417 child_ptregs
= (struct pt_regs
*) ((unsigned long) p
+ IA64_STK_OFFSET
) - 1;
418 child_stack
= (struct switch_stack
*) child_ptregs
- 1;
420 /* copy parent's switch_stack & pt_regs to child: */
421 memcpy(child_stack
, stack
, sizeof(*child_ptregs
) + sizeof(*child_stack
));
423 rbs
= (unsigned long) current
+ IA64_RBS_OFFSET
;
424 child_rbs
= (unsigned long) p
+ IA64_RBS_OFFSET
;
425 rbs_size
= stack
->ar_bspstore
- rbs
;
427 /* copy the parent's register backing store to the child: */
428 memcpy((void *) child_rbs
, (void *) rbs
, rbs_size
);
430 if (likely(user_mode(child_ptregs
))) {
431 if ((clone_flags
& CLONE_SETTLS
) && !IS_IA32_PROCESS(regs
))
432 child_ptregs
->r13
= regs
->r16
; /* see sys_clone2() in entry.S */
433 if (user_stack_base
) {
434 child_ptregs
->r12
= user_stack_base
+ user_stack_size
- 16;
435 child_ptregs
->ar_bspstore
= user_stack_base
;
436 child_ptregs
->ar_rnat
= 0;
437 child_ptregs
->loadrs
= 0;
441 * Note: we simply preserve the relative position of
442 * the stack pointer here. There is no need to
443 * allocate a scratch area here, since that will have
444 * been taken care of by the caller of sys_clone()
447 child_ptregs
->r12
= (unsigned long) child_ptregs
- 16; /* kernel sp */
448 child_ptregs
->r13
= (unsigned long) p
; /* set `current' pointer */
450 child_stack
->ar_bspstore
= child_rbs
+ rbs_size
;
451 if (IS_IA32_PROCESS(regs
))
452 child_stack
->b0
= (unsigned long) &ia32_ret_from_clone
;
454 child_stack
->b0
= (unsigned long) &ia64_ret_from_clone
;
456 /* copy parts of thread_struct: */
457 p
->thread
.ksp
= (unsigned long) child_stack
- 16;
459 /* stop some PSR bits from being inherited.
460 * the psr.up/psr.pp bits must be cleared on fork but inherited on execve()
461 * therefore we must specify them explicitly here and not include them in
462 * IA64_PSR_BITS_TO_CLEAR.
464 child_ptregs
->cr_ipsr
= ((child_ptregs
->cr_ipsr
| IA64_PSR_BITS_TO_SET
)
465 & ~(IA64_PSR_BITS_TO_CLEAR
| IA64_PSR_PP
| IA64_PSR_UP
));
468 * NOTE: The calling convention considers all floating point
469 * registers in the high partition (fph) to be scratch. Since
470 * the only way to get to this point is through a system call,
471 * we know that the values in fph are all dead. Hence, there
472 * is no need to inherit the fph state from the parent to the
473 * child and all we have to do is to make sure that
474 * IA64_THREAD_FPH_VALID is cleared in the child.
476 * XXX We could push this optimization a bit further by
477 * clearing IA64_THREAD_FPH_VALID on ANY system call.
478 * However, it's not clear this is worth doing. Also, it
479 * would be a slight deviation from the normal Linux system
480 * call behavior where scratch registers are preserved across
481 * system calls (unless used by the system call itself).
483 # define THREAD_FLAGS_TO_CLEAR (IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
484 | IA64_THREAD_PM_VALID)
485 # define THREAD_FLAGS_TO_SET 0
486 p
->thread
.flags
= ((current
->thread
.flags
& ~THREAD_FLAGS_TO_CLEAR
)
487 | THREAD_FLAGS_TO_SET
);
488 ia64_drop_fpu(p
); /* don't pick up stale state from a CPU's fph */
489 #ifdef CONFIG_IA32_SUPPORT
491 * If we're cloning an IA32 task then save the IA32 extra
492 * state from the current task to the new task
494 if (IS_IA32_PROCESS(task_pt_regs(current
))) {
496 if (clone_flags
& CLONE_SETTLS
)
497 retval
= ia32_clone_tls(p
, child_ptregs
);
499 /* Copy partially mapped page list */
501 retval
= ia32_copy_partial_page_list(p
, clone_flags
);
505 #ifdef CONFIG_PERFMON
506 if (current
->thread
.pfm_context
)
507 pfm_inherit(p
, child_ptregs
);
513 do_copy_task_regs (struct task_struct
*task
, struct unw_frame_info
*info
, void *arg
)
515 unsigned long mask
, sp
, nat_bits
= 0, ip
, ar_rnat
, urbs_end
, cfm
;
516 elf_greg_t
*dst
= arg
;
521 memset(dst
, 0, sizeof(elf_gregset_t
)); /* don't leak any kernel bits to user-level */
523 if (unw_unwind_to_user(info
) < 0)
526 unw_get_sp(info
, &sp
);
527 pt
= (struct pt_regs
*) (sp
+ 16);
529 urbs_end
= ia64_get_user_rbs_end(task
, pt
, &cfm
);
531 if (ia64_sync_user_rbs(task
, info
->sw
, pt
->ar_bspstore
, urbs_end
) < 0)
534 ia64_peek(task
, info
->sw
, urbs_end
, (long) ia64_rse_rnat_addr((long *) urbs_end
),
540 * NaT bits (for r0-r31; bit N == 1 iff rN is a NaT)
541 * predicate registers (p0-p63)
544 * ar.rsc ar.bsp ar.bspstore ar.rnat
545 * ar.ccv ar.unat ar.fpsr ar.pfs ar.lc ar.ec
549 for (i
= 1, mask
= (1UL << i
); i
< 32; ++i
) {
550 unw_get_gr(info
, i
, &dst
[i
], &nat
);
556 unw_get_pr(info
, &dst
[33]);
558 for (i
= 0; i
< 8; ++i
)
559 unw_get_br(info
, i
, &dst
[34 + i
]);
561 unw_get_rp(info
, &ip
);
562 dst
[42] = ip
+ ia64_psr(pt
)->ri
;
564 dst
[44] = pt
->cr_ipsr
& IA64_PSR_UM
;
566 unw_get_ar(info
, UNW_AR_RSC
, &dst
[45]);
568 * For bsp and bspstore, unw_get_ar() would return the kernel
569 * addresses, but we need the user-level addresses instead:
571 dst
[46] = urbs_end
; /* note: by convention PT_AR_BSP points to the end of the urbs! */
572 dst
[47] = pt
->ar_bspstore
;
574 unw_get_ar(info
, UNW_AR_CCV
, &dst
[49]);
575 unw_get_ar(info
, UNW_AR_UNAT
, &dst
[50]);
576 unw_get_ar(info
, UNW_AR_FPSR
, &dst
[51]);
577 dst
[52] = pt
->ar_pfs
; /* UNW_AR_PFS is == to pt->cr_ifs for interrupt frames */
578 unw_get_ar(info
, UNW_AR_LC
, &dst
[53]);
579 unw_get_ar(info
, UNW_AR_EC
, &dst
[54]);
580 unw_get_ar(info
, UNW_AR_CSD
, &dst
[55]);
581 unw_get_ar(info
, UNW_AR_SSD
, &dst
[56]);
585 do_dump_task_fpu (struct task_struct
*task
, struct unw_frame_info
*info
, void *arg
)
587 elf_fpreg_t
*dst
= arg
;
590 memset(dst
, 0, sizeof(elf_fpregset_t
)); /* don't leak any "random" bits */
592 if (unw_unwind_to_user(info
) < 0)
595 /* f0 is 0.0, f1 is 1.0 */
597 for (i
= 2; i
< 32; ++i
)
598 unw_get_fr(info
, i
, dst
+ i
);
600 ia64_flush_fph(task
);
601 if ((task
->thread
.flags
& IA64_THREAD_FPH_VALID
) != 0)
602 memcpy(dst
+ 32, task
->thread
.fph
, 96*16);
606 do_copy_regs (struct unw_frame_info
*info
, void *arg
)
608 do_copy_task_regs(current
, info
, arg
);
612 do_dump_fpu (struct unw_frame_info
*info
, void *arg
)
614 do_dump_task_fpu(current
, info
, arg
);
618 dump_task_regs(struct task_struct
*task
, elf_gregset_t
*regs
)
620 struct unw_frame_info tcore_info
;
622 if (current
== task
) {
623 unw_init_running(do_copy_regs
, regs
);
625 memset(&tcore_info
, 0, sizeof(tcore_info
));
626 unw_init_from_blocked_task(&tcore_info
, task
);
627 do_copy_task_regs(task
, &tcore_info
, regs
);
633 ia64_elf_core_copy_regs (struct pt_regs
*pt
, elf_gregset_t dst
)
635 unw_init_running(do_copy_regs
, dst
);
639 dump_task_fpu (struct task_struct
*task
, elf_fpregset_t
*dst
)
641 struct unw_frame_info tcore_info
;
643 if (current
== task
) {
644 unw_init_running(do_dump_fpu
, dst
);
646 memset(&tcore_info
, 0, sizeof(tcore_info
));
647 unw_init_from_blocked_task(&tcore_info
, task
);
648 do_dump_task_fpu(task
, &tcore_info
, dst
);
654 dump_fpu (struct pt_regs
*pt
, elf_fpregset_t dst
)
656 unw_init_running(do_dump_fpu
, dst
);
657 return 1; /* f0-f31 are always valid so we always return 1 */
661 sys_execve (char __user
*filename
, char __user
* __user
*argv
, char __user
* __user
*envp
,
662 struct pt_regs
*regs
)
667 fname
= getname(filename
);
668 error
= PTR_ERR(fname
);
671 error
= do_execve(fname
, argv
, envp
, regs
);
678 kernel_thread (int (*fn
)(void *), void *arg
, unsigned long flags
)
680 extern void start_kernel_thread (void);
681 unsigned long *helper_fptr
= (unsigned long *) &start_kernel_thread
;
683 struct switch_stack sw
;
687 memset(®s
, 0, sizeof(regs
));
688 regs
.pt
.cr_iip
= helper_fptr
[0]; /* set entry point (IP) */
689 regs
.pt
.r1
= helper_fptr
[1]; /* set GP */
690 regs
.pt
.r9
= (unsigned long) fn
; /* 1st argument */
691 regs
.pt
.r11
= (unsigned long) arg
; /* 2nd argument */
692 /* Preserve PSR bits, except for bits 32-34 and 37-45, which we can't read. */
693 regs
.pt
.cr_ipsr
= ia64_getreg(_IA64_REG_PSR
) | IA64_PSR_BN
;
694 regs
.pt
.cr_ifs
= 1UL << 63; /* mark as valid, empty frame */
695 regs
.sw
.ar_fpsr
= regs
.pt
.ar_fpsr
= ia64_getreg(_IA64_REG_AR_FPSR
);
696 regs
.sw
.ar_bspstore
= (unsigned long) current
+ IA64_RBS_OFFSET
;
697 regs
.sw
.pr
= (1 << PRED_KERNEL_STACK
);
698 return do_fork(flags
| CLONE_VM
| CLONE_UNTRACED
, 0, ®s
.pt
, 0, NULL
, NULL
);
700 EXPORT_SYMBOL(kernel_thread
);
702 /* This gets called from kernel_thread() via ia64_invoke_thread_helper(). */
704 kernel_thread_helper (int (*fn
)(void *), void *arg
)
706 #ifdef CONFIG_IA32_SUPPORT
707 if (IS_IA32_PROCESS(task_pt_regs(current
))) {
708 /* A kernel thread is always a 64-bit process. */
709 current
->thread
.map_base
= DEFAULT_MAP_BASE
;
710 current
->thread
.task_size
= DEFAULT_TASK_SIZE
;
711 ia64_set_kr(IA64_KR_IO_BASE
, current
->thread
.old_iob
);
712 ia64_set_kr(IA64_KR_TSSD
, current
->thread
.old_k1
);
719 * Flush thread state. This is called when a thread does an execve().
724 /* drop floating-point and debug-register state if it exists: */
725 current
->thread
.flags
&= ~(IA64_THREAD_FPH_VALID
| IA64_THREAD_DBG_VALID
);
726 ia64_drop_fpu(current
);
727 #ifdef CONFIG_IA32_SUPPORT
728 if (IS_IA32_PROCESS(task_pt_regs(current
))) {
729 ia32_drop_partial_page_list(current
);
730 current
->thread
.task_size
= IA32_PAGE_OFFSET
;
737 * Clean up state associated with current thread. This is called when
738 * the thread calls exit().
744 ia64_drop_fpu(current
);
745 #ifdef CONFIG_PERFMON
746 /* if needed, stop monitoring and flush state to perfmon context */
747 if (current
->thread
.pfm_context
)
748 pfm_exit_thread(current
);
750 /* free debug register resources */
751 if (current
->thread
.flags
& IA64_THREAD_DBG_VALID
)
752 pfm_release_debug_registers(current
);
754 if (IS_IA32_PROCESS(task_pt_regs(current
)))
755 ia32_drop_partial_page_list(current
);
759 get_wchan (struct task_struct
*p
)
761 struct unw_frame_info info
;
766 * Note: p may not be a blocked task (it could be current or
767 * another process running on some other CPU. Rather than
768 * trying to determine if p is really blocked, we just assume
769 * it's blocked and rely on the unwind routines to fail
770 * gracefully if the process wasn't really blocked after all.
773 unw_init_from_blocked_task(&info
, p
);
775 if (unw_unwind(&info
) < 0)
777 unw_get_ip(&info
, &ip
);
778 if (!in_sched_functions(ip
))
780 } while (count
++ < 16);
787 pal_power_mgmt_info_u_t power_info
[8];
788 unsigned long min_power
;
789 int i
, min_power_state
;
791 if (ia64_pal_halt_info(power_info
) != 0)
795 min_power
= power_info
[0].pal_power_mgmt_info_s
.power_consumption
;
796 for (i
= 1; i
< 8; ++i
)
797 if (power_info
[i
].pal_power_mgmt_info_s
.im
798 && power_info
[i
].pal_power_mgmt_info_s
.power_consumption
< min_power
) {
799 min_power
= power_info
[i
].pal_power_mgmt_info_s
.power_consumption
;
804 ia64_pal_halt(min_power_state
);
807 void machine_shutdown(void)
809 #ifdef CONFIG_HOTPLUG_CPU
812 for_each_online_cpu(cpu
) {
813 if (cpu
!= smp_processor_id())
818 kexec_disable_iosapic();
823 machine_restart (char *restart_cmd
)
825 (void) notify_die(DIE_MACHINE_RESTART
, restart_cmd
, NULL
, 0, 0, 0);
826 (*efi
.reset_system
)(EFI_RESET_WARM
, 0, 0, NULL
);
832 (void) notify_die(DIE_MACHINE_HALT
, "", NULL
, 0, 0, 0);
837 machine_power_off (void)