1
2
3
4
5
6
7
8
9
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/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/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
33#include <asm/cpu.h>
34#include <asm/delay.h>
35#include <asm/elf.h>
36#include <asm/ia32.h>
37#include <asm/irq.h>
38#include <asm/kexec.h>
39#include <asm/pgalloc.h>
40#include <asm/processor.h>
41#include <asm/sal.h>
42#include <asm/tlbflush.h>
43#include <asm/uaccess.h>
44#include <asm/unwind.h>
45#include <asm/user.h>
46
47#include "entry.h"
48
49#ifdef CONFIG_PERFMON
50# include <asm/perfmon.h>
51#endif
52
53#include "sigframe.h"
54
55void (*ia64_mark_idle)(int);
56
57unsigned long boot_option_idle_override = 0;
58EXPORT_SYMBOL(boot_option_idle_override);
59unsigned long idle_halt;
60EXPORT_SYMBOL(idle_halt);
61unsigned long idle_nomwait;
62EXPORT_SYMBOL(idle_nomwait);
63
64void
65ia64_do_show_stack (struct unw_frame_info *info, void *arg)
66{
67 unsigned long ip, sp, bsp;
68 char buf[128];
69
70 printk("\nCall Trace:\n");
71 do {
72 unw_get_ip(info, &ip);
73 if (ip == 0)
74 break;
75
76 unw_get_sp(info, &sp);
77 unw_get_bsp(info, &bsp);
78 snprintf(buf, sizeof(buf),
79 " [<%016lx>] %%s\n"
80 " sp=%016lx bsp=%016lx\n",
81 ip, sp, bsp);
82 print_symbol(buf, ip);
83 } while (unw_unwind(info) >= 0);
84}
85
86void
87show_stack (struct task_struct *task, unsigned long *sp)
88{
89 if (!task)
90 unw_init_running(ia64_do_show_stack, NULL);
91 else {
92 struct unw_frame_info info;
93
94 unw_init_from_blocked_task(&info, task);
95 ia64_do_show_stack(&info, NULL);
96 }
97}
98
99void
100dump_stack (void)
101{
102 show_stack(NULL, NULL);
103}
104
105EXPORT_SYMBOL(dump_stack);
106
107void
108show_regs (struct pt_regs *regs)
109{
110 unsigned long ip = regs->cr_iip + ia64_psr(regs)->ri;
111
112 print_modules();
113 printk("\nPid: %d, CPU %d, comm: %20s\n", task_pid_nr(current),
114 smp_processor_id(), current->comm);
115 printk("psr : %016lx ifs : %016lx ip : [<%016lx>] %s (%s)\n",
116 regs->cr_ipsr, regs->cr_ifs, ip, print_tainted(),
117 init_utsname()->release);
118 print_symbol("ip is at %s\n", ip);
119 printk("unat: %016lx pfs : %016lx rsc : %016lx\n",
120 regs->ar_unat, regs->ar_pfs, regs->ar_rsc);
121 printk("rnat: %016lx bsps: %016lx pr : %016lx\n",
122 regs->ar_rnat, regs->ar_bspstore, regs->pr);
123 printk("ldrs: %016lx ccv : %016lx fpsr: %016lx\n",
124 regs->loadrs, regs->ar_ccv, regs->ar_fpsr);
125 printk("csd : %016lx ssd : %016lx\n", regs->ar_csd, regs->ar_ssd);
126 printk("b0 : %016lx b6 : %016lx b7 : %016lx\n", regs->b0, regs->b6, regs->b7);
127 printk("f6 : %05lx%016lx f7 : %05lx%016lx\n",
128 regs->f6.u.bits[1], regs->f6.u.bits[0],
129 regs->f7.u.bits[1], regs->f7.u.bits[0]);
130 printk("f8 : %05lx%016lx f9 : %05lx%016lx\n",
131 regs->f8.u.bits[1], regs->f8.u.bits[0],
132 regs->f9.u.bits[1], regs->f9.u.bits[0]);
133 printk("f10 : %05lx%016lx f11 : %05lx%016lx\n",
134 regs->f10.u.bits[1], regs->f10.u.bits[0],
135 regs->f11.u.bits[1], regs->f11.u.bits[0]);
136
137 printk("r1 : %016lx r2 : %016lx r3 : %016lx\n", regs->r1, regs->r2, regs->r3);
138 printk("r8 : %016lx r9 : %016lx r10 : %016lx\n", regs->r8, regs->r9, regs->r10);
139 printk("r11 : %016lx r12 : %016lx r13 : %016lx\n", regs->r11, regs->r12, regs->r13);
140 printk("r14 : %016lx r15 : %016lx r16 : %016lx\n", regs->r14, regs->r15, regs->r16);
141 printk("r17 : %016lx r18 : %016lx r19 : %016lx\n", regs->r17, regs->r18, regs->r19);
142 printk("r20 : %016lx r21 : %016lx r22 : %016lx\n", regs->r20, regs->r21, regs->r22);
143 printk("r23 : %016lx r24 : %016lx r25 : %016lx\n", regs->r23, regs->r24, regs->r25);
144 printk("r26 : %016lx r27 : %016lx r28 : %016lx\n", regs->r26, regs->r27, regs->r28);
145 printk("r29 : %016lx r30 : %016lx r31 : %016lx\n", regs->r29, regs->r30, regs->r31);
146
147 if (user_mode(regs)) {
148
149 unsigned long val, *bsp, ndirty;
150 int i, sof, is_nat = 0;
151
152 sof = regs->cr_ifs & 0x7f;
153 ndirty = (regs->loadrs >> 19);
154 bsp = ia64_rse_skip_regs((unsigned long *) regs->ar_bspstore, ndirty);
155 for (i = 0; i < sof; ++i) {
156 get_user(val, (unsigned long __user *) ia64_rse_skip_regs(bsp, i));
157 printk("r%-3u:%c%016lx%s", 32 + i, is_nat ? '*' : ' ', val,
158 ((i == sof - 1) || (i % 3) == 2) ? "\n" : " ");
159 }
160 } else
161 show_stack(NULL, NULL);
162}
163
164
165void
166console_print(const char *s)
167{
168 printk(KERN_EMERG "%s", s);
169}
170
171void
172do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
173{
174 if (fsys_mode(current, &scr->pt)) {
175
176
177
178
179 if (!ia64_psr(&scr->pt)->lp)
180 ia64_psr(&scr->pt)->lp = 1;
181 return;
182 }
183
184#ifdef CONFIG_PERFMON
185 if (current->thread.pfm_needs_checking)
186
187
188
189
190 pfm_handle_work();
191#endif
192
193
194 if (test_thread_flag(TIF_SIGPENDING)) {
195 local_irq_enable();
196 ia64_do_signal(scr, in_syscall);
197 }
198
199 if (test_thread_flag(TIF_NOTIFY_RESUME)) {
200 clear_thread_flag(TIF_NOTIFY_RESUME);
201 tracehook_notify_resume(&scr->pt);
202 if (current->replacement_session_keyring)
203 key_replace_session_keyring();
204 }
205
206
207 if (unlikely(test_thread_flag(TIF_RESTORE_RSE))) {
208 local_irq_enable();
209 ia64_sync_krbs();
210 }
211
212 local_irq_disable();
213}
214
215static int pal_halt = 1;
216static int can_do_pal_halt = 1;
217
218static int __init nohalt_setup(char * str)
219{
220 pal_halt = can_do_pal_halt = 0;
221 return 1;
222}
223__setup("nohalt", nohalt_setup);
224
225void
226update_pal_halt_status(int status)
227{
228 can_do_pal_halt = pal_halt && status;
229}
230
231
232
233
234void
235default_idle (void)
236{
237 local_irq_enable();
238 while (!need_resched()) {
239 if (can_do_pal_halt) {
240 local_irq_disable();
241 if (!need_resched()) {
242 safe_halt();
243 }
244 local_irq_enable();
245 } else
246 cpu_relax();
247 }
248}
249
250#ifdef CONFIG_HOTPLUG_CPU
251
252static inline void play_dead(void)
253{
254 unsigned int this_cpu = smp_processor_id();
255
256
257 __get_cpu_var(cpu_state) = CPU_DEAD;
258
259 max_xtp();
260 local_irq_disable();
261 idle_task_exit();
262 ia64_jump_to_sal(&sal_boot_rendez_state[this_cpu]);
263
264
265
266
267 BUG();
268}
269#else
270static inline void play_dead(void)
271{
272 BUG();
273}
274#endif
275
276static void do_nothing(void *unused)
277{
278}
279
280
281
282
283
284
285
286
287
288void cpu_idle_wait(void)
289{
290 smp_mb();
291
292 smp_call_function(do_nothing, NULL, 1);
293}
294EXPORT_SYMBOL_GPL(cpu_idle_wait);
295
296void __attribute__((noreturn))
297cpu_idle (void)
298{
299 void (*mark_idle)(int) = ia64_mark_idle;
300 int cpu = smp_processor_id();
301
302
303 while (1) {
304 if (can_do_pal_halt) {
305 current_thread_info()->status &= ~TS_POLLING;
306
307
308
309
310 smp_mb();
311 } else {
312 current_thread_info()->status |= TS_POLLING;
313 }
314
315 if (!need_resched()) {
316 void (*idle)(void);
317#ifdef CONFIG_SMP
318 min_xtp();
319#endif
320 rmb();
321 if (mark_idle)
322 (*mark_idle)(1);
323
324 idle = pm_idle;
325 if (!idle)
326 idle = default_idle;
327 (*idle)();
328 if (mark_idle)
329 (*mark_idle)(0);
330#ifdef CONFIG_SMP
331 normal_xtp();
332#endif
333 }
334 preempt_enable_no_resched();
335 schedule();
336 preempt_disable();
337 check_pgt_cache();
338 if (cpu_is_offline(cpu))
339 play_dead();
340 }
341}
342
343void
344ia64_save_extra (struct task_struct *task)
345{
346#ifdef CONFIG_PERFMON
347 unsigned long info;
348#endif
349
350 if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
351 ia64_save_debug_regs(&task->thread.dbr[0]);
352
353#ifdef CONFIG_PERFMON
354 if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
355 pfm_save_regs(task);
356
357 info = __get_cpu_var(pfm_syst_info);
358 if (info & PFM_CPUINFO_SYST_WIDE)
359 pfm_syst_wide_update_task(task, info, 0);
360#endif
361
362#ifdef CONFIG_IA32_SUPPORT
363 if (IS_IA32_PROCESS(task_pt_regs(task)))
364 ia32_save_state(task);
365#endif
366}
367
368void
369ia64_load_extra (struct task_struct *task)
370{
371#ifdef CONFIG_PERFMON
372 unsigned long info;
373#endif
374
375 if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
376 ia64_load_debug_regs(&task->thread.dbr[0]);
377
378#ifdef CONFIG_PERFMON
379 if ((task->thread.flags & IA64_THREAD_PM_VALID) != 0)
380 pfm_load_regs(task);
381
382 info = __get_cpu_var(pfm_syst_info);
383 if (info & PFM_CPUINFO_SYST_WIDE)
384 pfm_syst_wide_update_task(task, info, 1);
385#endif
386
387#ifdef CONFIG_IA32_SUPPORT
388 if (IS_IA32_PROCESS(task_pt_regs(task)))
389 ia32_load_state(task);
390#endif
391}
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424int
425copy_thread(unsigned long clone_flags,
426 unsigned long user_stack_base, unsigned long user_stack_size,
427 struct task_struct *p, struct pt_regs *regs)
428{
429 extern char ia64_ret_from_clone, ia32_ret_from_clone;
430 struct switch_stack *child_stack, *stack;
431 unsigned long rbs, child_rbs, rbs_size;
432 struct pt_regs *child_ptregs;
433 int retval = 0;
434
435#ifdef CONFIG_SMP
436
437
438
439
440 if (!regs)
441 return 0;
442#endif
443
444 stack = ((struct switch_stack *) regs) - 1;
445
446 child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
447 child_stack = (struct switch_stack *) child_ptregs - 1;
448
449
450 memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
451
452 rbs = (unsigned long) current + IA64_RBS_OFFSET;
453 child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
454 rbs_size = stack->ar_bspstore - rbs;
455
456
457 memcpy((void *) child_rbs, (void *) rbs, rbs_size);
458
459 if (likely(user_mode(child_ptregs))) {
460 if ((clone_flags & CLONE_SETTLS) && !IS_IA32_PROCESS(regs))
461 child_ptregs->r13 = regs->r16;
462 if (user_stack_base) {
463 child_ptregs->r12 = user_stack_base + user_stack_size - 16;
464 child_ptregs->ar_bspstore = user_stack_base;
465 child_ptregs->ar_rnat = 0;
466 child_ptregs->loadrs = 0;
467 }
468 } else {
469
470
471
472
473
474
475
476 child_ptregs->r12 = (unsigned long) child_ptregs - 16;
477 child_ptregs->r13 = (unsigned long) p;
478 }
479 child_stack->ar_bspstore = child_rbs + rbs_size;
480 if (IS_IA32_PROCESS(regs))
481 child_stack->b0 = (unsigned long) &ia32_ret_from_clone;
482 else
483 child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
484
485
486 p->thread.ksp = (unsigned long) child_stack - 16;
487
488
489
490
491
492
493 child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
494 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512# define THREAD_FLAGS_TO_CLEAR (IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
513 | IA64_THREAD_PM_VALID)
514# define THREAD_FLAGS_TO_SET 0
515 p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
516 | THREAD_FLAGS_TO_SET);
517 ia64_drop_fpu(p);
518#ifdef CONFIG_IA32_SUPPORT
519
520
521
522
523 if (IS_IA32_PROCESS(task_pt_regs(current))) {
524 ia32_save_state(p);
525 if (clone_flags & CLONE_SETTLS)
526 retval = ia32_clone_tls(p, child_ptregs);
527
528
529 if (!retval)
530 retval = ia32_copy_ia64_partial_page_list(p,
531 clone_flags);
532 }
533#endif
534
535#ifdef CONFIG_PERFMON
536 if (current->thread.pfm_context)
537 pfm_inherit(p, child_ptregs);
538#endif
539 return retval;
540}
541
542static void
543do_copy_task_regs (struct task_struct *task, struct unw_frame_info *info, void *arg)
544{
545 unsigned long mask, sp, nat_bits = 0, ar_rnat, urbs_end, cfm;
546 unsigned long uninitialized_var(ip);
547 elf_greg_t *dst = arg;
548 struct pt_regs *pt;
549 char nat;
550 int i;
551
552 memset(dst, 0, sizeof(elf_gregset_t));
553
554 if (unw_unwind_to_user(info) < 0)
555 return;
556
557 unw_get_sp(info, &sp);
558 pt = (struct pt_regs *) (sp + 16);
559
560 urbs_end = ia64_get_user_rbs_end(task, pt, &cfm);
561
562 if (ia64_sync_user_rbs(task, info->sw, pt->ar_bspstore, urbs_end) < 0)
563 return;
564
565 ia64_peek(task, info->sw, urbs_end, (long) ia64_rse_rnat_addr((long *) urbs_end),
566 &ar_rnat);
567
568
569
570
571
572
573
574
575
576
577
578
579
580 for (i = 1, mask = (1UL << i); i < 32; ++i) {
581 unw_get_gr(info, i, &dst[i], &nat);
582 if (nat)
583 nat_bits |= mask;
584 mask <<= 1;
585 }
586 dst[32] = nat_bits;
587 unw_get_pr(info, &dst[33]);
588
589 for (i = 0; i < 8; ++i)
590 unw_get_br(info, i, &dst[34 + i]);
591
592 unw_get_rp(info, &ip);
593 dst[42] = ip + ia64_psr(pt)->ri;
594 dst[43] = cfm;
595 dst[44] = pt->cr_ipsr & IA64_PSR_UM;
596
597 unw_get_ar(info, UNW_AR_RSC, &dst[45]);
598
599
600
601
602 dst[46] = urbs_end;
603 dst[47] = pt->ar_bspstore;
604 dst[48] = ar_rnat;
605 unw_get_ar(info, UNW_AR_CCV, &dst[49]);
606 unw_get_ar(info, UNW_AR_UNAT, &dst[50]);
607 unw_get_ar(info, UNW_AR_FPSR, &dst[51]);
608 dst[52] = pt->ar_pfs;
609 unw_get_ar(info, UNW_AR_LC, &dst[53]);
610 unw_get_ar(info, UNW_AR_EC, &dst[54]);
611 unw_get_ar(info, UNW_AR_CSD, &dst[55]);
612 unw_get_ar(info, UNW_AR_SSD, &dst[56]);
613}
614
615void
616do_dump_task_fpu (struct task_struct *task, struct unw_frame_info *info, void *arg)
617{
618 elf_fpreg_t *dst = arg;
619 int i;
620
621 memset(dst, 0, sizeof(elf_fpregset_t));
622
623 if (unw_unwind_to_user(info) < 0)
624 return;
625
626
627
628 for (i = 2; i < 32; ++i)
629 unw_get_fr(info, i, dst + i);
630
631 ia64_flush_fph(task);
632 if ((task->thread.flags & IA64_THREAD_FPH_VALID) != 0)
633 memcpy(dst + 32, task->thread.fph, 96*16);
634}
635
636void
637do_copy_regs (struct unw_frame_info *info, void *arg)
638{
639 do_copy_task_regs(current, info, arg);
640}
641
642void
643do_dump_fpu (struct unw_frame_info *info, void *arg)
644{
645 do_dump_task_fpu(current, info, arg);
646}
647
648void
649ia64_elf_core_copy_regs (struct pt_regs *pt, elf_gregset_t dst)
650{
651 unw_init_running(do_copy_regs, dst);
652}
653
654int
655dump_fpu (struct pt_regs *pt, elf_fpregset_t dst)
656{
657 unw_init_running(do_dump_fpu, dst);
658 return 1;
659}
660
661long
662sys_execve (char __user *filename, char __user * __user *argv, char __user * __user *envp,
663 struct pt_regs *regs)
664{
665 char *fname;
666 int error;
667
668 fname = getname(filename);
669 error = PTR_ERR(fname);
670 if (IS_ERR(fname))
671 goto out;
672 error = do_execve(fname, argv, envp, regs);
673 putname(fname);
674out:
675 return error;
676}
677
678pid_t
679kernel_thread (int (*fn)(void *), void *arg, unsigned long flags)
680{
681 extern void start_kernel_thread (void);
682 unsigned long *helper_fptr = (unsigned long *) &start_kernel_thread;
683 struct {
684 struct switch_stack sw;
685 struct pt_regs pt;
686 } regs;
687
688 memset(®s, 0, sizeof(regs));
689 regs.pt.cr_iip = helper_fptr[0];
690 regs.pt.r1 = helper_fptr[1];
691 regs.pt.r9 = (unsigned long) fn;
692 regs.pt.r11 = (unsigned long) arg;
693
694 regs.pt.cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
695 regs.pt.cr_ifs = 1UL << 63;
696 regs.sw.ar_fpsr = regs.pt.ar_fpsr = ia64_getreg(_IA64_REG_AR_FPSR);
697 regs.sw.ar_bspstore = (unsigned long) current + IA64_RBS_OFFSET;
698 regs.sw.pr = (1 << PRED_KERNEL_STACK);
699 return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, ®s.pt, 0, NULL, NULL);
700}
701EXPORT_SYMBOL(kernel_thread);
702
703
704int
705kernel_thread_helper (int (*fn)(void *), void *arg)
706{
707#ifdef CONFIG_IA32_SUPPORT
708 if (IS_IA32_PROCESS(task_pt_regs(current))) {
709
710 current->thread.map_base = DEFAULT_MAP_BASE;
711 current->thread.task_size = DEFAULT_TASK_SIZE;
712 ia64_set_kr(IA64_KR_IO_BASE, current->thread.old_iob);
713 ia64_set_kr(IA64_KR_TSSD, current->thread.old_k1);
714 }
715#endif
716 return (*fn)(arg);
717}
718
719
720
721
722void
723flush_thread (void)
724{
725
726 current->thread.flags &= ~(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID);
727 ia64_drop_fpu(current);
728#ifdef CONFIG_IA32_SUPPORT
729 if (IS_IA32_PROCESS(task_pt_regs(current))) {
730 ia32_drop_ia64_partial_page_list(current);
731 current->thread.task_size = IA32_PAGE_OFFSET;
732 set_fs(USER_DS);
733 memset(current->thread.tls_array, 0, sizeof(current->thread.tls_array));
734 }
735#endif
736}
737
738
739
740
741
742void
743exit_thread (void)
744{
745
746 ia64_drop_fpu(current);
747#ifdef CONFIG_PERFMON
748
749 if (current->thread.pfm_context)
750 pfm_exit_thread(current);
751
752
753 if (current->thread.flags & IA64_THREAD_DBG_VALID)
754 pfm_release_debug_registers(current);
755#endif
756 if (IS_IA32_PROCESS(task_pt_regs(current)))
757 ia32_drop_ia64_partial_page_list(current);
758}
759
760unsigned long
761get_wchan (struct task_struct *p)
762{
763 struct unw_frame_info info;
764 unsigned long ip;
765 int count = 0;
766
767 if (!p || p == current || p->state == TASK_RUNNING)
768 return 0;
769
770
771
772
773
774
775
776
777
778 unw_init_from_blocked_task(&info, p);
779 do {
780 if (p->state == TASK_RUNNING)
781 return 0;
782 if (unw_unwind(&info) < 0)
783 return 0;
784 unw_get_ip(&info, &ip);
785 if (!in_sched_functions(ip))
786 return ip;
787 } while (count++ < 16);
788 return 0;
789}
790
791void
792cpu_halt (void)
793{
794 pal_power_mgmt_info_u_t power_info[8];
795 unsigned long min_power;
796 int i, min_power_state;
797
798 if (ia64_pal_halt_info(power_info) != 0)
799 return;
800
801 min_power_state = 0;
802 min_power = power_info[0].pal_power_mgmt_info_s.power_consumption;
803 for (i = 1; i < 8; ++i)
804 if (power_info[i].pal_power_mgmt_info_s.im
805 && power_info[i].pal_power_mgmt_info_s.power_consumption < min_power) {
806 min_power = power_info[i].pal_power_mgmt_info_s.power_consumption;
807 min_power_state = i;
808 }
809
810 while (1)
811 ia64_pal_halt(min_power_state);
812}
813
814void machine_shutdown(void)
815{
816#ifdef CONFIG_HOTPLUG_CPU
817 int cpu;
818
819 for_each_online_cpu(cpu) {
820 if (cpu != smp_processor_id())
821 cpu_down(cpu);
822 }
823#endif
824#ifdef CONFIG_KEXEC
825 kexec_disable_iosapic();
826#endif
827}
828
829void
830machine_restart (char *restart_cmd)
831{
832 (void) notify_die(DIE_MACHINE_RESTART, restart_cmd, NULL, 0, 0, 0);
833 (*efi.reset_system)(EFI_RESET_WARM, 0, 0, NULL);
834}
835
836void
837machine_halt (void)
838{
839 (void) notify_die(DIE_MACHINE_HALT, "", NULL, 0, 0, 0);
840 cpu_halt();
841}
842
843void
844machine_power_off (void)
845{
846 if (pm_power_off)
847 pm_power_off();
848 machine_halt();
849}
850
851