1 /*
2 * Copyright (c) 2017-2023 The strace developers.
3 * All rights reserved.
4 *
5 * SPDX-License-Identifier: GPL-2.0-or-later
6 */
7
8 #include "tests.h"
9 #include <stdint.h>
10 #include <stdio.h>
11 #include <sys/mman.h>
12 #include <unistd.h>
13 #include "scno.h"
14
15 static const char *errstr;
16
17 static long
18 k_madvise(const kernel_ulong_t addr,
19 const kernel_ulong_t length,
20 const kernel_ulong_t advice)
21 {
22 long rc = syscall(__NR_madvise, addr, length, advice);
23 errstr = sprintrc(rc);
24 return rc;
25 }
26
27 int
28 main(void)
29 {
30 const unsigned long length = get_page_size();
31 void *const addr = tail_alloc(length);
32 long rc;
33
34 rc = madvise(addr, length, MADV_NORMAL);
35 printf("madvise(%p, %lu, " XLAT_FMT ") = %s\n",
36 addr, length, XLAT_ARGS(MADV_NORMAL), sprintrc(rc));
37
38 static const kernel_ulong_t advice =
39 (kernel_ulong_t) 0xfacefeed00000000ULL | MADV_RANDOM;
40 rc = k_madvise((uintptr_t) addr, length, advice);
41 printf("madvise(%p, %lu, " XLAT_FMT ") = %s\n",
42 addr, length, XLAT_ARGS(MADV_RANDOM), sprintrc(rc));
43
44 static const kernel_ulong_t bogus_length =
45 (kernel_ulong_t) 0xfffffffffffffaceULL;
46 rc = k_madvise(0, bogus_length, MADV_SEQUENTIAL);
47 printf("madvise(NULL, %llu, " XLAT_FMT ") = %s\n",
48 (unsigned long long) bogus_length,
49 XLAT_ARGS(MADV_SEQUENTIAL), sprintrc(rc));
50
51 if (F8ILL_KULONG_SUPPORTED) {
52 rc = k_madvise(f8ill_ptr_to_kulong(addr), length,
53 MADV_WILLNEED);
54 printf("madvise(%#llx, %lu, " XLAT_FMT ") = %s\n",
55 (unsigned long long) f8ill_ptr_to_kulong(addr),
56 length, XLAT_ARGS(MADV_WILLNEED), sprintrc(rc));
57 }
58
59 static const struct strval32 advices[] = {
60 #ifdef __alpha__
61 { 4, "0x4" NRAW(" /* MADV_??? */") },
62 { ARG_XLAT_KNOWN(0x6, "MADV_DONTNEED") },
63 #else
64 { ARG_XLAT_KNOWN(0x4, "MADV_DONTNEED") },
65 { 6, "0x6" NRAW(" /* MADV_??? */") },
66 #endif
67 { 5, "0x5" NRAW(" /* MADV_??? */") },
68 { 7, "0x7" NRAW(" /* MADV_??? */") },
69 { ARG_XLAT_KNOWN(0x8, "MADV_FREE") },
70 { ARG_XLAT_KNOWN(0x9, "MADV_REMOVE") },
71 { ARG_XLAT_KNOWN(0xa, "MADV_DONTFORK") },
72 { ARG_XLAT_KNOWN(0xb, "MADV_DOFORK") },
73 #ifdef __hppa__
74 { 12, "0xc" NRAW(" /* generic MADV_MERGEABLE */") },
75 { 13, "0xd" NRAW(" /* generic MADV_UNMERGEABLE */") },
76 { 14, "0xe" NRAW(" /* generic MADV_HUGEPAGE */") },
77 { 15, "0xf" NRAW(" /* generic MADV_NOHUGEPAGE */") },
78 { 16, "0x10" NRAW(" /* generic MADV_DONTDUMP */") },
79 { 17, "0x11" NRAW(" /* generic MADV_DODUMP */") },
80 { 18, "0x12" NRAW(" /* generic MADV_WIPEONFORK */") },
81 { 19, "0x13" NRAW(" /* generic MADV_KEEPONFORK */") },
82 #else
83 { ARG_XLAT_KNOWN(0xc, "MADV_MERGEABLE") },
84 { ARG_XLAT_KNOWN(0xd, "MADV_UNMERGEABLE") },
85 { ARG_XLAT_KNOWN(0xe, "MADV_HUGEPAGE") },
86 { ARG_XLAT_KNOWN(0xf, "MADV_NOHUGEPAGE") },
87 { ARG_XLAT_KNOWN(0x10, "MADV_DONTDUMP") },
88 { ARG_XLAT_KNOWN(0x11, "MADV_DODUMP") },
89 { ARG_XLAT_KNOWN(0x12, "MADV_WIPEONFORK") },
90 { ARG_XLAT_KNOWN(0x13, "MADV_KEEPONFORK") },
91 #endif
92 { ARG_XLAT_KNOWN(0x14, "MADV_COLD") },
93 { ARG_XLAT_KNOWN(0x15, "MADV_PAGEOUT") },
94 { ARG_XLAT_KNOWN(0x16, "MADV_POPULATE_READ") },
95 { ARG_XLAT_KNOWN(0x17, "MADV_POPULATE_WRITE") },
96 { ARG_XLAT_KNOWN(0x18, "MADV_DONTNEED_LOCKED") },
97 #ifdef __hppa__
98 { 25, "0x19" NRAW(" /* generic MADV_COLLAPSE */") },
99 #else
100 { ARG_XLAT_KNOWN(0x19, "MADV_COLLAPSE") },
101 #endif
102 { ARG_XLAT_UNKNOWN(0x1a, "MADV_???") },
103
104 { ARG_XLAT_UNKNOWN(0x40, "MADV_???") },
105 #ifdef __hppa__
106 { 65, "0x41" NRAW(" /* old MADV_MERGEABLE */") },
107 { 66, "0x42" NRAW(" /* old MADV_UNMERGEABLE */") },
108 { 67, "0x43" NRAW(" /* old MADV_HUGEPAGE */") },
109 { 68, "0x44" NRAW(" /* old MADV_NOHUGEPAGE */") },
110 { 69, "0x45" NRAW(" /* old MADV_DONTDUMP */") },
111 { 70, "0x46" NRAW(" /* old MADV_DODUMP */") },
112 { 71, "0x47" NRAW(" /* old MADV_WIPEONFORK */") },
113 { 72, "0x48" NRAW(" /* old MADV_KEEPONFORK */") },
114 { 73, "0x49" NRAW(" /* old MADV_COLLAPSE */") },
115 #else
116 { ARG_XLAT_UNKNOWN(0x41, "MADV_???") },
117 { ARG_XLAT_UNKNOWN(0x42, "MADV_???") },
118 { ARG_XLAT_UNKNOWN(0x43, "MADV_???") },
119 { ARG_XLAT_UNKNOWN(0x44, "MADV_???") },
120 { ARG_XLAT_UNKNOWN(0x45, "MADV_???") },
121 { ARG_XLAT_UNKNOWN(0x46, "MADV_???") },
122 { ARG_XLAT_UNKNOWN(0x47, "MADV_???") },
123 { ARG_XLAT_UNKNOWN(0x48, "MADV_???") },
124 { ARG_XLAT_UNKNOWN(0x49, "MADV_???") },
125 #endif
126 { ARG_XLAT_UNKNOWN(0x4a, "MADV_???") },
127
128 { ARG_XLAT_UNKNOWN(0x63, "MADV_???") },
129 { ARG_XLAT_KNOWN(0x64, "MADV_HWPOISON") },
130 { ARG_XLAT_KNOWN(0x65, "MADV_SOFT_OFFLINE") },
131 { ARG_XLAT_UNKNOWN(0x66, "MADV_???") },
132
133 { ARG_XLAT_UNKNOWN(0x80, "MADV_???") },
134 { ARG_XLAT_UNKNOWN(0x81, "MADV_???") },
135 { ARG_XLAT_UNKNOWN(0x100, "MADV_???") },
136 { ARG_XLAT_UNKNOWN(0x101, "MADV_???") },
137 { ARG_XLAT_UNKNOWN(0x1000, "MADV_???") },
138 { ARG_XLAT_UNKNOWN(0x1001, "MADV_???") },
139 { ARG_XLAT_UNKNOWN(0xbadc0ded, "MADV_???") },
140 };
141
142 for (unsigned int i = 0; i < ARRAY_SIZE(advices); i++) {
143 rc = madvise(NULL, length, advices[i].val);
144 printf("madvise(NULL, %lu, %s) = %s\n",
145 length, advices[i].str, sprintrc(rc));
146 }
147
148 puts("+++ exited with 0 +++");
149 return 0;
150 }