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 anon1 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();

typedef uint32 tcflag_t;

typedef uint32 speed_t;

struct termios{
tcflag_t	c_iflag;
tcflag_t	c_oflag;
tcflag_t	c_cflag;
tcflag_t	c_lflag;
uint16	c_line;
uint16	c_cc[NCCS];
speed_t	c_ispeed;
speed_t	c_ospeed;
};

void makeraw();

void makecooked();

void setattr(
    termios t);

termios getattr();

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

bool verifyYield(
    Cap yield);

Constructor freeze();

Method invoked by the IrqHelper to advise the receiver that an interrupt has arrived.

void onInterrupt(
    coyotos.IrqCtl.irq_t irq);

Provide the helper with a notification callback capability that should be called from the wait-and-notify loop.

void setCallback(
    IrqCallback callbackCap);

Return true iff an interrupt callback is pending.

bool isDeliveryPending();

This will return true if an interrupt wait has completed and the associated callback generated an exception. If runWaitLoop() or waitOnce() are called while a delivery is pending, they will re-try the callback.

If an interrupt delivery is pending, cancel it, returning true iff cancelation occurred.

bool cancelPendingDelivery();

It is the responsibility of the caller not to lose track of pending interrupts.

Start the wait and notify loop, continuing until otherwise instructed by the notification response.

void runWaitLoop();

The IrqHelper returns immediately from this request, and then enters a loop in which it waits for its assigned interrupt, calls the callback capability, and repeats. If the callback generates an exception, the wait loop is terminated and the helper re-enters the control state.

Raises cap.RequestError exception if interrupt is not initialized or callback capability is not set.

Execute the wait and notify loop exactly once.

void waitOnce();

Tell the helper what interrupt it should wait for.

void setIRQ(
    coyotos.IrqCtl.irq_t irq);

IrqHelper getHelper();

typedef anon9 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);