United States |
Previous | Contents | Index |
This function inserts an entry at the end of a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. The pointers to head and new_entry must not be equal. All parts of the queue must be memory resident.
This function has the following format:
int __PAL_INSQTIQR (void *head, void *new_entry); /* At tail, interlocked resident */ |
head
A pointer to the queue header. The header must be aligned on an octaword boundary.new_entry
A pointer to the new entry to be inserted. The entry must be aligned on an octaword boundary.
There are three possible return values:
This function inserts a new entry after an existing entry into a longword queue. This function must have write access to header and queue entries.
This function has the following format:
int __PAL_INSQUEL (void *predecessor, void *new_entry); |
predecessor
A pointer to an existing entry in the queue.new_entry
A pointer to the new entry to be inserted.
There are two possible return values:
This function inserts a new entry after an existing entry into a longword queue deferred. This function must have write access to header and queue entries.
This function has the following format:
int __PAL_INSQUEL_D (void **predecessor, void *new_entry); /* Deferred */ |
predecessor
A pointer to a pointer to the predecessor entry.new_entry
A pointer to the new entry to be inserted.
There are two possible return values:
This function inserts a new entry after an existing entry into a quadword queue. This function must have write access to header and queue entries.
This function has the following format:
int __PAL_INSQUEQ (void *predecessor, void *new_entry); |
predecessor
A pointer to an existing entry in the queue.new_entry
A pointer to the new entry to be inserted.
There are two possible return values:
This function inserts a new entry after an existing entry into a quadword queue deferred. This function must have write access to header and queue entries.
This function has the following format:
int __PAL_INSQUEQ_D (void **predecessor, void *new_entry); /* Deferred */ |
predecessor
A pointer to a pointer to the predecessor entry.new_entry
A pointer to the new entry to be inserted.
There are two possible return values:
This function returns the quadword-aligned memory object specified by address.
This function has the following format:
uint64 __PAL_LDQP (void *address); |
address
A pointer to the quadword-aligned memory object to be returned.
If the object pointed to by address is not quadword-aligned,
the result is unpredictable.
6.2.1.67 __PAL_STQP
This function writes the quadword value to the memory location pointed to by address.
This function has the following format:
void __PAL_STQP (void *address, uint64 value); |
address
Memory location to be written to.value
Quadword value to be stored.
If the location pointed to by address is not quadword-aligned,
the result is unpredictable.
6.2.1.68 __PAL_MFPR_XXXX
These privileged functions return the contents of a particular processor register. The XXXX indicates the processor register to be read.
These functions have the following format:
unsigned int __PAL_MFPR_ASTEN (void); /* AST Enable */ unsigned int __PAL_MFPR_ASTSR (void); /* AST Summary Register */ void *__PAL_MFPR_ESP (void); /* Executive Stack Pointer */ int __PAL_MFPR_FEN (void); /* Floating-Point Enable */ int __PAL_MFPR_IPL (void); /* Interrupt Priority Level */ int __PAL_MFPR_MCES (void); /* Machine Check Error Summary */ void *__PAL_MFPR_PCBB (void); /* Privileged Context Block Base */ int64 __PAL_MFPR_PRBR (void); /* Processor Base Register */ int __PAL_MFPR_PTBR (void); /* Page Table Base Register */ void *__PAL_MFPR_SCBB (void); /* System Control Block Base */ unsigned int __PAL_MFPR_SISR (void); /* Software Interrupt Summary Register */ void *__PAL_MFPR_SSP (void); /* Supervisor Stack Pointer */ int64 __PAL_MFPR_TBCHK (void *address); /* Translation Buffer Check */ void *__PAL_MFPR_USP (void); /* User Stack Pointer */ void *__PAL_MFPR_VPTB (void); /* Virtual Page Table */ int64 __PAL_MFPR_WHAMI (void); /* Who Am I */ |
These privileged functions load a value into one of the special processor registers. The XXXX indicates the processor register to be loaded.
These functions have the following format:
void __PAL_MTPR_ASTEN (unsigned int mask); /* AST Enable */ void __PAL_MTPR_ASTSR (unsigned int mask); /* AST Summary Register */ void __PAL_MTPR_DATFX (int value); /* Data Alignment Trap Fixup */ void __PAL_MTPR_ESP (void *address); /* Executive Stack Pointer */ void __PAL_MTPR_FEN (int value); /* Floating-Point Enable */ void __PAL_MTPR_IPIR (int64 number); /* Interprocessor Interrupt Request */ int __PAL_MTPR_IPL (int value); /* Interrupt Priority Level */ void __PAL_MTPR_MCES (int value); /* Machine Check Error Summary */ void __PAL_MTPR_PRBR (int64 value); /* Processor Base Register */ void __PAL_MTPR_SCBB (void *address); /* System Control Block Base */ void __PAL_MTPR_SIRR (int level); /* Software Interrupt Request Register */ void __PAL_MTPR_SSP (int *address); /* Supervisor Stack Pointer */ void __PAL_MTPR_TBIA (void); /* User Stack Pointer */ void __PAL_MTPR_TBIAP (void); /* Translation Buffer Invalidate All Process */ void __PAL_MTPR_TBIS (void *address); /* Translation Buffer Invalidate Single */ void __PAL_MTPR_TBISD (void *address); /* Translation Buffer Invalidate Single Data */ void __PAL_MTPR_TBISI (void *address); /* Translation Buffer Invalidate Single Instruction */ void __PAL_MTPR_USP (void *address); /* User Stack Pointer */ void __PAL_MTPR_VPTB (void *address); /* Virtual Page Table */ |
This function checks the read accessibility of the first and last byte of the given address and offset pair.
This function has the following format:
int __PAL_PROBER (const void *base_address, int offset, char mode); |
base_address
The pointer to the memory segment to be tested for read access.offset
The signed offset to the last byte in the memory segment.mode
The processor mode used for checking access.
There are two possible return values:
This function checks the write accessibility of the first and last byte of the given address and offset pair.
This function has the following format:
int __PAL_PROBEW (const void *base_address, int offset, char mode); |
base_address
The pointer to the memory segment to be tested for write access.offset
The signed offset to the last byte in the memory segment.mode
The processor mode used for checking access.
There are two possible return values:
This function returns the Processor Status (PS).
This function has the following format:
uint64 __PAL_RD_PS (void); |
This function removes the first entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.
This function has the following format:
int __PAL_REMQHIL (void *head, void **removed_entry); /* At head, interlocked */ |
head
A pointer to the queue header. The header must be aligned on a quadword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes the first entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.
This function has the following format:
int __PAL_REMQHILR (void *head, void **removed_entry); /* At head, interlocked resident */ |
head
A pointer to the queue header. The header must be aligned on a quadword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes the first entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.
This function has the following format:
int __PAL_REMQHIQ (void *head, void **removed_entry); /* At head, interlocked */ |
head
A pointer to the queue header. The header must be aligned on an octaword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes the first entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.
This function has the following format:
int __PAL_REMQHIQR (void *head, void **removed_entry); /* At head, interlocked resident */ |
head
A pointer to the queue header. The header must be aligned on an octaword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes the last entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.
This function has the following format:
int __PAL_REMQTIL (void *head, void **removed_entry); /* At tail, interlocked */ |
head
A pointer to the queue header. The header must be aligned on a quadword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes the last entry from a longword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.
This function has the following format:
int __PAL_REMQTILR (void *head, void **removed_entry); /* At tail, interlocked resident */ |
head
A pointer to the queue header. The header must be aligned on a quadword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes the last entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries.
This function has the following format:
int __PAL_REMQTIQ (void *head, void **removed_entry); /* At tail, interlocked */ |
head
A pointer to the queue header. The header must be aligned on an octaword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes the last entry from a quadword queue in an indivisible manner. This operation is interlocked against similar operations by other processors or devices in the system. This function must have write access to the header and queue entries. All parts of the queue must be memory resident.
This function has the following format:
int __PAL_REMQTIQR (void *head, void **removed_entry); /* At tail, interlocked resident */ |
head
A pointer to the queue header. The header must be aligned on an octaword boundary.removed_entry
A pointer to the address of the entry removed from the queue.
There are four possible return values:
This function removes an entry from a longword queue. This function must have write access to header and queue entries.
This function has the following format:
int _PAL_REMQUEL (void *entry, void **removed_entry); |
entry
A pointer to the queue entry to be removed.removed_entry
A pointer to the address of the entry removed from the queue.
There are three possible return values:
This function removes an entry from a longword queue deferred. This function must have write access to header and queue entries.
This function has the following format:
int __PAL_REMQUEL_D (void **entry, void **removed_entry); /* Deferred */ |
entry
A pointer to a pointer to the queue entry to be removed.removed_entry
A pointer to the address of the entry removed from the queue.
There are three possible return values:
This function removes an entry from a quadword queue. This function must have write access to header and queue entries.
This function has the following format:
int __PAL_REMQUEQ (void *entry, void **removed_entry); |
entry
A pointer to the queue entry to be removed.removed_entry
A pointer to the address of the entry removed from the queue.
There are three possible return values:
This function removes an entry from a quadword queue deferred. This function must have write access to header and queue entries.
This function has the following format:
int __PAL_REMQUEQ_D (void **entry, void **removed_entry); /* Deferred */ |
entry
A pointer to a pointer to the queue entry to be removed.removed_entry
A pointer to the address of the entry removed from the queue.
There are three possible return values:
Previous | Next | Contents | Index |
|