kotovalexarian-likes-gitlab/sortix--sortix
1
0
Fork 0
mirror of https://gitlab.com/sortix/sortix.git synced 2023-02-13 20:55:38 -05:00
Code Releases Activity

Refactor user-space stack creation.

Browse source
This commit is contained in:
Jonas 'Sortie' Termansen 2013-08-22 16:08:08 +02:00
parent f441066d02
commit 8e867908ab
5 changed files with 22 additions and 37 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
sortix/include/sortix/kernel/process.h
View file

@ -115,7 +115,6 @@ private:
size_t zombiewaiting;
bool iszombie;
bool nozombify;
addr_t mmapfrom;
int exitstatus;
public:
@ -182,7 +181,6 @@ public:
public:
void ResetForExecute();
addr_t AllocVirtualAddr(size_t size);
public:
static Process* Get(pid_t pid);

2
sortix/include/sortix/kernel/thread.h
View file

@ -106,8 +106,6 @@ public:
public:
addr_t addrspace;
addr_t stackpos;
size_t stacksize;
sighandler_t sighandler;
addr_t kernelstackpos;
size_t kernelstacksize;

16
sortix/kernel.cpp
View file

@ -632,7 +632,6 @@ static void InitThread(void* /*user*/)
// the init ramdisk and transfer execution to it. We will then become a
// regular user-space program with root permissions.
Thread* thread = CurrentThread();
Process* process = CurrentProcess();
const char* initpath = "/" CPUTYPE_STR "/bin/init";
@ -666,21 +665,6 @@ static void InitThread(void* /*user*/)
init.Reset();
const size_t DEFAULT_STACK_SIZE = 512UL * 1024UL;
size_t stacksize = 0;
if ( !stacksize ) { stacksize = DEFAULT_STACK_SIZE; }
addr_t stackpos = process->AllocVirtualAddr(stacksize);
if ( !stackpos ) { Panic("Could not allocate init stack space"); }
int prot = PROT_FORK | PROT_READ | PROT_WRITE | PROT_KREAD | PROT_KWRITE;
if ( !Memory::MapRange(stackpos, stacksize, prot) )
Panic("Could not allocate init stack memory");
thread->stackpos = stackpos;
thread->stacksize = stacksize;
int argc = 1;
const char* argv[] = { "init", NULL };
const char* cputype = "cputype=" CPUTYPE_STR;

35
sortix/process.cpp
View file

@ -98,7 +98,6 @@ Process::Process()
segments_used = 0;
segments_length = 0;
segment_lock = KTHREAD_MUTEX_INITIALIZER;
mmapfrom = 0x80000000UL;
exitstatus = -1;
pid = AllocatePID();
uid = euid = 0;
@ -648,8 +647,6 @@ Process* Process::Fork()
kthread_mutex_unlock(&groupchildlock);
// Initialize everything that is safe and can't fail.
clone->mmapfrom = mmapfrom;
kthread_mutex_lock(&ptrlock);
clone->root = root;
clone->cwd = cwd;
@ -745,10 +742,29 @@ int Process::Execute(const char* programname, const uint8_t* program,
delete[] program_image_path;
program_image_path = programname_clone; programname_clone = NULL;
// TODO: This may be an ugly hack!
// TODO: Move this to x86/process.cpp.
uintptr_t userspace_addr;
size_t userspace_size;
Memory::GetUserVirtualArea(&userspace_addr, &userspace_size);
addr_t stackpos = CurrentThread()->stackpos + CurrentThread()->stacksize;
const size_t DEFAULT_STACK_SIZE = 512UL * 1024UL;
void* const PREFERRED_STACK_LOCATION =
(void*) (userspace_addr + userspace_size - DEFAULT_STACK_SIZE);
const int STACK_PROTECTION = PROT_READ | PROT_WRITE | PROT_KREAD |
PROT_KWRITE | PROT_FORK;
// Attempt to allocate a stack for the new process.
kthread_mutex_lock(&segment_lock);
struct segment stack_segment;
if ( !PlaceSegment(&stack_segment, this, PREFERRED_STACK_LOCATION, DEFAULT_STACK_SIZE, 0) ||
!Memory::MapMemory(this, stack_segment.addr, stack_segment.size, stack_segment.prot = STACK_PROTECTION) )
{
kthread_mutex_unlock(&segment_lock);
ResetForExecute();
return errno = ENOMEM, -1;
}
kthread_mutex_unlock(&segment_lock);
addr_t stackpos = stack_segment.addr + stack_segment.size;
// Alright, move argv onto the new stack! First figure out exactly how
// big argv actually is.
@ -929,8 +945,6 @@ pid_t sys_tfork(int flags, tforkregs_t* regs)
thread->kernelstackpos = (addr_t) newkernelstack;
thread->kernelstacksize = curthread->kernelstacksize;
thread->kernelstackmalloced = true;
thread->stackpos = curthread->stackpos;
thread->stacksize = curthread->stacksize;
thread->sighandler = curthread->sighandler;
StartKernelThread(thread);
@ -1194,9 +1208,4 @@ void Process::Init()
Panic("could not allocate pidlist\n");
}
addr_t Process::AllocVirtualAddr(size_t size)
{
return mmapfrom -= size;
}
} // namespace Sortix

4
sortix/thread.cpp
View file

@ -51,8 +51,6 @@ Thread::Thread()
schedulerlistnext = NULL;
state = NONE;
memset(&registers, 0, sizeof(registers));
stackpos = 0;
stacksize = 0;
kernelstackpos = 0;
kernelstacksize = 0;
kernelstackmalloced = false;
@ -90,8 +88,6 @@ addr_t Thread::SwitchAddressSpace(addr_t newaddrspace)
// Last chance to clean up user-space things before this thread dies.
void Thread::LastPrayer()
{
Memory::UnmapRange(stackpos, stacksize);
Memory::Flush();
}
extern "C" void BootstrapKernelThread(void* user, ThreadEntry entry)