i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert team and thread changes for COMPAT_MODE (hrev52010 & hrev52011).

Browse Source 
This reverts commit c558f9c8fe.
This reverts commit 44f24718b1.
This reverts commit a69cb33030.
This reverts commit 951182620e.

There have been multiple reports that these changes break mounting NTFS partitions
(on all systems, see #14204), and shutting down (on certain systems, see #12405.)
Until they can be fixed, they are being backed out.
This commit is contained in:
Augustin Cavalier
2018-06-14 22:25:06 -04:00
parent 211cb77acf
commit 513403d420
17 changed files with 57 additions and 549 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/private/kernel/arch/x86/arch_cpu.h
+3 -8
View File
@@ -579,6 +579,9 @@ void x86_write_msr(uint32 registerNumber, uint64 value);
void x86_context_switch(struct arch_thread* oldState,
struct arch_thread* newState);
void x86_fnsave(void* fpuState);
void x86_frstor(const void* fpuState);
void x86_fxsave(void* fpuState);
void x86_fxrstor(const void* fpuState);
@@ -589,14 +592,6 @@ void x86_fxsave_swap(void* oldFpuState, const void* newFpuState);
#endif
#if !defined(__x86_64__) || defined(_COMPAT_MODE)
void x86_fnsave(void* fpuState);
void x86_frstor(const void* fpuState);
#endif // !defined(__x86_64__) || defined(_COMPAT_MODE)
static inline void
arch_cpu_idle(void)
{
headers/private/kernel/compat/OS_compat.h
-28
View File
@@ -163,34 +163,6 @@ static_assert(sizeof(compat_thread_info) == 76,
"size of compat_thread_info mismatch");
inline status_t
copy_ref_var_to_user(thread_info &info, thread_info* userInfo)
{
if (!IS_USER_ADDRESS(userInfo))
return B_BAD_ADDRESS;
Thread* thread = thread_get_current_thread();
bool compatMode = (thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0;
if (compatMode) {
compat_thread_info compatInfo;
compatInfo.thread = info.thread;
compatInfo.team = info.team;
strlcpy(compatInfo.name, info.name, sizeof(compatInfo.name));
compatInfo.state = info.state;
compatInfo.priority = info.priority;
compatInfo.sem = info.sem;
compatInfo.user_time = info.user_time;
compatInfo.kernel_time = info.kernel_time;
compatInfo.stack_base = (uint32)(addr_t)info.stack_base;
compatInfo.stack_end = (uint32)(addr_t)info.stack_end;
if (user_memcpy(userInfo, &compatInfo, sizeof(compatInfo)) < B_OK)
return B_BAD_ADDRESS;
} else if (user_memcpy(userInfo, &info, sizeof(info)) < B_OK) {
return B_BAD_ADDRESS;
}
return B_OK;
}
inline status_t
copy_ref_var_to_user(void* &addr, void** userAddr)
{
headers/private/kernel/compat/resource_compat.h
-60
View File
@@ -1,60 +0,0 @@
/*
* Copyright 2018, Haiku Inc. All rights reserved.
*
* Distributed under the terms of the MIT License.
*/
#ifndef _KERNEL_COMPAT_RESOURCE_H
#define _KERNEL_COMPAT_RESOURCE_H
#include <sys/resource.h>
typedef uint32 compat_rlim_t;
struct compat_rlimit {
compat_rlim_t rlim_cur; /* current soft limit */
compat_rlim_t rlim_max; /* hard limit */
};
inline status_t
copy_ref_var_to_user(struct rlimit &rl, struct rlimit* urlp)
{
if (!IS_USER_ADDRESS(urlp))
return B_BAD_ADDRESS;
Thread* thread = thread_get_current_thread();
bool compatMode = (thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0;
if (compatMode) {
struct compat_rlimit compat_rl;
compat_rl.rlim_cur = rl.rlim_cur;
compat_rl.rlim_max = rl.rlim_max;
if (user_memcpy(urlp, &compat_rl, sizeof(compat_rl)) < B_OK)
return B_BAD_ADDRESS;
} else if (user_memcpy(urlp, &rl, sizeof(rl)) < B_OK) {
return B_BAD_ADDRESS;
}
return B_OK;
}
inline status_t
copy_ref_var_from_user(struct rlimit* urlp, struct rlimit &rl)
{
if (!IS_USER_ADDRESS(urlp))
return B_BAD_ADDRESS;
Thread* thread = thread_get_current_thread();
bool compatMode = (thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0;
if (compatMode) {
struct compat_rlimit compat_rl;
if (user_memcpy(&compat_rl, urlp, sizeof(compat_rl)) < B_OK)
return B_BAD_ADDRESS;
rl.rlim_cur = compat_rl.rlim_cur;
rl.rlim_max = compat_rl.rlim_max;
} else if (user_memcpy(&rl, urlp, sizeof(rl)) < B_OK) {
return B_BAD_ADDRESS;
}
return B_OK;
}
#endif // _KERNEL_COMPAT_RESOURCE_H
headers/private/kernel/compat/thread_defs_compat.h
-61
View File
@@ -1,61 +0,0 @@
/*
* Copyright 2018, Haiku Inc. All rights reserved.
*
* Distributed under the terms of the MIT License.
*/
#ifndef _KERNEL_COMPAT_THREAD_DEFS_H
#define _KERNEL_COMPAT_THREAD_DEFS_H
#include <thread_defs.h>
#define compat_ptr_t uint32
struct compat_thread_creation_attributes {
compat_ptr_t entry;
compat_ptr_t name;
int32 priority;
compat_ptr_t args1;
compat_ptr_t args2;
compat_ptr_t stack_address;
uint32_t stack_size;
uint32_t guard_size;
compat_ptr_t pthread;
uint32 flags;
} _PACKED;
static_assert(sizeof(struct compat_thread_creation_attributes) == 40,
"size of compat_thread_creation_attributes mismatch");
inline status_t
copy_ref_var_from_user(BKernel::ThreadCreationAttributes* userAttrs,
BKernel::ThreadCreationAttributes &attrs)
{
if (!IS_USER_ADDRESS(userAttrs))
return B_BAD_ADDRESS;
Thread* thread = thread_get_current_thread();
bool compatMode = (thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0;
if (compatMode) {
struct compat_thread_creation_attributes compatAttrs;
if (user_memcpy(&compatAttrs, userAttrs, sizeof(compatAttrs)) < B_OK)
return B_BAD_ADDRESS;
attrs.entry = (int32 (*)(void*, void*))(addr_t)compatAttrs.entry;
attrs.name = (const char*)(addr_t)compatAttrs.name;
attrs.priority = compatAttrs.priority;
attrs.args1 = (void*)(addr_t)compatAttrs.args1;
attrs.args2 = (void*)(addr_t)compatAttrs.args2;
attrs.stack_address = (void*)(addr_t)compatAttrs.stack_address;
attrs.stack_size = compatAttrs.stack_size;
attrs.guard_size = compatAttrs.guard_size;
attrs.pthread = (pthread_t)(addr_t)compatAttrs.pthread;
attrs.flags = compatAttrs.flags;
} else if (user_memcpy(&attrs, userAttrs, sizeof(attrs)) < B_OK) {
return B_BAD_ADDRESS;
}
return B_OK;
}
#endif // _KERNEL_COMPAT_THREAD_DEFS_H
headers/private/kernel/elf_priv.h
-5
View File
@@ -82,11 +82,6 @@ extern "C" {
extern status_t elf_resolve_symbol(struct elf_image_info* image,
elf_sym* symbol, struct elf_image_info* sharedImage,
elf_addr* _symbolAddress);
#ifdef _COMPAT_MODE
extern status_t elf32_resolve_symbol(struct elf_image_info* image,
elf_sym* symbol, struct elf_image_info* sharedImage,
elf_addr* _symbolAddress);
#endif
#ifdef __cplusplus
}
headers/private/kernel/vm/VMAddressSpace.h
-4
View File
@@ -35,10 +35,6 @@ public:
addr_t Base() const { return fBase; }
addr_t EndAddress() const { return fEndAddress; }
size_t Size() const { return fEndAddress - fBase + 1; }
void SetSize(size_t size) {
fEndAddress = fBase + (size - 1);
fFreeSpace = size; }
size_t FreeSpace() const { return fFreeSpace; }
bool IsBeingDeleted() const { return fDeleting; }
headers/private/system/thread_defs.h
-4
View File
@@ -37,10 +37,6 @@ enum {
#define THREAD_CREATION_FLAG_DEFER_SIGNALS 0x01
// create the thread with signals deferred, i.e. with
// user_thread::defer_signals set to 1
#ifdef _COMPAT_MODE
# define THREAD_CREATION_FLAG_COMPAT_MODE 0x02
// create the thread with a compatibility mode
#endif
struct thread_creation_attributes {
src/system/kernel/Jamfile
-8
View File
@@ -22,12 +22,6 @@ AddResources kernel_$(TARGET_ARCH) : kernel.rdef ;
SetVersionScript kernel_$(TARGET_ARCH) : kernel_versions ;
SetVersionScript kernel.so : kernel_versions ;
local compatSources = ;
if $(HAIKU_KERNEL_COMPAT_MODE) = 1 {
UsePrivateHeaders [ FDirName kernel compat ] ;
compatSources = commpage_compat.cpp elf_compat.cpp ;
}
KernelMergeObject kernel_core.o :
boot_item.cpp
boot_splash.cpp
@@ -78,8 +72,6 @@ KernelMergeObject kernel_core.o :
scheduler_tracing.cpp
scheduling_analysis.cpp
# compatibility
$(compatSources)
: $(TARGET_KERNEL_PIC_CCFLAGS)
;
src/system/kernel/arch/x86/64/arch.S
-22
View File
@@ -119,25 +119,3 @@ FUNCTION_END(_stac)
FUNCTION(_clac):
clac
FUNCTION_END(_clac)
#ifdef _COMPAT_MODE
/* void x86_fnsave(void *fpu_state); */
FUNCTION(x86_fnsave):
movq %rdi, %rax
fnsave (%rax)
ret
FUNCTION_END(x86_fnsave)
/* void x86_frstor(const void *fpu_state); */
FUNCTION(x86_frstor):
movq %rdi, %rax
frstor (%rax)
ret
FUNCTION_END(x86_frstor)
#endif // _COMPAT_MODE
src/system/kernel/arch/x86/64/thread.cpp
+3 -4
View File
@@ -18,6 +18,9 @@
#include <debug.h>
#include <kernel.h>
#include <ksignal.h>
#ifdef _COMPAT_MODE
# include <compat/ksignal_compat.h>
#endif
#include <int.h>
#include <team.h>
#include <thread.h>
@@ -27,10 +30,6 @@
#include <vm/vm_types.h>
#include <vm/VMAddressSpace.h>
#ifdef _COMPAT_MODE
# include <compat/ksignal_compat.h>
#endif
#include "paging/X86PagingStructures.h"
#include "paging/X86VMTranslationMap.h"
src/system/kernel/arch/x86/Jamfile
+3 -29
View File
@@ -1,5 +1,8 @@
SubDir HAIKU_TOP src system kernel arch x86 ;
SubDirHdrs [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH))
system kernel ] ;
# for syscall_numbers.h
SubDirHdrs $(HAIKU_TOP) src add-ons kernel bus_managers ps2 ;
SubDirHdrs $(HAIKU_TOP) src add-ons kernel bus_managers acpi acpica include ;
SubDirHdrs $(HAIKU_TOP) src add-ons kernel bus_managers acpi acpica include
@@ -12,10 +15,6 @@ UsePrivateHeaders shared ;
SEARCH_SOURCE += [ FDirName $(SUBDIR) paging ] ;
SEARCH_SOURCE += [ FDirName $(SUBDIR) timers ] ;
ObjectHdrs interrupts.S signals.cpp signals_asm.S : [ FDirName
$(TARGET_COMMON_DEBUG_OBJECT_DIR_$(TARGET_PACKAGING_ARCH)) system kernel ] ;
# for syscall_numbers.h
local archSpecificSources ;
if $(TARGET_ARCH) = x86_64 {
SEARCH_SOURCE += [ FDirName $(SUBDIR) 64 ] ;
@@ -29,7 +28,6 @@ if $(TARGET_ARCH) = x86_64 {
signals.cpp
signals_asm.S
syscalls.cpp
syscalls_asm.S
thread.cpp
# paging
@@ -40,17 +38,6 @@ if $(TARGET_ARCH) = x86_64 {
X86PagingStructures64Bit.cpp
X86VMTranslationMap64Bit.cpp
;
if $(HAIKU_KERNEL_COMPAT_MODE) = 1 {
archSpecificSources +=
arch_commpage_compat.cpp
arch_elf_compat.cpp
entry_compat.S
syscalls_compat.cpp
signals_compat_asm.S
signals_compat.cpp
;
}
} else {
SEARCH_SOURCE += [ FDirName $(SUBDIR) 32 ] ;
SEARCH_SOURCE += [ FDirName $(SUBDIR) paging 32bit ] ;
@@ -132,16 +119,3 @@ Includes [ FGristFiles interrupts.S arch.S signals.cpp signals_asm.S ]
: <syscalls!$(TARGET_PACKAGING_ARCH)>syscall_numbers.h ;
Includes [ FGristFiles interrupts.S ]
: <syscalls!$(TARGET_PACKAGING_ARCH)>syscall_table.h ;
if $(TARGET_ARCH) = x86_64 && $(HAIKU_KERNEL_COMPAT_MODE) = 1 {
ObjectHdrs entry_compat.S syscalls_compat.cpp : [ FDirName
$(TARGET_COMMON_DEBUG_OBJECT_DIR_x86) system kernel ] ;
# for syscall_numbers.h
# We need to specify the dependency on the generated syscalls file explicitly.
Includes [ FGristFiles entry_compat.S ]
: <syscalls!x86>syscall_numbers.h ;
Includes [ FGristFiles entry_compat.S syscalls_compat.cpp ]
: <syscalls!x86>syscall_table.h ;
}
src/system/kernel/arch/x86/arch_debug.cpp
+1 -58
View File
@@ -1,5 +1,4 @@
/*
* Copyright 2018, Jérôme Duval, [email protected].
* Copyright 2009-2011, Ingo Weinhold, [email protected].
* Copyright 2002-2008, Axel Dörfler, [email protected].
* Copyright 2012, Alex Smith, [email protected].
@@ -36,20 +35,6 @@ struct stack_frame {
addr_t return_address;
};
#ifdef _COMPAT_MODE
typedef uint32 compat_addr_t;
struct compat_stack_frame {
compat_addr_t previous;
compat_addr_t return_address;
};
#endif // _COMPAT_MODE
#define NUM_PREVIOUS_LOCATIONS 32
@@ -115,28 +100,6 @@ get_next_frame_debugger(addr_t bp, addr_t* _next, addr_t* _ip)
}
#ifdef _COMPAT_MODE
/*! Safe to be called only from inside the debugger.
*/
static status_t
compat_get_next_frame_debugger(addr_t bp, addr_t* _next, addr_t* _ip)
{
compat_stack_frame frame;
if (debug_memcpy(B_CURRENT_TEAM, &frame, (void*)bp, sizeof(frame)) != B_OK)
return B_BAD_ADDRESS;
*_ip = (addr_t)frame.return_address;
*_next = (addr_t)frame.previous;
return B_OK;
}
#endif // _COMPAT_MODE
static status_t
lookup_symbol(Thread* thread, addr_t address, addr_t* _baseAddress,
const char** _symbolName, const char** _imageName, bool* _exactMatch)
@@ -412,7 +375,7 @@ print_stack_frame(Thread* thread, addr_t ip, addr_t bp, addr_t nextBp,
const char* image;
addr_t baseAddress;
bool exactMatch;
status_t status = B_ERROR;
status_t status;
addr_t diff;
diff = nextBp - bp;
@@ -421,18 +384,8 @@ print_stack_frame(Thread* thread, addr_t ip, addr_t bp, addr_t nextBp,
if (diff & ~((addr_t)-1 >> 1))
diff = 0;
#ifdef _COMPAT_MODE
// only lookup kernel symbols in compatibility mode
// TODO: support lookup user symbols in compatibility mode
if ((thread->flags & THREAD_FLAGS_COMPAT_MODE) == 0
|| IS_KERNEL_ADDRESS(ip)) {
status = lookup_symbol(thread, ip, &baseAddress, &symbol, &image,
&exactMatch);
}
#else
status = lookup_symbol(thread, ip, &baseAddress, &symbol, &image,
&exactMatch);
#endif
kprintf("%2" B_PRId32 " %0*lx (+%4ld) %0*lx ", callIndex,
B_PRINTF_POINTER_WIDTH, bp, diff, B_PRINTF_POINTER_WIDTH, ip);
@@ -771,16 +724,6 @@ stack_trace(int argc, char** argv)
} else {
addr_t ip, nextBp;
#ifdef _COMPAT_MODE
if ((thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0
&& !is_kernel_stack_address(thread, bp)) {
if (compat_get_next_frame_debugger(bp, &nextBp, &ip) != B_OK) {
kprintf("%0*lx -- read fault\n", B_PRINTF_POINTER_WIDTH,
bp);
break;
}
} else
#endif
if (get_next_frame_debugger(bp, &nextBp, &ip) != B_OK) {
kprintf("%0*lx -- read fault\n", B_PRINTF_POINTER_WIDTH, bp);
break;
src/system/kernel/arch/x86/arch_thread.cpp
-17
View File
@@ -192,23 +192,6 @@ arch_team_init_team_struct(Team* p, bool kernel)
status_t
arch_thread_init_tls(Thread* thread)
{
#ifdef _COMPAT_MODE
if ((thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0) {
uint32 tls[TLS_FIRST_FREE_SLOT];
thread->user_local_storage = thread->user_stack_base
+ thread->user_stack_size;
// initialize default TLS fields
memset(tls, 0, sizeof(tls));
tls[TLS_BASE_ADDRESS_SLOT] = thread->user_local_storage;
tls[TLS_THREAD_ID_SLOT] = thread->id;
tls[TLS_USER_THREAD_SLOT] = (uint32)(addr_t)thread->user_thread;
return user_memcpy((void*)thread->user_local_storage, tls, sizeof(tls));
}
#endif
addr_t tls[TLS_FIRST_FREE_SLOT];
thread->user_local_storage = thread->user_stack_base
src/system/kernel/fs/Jamfile
-4
View File
@@ -7,10 +7,6 @@ UsePrivateHeaders net shared storage ;
UseHeaders [ FDirName $(SUBDIR) $(DOTDOT) device_manager ] ;
if $(HAIKU_KERNEL_COMPAT_MODE) = 1 {
UsePrivateHeaders [ FDirName kernel compat ] ;
}
KernelMergeObject kernel_fs.o :
EntryCache.cpp
fd.cpp
src/system/kernel/team.cpp
+28 -199
View File
@@ -28,9 +28,6 @@
#include <extended_system_info_defs.h>
#include <commpage.h>
#ifdef _COMPAT_MODE
# include <commpage_compat.h>
#endif
#include <boot_device.h>
#include <elf.h>
#include <file_cache.h>
@@ -88,7 +85,6 @@ struct team_arg {
};
#define TEAM_ARGS_FLAG_NO_ASLR 0x01
#define TEAM_ARGS_FLAG_COMPAT_FLATARGS 0x02
namespace {
@@ -1349,8 +1345,7 @@ remove_team_from_group(Team* team)
static status_t
create_team_user_data(Team* team, void* exactAddress = NULL,
void* baseAddress = NULL)
create_team_user_data(Team* team, void* exactAddress = NULL)
{
void* address;
uint32 addressSpec;
@@ -1359,8 +1354,7 @@ create_team_user_data(Team* team, void* exactAddress = NULL,
address = exactAddress;
addressSpec = B_EXACT_ADDRESS;
} else {
address = baseAddress != NULL ? baseAddress
: (void*)KERNEL_USER_DATA_BASE;
address = (void*)KERNEL_USER_DATA_BASE;
addressSpec = B_RANDOMIZED_BASE_ADDRESS;
}
@@ -1375,8 +1369,7 @@ create_team_user_data(Team* team, void* exactAddress = NULL,
virtualRestrictions.address = address;
virtualRestrictions.address_specification = B_EXACT_ADDRESS;
} else {
virtualRestrictions.address = baseAddress != NULL ? baseAddress
: (void*)KERNEL_USER_DATA_BASE;
virtualRestrictions.address = (void*)KERNEL_USER_DATA_BASE;
virtualRestrictions.address_specification = B_RANDOMIZED_BASE_ADDRESS;
}
@@ -1520,12 +1513,6 @@ create_team_arg(struct team_arg** _teamArg, const char* path, char** flatArgs,
}
}
#ifdef _COMPAT_MODE
Thread* thread = thread_get_current_thread();
if ((thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0)
teamArg->flags |= TEAM_ARGS_FLAG_COMPAT_FLATARGS;
#endif
*_teamArg = teamArg;
return B_OK;
}
@@ -1576,119 +1563,17 @@ team_create_thread_start_internal(void* args)
userEnv = userArgs + argCount + 1;
path = teamArgs->path;
// set team args and update state
// TODO: this can't work with a compat flat_args
team->Lock();
team->SetArgs(path, teamArgs->flat_args + 1, argCount - 1);
team->state = TEAM_STATE_NORMAL;
team->Unlock();
#ifdef _COMPAT_MODE
// in compat mode, userArgs and userEnv should only be uint32
if ((teamArgs->flags & TEAM_ARGS_FLAG_COMPAT_FLATARGS) == 0
&& (thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0) {
// now make the arrays 32-bits wide
addr_t pointerOffset = 4; // sizeof(addr_t) - sizeof(uint32)
size_t pointerSize = sizeof(uint32);
uint32 *elfArgs = (uint32*)teamArgs->flat_args;
addr_t *tempArgs = (addr_t*)teamArgs->flat_args;
if (argCount > 0) {
for (int i = 0; i < argCount; i++) {
*elfArgs = (uint32)*tempArgs;
elfArgs++;
tempArgs++;
}
}
*elfArgs = NULL;
elfArgs++;
tempArgs++;
userEnv = (char**)elfArgs;
if (envCount > 0) {
for (int i = 0; i < envCount; i++) {
*elfArgs = (uint32)*tempArgs;
elfArgs++;
tempArgs++;
}
}
*elfArgs = NULL;
// now move the flat strings
size_t stringsOffset = (argCount + envCount + 2) * sizeof(char*);
addr_t strings = (addr_t)teamArgs->flat_args + stringsOffset;
size_t strings32Offset = (argCount + envCount + 2) * sizeof(uint32);
addr_t strings32 = (addr_t)teamArgs->flat_args + strings32Offset;
memmove((void*)strings32, (void*)strings,
teamArgs->flat_args_size - stringsOffset);
uint32 user32Args = (uint32)(addr_t)userArgs;
uint32 user32Env = user32Args + (argCount + 1) * sizeof(uint32);
if (user_strlcpy(programArgs->program_path, path,
sizeof(programArgs->program_path)) < B_OK
|| user_memcpy(&programArgs->arg_count, &argCount, sizeof(int32))
< B_OK
|| user_memcpy(&programArgs->env_count, &envCount, sizeof(int32))
< B_OK
|| user_memcpy(&programArgs->args, &user32Args, sizeof(user32Args))
< B_OK
|| user_memcpy((void*)(((addr_t)&programArgs->args) + 4),
&user32Env, sizeof(user32Env)) < B_OK
|| user_memcpy(&programArgs->error_port, &teamArgs->error_port,
sizeof(port_id)) < B_OK
|| user_memcpy(&programArgs->error_token, &teamArgs->error_token,
sizeof(uint32)) < B_OK
|| user_memcpy(&programArgs->umask, &teamArgs->umask,
sizeof(mode_t)) < B_OK
|| user_memcpy(userArgs, teamArgs->flat_args,
teamArgs->flat_args_size - (stringsOffset -
strings32Offset)) < B_OK) {
// the team deletion process will clean this mess
free_team_arg(teamArgs);
return B_BAD_ADDRESS;
}
} else if ((teamArgs->flags & TEAM_ARGS_FLAG_COMPAT_FLATARGS) != 0
&& (thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0) {
uint32 user32Args = (uint32)(addr_t)userArgs;
uint32 user32Env = user32Args + (argCount + 1) * sizeof(uint32);
if (user_strlcpy(programArgs->program_path, path,
sizeof(programArgs->program_path)) < B_OK
|| user_memcpy(&programArgs->arg_count, &argCount,
sizeof(int32)) < B_OK
|| user_memcpy(&programArgs->args, &user32Args, sizeof(uint32))
< B_OK
|| user_memcpy(&programArgs->env_count, &envCount, sizeof(int32))
< B_OK
|| user_memcpy(&programArgs->env, &user32Env, sizeof(uint32))
< B_OK
|| user_memcpy(&programArgs->error_port, &teamArgs->error_port,
sizeof(port_id)) < B_OK
|| user_memcpy(&programArgs->error_token, &teamArgs->error_token,
sizeof(uint32)) < B_OK
|| user_memcpy(&programArgs->umask, &teamArgs->umask,
sizeof(mode_t)) < B_OK
|| user_memcpy(userArgs, teamArgs->flat_args,
teamArgs->flat_args_size) < B_OK) {
// the team deletion process will clean this mess
free_team_arg(teamArgs);
return B_BAD_ADDRESS;
}
} else
#endif
if (user_strlcpy(programArgs->program_path, path,
sizeof(programArgs->program_path)) < B_OK
|| user_memcpy(&programArgs->arg_count, &argCount, sizeof(int32))
< B_OK
|| user_memcpy(&programArgs->arg_count, &argCount, sizeof(int32)) < B_OK
|| user_memcpy(&programArgs->args, &userArgs, sizeof(char**)) < B_OK
|| user_memcpy(&programArgs->env_count, &envCount, sizeof(int32))
< B_OK
|| user_memcpy(&programArgs->env_count, &envCount, sizeof(int32)) < B_OK
|| user_memcpy(&programArgs->env, &userEnv, sizeof(char**)) < B_OK
|| user_memcpy(&programArgs->error_port, &teamArgs->error_port,
sizeof(port_id)) < B_OK
|| user_memcpy(&programArgs->error_token, &teamArgs->error_token,
sizeof(uint32)) < B_OK
|| user_memcpy(&programArgs->umask, &teamArgs->umask, sizeof(mode_t))
< B_OK
|| user_memcpy(&programArgs->umask, &teamArgs->umask, sizeof(mode_t)) < B_OK
|| user_memcpy(userArgs, teamArgs->flat_args,
teamArgs->flat_args_size) < B_OK) {
// the team deletion process will clean this mess
@@ -1698,25 +1583,19 @@ team_create_thread_start_internal(void* args)
TRACE(("team_create_thread_start: loading elf binary '%s'\n", path));
const char* threadName = strrchr(path, '/');
// set team args and update state
team->Lock();
team->SetArgs(path, teamArgs->flat_args + 1, argCount - 1);
team->state = TEAM_STATE_NORMAL;
team->Unlock();
free_team_arg(teamArgs);
// the arguments are already on the user stack, we no longer need
// them in this form
// Clone commpage area
area_id commPageArea = -1;
#ifdef _COMPAT_MODE
if ((thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0) {
team->commpage_address = (void*)KERNEL_USER32_DATA_BASE;
commPageArea = clone_commpage_compat_area(team->id,
&team->commpage_address);
} else
#endif
{
team->commpage_address = (void*)KERNEL_USER_DATA_BASE;
commPageArea = clone_commpage_area(team->id, &team->commpage_address);
}
area_id commPageArea = clone_commpage_area(team->id,
&team->commpage_address);
if (commPageArea < B_OK) {
TRACE(("team_create_thread_start: clone_commpage_area() failed: %s\n",
strerror(commPageArea)));
@@ -1757,21 +1636,11 @@ team_create_thread_start_internal(void* args)
return err;
}
runtimeLoaderPath.UnlockBuffer();
#ifdef _COMPAT_MODE
if ((thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0) {
err = runtimeLoaderPath.Append("x86/runtime_loader");
if (err == B_OK) {
err = elf32_load_user_image(runtimeLoaderPath.Path(), team, 0,
&entry);
}
} else
#endif
{
err = runtimeLoaderPath.Append("runtime_loader");
if (err == B_OK) {
err = elf_load_user_image(runtimeLoaderPath.Path(), team, 0,
&entry);
}
err = runtimeLoaderPath.Append("runtime_loader");
if (err == B_OK) {
err = elf_load_user_image(runtimeLoaderPath.Path(), team, 0,
&entry);
}
}
@@ -1815,8 +1684,6 @@ load_image_internal(char**& _flatArgs, size_t flatArgsSize, int32 argCount,
io_context* parentIOContext = NULL;
team_id teamID;
bool teamLimitReached = false;
void* kernelUserDataBase = (void*)KERNEL_USER_DATA_BASE;
size_t addressSpaceSize = USER_SIZE;
if (flatArgs == NULL || argCount == 0)
return B_BAD_VALUE;
@@ -1833,15 +1700,6 @@ load_image_internal(char**& _flatArgs, size_t flatArgsSize, int32 argCount,
else
threadName = path;
#ifdef _COMPAT_MODE
bool isCompatMode = false;
KPath tmpFilePath;
if (tmpFilePath.SetTo(path, KPath::NORMALIZE) == B_OK) {
isCompatMode = (elf32_load_user_image(tmpFilePath.Path(), NULL,
ELF_LOAD_USER_IMAGE_TEST_EXECUTABLE, NULL) == B_OK);
}
#endif
// create the main thread object
Thread* mainThread;
status = Thread::Create(threadName, mainThread);
@@ -1849,14 +1707,6 @@ load_image_internal(char**& _flatArgs, size_t flatArgsSize, int32 argCount,
return status;
BReference<Thread> mainThreadReference(mainThread, true);
#ifdef _COMPAT_MODE
if (isCompatMode) {
atomic_or(&mainThread->flags, THREAD_FLAGS_COMPAT_MODE);
kernelUserDataBase = (void*)KERNEL_USER32_DATA_BASE;
addressSpaceSize = USER32_SIZE;
}
#endif
// create team object
Team* team = Team::Create(mainThread->id, path, false);
if (team == NULL)
@@ -1915,9 +1765,7 @@ load_image_internal(char**& _flatArgs, size_t flatArgsSize, int32 argCount,
vfs_exec_io_context(team->io_context);
// create an address space for this team
// TODO: check the thread compat mode in an arch specific function
status = VMAddressSpace::Create(team->id, USER_BASE,
addressSpaceSize, false,
status = VMAddressSpace::Create(team->id, USER_BASE, USER_SIZE, false,
&team->address_space);
if (status != B_OK)
goto err2;
@@ -1926,7 +1774,7 @@ load_image_internal(char**& _flatArgs, size_t flatArgsSize, int32 argCount,
(teamArgs->flags & TEAM_ARGS_FLAG_NO_ASLR) == 0);
// create the user data area
status = create_team_user_data(team, NULL, kernelUserDataBase);
status = create_team_user_data(team);
if (status != B_OK)
goto err4;
@@ -2054,7 +1902,6 @@ exec_team(const char* path, char**& _flatArgs, size_t flatArgsSize,
struct team_arg* teamArgs;
const char* threadName;
thread_id nubThreadID = -1;
void* kernelUserDataBase = (void*)KERNEL_USER_DATA_BASE;
TRACE(("exec_team(path = \"%s\", argc = %" B_PRId32 ", envCount = %"
B_PRId32 "): team %" B_PRId32 "\n", path, argCount, envCount,
@@ -2124,26 +1971,7 @@ exec_team(const char* path, char**& _flatArgs, size_t flatArgsSize,
team->address_space->SetRandomizingEnabled(
(teamArgs->flags & TEAM_ARGS_FLAG_NO_ASLR) == 0);
// cut the path from the team name and rename the main thread, too
threadName = strrchr(path, '/');
if (threadName != NULL)
threadName++;
else
threadName = path;
#ifdef _COMPAT_MODE
bool isCompatMode = false;
KPath tmpFilePath;
if (tmpFilePath.SetTo(path, KPath::NORMALIZE) == B_OK) {
isCompatMode = (elf32_load_user_image(tmpFilePath.Path(), NULL,
ELF_LOAD_USER_IMAGE_TEST_EXECUTABLE, NULL) == B_OK);
}
// user address space shouldn't have user areas left
team->address_space->SetSize(isCompatMode ? USER32_SIZE : USER_SIZE);
if (isCompatMode)
kernelUserDataBase = (void*)KERNEL_USER32_DATA_BASE;
#endif
status = create_team_user_data(team, NULL, kernelUserDataBase);
status = create_team_user_data(team);
if (status != B_OK) {
// creating the user data failed -- we're toast
free_team_arg(teamArgs);
@@ -2159,6 +1987,12 @@ exec_team(const char* path, char**& _flatArgs, size_t flatArgsSize,
team->SetName(path);
team->Unlock();
// cut the path from the team name and rename the main thread, too
threadName = strrchr(path, '/');
if (threadName != NULL)
threadName++;
else
threadName = path;
rename_thread(thread_get_current_thread_id(), threadName);
atomic_or(&team->flags, TEAM_FLAG_EXEC_DONE);
@@ -2177,13 +2011,8 @@ exec_team(const char* path, char**& _flatArgs, size_t flatArgsSize,
// cannot fail (the allocation for the team would have failed already)
ThreadLocker currentThreadLocker(currentThread);
currentThread->user_thread = userThread;
#ifdef _COMPAT_MODE
if (isCompatMode)
atomic_or(&currentThread->flags, THREAD_FLAGS_COMPAT_MODE);
else
atomic_and(&currentThread->flags, ~THREAD_FLAGS_COMPAT_MODE);
#endif
currentThreadLocker.Unlock();
// create the user stack for the thread
status = thread_create_user_stack(currentThread->team, currentThread, NULL,
0, sizeof(user_space_program_args) + teamArgs->flat_args_size);
src/system/kernel/thread.cpp
+19 -35
View File
@@ -43,7 +43,6 @@
#include <syscall_restart.h>
#include <team.h>
#include <tls.h>
#include <util/syscall_args.h>
#include <user_runtime.h>
#include <user_thread.h>
#include <vfs.h>
@@ -51,12 +50,6 @@
#include <vm/VMAddressSpace.h>
#include <wait_for_objects.h>
#ifdef _COMPAT_MODE
# include <OS_compat.h>
# include <resource_compat.h>
# include <thread_defs_compat.h>
#endif
#include "TeamThreadTables.h"
@@ -559,14 +552,11 @@ status_t
ThreadCreationAttributes::InitFromUserAttributes(
const thread_creation_attributes* userAttributes, char* nameBuffer)
{
if (userAttributes == NULL)
if (userAttributes == NULL || !IS_USER_ADDRESS(userAttributes)
|| user_memcpy((thread_creation_attributes*)this, userAttributes,
sizeof(thread_creation_attributes)) != B_OK) {
return B_BAD_ADDRESS;
status_t status = copy_ref_var_from_user(
(BKernel::ThreadCreationAttributes*)userAttributes,
*this);
if (status != B_OK)
return status;
}
if (stack_size != 0
&& (stack_size < MIN_USER_STACK_SIZE
@@ -825,10 +815,6 @@ create_thread_user_stack(Team* team, Thread* thread, void* _stackBase,
thread->name, thread->id);
stackBase = (uint8*)USER_STACK_REGION;
#ifdef _COMPAT_MODE
if ((thread->flags & THREAD_FLAGS_COMPAT_MODE) != 0)
stackBase = (uint8*)USER32_STACK_REGION;
#endif
virtual_address_restrictions virtualRestrictions = {};
virtualRestrictions.address_specification = B_RANDOMIZED_BASE_ADDRESS;
@@ -914,12 +900,6 @@ thread_create_thread(const ThreadCreationAttributes& attributes, bool kernel)
(int32)THREAD_MAX_SET_PRIORITY);
thread->state = B_THREAD_SUSPENDED;
#ifdef _COMPAT_MODE
Thread* currentThread = thread_get_current_thread();
if ((currentThread->flags & THREAD_FLAGS_COMPAT_MODE) != 0)
thread->flags |= THREAD_FLAGS_COMPAT_MODE;
#endif
thread->sig_block_mask = attributes.signal_mask;
// init debug structure
@@ -3530,8 +3510,10 @@ _user_get_thread_info(thread_id id, thread_info *userInfo)
status = _get_thread_info(id, &info, sizeof(thread_info));
if (status >= B_OK)
status = copy_ref_var_to_user(info, userInfo);
if (status >= B_OK
&& user_memcpy(userInfo, &info, sizeof(thread_info)) < B_OK)
return B_BAD_ADDRESS;
return status;
}
@@ -3552,9 +3534,11 @@ _user_get_next_thread_info(team_id team, int32 *userCookie,
if (status < B_OK)
return status;
if (user_memcpy(userCookie, &cookie, sizeof(int32)) < B_OK)
if (user_memcpy(userCookie, &cookie, sizeof(int32)) < B_OK
|| user_memcpy(userInfo, &info, sizeof(thread_info)) < B_OK)
return B_BAD_ADDRESS;
return copy_ref_var_to_user(info, userInfo);
return status;
}
@@ -3736,9 +3720,9 @@ _user_getrlimit(int resource, struct rlimit *urlp)
ret = common_getrlimit(resource, &rl);
if (ret == 0) {
status_t status = copy_ref_var_to_user(rl, urlp);
if (status != B_OK)
return status;
ret = user_memcpy(urlp, &rl, sizeof(struct rlimit));
if (ret < 0)
return ret;
return 0;
}
@@ -3755,10 +3739,10 @@ _user_setrlimit(int resource, const struct rlimit *userResourceLimit)
if (userResourceLimit == NULL)
return EINVAL;
status_t status = copy_ref_var_from_user((struct rlimit*)userResourceLimit,
resourceLimit);
if (status != B_OK)
return status;
if (!IS_USER_ADDRESS(userResourceLimit)
|| user_memcpy(&resourceLimit, userResourceLimit,
sizeof(struct rlimit)) < B_OK)
return B_BAD_ADDRESS;
return common_setrlimit(resource, &resourceLimit);
}
src/system/kernel/vm/Jamfile
-3
View File
@@ -5,9 +5,6 @@ UsePrivateHeaders shared ;
UseHeaders [ FDirName $(SUBDIR) $(DOTDOT) device_manager ] ;
UsePrivateHeaders [ FDirName kernel disk_device_manager ] ;
UsePrivateHeaders [ FDirName kernel util ] ;
if $(HAIKU_KERNEL_COMPAT_MODE) = 1 {
UsePrivateHeaders [ FDirName kernel compat ] ;
}
KernelMergeObject kernel_vm.o :
PageCacheLocker.cpp