1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3 * Ptrace interface test helper functions
4 *
5 * Copyright (C) 2015 Anshuman Khandual, IBM Corporation.
6 */
7
8 #define __SANE_USERSPACE_TYPES__
9
10 #include <inttypes.h>
11 #include <unistd.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <malloc.h>
15 #include <errno.h>
16 #include <time.h>
17 #include <sys/ptrace.h>
18 #include <sys/ioctl.h>
19 #include <sys/uio.h>
20 #include <sys/types.h>
21 #include <sys/wait.h>
22 #include <sys/signal.h>
23 #include <sys/ipc.h>
24 #include <sys/shm.h>
25 #include <sys/user.h>
26 #include <sys/syscall.h>
27 #include <linux/elf.h>
28 #include <linux/types.h>
29 #include <linux/auxvec.h>
30 #include "reg.h"
31 #include "utils.h"
32
33 #define TEST_PASS 0
34 #define TEST_FAIL 1
35
36 struct fpr_regs {
37 __u64 fpr[32];
38 __u64 fpscr;
39 };
40
41 struct tm_spr_regs {
42 unsigned long tm_tfhar;
43 unsigned long tm_texasr;
44 unsigned long tm_tfiar;
45 };
46
47 #ifndef NT_PPC_TAR
48 #define NT_PPC_TAR 0x103
49 #define NT_PPC_PPR 0x104
50 #define NT_PPC_DSCR 0x105
51 #define NT_PPC_EBB 0x106
52 #define NT_PPC_PMU 0x107
53 #define NT_PPC_TM_CGPR 0x108
54 #define NT_PPC_TM_CFPR 0x109
55 #define NT_PPC_TM_CVMX 0x10a
56 #define NT_PPC_TM_CVSX 0x10b
57 #define NT_PPC_TM_SPR 0x10c
58 #define NT_PPC_TM_CTAR 0x10d
59 #define NT_PPC_TM_CPPR 0x10e
60 #define NT_PPC_TM_CDSCR 0x10f
61 #endif
62
63 /* Basic ptrace operations */
64 int start_trace(pid_t child)
65 {
66 int ret;
67
68 ret = ptrace(PTRACE_ATTACH, child, NULL, NULL);
69 if (ret) {
70 perror("ptrace(PTRACE_ATTACH) failed");
71 return TEST_FAIL;
72 }
73 ret = waitpid(child, NULL, 0);
74 if (ret != child) {
75 perror("waitpid() failed");
76 return TEST_FAIL;
77 }
78 return TEST_PASS;
79 }
80
81 int stop_trace(pid_t child)
82 {
83 int ret;
84
85 ret = ptrace(PTRACE_DETACH, child, NULL, NULL);
86 if (ret) {
87 perror("ptrace(PTRACE_DETACH) failed");
88 return TEST_FAIL;
89 }
90 return TEST_PASS;
91 }
92
93 int cont_trace(pid_t child)
94 {
95 int ret;
96
97 ret = ptrace(PTRACE_CONT, child, NULL, NULL);
98 if (ret) {
99 perror("ptrace(PTRACE_CONT) failed");
100 return TEST_FAIL;
101 }
102 return TEST_PASS;
103 }
104
105 int ptrace_read_regs(pid_t child, unsigned long type, unsigned long regs[],
106 int n)
107 {
108 struct iovec iov;
109 long ret;
110
111 FAIL_IF(start_trace(child));
112
113 iov.iov_base = regs;
114 iov.iov_len = n * sizeof(unsigned long);
115
116 ret = ptrace(PTRACE_GETREGSET, child, type, &iov);
117 if (ret)
118 return ret;
119
120 FAIL_IF(stop_trace(child));
121
122 return TEST_PASS;
123 }
124
125 long ptrace_write_regs(pid_t child, unsigned long type, unsigned long regs[],
126 int n)
127 {
128 struct iovec iov;
129 long ret;
130
131 FAIL_IF(start_trace(child));
132
133 iov.iov_base = regs;
134 iov.iov_len = n * sizeof(unsigned long);
135
136 ret = ptrace(PTRACE_SETREGSET, child, type, &iov);
137
138 FAIL_IF(stop_trace(child));
139
140 return ret;
141 }
142
143 /* TAR, PPR, DSCR */
144 int show_tar_registers(pid_t child, unsigned long *out)
145 {
146 struct iovec iov;
147 unsigned long *reg;
148 int ret;
149
150 reg = malloc(sizeof(unsigned long));
151 if (!reg) {
152 perror("malloc() failed");
153 return TEST_FAIL;
154 }
155 iov.iov_base = (u64 *) reg;
156 iov.iov_len = sizeof(unsigned long);
157
158 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TAR, &iov);
159 if (ret) {
160 perror("ptrace(PTRACE_GETREGSET) failed");
161 goto fail;
162 }
163 if (out)
164 out[0] = *reg;
165
166 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_PPR, &iov);
167 if (ret) {
168 perror("ptrace(PTRACE_GETREGSET) failed");
169 goto fail;
170 }
171 if (out)
172 out[1] = *reg;
173
174 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_DSCR, &iov);
175 if (ret) {
176 perror("ptrace(PTRACE_GETREGSET) failed");
177 goto fail;
178 }
179 if (out)
180 out[2] = *reg;
181
182 free(reg);
183 return TEST_PASS;
184 fail:
185 free(reg);
186 return TEST_FAIL;
187 }
188
189 int write_tar_registers(pid_t child, unsigned long tar,
190 unsigned long ppr, unsigned long dscr)
191 {
192 struct iovec iov;
193 unsigned long *reg;
194 int ret;
195
196 reg = malloc(sizeof(unsigned long));
197 if (!reg) {
198 perror("malloc() failed");
199 return TEST_FAIL;
200 }
201
202 iov.iov_base = (u64 *) reg;
203 iov.iov_len = sizeof(unsigned long);
204
205 *reg = tar;
206 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TAR, &iov);
207 if (ret) {
208 perror("ptrace(PTRACE_SETREGSET) failed");
209 goto fail;
210 }
211
212 *reg = ppr;
213 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_PPR, &iov);
214 if (ret) {
215 perror("ptrace(PTRACE_SETREGSET) failed");
216 goto fail;
217 }
218
219 *reg = dscr;
220 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_DSCR, &iov);
221 if (ret) {
222 perror("ptrace(PTRACE_SETREGSET) failed");
223 goto fail;
224 }
225
226 free(reg);
227 return TEST_PASS;
228 fail:
229 free(reg);
230 return TEST_FAIL;
231 }
232
233 int show_tm_checkpointed_state(pid_t child, unsigned long *out)
234 {
235 struct iovec iov;
236 unsigned long *reg;
237 int ret;
238
239 reg = malloc(sizeof(unsigned long));
240 if (!reg) {
241 perror("malloc() failed");
242 return TEST_FAIL;
243 }
244
245 iov.iov_base = (u64 *) reg;
246 iov.iov_len = sizeof(unsigned long);
247
248 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CTAR, &iov);
249 if (ret) {
250 perror("ptrace(PTRACE_GETREGSET) failed");
251 goto fail;
252 }
253 if (out)
254 out[0] = *reg;
255
256 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CPPR, &iov);
257 if (ret) {
258 perror("ptrace(PTRACE_GETREGSET) failed");
259 goto fail;
260 }
261 if (out)
262 out[1] = *reg;
263
264 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CDSCR, &iov);
265 if (ret) {
266 perror("ptrace(PTRACE_GETREGSET) failed");
267 goto fail;
268 }
269 if (out)
270 out[2] = *reg;
271
272 free(reg);
273 return TEST_PASS;
274
275 fail:
276 free(reg);
277 return TEST_FAIL;
278 }
279
280 int write_ckpt_tar_registers(pid_t child, unsigned long tar,
281 unsigned long ppr, unsigned long dscr)
282 {
283 struct iovec iov;
284 unsigned long *reg;
285 int ret;
286
287 reg = malloc(sizeof(unsigned long));
288 if (!reg) {
289 perror("malloc() failed");
290 return TEST_FAIL;
291 }
292
293 iov.iov_base = (u64 *) reg;
294 iov.iov_len = sizeof(unsigned long);
295
296 *reg = tar;
297 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CTAR, &iov);
298 if (ret) {
299 perror("ptrace(PTRACE_GETREGSET) failed");
300 goto fail;
301 }
302
303 *reg = ppr;
304 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CPPR, &iov);
305 if (ret) {
306 perror("ptrace(PTRACE_GETREGSET) failed");
307 goto fail;
308 }
309
310 *reg = dscr;
311 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CDSCR, &iov);
312 if (ret) {
313 perror("ptrace(PTRACE_GETREGSET) failed");
314 goto fail;
315 }
316
317 free(reg);
318 return TEST_PASS;
319 fail:
320 free(reg);
321 return TEST_FAIL;
322 }
323
324 /* FPR */
325 int show_fpr(pid_t child, __u64 *fpr)
326 {
327 struct fpr_regs *regs;
328 int ret, i;
329
330 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
331 ret = ptrace(PTRACE_GETFPREGS, child, NULL, regs);
332 if (ret) {
333 perror("ptrace(PTRACE_GETREGSET) failed");
334 return TEST_FAIL;
335 }
336
337 if (fpr) {
338 for (i = 0; i < 32; i++)
339 fpr[i] = regs->fpr[i];
340 }
341 return TEST_PASS;
342 }
343
344 int write_fpr(pid_t child, __u64 val)
345 {
346 struct fpr_regs *regs;
347 int ret, i;
348
349 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
350 ret = ptrace(PTRACE_GETFPREGS, child, NULL, regs);
351 if (ret) {
352 perror("ptrace(PTRACE_GETREGSET) failed");
353 return TEST_FAIL;
354 }
355
356 for (i = 0; i < 32; i++)
357 regs->fpr[i] = val;
358
359 ret = ptrace(PTRACE_SETFPREGS, child, NULL, regs);
360 if (ret) {
361 perror("ptrace(PTRACE_GETREGSET) failed");
362 return TEST_FAIL;
363 }
364 return TEST_PASS;
365 }
366
367 int show_ckpt_fpr(pid_t child, __u64 *fpr)
368 {
369 struct fpr_regs *regs;
370 struct iovec iov;
371 int ret, i;
372
373 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
374 iov.iov_base = regs;
375 iov.iov_len = sizeof(struct fpr_regs);
376
377 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CFPR, &iov);
378 if (ret) {
379 perror("ptrace(PTRACE_GETREGSET) failed");
380 return TEST_FAIL;
381 }
382
383 if (fpr) {
384 for (i = 0; i < 32; i++)
385 fpr[i] = regs->fpr[i];
386 }
387
388 return TEST_PASS;
389 }
390
391 int write_ckpt_fpr(pid_t child, unsigned long val)
392 {
393 struct fpr_regs *regs;
394 struct iovec iov;
395 int ret, i;
396
397 regs = (struct fpr_regs *) malloc(sizeof(struct fpr_regs));
398 iov.iov_base = regs;
399 iov.iov_len = sizeof(struct fpr_regs);
400
401 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CFPR, &iov);
402 if (ret) {
403 perror("ptrace(PTRACE_GETREGSET) failed");
404 return TEST_FAIL;
405 }
406
407 for (i = 0; i < 32; i++)
408 regs->fpr[i] = val;
409
410 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CFPR, &iov);
411 if (ret) {
412 perror("ptrace(PTRACE_GETREGSET) failed");
413 return TEST_FAIL;
414 }
415 return TEST_PASS;
416 }
417
418 /* GPR */
419 int show_gpr(pid_t child, unsigned long *gpr)
420 {
421 struct pt_regs *regs;
422 int ret, i;
423
424 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
425 if (!regs) {
426 perror("malloc() failed");
427 return TEST_FAIL;
428 }
429
430 ret = ptrace(PTRACE_GETREGS, child, NULL, regs);
431 if (ret) {
432 perror("ptrace(PTRACE_GETREGSET) failed");
433 return TEST_FAIL;
434 }
435
436 if (gpr) {
437 for (i = 14; i < 32; i++)
438 gpr[i-14] = regs->gpr[i];
439 }
440
441 return TEST_PASS;
442 }
443
444 long sys_ptrace(enum __ptrace_request request, pid_t pid, unsigned long addr, unsigned long data)
445 {
446 return syscall(__NR_ptrace, request, pid, (void *)addr, data);
447 }
448
449 // 33 because of FPSCR
450 #define PT_NUM_FPRS (33 * (sizeof(__u64) / sizeof(unsigned long)))
451
452 __u64 *peek_fprs(pid_t child)
453 {
454 unsigned long *fprs, *p, addr;
455 long ret;
456 int i;
457
458 fprs = malloc(sizeof(unsigned long) * PT_NUM_FPRS);
459 if (!fprs) {
460 perror("malloc() failed");
461 return NULL;
462 }
463
464 for (i = 0, p = fprs; i < PT_NUM_FPRS; i++, p++) {
465 addr = sizeof(unsigned long) * (PT_FPR0 + i);
466 ret = sys_ptrace(PTRACE_PEEKUSER, child, addr, (unsigned long)p);
467 if (ret) {
468 perror("ptrace(PTRACE_PEEKUSR) failed");
469 return NULL;
470 }
471 }
472
473 addr = sizeof(unsigned long) * (PT_FPR0 + i);
474 ret = sys_ptrace(PTRACE_PEEKUSER, child, addr, (unsigned long)&addr);
475 if (!ret) {
476 printf("ptrace(PTRACE_PEEKUSR) succeeded unexpectedly!\n");
477 return NULL;
478 }
479
480 return (__u64 *)fprs;
481 }
482
483 int poke_fprs(pid_t child, unsigned long *fprs)
484 {
485 unsigned long *p, addr;
486 long ret;
487 int i;
488
489 for (i = 0, p = fprs; i < PT_NUM_FPRS; i++, p++) {
490 addr = sizeof(unsigned long) * (PT_FPR0 + i);
491 ret = sys_ptrace(PTRACE_POKEUSER, child, addr, *p);
492 if (ret) {
493 perror("ptrace(PTRACE_POKEUSR) failed");
494 return -1;
495 }
496 }
497
498 addr = sizeof(unsigned long) * (PT_FPR0 + i);
499 ret = sys_ptrace(PTRACE_POKEUSER, child, addr, addr);
500 if (!ret) {
501 printf("ptrace(PTRACE_POKEUSR) succeeded unexpectedly!\n");
502 return -1;
503 }
504
505 return 0;
506 }
507
508 int write_gpr(pid_t child, unsigned long val)
509 {
510 struct pt_regs *regs;
511 int i, ret;
512
513 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
514 if (!regs) {
515 perror("malloc() failed");
516 return TEST_FAIL;
517 }
518
519 ret = ptrace(PTRACE_GETREGS, child, NULL, regs);
520 if (ret) {
521 perror("ptrace(PTRACE_GETREGSET) failed");
522 return TEST_FAIL;
523 }
524
525 for (i = 14; i < 32; i++)
526 regs->gpr[i] = val;
527
528 ret = ptrace(PTRACE_SETREGS, child, NULL, regs);
529 if (ret) {
530 perror("ptrace(PTRACE_GETREGSET) failed");
531 return TEST_FAIL;
532 }
533 return TEST_PASS;
534 }
535
536 int show_ckpt_gpr(pid_t child, unsigned long *gpr)
537 {
538 struct pt_regs *regs;
539 struct iovec iov;
540 int ret, i;
541
542 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
543 if (!regs) {
544 perror("malloc() failed");
545 return TEST_FAIL;
546 }
547
548 iov.iov_base = (u64 *) regs;
549 iov.iov_len = sizeof(struct pt_regs);
550
551 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CGPR, &iov);
552 if (ret) {
553 perror("ptrace(PTRACE_GETREGSET) failed");
554 return TEST_FAIL;
555 }
556
557 if (gpr) {
558 for (i = 14; i < 32; i++)
559 gpr[i-14] = regs->gpr[i];
560 }
561
562 return TEST_PASS;
563 }
564
565 int write_ckpt_gpr(pid_t child, unsigned long val)
566 {
567 struct pt_regs *regs;
568 struct iovec iov;
569 int ret, i;
570
571 regs = (struct pt_regs *) malloc(sizeof(struct pt_regs));
572 if (!regs) {
573 perror("malloc() failed\n");
574 return TEST_FAIL;
575 }
576 iov.iov_base = (u64 *) regs;
577 iov.iov_len = sizeof(struct pt_regs);
578
579 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CGPR, &iov);
580 if (ret) {
581 perror("ptrace(PTRACE_GETREGSET) failed");
582 return TEST_FAIL;
583 }
584
585 for (i = 14; i < 32; i++)
586 regs->gpr[i] = val;
587
588 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CGPR, &iov);
589 if (ret) {
590 perror("ptrace(PTRACE_GETREGSET) failed");
591 return TEST_FAIL;
592 }
593 return TEST_PASS;
594 }
595
596 /* VMX */
597 int show_vmx(pid_t child, unsigned long vmx[][2])
598 {
599 int ret;
600
601 ret = ptrace(PTRACE_GETVRREGS, child, 0, vmx);
602 if (ret) {
603 perror("ptrace(PTRACE_GETVRREGS) failed");
604 return TEST_FAIL;
605 }
606 return TEST_PASS;
607 }
608
609 int show_vmx_ckpt(pid_t child, unsigned long vmx[][2])
610 {
611 unsigned long regs[34][2];
612 struct iovec iov;
613 int ret;
614
615 iov.iov_base = (u64 *) regs;
616 iov.iov_len = sizeof(regs);
617 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CVMX, &iov);
618 if (ret) {
619 perror("ptrace(PTRACE_GETREGSET, NT_PPC_TM_CVMX) failed");
620 return TEST_FAIL;
621 }
622 memcpy(vmx, regs, sizeof(regs));
623 return TEST_PASS;
624 }
625
626
627 int write_vmx(pid_t child, unsigned long vmx[][2])
628 {
629 int ret;
630
631 ret = ptrace(PTRACE_SETVRREGS, child, 0, vmx);
632 if (ret) {
633 perror("ptrace(PTRACE_SETVRREGS) failed");
634 return TEST_FAIL;
635 }
636 return TEST_PASS;
637 }
638
639 int write_vmx_ckpt(pid_t child, unsigned long vmx[][2])
640 {
641 unsigned long regs[34][2];
642 struct iovec iov;
643 int ret;
644
645 memcpy(regs, vmx, sizeof(regs));
646 iov.iov_base = (u64 *) regs;
647 iov.iov_len = sizeof(regs);
648 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CVMX, &iov);
649 if (ret) {
650 perror("ptrace(PTRACE_SETREGSET, NT_PPC_TM_CVMX) failed");
651 return TEST_FAIL;
652 }
653 return TEST_PASS;
654 }
655
656 /* VSX */
657 int show_vsx(pid_t child, unsigned long *vsx)
658 {
659 int ret;
660
661 ret = ptrace(PTRACE_GETVSRREGS, child, 0, vsx);
662 if (ret) {
663 perror("ptrace(PTRACE_GETVSRREGS) failed");
664 return TEST_FAIL;
665 }
666 return TEST_PASS;
667 }
668
669 int show_vsx_ckpt(pid_t child, unsigned long *vsx)
670 {
671 unsigned long regs[32];
672 struct iovec iov;
673 int ret;
674
675 iov.iov_base = (u64 *) regs;
676 iov.iov_len = sizeof(regs);
677 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_CVSX, &iov);
678 if (ret) {
679 perror("ptrace(PTRACE_GETREGSET, NT_PPC_TM_CVSX) failed");
680 return TEST_FAIL;
681 }
682 memcpy(vsx, regs, sizeof(regs));
683 return TEST_PASS;
684 }
685
686 int write_vsx(pid_t child, unsigned long *vsx)
687 {
688 int ret;
689
690 ret = ptrace(PTRACE_SETVSRREGS, child, 0, vsx);
691 if (ret) {
692 perror("ptrace(PTRACE_SETVSRREGS) failed");
693 return TEST_FAIL;
694 }
695 return TEST_PASS;
696 }
697
698 int write_vsx_ckpt(pid_t child, unsigned long *vsx)
699 {
700 unsigned long regs[32];
701 struct iovec iov;
702 int ret;
703
704 memcpy(regs, vsx, sizeof(regs));
705 iov.iov_base = (u64 *) regs;
706 iov.iov_len = sizeof(regs);
707 ret = ptrace(PTRACE_SETREGSET, child, NT_PPC_TM_CVSX, &iov);
708 if (ret) {
709 perror("ptrace(PTRACE_SETREGSET, NT_PPC_TM_CVSX) failed");
710 return TEST_FAIL;
711 }
712 return TEST_PASS;
713 }
714
715 /* TM SPR */
716 int show_tm_spr(pid_t child, struct tm_spr_regs *out)
717 {
718 struct tm_spr_regs *regs;
719 struct iovec iov;
720 int ret;
721
722 regs = (struct tm_spr_regs *) malloc(sizeof(struct tm_spr_regs));
723 if (!regs) {
724 perror("malloc() failed");
725 return TEST_FAIL;
726 }
727
728 iov.iov_base = (u64 *) regs;
729 iov.iov_len = sizeof(struct tm_spr_regs);
730
731 ret = ptrace(PTRACE_GETREGSET, child, NT_PPC_TM_SPR, &iov);
732 if (ret) {
733 perror("ptrace(PTRACE_GETREGSET) failed");
734 return TEST_FAIL;
735 }
736
737 if (out)
738 memcpy(out, regs, sizeof(struct tm_spr_regs));
739
740 return TEST_PASS;
741 }
742
743
744
745 /* Analyse TEXASR after TM failure */
746 inline unsigned long get_tfiar(void)
747 {
748 return mfspr(SPRN_TFIAR);
749 }
750
751 void analyse_texasr(unsigned long texasr)
752 {
753 printf("TEXASR: %16lx\t", texasr);
754
755 if (texasr & TEXASR_FP)
756 printf("TEXASR_FP ");
757
758 if (texasr & TEXASR_DA)
759 printf("TEXASR_DA ");
760
761 if (texasr & TEXASR_NO)
762 printf("TEXASR_NO ");
763
764 if (texasr & TEXASR_FO)
765 printf("TEXASR_FO ");
766
767 if (texasr & TEXASR_SIC)
768 printf("TEXASR_SIC ");
769
770 if (texasr & TEXASR_NTC)
771 printf("TEXASR_NTC ");
772
773 if (texasr & TEXASR_TC)
774 printf("TEXASR_TC ");
775
776 if (texasr & TEXASR_TIC)
777 printf("TEXASR_TIC ");
778
779 if (texasr & TEXASR_IC)
780 printf("TEXASR_IC ");
781
782 if (texasr & TEXASR_IFC)
783 printf("TEXASR_IFC ");
784
785 if (texasr & TEXASR_ABT)
786 printf("TEXASR_ABT ");
787
788 if (texasr & TEXASR_SPD)
789 printf("TEXASR_SPD ");
790
791 if (texasr & TEXASR_HV)
792 printf("TEXASR_HV ");
793
794 if (texasr & TEXASR_PR)
795 printf("TEXASR_PR ");
796
797 if (texasr & TEXASR_FS)
798 printf("TEXASR_FS ");
799
800 if (texasr & TEXASR_TE)
801 printf("TEXASR_TE ");
802
803 if (texasr & TEXASR_ROT)
804 printf("TEXASR_ROT ");
805
806 printf("TFIAR :%lx\n", get_tfiar());
807 }
808
809 void store_gpr(unsigned long *addr);
810
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.