libcommunism::internal::Aarch64 Class Reference

Architecture specific methods for working with cothreads on 64 bit ARM machines. More...

#include <Common.h>

Inheritance diagram for libcommunism::internal::Aarch64:

Public Member Functions
	Aarch64 (const Entry &entry, const size_t stackSize=0)
	Aarch64 (const Entry &entry, std::span< uintptr_t > stack)
	Aarch64 (std::span< uintptr_t > stack)
	~Aarch64 ()
void	switchTo (CothreadImpl *from) override
Public Member Functions inherited from libcommunism::CothreadImpl
	CothreadImpl (const Cothread::Entry &entry, const size_t stackSize=0)
	CothreadImpl (const Cothread::Entry &entry, std::span< uintptr_t > stack)
	CothreadImpl (std::span< uintptr_t > stack)
virtual	~CothreadImpl ()=default
virtual size_t	getStackSize () const
virtual void *	getStack () const

Static Public Attributes
static constexpr const size_t	kContextSaveAreaSize {0x100}
static constexpr const size_t	kMainStackSize {(kContextSaveAreaSize * 2) / sizeof(uintptr_t)}
static constexpr const size_t	kStackAlignment {64}
static constexpr const size_t	kDefaultStackSize {0x80000}

Friends
CothreadImpl *	libcommunism::AllocKernelThreadWrapper ()

Additional Inherited Members
Public Types inherited from libcommunism::CothreadImpl
using	Entry = Cothread::Entry
Protected Attributes inherited from libcommunism::CothreadImpl
std::span< uintptr_t >	stack
	Stack used by this cothread, if any. More...

Detailed Description

Architecture specific methods for working with cothreads on 64 bit ARM machines.

Remarks

The context of threads is stored at the top of the allocated stack. Therefore, roughly 0x100 bytes fewer than provided are available as actual program stack.

Definition at line 18 of file Common.h.

Constructor & Destructor Documentation

Aarch64() [1/3]

Aarch64::Aarch64	(	const Entry &	entry,
		const size_t	stackSize = 0
	)

Allocate a cothread with a private stack.

Parameters

entry	Method to execute on entry to this cothread
stackSize	Size of the stack to be allocated, in bytes. it should be a multiple of the machine word size, or specify zero to use the platform default.

Exceptions

std::runtime_error	If the memory for the cothread could not be allocated.
std::runtime_error	If the provided stack size is invalid

Definition at line 33 of file Common.cpp.

                                                           : CothreadImpl(entry, stackSize) {
    void *buf{nullptr};
 
    // round down stack size to ensure it's aligned before allocating it
    auto allocSize = stackSize & ~(Aarch64::kStackAlignment - 1);
    allocSize = allocSize ? allocSize : Aarch64::kDefaultStackSize;
    allocSize += Aarch64::kContextSaveAreaSize;
 
    buf = Aarch64::AllocStack(allocSize);
 
    // create it as if we had provided the memory in the first place
    this->stack = {reinterpret_cast<uintptr_t *>(buf), allocSize / sizeof(uintptr_t)};
    this->ownsStack = true;
 
    Aarch64::Prepare(this, entry);
}

Aarch64() [2/3]

Aarch64::Aarch64	(	const Entry &	entry,
		std::span< uintptr_t >	_stack
	)

Allocates a cothread with an already provided stack.

Parameters

entry	Method to execute on entry to this cothread
stack	Buffer to use as the stack of the cothread

Exceptions

std::runtime_error

If the provided stack is invalid

Definition at line 58 of file Common.cpp.

                                                              : CothreadImpl(entry, _stack) {
    Aarch64::ValidateStackSize(_stack.size() * sizeof(uintptr_t));
    Aarch64::Prepare(this, entry);
}

Aarch64() [3/3]

Aarch64::Aarch64

(

std::span< uintptr_t >

stack

)

Allocate a cothread placeholder for a kernel thread. This uses a preallocated "stack" to store the kernel thread's context at the time we switched to the cothread.

Definition at line 67 of file Common.cpp.

                                         : CothreadImpl(stack), stackTop(stack.data()) {
}

~Aarch64()

Aarch64::~Aarch64

(

)

Release the stack if we allocated it.

Definition at line 74 of file Common.cpp.

                  {
    if(this->ownsStack) {
        DeallocStack(this->stack.data());
    }
}

Member Function Documentation

switchTo()

void Aarch64::switchTo ( CothreadImpl *  from )

overridevirtual

Performs a context switch to the provided cothread.

The state of the caller is stored on the stack of the currently active thread.

Implements libcommunism::CothreadImpl.

Definition at line 85 of file Common.cpp.

                                         {
    Switch(static_cast<Aarch64 *>(from), this);
}

Friends And Related Function Documentation

libcommunism::AllocKernelThreadWrapper

CothreadImpl* libcommunism::AllocKernelThreadWrapper ( )

friend

Member Data Documentation

kContextSaveAreaSize

constexpr const size_t libcommunism::internal::Aarch64::kContextSaveAreaSize {0x100}

staticconstexpr

Size of the reserved region, at the top of the stack, which is reserved for saving the context of a thread. This is in bytes.

Definition at line 69 of file Common.h.

kDefaultStackSize

constexpr const size_t libcommunism::internal::Aarch64::kDefaultStackSize {0x80000}

staticconstexpr

Platform default size to use for the stack, in bytes, if no size is requested by the caller. We default to 512K.

Definition at line 86 of file Common.h.

kMainStackSize

constexpr const size_t libcommunism::internal::Aarch64::kMainStackSize {(kContextSaveAreaSize * 2) / sizeof(uintptr_t)}

staticconstexpr

Size of the stack buffer for the "fake" initial cothread, in machine words. This only needs to be large enough to fit the register frame. This must be a power of two.

Definition at line 75 of file Common.h.

kStackAlignment

constexpr const size_t libcommunism::internal::Aarch64::kStackAlignment {64}

staticconstexpr

Requested alignment for stack allocations, in bytes.

Definition at line 80 of file Common.h.

---

The documentation for this class was generated from the following files:

• src/arch/aarch64/Common.h
• src/arch/aarch64/AAPCS.cpp
• src/arch/aarch64/Common.cpp