1 /* Test for syscall interfaces.
2 Copyright (C) 2020-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 /* This test verifies that the x32 system call handling zero-extends
20 unsigned 32-bit arguments to the 64-bit argument registers for
21 system calls (bug 25810). The bug is specific to x32, but the test
22 should pass on all architectures. */
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <fcntl.h>
27 #include <sys/mman.h>
28 #include <support/check.h>
29 #include <support/xunistd.h>
30
31 /* On x32, this can be passed in a single 64-bit integer register. */
32 struct Array
33 {
34 size_t length;
35 void *ptr;
36 };
37
38 static int error_count;
39
40 __attribute__ ((noclone, noinline))
41 struct Array
42 allocate (size_t bytes)
43 {
44 if (!bytes)
45 return __extension__ (struct Array) {0, 0};
46
47 void *p = mmap (0x0, bytes, PROT_READ | PROT_WRITE,
48 MAP_PRIVATE | MAP_ANON, -1, 0);
49 if (p == MAP_FAILED)
50 return __extension__ (struct Array) {0, 0};
51
52 return __extension__ (struct Array) {bytes, p};
53 }
54
55 __attribute__ ((noclone, noinline))
56 void
57 deallocate (struct Array b)
58 {
59 /* On x32, the 64-bit integer register containing `b' may be copied
60 to another 64-bit integer register to pass the second argument to
61 munmap. */
62 if (b.length && munmap (b.ptr, b.length))
63 {
64 printf ("munmap error: %m\n");
65 error_count++;
66 }
67 }
68
69 __attribute__ ((noclone, noinline))
70 void *
71 do_mmap (void *addr, size_t length)
72 {
73 return mmap (addr, length, PROT_READ | PROT_WRITE,
74 MAP_PRIVATE | MAP_ANON, -1, 0);
75 }
76
77 __attribute__ ((noclone, noinline))
78 void *
79 reallocate (struct Array b)
80 {
81 /* On x32, the 64-bit integer register containing `b' may be copied
82 to another 64-bit integer register to pass the second argument to
83 do_mmap. */
84 if (b.length)
85 return do_mmap (b.ptr, b.length);
86 return NULL;
87 }
88
89 __attribute__ ((noclone, noinline))
90 void
91 protect (struct Array b)
92 {
93 if (b.length)
94 {
95 /* On x32, the 64-bit integer register containing `b' may be copied
96 to another 64-bit integer register to pass the second argument
97 to mprotect. */
98 if (mprotect (b.ptr, b.length,
99 PROT_READ | PROT_WRITE | PROT_EXEC))
100 {
101 printf ("mprotect error: %m\n");
102 error_count++;
103 }
104 }
105 }
106
107 __attribute__ ((noclone, noinline))
108 ssize_t
109 do_read (int fd, void *ptr, struct Array b)
110 {
111 /* On x32, the 64-bit integer register containing `b' may be copied
112 to another 64-bit integer register to pass the second argument to
113 read. */
114 if (b.length)
115 return read (fd, ptr, b.length);
116 return 0;
117 }
118
119 __attribute__ ((noclone, noinline))
120 ssize_t
121 do_write (int fd, void *ptr, struct Array b)
122 {
123 /* On x32, the 64-bit integer register containing `b' may be copied
124 to another 64-bit integer register to pass the second argument to
125 write. */
126 if (b.length)
127 return write (fd, ptr, b.length);
128 return 0;
129 }
130
131 static int
132 do_test (void)
133 {
134 struct Array array;
135
136 array = allocate (1);
137 protect (array);
138 deallocate (array);
139 void *p = reallocate (array);
140 if (p == MAP_FAILED)
141 {
142 printf ("mmap error: %m\n");
143 error_count++;
144 }
145 array.ptr = p;
146 protect (array);
147 deallocate (array);
148
149 int fd = xopen ("/dev/null", O_RDWR, 0);
150 char buf[2];
151 array.ptr = buf;
152 if (do_read (fd, array.ptr, array) == -1)
153 {
154 printf ("read error: %m\n");
155 error_count++;
156 }
157 if (do_write (fd, array.ptr, array) == -1)
158 {
159 printf ("write error: %m\n");
160 error_count++;
161 }
162 xclose (fd);
163
164 return error_count ? EXIT_FAILURE : EXIT_SUCCESS;
165 }
166
167 #include <support/test-driver.c>