Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
uml: remove PAGE_SIZE from libc code
Distros seem to be removing PAGE_SIZE from asm/page.h. So, the libc side of
UML should stop using it.
I replace it with UM_KERN_PAGE_SIZE, which is defined to be the same as
PAGE_SIZE on the kernel side of the house. I could also use getpagesize(),
but it's more important that UML have the same value of PAGE_SIZE everywhere.
It's conceivable that it could be built with a larger PAGE_SIZE, and use of
getpagesize() would break that badly.
PAGE_MASK got the same treatment, as it is closely tied to PAGE_SIZE.
Signed-off-by: Jeff Dike <jdike@linux.intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
authored by
Jeff Dike
and committed by
Linus Torvalds
c539ab73
f5a9c77d
+22
-16
+1
arch/um/include/common-offsets.h
+1
arch/um/include/common-offsets.h
+3
-1
arch/um/os-Linux/main.c
+3
-1
arch/um/os-Linux/main.c
···
24
24
#include "uml-config.h"
25
25
#include "os.h"
26
26
#include "um_malloc.h"
27
+
#include "kern_constants.h"
27
28
28
29
/* Set in main, unchanged thereafter */
29
30
char *linux_prog;
···
233
232
234
233
if(!CAN_KMALLOC())
235
234
return __real_malloc(size);
236
-
else if(size <= PAGE_SIZE) /* finding contiguos pages can be hard*/
235
+
else if(size <= UM_KERN_PAGE_SIZE)
236
+
/* finding contiguous pages can be hard*/
237
237
ret = um_kmalloc(size);
238
238
else ret = um_vmalloc(size);
239
239
+7
-6
arch/um/os-Linux/skas/mem.c
+7
-6
arch/um/os-Linux/skas/mem.c
···
25
25
#include "sysdep/ptrace.h"
26
26
#include "sysdep/stub.h"
27
27
#include "init.h"
28
+
#include "kern_constants.h"
28
29
29
30
extern unsigned long batch_syscall_stub, __syscall_stub_start;
30
31
···
150
149
*stack = 0;
151
150
multi_op_count++;
152
151
153
-
if(!done && ((((unsigned long) stack) & ~PAGE_MASK) <
154
-
PAGE_SIZE - 10 * sizeof(long))){
152
+
if(!done && ((((unsigned long) stack) & ~UM_KERN_PAGE_MASK) <
153
+
UM_KERN_PAGE_SIZE - 10 * sizeof(long))){
155
154
*addr = stack;
156
155
return 0;
157
156
}
···
169
168
/* If *addr still is uninitialized, it *must* contain NULL.
170
169
* Thus in this case do_syscall_stub correctly won't be called.
171
170
*/
172
-
if((((unsigned long) *addr) & ~PAGE_MASK) >=
173
-
PAGE_SIZE - (10 + data_count) * sizeof(long)) {
171
+
if((((unsigned long) *addr) & ~UM_KERN_PAGE_MASK) >=
172
+
UM_KERN_PAGE_SIZE - (10 + data_count) * sizeof(long)) {
174
173
ret = do_syscall_stub(mm_idp, addr);
175
174
/* in case of error, don't overwrite data on stack */
176
175
if(ret)
···
184
183
185
184
memcpy(stack + 1, data, data_count * sizeof(long));
186
185
187
-
*stub_addr = (void *)(((unsigned long)(stack + 1) & ~PAGE_MASK) +
188
-
UML_CONFIG_STUB_DATA);
186
+
*stub_addr = (void *)(((unsigned long)(stack + 1) &
187
+
~UM_KERN_PAGE_MASK) + UML_CONFIG_STUB_DATA);
189
188
190
189
return 0;
191
190
}
+7
-6
arch/um/os-Linux/skas/process.c
+7
-6
arch/um/os-Linux/skas/process.c
···
252
252
unsigned long sp;
253
253
int pid, status, n, flags;
254
254
255
-
stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
255
+
stack = mmap(NULL, UM_KERN_PAGE_SIZE,
256
+
PROT_READ | PROT_WRITE | PROT_EXEC,
256
257
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
257
258
if(stack == MAP_FAILED)
258
259
panic("start_userspace : mmap failed, errno = %d", errno);
259
-
sp = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
260
+
sp = (unsigned long) stack + UM_KERN_PAGE_SIZE - sizeof(void *);
260
261
261
262
flags = CLONE_FILES | SIGCHLD;
262
263
if(proc_mm) flags |= CLONE_VM;
···
280
279
panic("start_userspace : PTRACE_OLDSETOPTIONS failed, errno=%d\n",
281
280
errno);
282
281
283
-
if(munmap(stack, PAGE_SIZE) < 0)
282
+
if(munmap(stack, UM_KERN_PAGE_SIZE) < 0)
284
283
panic("start_userspace : munmap failed, errno = %d\n", errno);
285
284
286
285
return(pid);
···
366
365
thread_regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
367
366
(unsigned long) stub_clone_handler -
368
367
(unsigned long) &__syscall_stub_start;
369
-
thread_regs[REGS_SP_INDEX] = UML_CONFIG_STUB_DATA + PAGE_SIZE -
368
+
thread_regs[REGS_SP_INDEX] = UML_CONFIG_STUB_DATA + UM_KERN_PAGE_SIZE -
370
369
sizeof(void *);
371
370
#ifdef __SIGNAL_FRAMESIZE
372
371
thread_regs[REGS_SP_INDEX] -= __SIGNAL_FRAMESIZE;
···
454
453
.u =
455
454
{ .mmap =
456
455
{ .addr = code,
457
-
.len = PAGE_SIZE,
456
+
.len = UM_KERN_PAGE_SIZE,
458
457
.prot = PROT_EXEC,
459
458
.flags = MAP_FIXED | MAP_PRIVATE,
460
459
.fd = code_fd,
···
477
476
.u =
478
477
{ .mmap =
479
478
{ .addr = data,
480
-
.len = PAGE_SIZE,
479
+
.len = UM_KERN_PAGE_SIZE,
481
480
.prot = PROT_READ | PROT_WRITE,
482
481
.flags = MAP_FIXED | MAP_SHARED,
483
482
.fd = map_fd,
+4
-3
arch/um/os-Linux/start_up.c
+4
-3
arch/um/os-Linux/start_up.c
···
107
107
unsigned long sp;
108
108
int pid, n, status;
109
109
110
-
stack = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE | PROT_EXEC,
110
+
stack = mmap(NULL, UM_KERN_PAGE_SIZE,
111
+
PROT_READ | PROT_WRITE | PROT_EXEC,
111
112
MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
112
113
if(stack == MAP_FAILED)
113
114
fatal_perror("check_ptrace : mmap failed");
114
-
sp = (unsigned long) stack + PAGE_SIZE - sizeof(void *);
115
+
sp = (unsigned long) stack + UM_KERN_PAGE_SIZE - sizeof(void *);
115
116
pid = clone(ptrace_child, (void *) sp, SIGCHLD, NULL);
116
117
if(pid < 0)
117
118
fatal_perror("start_ptraced_child : clone failed");
···
154
153
ret = -1;
155
154
}
156
155
157
-
if(munmap(stack, PAGE_SIZE) < 0)
156
+
if(munmap(stack, UM_KERN_PAGE_SIZE) < 0)
158
157
fatal_perror("check_ptrace : munmap failed");
159
158
return ret;
160
159
}