Raised on insert operations when constructor has been sealed.

Insert a capability to be used as the yield's external fault handler.

void setHandler(
    Cap handler);

Raises: Sealed

If the installed capability is a constructor capability, a new address space will be fabricated from this constructor for each newly instantiatied process.

Insert a capability to be used as the yield's initial addres space.

void setSpace(
    Cap space);

Raises: Sealed

If the installed capability is a constructor capability, a new address space will be fabricated from this constructor for each newly instantiatied process.

Set the initial program counter for the yield.

void setPC(
    coyaddr_t pc);

Raises: Sealed

Insert a tool capability for the process.

void setTool(
    uint32 slot,
    Cap c);

Raises: Sealed

Seal the constructor, returning a constructor capability.

Constructor seal();

Return true exactly if the constructor's yield is confined.

bool isYieldConfined();

Create a new instance of the constructor's yield.

Cap create(
    SpaceBank bank,
    Schedule sched,
    Cap runtime);

The created instance is allocated from the provided space bank and executes under the provided schedule.

bank should be a newly created bank; upon any failure, the bank will be destroyed.

runtime is passed to the newly created process as its runtime information key.

Create a new instance of the constructor's yield, using the default arguments.

Cap simpleCreate(
    Cap runtime,
    OUT Cap newBank);

Uses CR_SELF's schedule and a new child of CR_SPACEBANK to invoke the constructor. runtime is passed through unchanged, and the new bank is returned through newBank.

Equivalent to:

 tmp_schedule = coyotos.Process.getSlot(CR_SELF, cslot.schedule);
 tmp_fullbank = coyotos.SpaceBank.createChild(CR_SPACEBANK);
 try {
   tmp_c_bank = coyotos.SpaceBank.reduce(tmp_fullbank, 
                                         restrictions.noRemove);
   ret =
     coyotos.Constructor.create(tmp_c_bank, tmp_schedule, runtime);
   newBank = tmp_fullbank;
   return ret;
 } catch (e) {
   try { coyotos.Cap.destroy(tmp_fullbank); } catch () { }
   throw (e);
 }

Get a Verifier for this Constructor

Verifier getVerifier();

No Virtual Address Space is available

Set the end of the heap, allowing further allocation

void setBreak(
    uint64 newBreak);

Raises: NoSpace

Maximum length character buffer that can be transmitted or received in a single read/write operation.

typedef anon0 chString;

void doRead(
    uint32 length,
    OUT chString s);

Raises: RequestWouldBlock

Return the read-specific channel for this IoStream.

IoStream getReadChannel();

Return the write-specific channel for this IoStream.

IoStream getWriteChannel();

uint32 doWrite(
    chString s);

Raises: RequestWouldBlock

Read length bytes into chString from stream.

void read(
    uint32 len,
    OUT chString s);

This declares a library-supplied wrapper that calls doRead() internally, hiding the details of the read blocking protocol.

Write chString to stream.

uint32 write(
    chString s);

This declares a library-supplied wrapper that calls doWrite() internally, hiding the details of the read blocking protocol.

A limit on the amount of usable space has been reached.

Reduced-authority space bank variants

Structure for limit information.

struct limits{
uint64	byType[Range.obType.otNUM_TYPES];
};

Allocate objects.

void alloc(
    Range.obType obType1,
    Range.obType obType2,
    Range.obType obType3,
    OUT Cap c1,
    OUT Cap c2,
    OUT Cap c3);

Raises: LimitReachedNoAccess

Allocates objects of type obType1, obType2, and obType3, returning them in c1, c2, c3. If range.obType.otInvalid is passed as a desired object type, the corresponding return capability will be cap.null. The operation is all or nothing; if three objects are requested but only two can be allocated, the LimitReached exception is raised.

An allocation performed on any bank is performed in parallel on all of its parent banks up to the prime bank. This means that the effective allocation limit is the most constraining limit applied by the invoked bank and all of its parent banks.

Raises LimitReached if this allocation would exceed the limits of the current bank or one of its parents.

Raises NoAccess if the capability has the noAlloc restriction.

Free objects.

void free(
    uint32 count,
    Cap c1,
    Cap c2,
    Cap c3);

Raises: LimitReachedNoAccess

Releases count objects, returning them to the free storage pool. If the passed capabilities are not owned by this space bank, the cap.RequestError exception is raised. The passed capabilities must additionally satisfy the constraints of coyotos.Range.rescind.

If any of the passed capabilities fail to meet these requirements, the operation fails with a cap.RequestError exception with no action taken.

If the count is not in the range 0 < count < 4, cap.RequestError is raised.

Raises NoAccess if the capability has the noFree restriction.

Allocate a process.

Cap allocProcess(
    Cap brand);

Raises: LimitReachedNoAccess

Allocates a new process object, installing brand in the brand slot of the process. Processes can be allocated using alloc(), but doing so will not permit their brand slot to be populated.

A process allocated using allocProcess() should be deallocated using free().

Destroy the target bank as in destroy(), and reply to the specified rcvr capability with result resultCode.

void destroyBankAndReturn(
    Cap rcvr,
    exception_t resultCode);

If resultCode is RC_OK, the reply to rcvr will be a "normal" (non-error) reply with no payload. Otherwise, it will be an exceptional reply with resultCode as the specified exception code.

Note that as with all spacebank replies, the reply will be non-blocking. if rcvr is not receiving, the reply will be lost.

If the operation fails, the failure is returned to the caller, not rcvr.

Set the limits imposed by this bank.

void setLimits(
    limits lims);

Raises: NoAccess

Retrieve the current limits imposed by this bank (directly).

limits getLimits();

Raises: NoAccess

Retrieve the most constraining limits that apply to allocations from this bank, including parent limits.

limits getEffectiveLimits();

Raises: NoAccess

Retrieve the current usage of the bank

limits getUsage();

Raises: NoAccess

inherited from coyotos.Cap.destroy

Destroy bank and storage.

void destroy();

In addition to deallocating the space bank itself, the destroy operation deallocates all storage that has been allocated from this bank.

Destroy this bank, transfering ownership of storage and sub-banks to the parent bank.

void remove();

Raises: NoAccess

Create a child bank from the current bank.

SpaceBank createChild();

Raises: NoAccessLimitReached

Verify that a bank is authentic.

bool verifyBank(
    SpaceBank bank);

Tests whether a capability references an official space bank. Note that to be able to usefully call this, you must have a capability that you know is a capability to an official space bank. The constructor holds such a capability and uses it to validate the bank that is passed for object construction. Applications can therefore bootstrap bank authentication from the initial bank provided through their constructor.

Return bank capability with reduced authority.

SpaceBank reduce(
    restrictions mask);

Returns bank capability to the same bank with the additional restrictions specified by mask. These restrictions are applied in addition to any pre-existing restrictions on the invoked capability.

Get the address space root for this space

AddressSpace getSpace();

Returns true exactly if yield is a child of this constructor.

bool verifyYield(
    Cap yield);

Constructor freeze();

typedef anon0 chString;

Clear the display

void clear();

Write ASSCII character to display.

void putChar(
    wchar8 c);

Write ASSCII character string to display.

void putCharSequence(
    chString s);