1
2
3
4
5
6
7
8
9
10
11
12#include <linux/cpu.h>
13#include <linux/pm.h>
14#include <linux/elf.h>
15#include <linux/errno.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/sched/debug.h>
24#include <linux/sched/hotplug.h>
25#include <linux/sched/task.h>
26#include <linux/sched/task_stack.h>
27#include <linux/stddef.h>
28#include <linux/thread_info.h>
29#include <linux/unistd.h>
30#include <linux/efi.h>
31#include <linux/interrupt.h>
32#include <linux/delay.h>
33#include <linux/kdebug.h>
34#include <linux/utsname.h>
35#include <linux/tracehook.h>
36#include <linux/rcupdate.h>
37
38#include <asm/cpu.h>
39#include <asm/delay.h>
40#include <asm/elf.h>
41#include <asm/irq.h>
42#include <asm/kexec.h>
43#include <asm/processor.h>
44#include <asm/sal.h>
45#include <asm/switch_to.h>
46#include <asm/tlbflush.h>
47#include <linux/uaccess.h>
48#include <asm/unwind.h>
49#include <asm/user.h>
50#include <asm/xtp.h>
51
52#include "entry.h"
53
54#include "sigframe.h"
55
56void (*ia64_mark_idle)(int);
57
58unsigned long boot_option_idle_override = IDLE_NO_OVERRIDE;
59EXPORT_SYMBOL(boot_option_idle_override);
60void (*pm_power_off) (void);
61EXPORT_SYMBOL(pm_power_off);
62
63static void
64ia64_do_show_stack (struct unw_frame_info *info, void *arg)
65{
66 unsigned long ip, sp, bsp;
67 const char *loglvl = arg;
68
69 printk("%s\nCall Trace:\n", loglvl);
70 do {
71 unw_get_ip(info, &ip);
72 if (ip == 0)
73 break;
74
75 unw_get_sp(info, &sp);
76 unw_get_bsp(info, &bsp);
77 printk("%s [<%016lx>] %pS\n"
78 " sp=%016lx bsp=%016lx\n",
79 loglvl, ip, (void *)ip, sp, bsp);
80 } while (unw_unwind(info) >= 0);
81}
82
83void
84show_stack (struct task_struct *task, unsigned long *sp, const char *loglvl)
85{
86 if (!task)
87 unw_init_running(ia64_do_show_stack, (void *)loglvl);
88 else {
89 struct unw_frame_info info;
90
91 unw_init_from_blocked_task(&info, task);
92 ia64_do_show_stack(&info, (void *)loglvl);
93 }
94}
95
96void
97show_regs (struct pt_regs *regs)
98{
99 unsigned long ip = regs->cr_iip + ia64_psr(regs)->ri;
100
101 print_modules();
102 printk("\n");
103 show_regs_print_info(KERN_DEFAULT);
104 printk("psr : %016lx ifs : %016lx ip : [<%016lx>] %s (%s)\n",
105 regs->cr_ipsr, regs->cr_ifs, ip, print_tainted(),
106 init_utsname()->release);
107 printk("ip is at %pS\n", (void *)ip);
108 printk("unat: %016lx pfs : %016lx rsc : %016lx\n",
109 regs->ar_unat, regs->ar_pfs, regs->ar_rsc);
110 printk("rnat: %016lx bsps: %016lx pr : %016lx\n",
111 regs->ar_rnat, regs->ar_bspstore, regs->pr);
112 printk("ldrs: %016lx ccv : %016lx fpsr: %016lx\n",
113 regs->loadrs, regs->ar_ccv, regs->ar_fpsr);
114 printk("csd : %016lx ssd : %016lx\n", regs->ar_csd, regs->ar_ssd);
115 printk("b0 : %016lx b6 : %016lx b7 : %016lx\n", regs->b0, regs->b6, regs->b7);
116 printk("f6 : %05lx%016lx f7 : %05lx%016lx\n",
117 regs->f6.u.bits[1], regs->f6.u.bits[0],
118 regs->f7.u.bits[1], regs->f7.u.bits[0]);
119 printk("f8 : %05lx%016lx f9 : %05lx%016lx\n",
120 regs->f8.u.bits[1], regs->f8.u.bits[0],
121 regs->f9.u.bits[1], regs->f9.u.bits[0]);
122 printk("f10 : %05lx%016lx f11 : %05lx%016lx\n",
123 regs->f10.u.bits[1], regs->f10.u.bits[0],
124 regs->f11.u.bits[1], regs->f11.u.bits[0]);
125
126 printk("r1 : %016lx r2 : %016lx r3 : %016lx\n", regs->r1, regs->r2, regs->r3);
127 printk("r8 : %016lx r9 : %016lx r10 : %016lx\n", regs->r8, regs->r9, regs->r10);
128 printk("r11 : %016lx r12 : %016lx r13 : %016lx\n", regs->r11, regs->r12, regs->r13);
129 printk("r14 : %016lx r15 : %016lx r16 : %016lx\n", regs->r14, regs->r15, regs->r16);
130 printk("r17 : %016lx r18 : %016lx r19 : %016lx\n", regs->r17, regs->r18, regs->r19);
131 printk("r20 : %016lx r21 : %016lx r22 : %016lx\n", regs->r20, regs->r21, regs->r22);
132 printk("r23 : %016lx r24 : %016lx r25 : %016lx\n", regs->r23, regs->r24, regs->r25);
133 printk("r26 : %016lx r27 : %016lx r28 : %016lx\n", regs->r26, regs->r27, regs->r28);
134 printk("r29 : %016lx r30 : %016lx r31 : %016lx\n", regs->r29, regs->r30, regs->r31);
135
136 if (user_mode(regs)) {
137
138 unsigned long val, *bsp, ndirty;
139 int i, sof, is_nat = 0;
140
141 sof = regs->cr_ifs & 0x7f;
142 ndirty = (regs->loadrs >> 19);
143 bsp = ia64_rse_skip_regs((unsigned long *) regs->ar_bspstore, ndirty);
144 for (i = 0; i < sof; ++i) {
145 get_user(val, (unsigned long __user *) ia64_rse_skip_regs(bsp, i));
146 printk("r%-3u:%c%016lx%s", 32 + i, is_nat ? '*' : ' ', val,
147 ((i == sof - 1) || (i % 3) == 2) ? "\n" : " ");
148 }
149 } else
150 show_stack(NULL, NULL, KERN_DEFAULT);
151}
152
153
154void
155console_print(const char *s)
156{
157 printk(KERN_EMERG "%s", s);
158}
159
160void
161do_notify_resume_user(sigset_t *unused, struct sigscratch *scr, long in_syscall)
162{
163 if (fsys_mode(current, &scr->pt)) {
164
165
166
167
168 if (!ia64_psr(&scr->pt)->lp)
169 ia64_psr(&scr->pt)->lp = 1;
170 return;
171 }
172
173
174 if (test_thread_flag(TIF_SIGPENDING) ||
175 test_thread_flag(TIF_NOTIFY_SIGNAL)) {
176 local_irq_enable();
177 ia64_do_signal(scr, in_syscall);
178 }
179
180 if (test_thread_flag(TIF_NOTIFY_RESUME)) {
181 local_irq_enable();
182 tracehook_notify_resume(&scr->pt);
183 }
184
185
186 if (unlikely(test_thread_flag(TIF_RESTORE_RSE))) {
187 local_irq_enable();
188 ia64_sync_krbs();
189 }
190
191 local_irq_disable();
192}
193
194static int __init nohalt_setup(char * str)
195{
196 cpu_idle_poll_ctrl(true);
197 return 1;
198}
199__setup("nohalt", nohalt_setup);
200
201#ifdef CONFIG_HOTPLUG_CPU
202
203static inline void play_dead(void)
204{
205 unsigned int this_cpu = smp_processor_id();
206
207
208 __this_cpu_write(cpu_state, CPU_DEAD);
209
210 max_xtp();
211 local_irq_disable();
212 idle_task_exit();
213 ia64_jump_to_sal(&sal_boot_rendez_state[this_cpu]);
214
215
216
217
218 BUG();
219}
220#else
221static inline void play_dead(void)
222{
223 BUG();
224}
225#endif
226
227void arch_cpu_idle_dead(void)
228{
229 play_dead();
230}
231
232void arch_cpu_idle(void)
233{
234 void (*mark_idle)(int) = ia64_mark_idle;
235
236#ifdef CONFIG_SMP
237 min_xtp();
238#endif
239 rmb();
240 if (mark_idle)
241 (*mark_idle)(1);
242
243 raw_safe_halt();
244
245 if (mark_idle)
246 (*mark_idle)(0);
247#ifdef CONFIG_SMP
248 normal_xtp();
249#endif
250}
251
252void
253ia64_save_extra (struct task_struct *task)
254{
255 if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
256 ia64_save_debug_regs(&task->thread.dbr[0]);
257}
258
259void
260ia64_load_extra (struct task_struct *task)
261{
262 if ((task->thread.flags & IA64_THREAD_DBG_VALID) != 0)
263 ia64_load_debug_regs(&task->thread.dbr[0]);
264}
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297int
298copy_thread(unsigned long clone_flags, unsigned long user_stack_base,
299 unsigned long user_stack_size, struct task_struct *p, unsigned long tls)
300{
301 extern char ia64_ret_from_clone;
302 struct switch_stack *child_stack, *stack;
303 unsigned long rbs, child_rbs, rbs_size;
304 struct pt_regs *child_ptregs;
305 struct pt_regs *regs = current_pt_regs();
306 int retval = 0;
307
308 child_ptregs = (struct pt_regs *) ((unsigned long) p + IA64_STK_OFFSET) - 1;
309 child_stack = (struct switch_stack *) child_ptregs - 1;
310
311 rbs = (unsigned long) current + IA64_RBS_OFFSET;
312 child_rbs = (unsigned long) p + IA64_RBS_OFFSET;
313
314
315 p->thread.ksp = (unsigned long) child_stack - 16;
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333# define THREAD_FLAGS_TO_CLEAR (IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID \
334 | IA64_THREAD_PM_VALID)
335# define THREAD_FLAGS_TO_SET 0
336 p->thread.flags = ((current->thread.flags & ~THREAD_FLAGS_TO_CLEAR)
337 | THREAD_FLAGS_TO_SET);
338
339 ia64_drop_fpu(p);
340
341 if (unlikely(p->flags & (PF_KTHREAD | PF_IO_WORKER))) {
342 if (unlikely(!user_stack_base)) {
343
344 return 0;
345 }
346 memset(child_stack, 0, sizeof(*child_ptregs) + sizeof(*child_stack));
347 child_stack->r4 = user_stack_base;
348 child_stack->r5 = user_stack_size;
349
350
351
352
353 child_ptregs->cr_ipsr = ia64_getreg(_IA64_REG_PSR) | IA64_PSR_BN;
354
355 child_ptregs->cr_ifs = 1UL << 63;
356 child_stack->ar_fpsr = child_ptregs->ar_fpsr
357 = ia64_getreg(_IA64_REG_AR_FPSR);
358 child_stack->pr = (1 << PRED_KERNEL_STACK);
359 child_stack->ar_bspstore = child_rbs;
360 child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
361
362
363
364
365
366
367 child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
368 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
369
370 return 0;
371 }
372 stack = ((struct switch_stack *) regs) - 1;
373
374 memcpy(child_stack, stack, sizeof(*child_ptregs) + sizeof(*child_stack));
375
376
377 rbs_size = stack->ar_bspstore - rbs;
378 memcpy((void *) child_rbs, (void *) rbs, rbs_size);
379 if (clone_flags & CLONE_SETTLS)
380 child_ptregs->r13 = tls;
381 if (user_stack_base) {
382 child_ptregs->r12 = user_stack_base + user_stack_size - 16;
383 child_ptregs->ar_bspstore = user_stack_base;
384 child_ptregs->ar_rnat = 0;
385 child_ptregs->loadrs = 0;
386 }
387 child_stack->ar_bspstore = child_rbs + rbs_size;
388 child_stack->b0 = (unsigned long) &ia64_ret_from_clone;
389
390
391
392
393
394
395 child_ptregs->cr_ipsr = ((child_ptregs->cr_ipsr | IA64_PSR_BITS_TO_SET)
396 & ~(IA64_PSR_BITS_TO_CLEAR | IA64_PSR_PP | IA64_PSR_UP));
397 return retval;
398}
399
400asmlinkage long ia64_clone(unsigned long clone_flags, unsigned long stack_start,
401 unsigned long stack_size, unsigned long parent_tidptr,
402 unsigned long child_tidptr, unsigned long tls)
403{
404 struct kernel_clone_args args = {
405 .flags = (lower_32_bits(clone_flags) & ~CSIGNAL),
406 .pidfd = (int __user *)parent_tidptr,
407 .child_tid = (int __user *)child_tidptr,
408 .parent_tid = (int __user *)parent_tidptr,
409 .exit_signal = (lower_32_bits(clone_flags) & CSIGNAL),
410 .stack = stack_start,
411 .stack_size = stack_size,
412 .tls = tls,
413 };
414
415 return kernel_clone(&args);
416}
417
418static void
419do_copy_task_regs (struct task_struct *task, struct unw_frame_info *info, void *arg)
420{
421 unsigned long mask, sp, nat_bits = 0, ar_rnat, urbs_end, cfm;
422 unsigned long ip;
423 elf_greg_t *dst = arg;
424 struct pt_regs *pt;
425 char nat;
426 int i;
427
428 memset(dst, 0, sizeof(elf_gregset_t));
429
430 if (unw_unwind_to_user(info) < 0)
431 return;
432
433 unw_get_sp(info, &sp);
434 pt = (struct pt_regs *) (sp + 16);
435
436 urbs_end = ia64_get_user_rbs_end(task, pt, &cfm);
437
438 if (ia64_sync_user_rbs(task, info->sw, pt->ar_bspstore, urbs_end) < 0)
439 return;
440
441 ia64_peek(task, info->sw, urbs_end, (long) ia64_rse_rnat_addr((long *) urbs_end),
442 &ar_rnat);
443
444
445
446
447
448
449
450
451
452
453
454
455
456 for (i = 1, mask = (1UL << i); i < 32; ++i) {
457 unw_get_gr(info, i, &dst[i], &nat);
458 if (nat)
459 nat_bits |= mask;
460 mask <<= 1;
461 }
462 dst[32] = nat_bits;
463 unw_get_pr(info, &dst[33]);
464
465 for (i = 0; i < 8; ++i)
466 unw_get_br(info, i, &dst[34 + i]);
467
468 unw_get_rp(info, &ip);
469 dst[42] = ip + ia64_psr(pt)->ri;
470 dst[43] = cfm;
471 dst[44] = pt->cr_ipsr & IA64_PSR_UM;
472
473 unw_get_ar(info, UNW_AR_RSC, &dst[45]);
474
475
476
477
478 dst[46] = urbs_end;
479 dst[47] = pt->ar_bspstore;
480 dst[48] = ar_rnat;
481 unw_get_ar(info, UNW_AR_CCV, &dst[49]);
482 unw_get_ar(info, UNW_AR_UNAT, &dst[50]);
483 unw_get_ar(info, UNW_AR_FPSR, &dst[51]);
484 dst[52] = pt->ar_pfs;
485 unw_get_ar(info, UNW_AR_LC, &dst[53]);
486 unw_get_ar(info, UNW_AR_EC, &dst[54]);
487 unw_get_ar(info, UNW_AR_CSD, &dst[55]);
488 unw_get_ar(info, UNW_AR_SSD, &dst[56]);
489}
490
491static void
492do_copy_regs (struct unw_frame_info *info, void *arg)
493{
494 do_copy_task_regs(current, info, arg);
495}
496
497void
498ia64_elf_core_copy_regs (struct pt_regs *pt, elf_gregset_t dst)
499{
500 unw_init_running(do_copy_regs, dst);
501}
502
503
504
505
506void
507flush_thread (void)
508{
509
510 current->thread.flags &= ~(IA64_THREAD_FPH_VALID | IA64_THREAD_DBG_VALID);
511 ia64_drop_fpu(current);
512}
513
514
515
516
517
518void
519exit_thread (struct task_struct *tsk)
520{
521
522 ia64_drop_fpu(tsk);
523}
524
525unsigned long
526get_wchan (struct task_struct *p)
527{
528 struct unw_frame_info info;
529 unsigned long ip;
530 int count = 0;
531
532 if (!p || p == current || task_is_running(p))
533 return 0;
534
535
536
537
538
539
540
541
542
543 unw_init_from_blocked_task(&info, p);
544 do {
545 if (task_is_running(p))
546 return 0;
547 if (unw_unwind(&info) < 0)
548 return 0;
549 unw_get_ip(&info, &ip);
550 if (!in_sched_functions(ip))
551 return ip;
552 } while (count++ < 16);
553 return 0;
554}
555
556void
557cpu_halt (void)
558{
559 pal_power_mgmt_info_u_t power_info[8];
560 unsigned long min_power;
561 int i, min_power_state;
562
563 if (ia64_pal_halt_info(power_info) != 0)
564 return;
565
566 min_power_state = 0;
567 min_power = power_info[0].pal_power_mgmt_info_s.power_consumption;
568 for (i = 1; i < 8; ++i)
569 if (power_info[i].pal_power_mgmt_info_s.im
570 && power_info[i].pal_power_mgmt_info_s.power_consumption < min_power) {
571 min_power = power_info[i].pal_power_mgmt_info_s.power_consumption;
572 min_power_state = i;
573 }
574
575 while (1)
576 ia64_pal_halt(min_power_state);
577}
578
579void machine_shutdown(void)
580{
581 smp_shutdown_nonboot_cpus(reboot_cpu);
582
583#ifdef CONFIG_KEXEC
584 kexec_disable_iosapic();
585#endif
586}
587
588void
589machine_restart (char *restart_cmd)
590{
591 (void) notify_die(DIE_MACHINE_RESTART, restart_cmd, NULL, 0, 0, 0);
592 efi_reboot(REBOOT_WARM, NULL);
593}
594
595void
596machine_halt (void)
597{
598 (void) notify_die(DIE_MACHINE_HALT, "", NULL, 0, 0, 0);
599 cpu_halt();
600}
601
602void
603machine_power_off (void)
604{
605 if (pm_power_off)
606 pm_power_off();
607 machine_halt();
608}
609
610EXPORT_SYMBOL(ia64_delay_loop);
611