g0 {return the contents of register `g0', also `g1' - `g7' (SPARC) and `g1' - `g14' (i960)} {g0\( \)} {g0(\ )} {VxWorks Reference Manual} Libraries {} {}
a0 {return the contents of register `a0' (also `a1' - `a7') (MC680x0)} {a0\( \)} {a0(\ )} {VxWorks Reference Manual} Libraries {} {}
d0 {return the contents of register `d0' (also `d1' - `d7') (MC680x0)} {d0\( \)} {d0(\ )} {VxWorks Reference Manual} Libraries {} {}
sr {return the contents of the status register (MC680x0, SH)} {sr\( \)} {sr(\ )} {VxWorks Reference Manual} Libraries {} {}
psrShow {display the meaning of a specified `psr' value, symbolically (SPARC)} {psrShow\( \)} {psrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
fsrShow {display the meaning of a specified fsr value, symbolically (SPARC)} {fsrShow\( \)} {fsrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
o0 {return the contents of register `o0' (also `o1' - `o7') (SPARC)} {o0\( \)} {o0(\ )} {VxWorks Reference Manual} Libraries {} {}
l0 {return the contents of register `l0' (also `l1' - `l7') (SPARC)} {l0\( \)} {l0(\ )} {VxWorks Reference Manual} Libraries {} {}
i0 {return the contents of register `i0' (also `i1' - `i7') (SPARC)} {i0\( \)} {i0(\ )} {VxWorks Reference Manual} Libraries {} {}
npc {return the contents of the next program counter (SPARC)} {npc\( \)} {npc(\ )} {VxWorks Reference Manual} Libraries {} {}
psr {return the contents of the processor status register (SPARC)} {psr\( \)} {psr(\ )} {VxWorks Reference Manual} Libraries {} {}
wim {return the contents of the window invalid mask register (SPARC)} {wim\( \)} {wim(\ )} {VxWorks Reference Manual} Libraries {} {}
y {return the contents of the `y' register (SPARC)} {y\( \)} {y(\ )} {VxWorks Reference Manual} Libraries {} {}
pfp {return the contents of register `pfp' (i960)} {pfp\( \)} {pfp(\ )} {VxWorks Reference Manual} Libraries {} {}
tsp {return the contents of register `sp' (i960)} {tsp\( \)} {tsp(\ )} {VxWorks Reference Manual} Libraries {} {}
rip {return the contents of register `rip' (i960)} {rip\( \)} {rip(\ )} {VxWorks Reference Manual} Libraries {} {}
r3 {return the contents of register `r3' (also `r4' - `r15') (i960)} {r3\( \)} {r3(\ )} {VxWorks Reference Manual} Libraries {} {}
fp {return the contents of register `fp' (i960)} {fp\( \)} {fp(\ )} {VxWorks Reference Manual} Libraries {} {}
fp0 {return the contents of register `fp0' (also `fp1' - `fp3') (i960KB, i960SB)} {fp0\( \)} {fp0(\ )} {VxWorks Reference Manual} Libraries {} {}
pcw {return the contents of the `pcw' register (i960)} {pcw\( \)} {pcw(\ )} {VxWorks Reference Manual} Libraries {} {}
tcw {return the contents of the `tcw' register (i960)} {tcw\( \)} {tcw(\ )} {VxWorks Reference Manual} Libraries {} {}
acw {return the contents of the `acw' register (i960)} {acw\( \)} {acw(\ )} {VxWorks Reference Manual} Libraries {} {}
dbgBpTypeBind {bind a breakpoint handler to a breakpoint type (MIPS R3000, R4000)} {dbgBpTypeBind\( \)} {dbgBpTypeBind(\ )} {VxWorks Reference Manual} Libraries {} {}
edi {return the contents of register `edi' (also `esi' - `eax') (i386/i486)} {edi\( \)} {edi(\ )} {VxWorks Reference Manual} Libraries {} {}
eflags {return the contents of the status register (i386/i486)} {eflags\( \)} {eflags(\ )} {VxWorks Reference Manual} Libraries {} {}
r0 {return the contents of register `r0' (also `r1' - `r14') (ARM)} {r0\( \)} {r0(\ )} {VxWorks Reference Manual} Libraries {} {}
cpsr {return the contents of the current processor status register (ARM)} {cpsr\( \)} {cpsr(\ )} {VxWorks Reference Manual} Libraries {} {}
psrShow {display the meaning of a specified PSR value, symbolically (ARM)} {psrShow;1\( \)} {psrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
r0 {return the contents of general register r0 (also r1-r15) (SH)} {r0;1\( \)} {r0(\ )} {VxWorks Reference Manual} Libraries {} {}
gbr {return the contents of the global base register (SH)} {gbr\( \)} {gbr(\ )} {VxWorks Reference Manual} Libraries {} {}
vbr {return the contents of the vector base register (SH)} {vbr\( \)} {vbr(\ )} {VxWorks Reference Manual} Libraries {} {}
mach {return the contents of system register mach (SH)} {mach\( \)} {mach(\ )} {VxWorks Reference Manual} Libraries {} {}
macl {return the contents of system register macl (SH)} {macl\( \)} {macl(\ )} {VxWorks Reference Manual} Libraries {} {}
pr {return the contents of system register pr (SH)} {pr\( \)} {pr(\ )} {VxWorks Reference Manual} Libraries {} {}
excVecInit {initialize the exception/interrupt vectors} {excVecInit\( \)} {excVecInit(\ )} {VxWorks Reference Manual} Libraries {} {}
excConnect {connect a C routine to an exception vector (PowerPC)} {excConnect\( \)} {excConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
excIntConnect {connect a C routine to an asynchronous exception vector (PowerPC, ARM)} {excIntConnect\( \)} {excIntConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
excCrtConnect {connect a C routine to a critical exception vector (PowerPC 403)} {excCrtConnect\( \)} {excCrtConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
excIntCrtConnect {connect a C routine to a critical interrupt vector (PowerPC 403)} {excIntCrtConnect\( \)} {excIntCrtConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
excVecSet {set a CPU exception vector (PowerPC, ARM)} {excVecSet\( \)} {excVecSet(\ )} {VxWorks Reference Manual} Libraries {} {}
excVecGet {get a CPU exception vector (PowerPC, ARM)} {excVecGet\( \)} {excVecGet(\ )} {VxWorks Reference Manual} Libraries {} {}
fppSave {save the floating-point coprocessor context} {fppSave\( \)} {fppSave(\ )} {VxWorks Reference Manual} Libraries {} {}
fppRestore {restore the floating-point coprocessor context} {fppRestore\( \)} {fppRestore(\ )} {VxWorks Reference Manual} Libraries {} {}
fppProbe {probe for the presence of a floating-point coprocessor} {fppProbe\( \)} {fppProbe(\ )} {VxWorks Reference Manual} Libraries {} {}
fppTaskRegsGet {get the floating-point registers from a task TCB} {fppTaskRegsGet\( \)} {fppTaskRegsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
fppTaskRegsSet {set the floating-point registers of a task} {fppTaskRegsSet\( \)} {fppTaskRegsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
intLevelSet {set the interrupt level (MC680x0, SPARC, i960, x86, ARM and SH)} {intLevelSet\( \)} {intLevelSet(\ )} {VxWorks Reference Manual} Libraries {} {}
intLock {lock out interrupts} {intLock\( \)} {intLock(\ )} {VxWorks Reference Manual} Libraries {} {}
intUnlock {cancel interrupt locks} {intUnlock\( \)} {intUnlock(\ )} {VxWorks Reference Manual} Libraries {} {}
intEnable {enable corresponding interrupt bits (MIPS, PowerPC, ARM)} {intEnable\( \)} {intEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
intDisable {disable corresponding interrupt bits (MIPS, PowerPC, ARM)} {intDisable\( \)} {intDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
intCRGet {read the contents of the cause register (MIPS)} {intCRGet\( \)} {intCRGet(\ )} {VxWorks Reference Manual} Libraries {} {}
intCRSet {write the contents of the cause register (MIPS)} {intCRSet\( \)} {intCRSet(\ )} {VxWorks Reference Manual} Libraries {} {}
intSRGet {read the contents of the status register (MIPS)} {intSRGet\( \)} {intSRGet(\ )} {VxWorks Reference Manual} Libraries {} {}
intSRSet {update the contents of the status register (MIPS)} {intSRSet\( \)} {intSRSet(\ )} {VxWorks Reference Manual} Libraries {} {}
intConnect {connect a C routine to a hardware interrupt} {intConnect\( \)} {intConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
intHandlerCreate {construct an interrupt handler for a C routine (MC680x0, SPARC, i960, x86, MIPS)} {intHandlerCreate\( \)} {intHandlerCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
intLockLevelSet {set the current interrupt lock-out level (MC680x0, SPARC, i960, x86, ARM, SH)} {intLockLevelSet\( \)} {intLockLevelSet(\ )} {VxWorks Reference Manual} Libraries {} {}
intLockLevelGet {get the current interrupt lock-out level (MC680x0, SPARC, i960, x86, ARM, SH)} {intLockLevelGet\( \)} {intLockLevelGet(\ )} {VxWorks Reference Manual} Libraries {} {}
intVecBaseSet {set the vector (trap) base address (MC680x0, SPARC, i960, x86, MIPS, ARM)} {intVecBaseSet\( \)} {intVecBaseSet(\ )} {VxWorks Reference Manual} Libraries {} {}
intVecBaseGet {get the vector (trap) base address (MC680x0, SPARC, i960, x86, MIPS, ARM)} {intVecBaseGet\( \)} {intVecBaseGet(\ )} {VxWorks Reference Manual} Libraries {} {}
intVecSet {set a CPU vector (trap) (MC680x0, SPARC, i960, x86, MIPS, SH)} {intVecSet\( \)} {intVecSet(\ )} {VxWorks Reference Manual} Libraries {} {}
intVecGet {get an interrupt vector (MC680x0, SPARC, i960, x86, MIPS, SH)} {intVecGet\( \)} {intVecGet(\ )} {VxWorks Reference Manual} Libraries {} {}
intVecTableWriteProtect {write-protect exception vector table (MC680x0, SPARC, i960, x86, ARM)} {intVecTableWriteProtect\( \)} {intVecTableWriteProtect(\ )} {VxWorks Reference Manual} Libraries {} {}
intUninitVecSet {set the uninitialized vector handler (ARM)} {intUninitVecSet\( \)} {intUninitVecSet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSRSet {set the task status register (MC680x0, MIPS, i386/i486)} {taskSRSet\( \)} {taskSRSet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSRInit {initialize the default task status register (MIPS)} {taskSRInit\( \)} {taskSRInit(\ )} {VxWorks Reference Manual} Libraries {} {}
vxTas {C-callable atomic test-and-set primitive} {vxTas\( \)} {vxTas(\ )} {VxWorks Reference Manual} Libraries {} {}
vxMemArchProbe {architecture specific part of vxMemProbe} {vxMemArchProbe\( \)} {vxMemArchProbe(\ )} {VxWorks Reference Manual} Libraries {} {}
vxMemProbe {probe an address for a bus error} {vxMemProbe\( \)} {vxMemProbe(\ )} {VxWorks Reference Manual} Libraries {} {}
vxMemProbeAsi {probe address in ASI space for bus error (SPARC)} {vxMemProbeAsi\( \)} {vxMemProbeAsi(\ )} {VxWorks Reference Manual} Libraries {} {}
vxSSEnable {enable the superscalar dispatch (MC68060)} {vxSSEnable\( \)} {vxSSEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
vxSSDisable {disable the superscalar dispatch (MC68060)} {vxSSDisable\( \)} {vxSSDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
vxPowerModeSet {set the power management mode (PowerPC)} {vxPowerModeSet\( \)} {vxPowerModeSet(\ )} {VxWorks Reference Manual} Libraries {} {}
vxPowerModeGet {get the power management mode (PowerPC)} {vxPowerModeGet\( \)} {vxPowerModeGet(\ )} {VxWorks Reference Manual} Libraries {} {}
vxPowerDown {place the processor in reduced-power mode (PowerPC)} {vxPowerDown\( \)} {vxPowerDown(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheArchLibInit {initialize the cache library} {cacheArchLibInit\( \)} {cacheArchLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheArchClearEntry {clear an entry from a cache (68K, x86)} {cacheArchClearEntry\( \)} {cacheArchClearEntry(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheStoreBufEnable {enable the store buffer (MC68060 only)} {cacheStoreBufEnable\( \)} {cacheStoreBufEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheStoreBufDisable {disable the store buffer (MC68060 only)} {cacheStoreBufDisable\( \)} {cacheStoreBufDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
mmuVirtToPhys {translate a virtual address to a physical address (ARM)} {mmuVirtToPhys\( \)} {mmuVirtToPhys(\ )} {VxWorks Reference Manual} Libraries {} {}
mmuPhysToVirt {translate a physical address to a virtual address (ARM)} {mmuPhysToVirt\( \)} {mmuPhysToVirt(\ )} {VxWorks Reference Manual} Libraries {} {}
mmuPro32LibInit {initialize module} {mmuPro32LibInit\( \)} {mmuPro32LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumCr4Get {get contents of CR4 register} {pentiumCr4Get\( \)} {pentiumCr4Get(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumCr4Set {sets specified value to the CR4 register} {pentiumCr4Set\( \)} {pentiumCr4Set(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcStart {start both PMC0 and PMC1} {pentiumPmcStart\( \)} {pentiumPmcStart(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcStop {stop both PMC0 and PMC1} {pentiumPmcStop\( \)} {pentiumPmcStop(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcStop1 {stop PMC1} {pentiumPmcStop1\( \)} {pentiumPmcStop1(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcGet {get the contents of PMC0 and PMC1} {pentiumPmcGet\( \)} {pentiumPmcGet(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcGet0 {get the contents of PMC0} {pentiumPmcGet0\( \)} {pentiumPmcGet0(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcGet1 {get the contents of PMC1} {pentiumPmcGet1\( \)} {pentiumPmcGet1(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcReset {reset both PMC0 and PMC1} {pentiumPmcReset\( \)} {pentiumPmcReset(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcReset0 {reset PMC0} {pentiumPmcReset0\( \)} {pentiumPmcReset0(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcReset1 {reset PMC1} {pentiumPmcReset1\( \)} {pentiumPmcReset1(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumTscGet64 {get 64Bit TSC (Timestamp Counter)} {pentiumTscGet64\( \)} {pentiumTscGet64(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumTscGet32 {get the lower half of the 64Bit TSC (Timestamp Counter)} {pentiumTscGet32\( \)} {pentiumTscGet32(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumTscReset {reset the TSC (Timestamp Counter)} {pentiumTscReset\( \)} {pentiumTscReset(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumMsrGet {get the contents of the specified MSR (Model Specific Register)} {pentiumMsrGet\( \)} {pentiumMsrGet(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumMsrSet {set a value to the specified MSR (Model Specific Registers)} {pentiumMsrSet\( \)} {pentiumMsrSet(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumTlbFlush {flush TLBs (Translation Lookaside Buffers)} {pentiumTlbFlush\( \)} {pentiumTlbFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumSerialize {execute a serializing instruction CPUID} {pentiumSerialize\( \)} {pentiumSerialize(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumBts {execute atomic compare-and-exchange instruction to set a bit} {pentiumBts\( \)} {pentiumBts(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumBtc {execute atomic compare-and-exchange instruction to clear a bit} {pentiumBtc\( \)} {pentiumBtc(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumMtrrEnable {enable MTRR (Memory Type Range Register)} {pentiumMtrrEnable\( \)} {pentiumMtrrEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumMtrrDisable {disable MTRR (Memory Type Range Register)} {pentiumMtrrDisable\( \)} {pentiumMtrrDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumMtrrGet {get MTRRs to a specified MTRR table} {pentiumMtrrGet\( \)} {pentiumMtrrGet(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumMtrrSet {set MTRRs from specified MTRR table with WRMSR instruction.} {pentiumMtrrSet\( \)} {pentiumMtrrSet(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumMcaShow {show MCA (Machine Check Architecture) registers } {pentiumMcaShow\( \)} {pentiumMcaShow(\ )} {VxWorks Reference Manual} Libraries {} {}
pentiumPmcShow {show PMCs (Performance Monitoring Counters)} {pentiumPmcShow\( \)} {pentiumPmcShow(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxICDisable {disable the I960Jx instruction cache (i960)} {cacheI960JxICDisable\( \)} {cacheI960JxICDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxICEnable {enable the I960Jx instruction cache (i960)} {cacheI960JxICEnable\( \)} {cacheI960JxICEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxICInvalidate {invalidate the I960Jx instruction cache (i960)} {cacheI960JxICInvalidate\( \)} {cacheI960JxICInvalidate(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxICLoadNLock {load and lock the I960Jx instruction cache (i960)} {cacheI960JxICLoadNLock\( \)} {cacheI960JxICLoadNLock(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxICStatusGet {get the I960Jx instruction cache status (i960)} {cacheI960JxICStatusGet\( \)} {cacheI960JxICStatusGet(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxICLockingStatusGet {get the I960Jx I-cache locking status (i960)} {cacheI960JxICLockingStatusGet\( \)} {cacheI960JxICLockingStatusGet(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxICFlush {flush the I960Jx instruction cache (i960)} {cacheI960JxICFlush\( \)} {cacheI960JxICFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxDCDisable {disable the I960Jx data cache (i960)} {cacheI960JxDCDisable\( \)} {cacheI960JxDCDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxDCEnable {enable the I960Jx data cache (i960)} {cacheI960JxDCEnable\( \)} {cacheI960JxDCEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxDCInvalidate {invalidate the I960Jx data cache (i960)} {cacheI960JxDCInvalidate\( \)} {cacheI960JxDCInvalidate(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxDCCoherent {ensure data cache coherency (i960)} {cacheI960JxDCCoherent\( \)} {cacheI960JxDCCoherent(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxDCStatusGet {get the I960Jx data cache status (i960)} {cacheI960JxDCStatusGet\( \)} {cacheI960JxDCStatusGet(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxDCFlush {flush the I960Jx data cache (i960)} {cacheI960JxDCFlush\( \)} {cacheI960JxDCFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960JxLibInit {initialize the I960Jx cache library (i960)} {cacheI960JxLibInit\( \)} {cacheI960JxLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960CxICDisable {disable the I960Cx instruction cache (i960)} {cacheI960CxICDisable\( \)} {cacheI960CxICDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960CxICEnable {enable the I960Cx instruction cache (i960)} {cacheI960CxICEnable\( \)} {cacheI960CxICEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960CxICInvalidate {invalidate the I960Cx instruction cache (i960)} {cacheI960CxICInvalidate\( \)} {cacheI960CxICInvalidate(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960CxICLoadNLock {load and lock I960Cx 512-byte instruction cache (i960)} {cacheI960CxICLoadNLock\( \)} {cacheI960CxICLoadNLock(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960CxIC1kLoadNLock {load and lock I960Cx 1KB instruction cache (i960)} {cacheI960CxIC1kLoadNLock\( \)} {cacheI960CxIC1kLoadNLock(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheI960CxLibInit {initialize the I960Cx cache library (i960)} {cacheI960CxLibInit\( \)} {cacheI960CxLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
acos {compute an arc cosine (ANSI)} {acos\( \)} {acos(\ )} {VxWorks Reference Manual} Libraries {} {}
asin {compute an arc sine (ANSI)} {asin\( \)} {asin(\ )} {VxWorks Reference Manual} Libraries {} {}
atan {compute an arc tangent (ANSI)} {atan\( \)} {atan(\ )} {VxWorks Reference Manual} Libraries {} {}
atan2 {compute the arc tangent of y/x (ANSI)} {atan2\( \)} {atan2(\ )} {VxWorks Reference Manual} Libraries {} {}
cbrt {compute a cube root} {cbrt\( \)} {cbrt(\ )} {VxWorks Reference Manual} Libraries {} {}
ceil {compute the smallest integer greater than or equal to a specified value (ANSI)} {ceil\( \)} {ceil(\ )} {VxWorks Reference Manual} Libraries {} {}
cos {compute a cosine (ANSI)} {cos\( \)} {cos(\ )} {VxWorks Reference Manual} Libraries {} {}
cosh {compute a hyperbolic cosine (ANSI)} {cosh\( \)} {cosh(\ )} {VxWorks Reference Manual} Libraries {} {}
exp {compute an exponential value (ANSI)} {exp\( \)} {exp(\ )} {VxWorks Reference Manual} Libraries {} {}
fabs {compute an absolute value (ANSI)} {fabs\( \)} {fabs(\ )} {VxWorks Reference Manual} Libraries {} {}
floor {compute the largest integer less than or equal to a specified value (ANSI)} {floor\( \)} {floor(\ )} {VxWorks Reference Manual} Libraries {} {}
fmod {compute the remainder of x/y (ANSI)} {fmod\( \)} {fmod(\ )} {VxWorks Reference Manual} Libraries {} {}
infinity {return a very large double} {infinity\( \)} {infinity(\ )} {VxWorks Reference Manual} Libraries {} {}
irint {convert a double-precision value to an integer} {irint\( \)} {irint(\ )} {VxWorks Reference Manual} Libraries {} {}
iround {round a number to the nearest integer} {iround\( \)} {iround(\ )} {VxWorks Reference Manual} Libraries {} {}
log {compute a natural logarithm (ANSI)} {log\( \)} {log(\ )} {VxWorks Reference Manual} Libraries {} {}
log10 {compute a base-10 logarithm (ANSI)} {log10\( \)} {log10(\ )} {VxWorks Reference Manual} Libraries {} {}
log2 {compute a base-2 logarithm} {log2\( \)} {log2(\ )} {VxWorks Reference Manual} Libraries {} {}
pow {compute the value of a number raised to a specified power (ANSI)} {pow\( \)} {pow(\ )} {VxWorks Reference Manual} Libraries {} {}
round {round a number to the nearest integer} {round\( \)} {round(\ )} {VxWorks Reference Manual} Libraries {} {}
sin {compute a sine (ANSI)} {sin\( \)} {sin(\ )} {VxWorks Reference Manual} Libraries {} {}
sincos {compute both a sine and cosine} {sincos\( \)} {sincos(\ )} {VxWorks Reference Manual} Libraries {} {}
sinh {compute a hyperbolic sine (ANSI)} {sinh\( \)} {sinh(\ )} {VxWorks Reference Manual} Libraries {} {}
sqrt {compute a non-negative square root (ANSI)} {sqrt\( \)} {sqrt(\ )} {VxWorks Reference Manual} Libraries {} {}
tan {compute a tangent (ANSI)} {tan\( \)} {tan(\ )} {VxWorks Reference Manual} Libraries {} {}
tanh {compute a hyperbolic tangent (ANSI)} {tanh\( \)} {tanh(\ )} {VxWorks Reference Manual} Libraries {} {}
trunc {truncate to integer} {trunc\( \)} {trunc(\ )} {VxWorks Reference Manual} Libraries {} {}
acosf {compute an arc cosine (ANSI)} {acosf\( \)} {acosf(\ )} {VxWorks Reference Manual} Libraries {} {}
asinf {compute an arc sine (ANSI)} {asinf\( \)} {asinf(\ )} {VxWorks Reference Manual} Libraries {} {}
atanf {compute an arc tangent (ANSI)} {atanf\( \)} {atanf(\ )} {VxWorks Reference Manual} Libraries {} {}
atan2f {compute the arc tangent of y/x (ANSI)} {atan2f\( \)} {atan2f(\ )} {VxWorks Reference Manual} Libraries {} {}
cbrtf {compute a cube root} {cbrtf\( \)} {cbrtf(\ )} {VxWorks Reference Manual} Libraries {} {}
ceilf {compute the smallest integer greater than or equal to a specified value (ANSI)} {ceilf\( \)} {ceilf(\ )} {VxWorks Reference Manual} Libraries {} {}
cosf {compute a cosine (ANSI)} {cosf\( \)} {cosf(\ )} {VxWorks Reference Manual} Libraries {} {}
coshf {compute a hyperbolic cosine (ANSI)} {coshf\( \)} {coshf(\ )} {VxWorks Reference Manual} Libraries {} {}
expf {compute an exponential value (ANSI)} {expf\( \)} {expf(\ )} {VxWorks Reference Manual} Libraries {} {}
fabsf {compute an absolute value (ANSI)} {fabsf\( \)} {fabsf(\ )} {VxWorks Reference Manual} Libraries {} {}
floorf {compute the largest integer less than or equal to a specified value (ANSI)} {floorf\( \)} {floorf(\ )} {VxWorks Reference Manual} Libraries {} {}
fmodf {compute the remainder of x/y (ANSI)} {fmodf\( \)} {fmodf(\ )} {VxWorks Reference Manual} Libraries {} {}
infinityf {return a very large float} {infinityf\( \)} {infinityf(\ )} {VxWorks Reference Manual} Libraries {} {}
irintf {convert a single-precision value to an integer} {irintf\( \)} {irintf(\ )} {VxWorks Reference Manual} Libraries {} {}
iroundf {round a number to the nearest integer} {iroundf\( \)} {iroundf(\ )} {VxWorks Reference Manual} Libraries {} {}
logf {compute a natural logarithm (ANSI)} {logf\( \)} {logf(\ )} {VxWorks Reference Manual} Libraries {} {}
log10f {compute a base-10 logarithm (ANSI)} {log10f\( \)} {log10f(\ )} {VxWorks Reference Manual} Libraries {} {}
log2f {compute a base-2 logarithm} {log2f\( \)} {log2f(\ )} {VxWorks Reference Manual} Libraries {} {}
powf {compute the value of a number raised to a specified power (ANSI)} {powf\( \)} {powf(\ )} {VxWorks Reference Manual} Libraries {} {}
roundf {round a number to the nearest integer} {roundf\( \)} {roundf(\ )} {VxWorks Reference Manual} Libraries {} {}
sinf {compute a sine (ANSI)} {sinf\( \)} {sinf(\ )} {VxWorks Reference Manual} Libraries {} {}
sincosf {compute both a sine and cosine} {sincosf\( \)} {sincosf(\ )} {VxWorks Reference Manual} Libraries {} {}
sinhf {compute a hyperbolic sine (ANSI)} {sinhf\( \)} {sinhf(\ )} {VxWorks Reference Manual} Libraries {} {}
sqrtf {compute a non-negative square root (ANSI)} {sqrtf\( \)} {sqrtf(\ )} {VxWorks Reference Manual} Libraries {} {}
tanf {compute a tangent (ANSI)} {tanf\( \)} {tanf(\ )} {VxWorks Reference Manual} Libraries {} {}
tanhf {compute a hyperbolic tangent (ANSI)} {tanhf\( \)} {tanhf(\ )} {VxWorks Reference Manual} Libraries {} {}
truncf {truncate to integer} {truncf\( \)} {truncf(\ )} {VxWorks Reference Manual} Libraries {} {}
mathHardInit {initialize hardware floating-point math support} {mathHardInit\( \)} {mathHardInit(\ )} {VxWorks Reference Manual} Libraries {} {}
mathSoftInit {initialize software floating-point math support} {mathSoftInit\( \)} {mathSoftInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheR33kLibInit {initialize the R33000 cache library} {cacheR33kLibInit\( \)} {cacheR33kLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheR333x0LibInit {initialize the R333x0 cache library} {cacheR333x0LibInit\( \)} {cacheR333x0LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheR3kDsize {return the size of the R3000 data cache} {cacheR3kDsize\( \)} {cacheR3kDsize(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheR3kIsize {return the size of the R3000 instruction cache} {cacheR3kIsize\( \)} {cacheR3kIsize(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheR3kLibInit {initialize the R3000 cache library} {cacheR3kLibInit\( \)} {cacheR3kLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheR4kLibInit {initialize the R4000 cache library} {cacheR4kLibInit\( \)} {cacheR4kLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheCy604LibInit {initialize the Cypress CY7C604 cache library} {cacheCy604LibInit\( \)} {cacheCy604LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheCy604ClearLine {clear a line from a CY7C604 cache} {cacheCy604ClearLine\( \)} {cacheCy604ClearLine(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheCy604ClearPage {clear a page from a CY7C604 cache} {cacheCy604ClearPage\( \)} {cacheCy604ClearPage(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheCy604ClearSegment {clear a segment from a CY7C604 cache} {cacheCy604ClearSegment\( \)} {cacheCy604ClearSegment(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheCy604ClearRegion {clear a region from a CY7C604 cache} {cacheCy604ClearRegion\( \)} {cacheCy604ClearRegion(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheMb930LibInit {initialize the Fujitsu MB86930 cache library} {cacheMb930LibInit\( \)} {cacheMb930LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheMb930LockAuto {enable MB86930 automatic locking of kernel instructions/data} {cacheMb930LockAuto\( \)} {cacheMb930LockAuto(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheMb930ClearLine {clear a line from an MB86930 cache} {cacheMb930ClearLine\( \)} {cacheMb930ClearLine(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSun4LibInit {initialize the Sun-4 cache library} {cacheSun4LibInit\( \)} {cacheSun4LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSun4ClearLine {clear a line from a Sun-4 cache} {cacheSun4ClearLine\( \)} {cacheSun4ClearLine(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSun4ClearPage {clear a page from a Sun-4 cache} {cacheSun4ClearPage\( \)} {cacheSun4ClearPage(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSun4ClearSegment {clear a segment from a Sun-4 cache} {cacheSun4ClearSegment\( \)} {cacheSun4ClearSegment(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSun4ClearContext {clear a specific context from a Sun-4 cache} {cacheSun4ClearContext\( \)} {cacheSun4ClearContext(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheMicroSparcLibInit {initialize the microSPARC cache library} {cacheMicroSparcLibInit\( \)} {cacheMicroSparcLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ioMmuMicroSparcInit {initialize the microSparc I/II I/O MMU data structures} {ioMmuMicroSparcInit\( \)} {ioMmuMicroSparcInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ioMmuMicroSparcMap {map the I/O MMU for microSparc I/II (TMS390S10/MB86904)} {ioMmuMicroSparcMap\( \)} {ioMmuMicroSparcMap(\ )} {VxWorks Reference Manual} Libraries {} {}
mmuSparcRomInit {initialize the MMU for the ROM (SPARC)} {mmuSparcRomInit\( \)} {mmuSparcRomInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheTiTms390LibInit {initialize the TI TMS390 cache library} {cacheTiTms390LibInit\( \)} {cacheTiTms390LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheTiTms390VirtToPhys {translate a virtual address for cacheLib} {cacheTiTms390VirtToPhys\( \)} {cacheTiTms390VirtToPhys(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheTiTms390PhysToVirt {translate a physical address for drivers} {cacheTiTms390PhysToVirt\( \)} {cacheTiTms390PhysToVirt(\ )} {VxWorks Reference Manual} Libraries {} {}
cleanUpStoreBuffer {clean up store buffer after a data store error interrupt} {cleanUpStoreBuffer\( \)} {cleanUpStoreBuffer(\ )} {VxWorks Reference Manual} Libraries {} {}
mmuL64862DmaInit {initialize the L64862 I/O MMU DMA data structures (SPARC)} {mmuL64862DmaInit\( \)} {mmuL64862DmaInit(\ )} {VxWorks Reference Manual} Libraries {} {}
bzeroDoubles {zero out a buffer eight bytes at a time (SPARC)} {bzeroDoubles\( \)} {bzeroDoubles(\ )} {VxWorks Reference Manual} Libraries {} {}
bfillDoubles {fill a buffer with a specified eight-byte pattern (SPARC)} {bfillDoubles\( \)} {bfillDoubles(\ )} {VxWorks Reference Manual} Libraries {} {}
bcopyDoubles {copy one buffer to another eight bytes at a time (SPARC)} {bcopyDoubles\( \)} {bcopyDoubles(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSh7040LibInit {initialize the SH7040 cache library} {cacheSh7040LibInit\( \)} {cacheSh7040LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSh7604LibInit {initialize the SH7604/SH7615 cache library} {cacheSh7604LibInit\( \)} {cacheSh7604LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSh7700LibInit {initialize the SH7700 cache library} {cacheSh7700LibInit\( \)} {cacheSh7700LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
mmuSh7700LibInit {initialize module} {mmuSh7700LibInit\( \)} {mmuSh7700LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSh7750LibInit {initialize the SH7750 cache library} {cacheSh7750LibInit\( \)} {cacheSh7750LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
mmuSh7750LibInit {initialize module} {mmuSh7750LibInit\( \)} {mmuSh7750LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheSh7729LibInit {initialize the SH7729 cache library} {cacheSh7729LibInit\( \)} {cacheSh7729LibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
romStart {generic ROM initialization} {romStart\( \)} {romStart(\ )} {VxWorks Reference Manual} Libraries {} {}
usrInit {user-defined system initialization routine} {usrInit\( \)} {usrInit(\ )} {VxWorks Reference Manual} Libraries {} {}
usrRoot {the root task} {usrRoot\( \)} {usrRoot(\ )} {VxWorks Reference Manual} Libraries {} {}
usrClock {user-defined system clock interrupt routine} {usrClock\( \)} {usrClock(\ )} {VxWorks Reference Manual} Libraries {} {}
sysClkConnect {connect a routine to the system clock interrupt} {sysClkConnect\( \)} {sysClkConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
sysClkDisable {turn off system clock interrupts} {sysClkDisable\( \)} {sysClkDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
sysClkEnable {turn on system clock interrupts} {sysClkEnable\( \)} {sysClkEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
sysClkRateGet {get the system clock rate} {sysClkRateGet\( \)} {sysClkRateGet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysClkRateSet {set the system clock rate} {sysClkRateSet\( \)} {sysClkRateSet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysAuxClkConnect {connect a routine to the auxiliary clock interrupt} {sysAuxClkConnect\( \)} {sysAuxClkConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
sysAuxClkDisable {turn off auxiliary clock interrupts} {sysAuxClkDisable\( \)} {sysAuxClkDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
sysAuxClkEnable {turn on auxiliary clock interrupts} {sysAuxClkEnable\( \)} {sysAuxClkEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
sysAuxClkRateGet {get the auxiliary clock rate} {sysAuxClkRateGet\( \)} {sysAuxClkRateGet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysAuxClkRateSet {set the auxiliary clock rate} {sysAuxClkRateSet\( \)} {sysAuxClkRateSet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysIntDisable {disable a bus interrupt level} {sysIntDisable\( \)} {sysIntDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
sysIntEnable {enable a bus interrupt level} {sysIntEnable\( \)} {sysIntEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
sysBusIntAck {acknowledge a bus interrupt} {sysBusIntAck\( \)} {sysBusIntAck(\ )} {VxWorks Reference Manual} Libraries {} {}
sysBusIntGen {generate a bus interrupt} {sysBusIntGen\( \)} {sysBusIntGen(\ )} {VxWorks Reference Manual} Libraries {} {}
sysMailboxConnect {connect a routine to the mailbox interrupt} {sysMailboxConnect\( \)} {sysMailboxConnect(\ )} {VxWorks Reference Manual} Libraries {} {}
sysMailboxEnable {enable the mailbox interrupt} {sysMailboxEnable\( \)} {sysMailboxEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
sysNvRamGet {get the contents of non-volatile RAM} {sysNvRamGet\( \)} {sysNvRamGet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysNvRamSet {write to non-volatile RAM} {sysNvRamSet\( \)} {sysNvRamSet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysModel {return the model name of the CPU board} {sysModel\( \)} {sysModel(\ )} {VxWorks Reference Manual} Libraries {} {}
sysBspRev {return the BSP version and revision number} {sysBspRev\( \)} {sysBspRev(\ )} {VxWorks Reference Manual} Libraries {} {}
sysHwInit {initialize the system hardware} {sysHwInit\( \)} {sysHwInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sysPhysMemTop {get the address of the top of memory} {sysPhysMemTop\( \)} {sysPhysMemTop(\ )} {VxWorks Reference Manual} Libraries {} {}
sysMemTop {get the address of the top of logical memory} {sysMemTop\( \)} {sysMemTop(\ )} {VxWorks Reference Manual} Libraries {} {}
sysToMonitor {transfer control to the ROM monitor} {sysToMonitor\( \)} {sysToMonitor(\ )} {VxWorks Reference Manual} Libraries {} {}
sysProcNumGet {get the processor number} {sysProcNumGet\( \)} {sysProcNumGet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysProcNumSet {set the processor number} {sysProcNumSet\( \)} {sysProcNumSet(\ )} {VxWorks Reference Manual} Libraries {} {}
sysBusTas {test and set a location across the bus} {sysBusTas\( \)} {sysBusTas(\ )} {VxWorks Reference Manual} Libraries {} {}
sysScsiBusReset {assert the RST line on the SCSI bus (Western Digital WD33C93 only)} {sysScsiBusReset\( \)} {sysScsiBusReset(\ )} {VxWorks Reference Manual} Libraries {} {}
sysScsiInit {initialize an on-board SCSI port} {sysScsiInit\( \)} {sysScsiInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sysScsiConfig {system SCSI configuration} {sysScsiConfig\( \)} {sysScsiConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
sysLocalToBusAdrs {convert a local address to a bus address} {sysLocalToBusAdrs\( \)} {sysLocalToBusAdrs(\ )} {VxWorks Reference Manual} Libraries {} {}
sysBusToLocalAdrs {convert a bus address to a local address} {sysBusToLocalAdrs\( \)} {sysBusToLocalAdrs(\ )} {VxWorks Reference Manual} Libraries {} {}
sysSerialHwInit {initialize the BSP serial devices to a quiesent state} {sysSerialHwInit\( \)} {sysSerialHwInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sysSerialHwInit2 {connect BSP serial device interrupts} {sysSerialHwInit2\( \)} {sysSerialHwInit2(\ )} {VxWorks Reference Manual} Libraries {} {}
sysSerialReset {reset all SIO devices to a quiet state} {sysSerialReset\( \)} {sysSerialReset(\ )} {VxWorks Reference Manual} Libraries {} {}
sysSerialChanGet {get the SIO_CHAN device associated with a serial channel} {sysSerialChanGet\( \)} {sysSerialChanGet(\ )} {VxWorks Reference Manual} Libraries {} {}
usrAtaConfig {mount a DOS file system from an ATA hard disk} {usrAtaConfig\( \)} {usrAtaConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
usrAtaPartition {get an offset to the first partition of the drive} {usrAtaPartition\( \)} {usrAtaPartition(\ )} {VxWorks Reference Manual} Libraries {} {}
usrFdConfig {mount a DOS file system from a floppy disk} {usrFdConfig\( \)} {usrFdConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
usrIdeConfig {mount a DOS file system from an IDE hard disk} {usrIdeConfig\( \)} {usrIdeConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
usrScsiConfig {configure SCSI peripherals} {usrScsiConfig\( \)} {usrScsiConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
usrSmObjInit {initialize shared memory objects} {usrSmObjInit\( \)} {usrSmObjInit(\ )} {VxWorks Reference Manual} Libraries {} {}
smNetInit {initialize the shared memory network driver} {smNetInit\( \)} {smNetInit(\ )} {VxWorks Reference Manual} Libraries {} {}
smNetAttach {attach the shared memory network interface} {smNetAttach\( \)} {smNetAttach(\ )} {VxWorks Reference Manual} Libraries {} {}
smNetInetGet {get an address associated with a shared memory network interface} {smNetInetGet\( \)} {smNetInetGet(\ )} {VxWorks Reference Manual} Libraries {} {}
smNetShow {show information about a shared memory network} {smNetShow\( \)} {smNetShow(\ )} {VxWorks Reference Manual} Libraries {} {}
bpfDrv {initialize the BPF driver} {bpfDrv\( \)} {bpfDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
bpfDevCreate {create Berkeley Packet Filter device} {bpfDevCreate\( \)} {bpfDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
bpfDevDelete {destroy Berkeley Packet Filter device} {bpfDevDelete\( \)} {bpfDevDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusCallNewHandler {call the allocation failure handler (C++)} {cplusCallNewHandler\( \)} {cplusCallNewHandler(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusCtors {call static constructors (C++)} {cplusCtors\( \)} {cplusCtors(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusCtorsLink {call all linked static constructors (C++)} {cplusCtorsLink\( \)} {cplusCtorsLink(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusDemanglerSet {change C++ demangling mode (C++)} {cplusDemanglerSet\( \)} {cplusDemanglerSet(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusDtors {call static destructors (C++)} {cplusDtors\( \)} {cplusDtors(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusDtorsLink {call all linked static destructors (C++)} {cplusDtorsLink\( \)} {cplusDtorsLink(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusLibInit {initialize the C++ library (C++)} {cplusLibInit\( \)} {cplusLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cplusXtorSet {change C++ static constructor calling strategy (C++)} {cplusXtorSet\( \)} {cplusXtorSet(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator delete} {default run-time support for memory deallocation (C++)} {operator delete\( \)} {operator delete(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {default run-time support for operator new (C++)} {operator new\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {default run-time support for operator new (nothrow) (C++)} {operator new;1\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {run-time support for operator new with placement (C++)} {operator new;2\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
set_new_handler {set new_handler to user-defined function (C++)} {set_new_handler\( \)} {set_new_handler(\ )} {VxWorks Reference Manual} Libraries {} {}
set_terminate {set terminate to user-defined function (C++)} {set_terminate\( \)} {set_terminate(\ )} {VxWorks Reference Manual} Libraries {} {}
VXWModule::VXWModule {build module object from module ID} {VXWModule::VXWModule\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {load an object module at specified memory addresses} {VXWModule::VXWModule;1\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {load an object module into memory} {VXWModule::VXWModule;2\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {create and initialize an object module} {VXWModule::VXWModule;3\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::~VXWModule {unload an object module} {VXWModule::~VXWModule\( \)} {VXWModule::~VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::flags {get the flags associated with this module} {VXWModule::flags\( \)} {VXWModule::flags(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::info {get information about object module} {VXWModule::info\( \)} {VXWModule::info(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::name {get the name associated with module} {VXWModule::name\( \)} {VXWModule::name(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::segFirst {find the first segment in module} {VXWModule::segFirst\( \)} {VXWModule::segFirst(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::segGet {get (delete and return) the first segment from module} {VXWModule::segGet\( \)} {VXWModule::segGet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::segNext {find the next segment in module} {VXWModule::segNext\( \)} {VXWModule::segNext(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::VXWList {initialize a list} {VXWList::VXWList\( \)} {VXWList::VXWList(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::VXWList {initialize a list as a copy of another} {VXWList::VXWList;1\( \)} {VXWList::VXWList(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::~VXWList {free up a list} {VXWList::~VXWList\( \)} {VXWList::~VXWList(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::add {add a node to the end of list} {VXWList::add\( \)} {VXWList::add(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::concat {concatenate two lists} {VXWList::concat\( \)} {VXWList::concat(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::count {report the number of nodes in a list} {VXWList::count\( \)} {VXWList::count(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::extract {extract a sublist from list} {VXWList::extract\( \)} {VXWList::extract(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::find {find a node in list} {VXWList::find\( \)} {VXWList::find(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::first {find first node in list} {VXWList::first\( \)} {VXWList::first(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::get {delete and return the first node from list} {VXWList::get\( \)} {VXWList::get(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::insert {insert a node in list after a specified node} {VXWList::insert\( \)} {VXWList::insert(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::last {find the last node in list} {VXWList::last\( \)} {VXWList::last(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::next {find the next node in list} {VXWList::next\( \)} {VXWList::next(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::nStep {find a list node steps away from a specified node} {VXWList::nStep\( \)} {VXWList::nStep(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::nth {find the Nth node in a list} {VXWList::nth\( \)} {VXWList::nth(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::previous {find the previous node in list} {VXWList::previous\( \)} {VXWList::previous(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::remove {delete a specified node from list} {VXWList::remove\( \)} {VXWList::remove(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::VXWMemPart {create a memory partition} {VXWMemPart::VXWMemPart\( \)} {VXWMemPart::VXWMemPart(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::addToPool {add memory to a memory partition} {VXWMemPart::addToPool\( \)} {VXWMemPart::addToPool(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::alignedAlloc {allocate aligned memory from partition} {VXWMemPart::alignedAlloc\( \)} {VXWMemPart::alignedAlloc(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::alloc {allocate a block of memory from partition} {VXWMemPart::alloc\( \)} {VXWMemPart::alloc(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::findMax {find the size of the largest available free block} {VXWMemPart::findMax\( \)} {VXWMemPart::findMax(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::free {free a block of memory in partition} {VXWMemPart::free\( \)} {VXWMemPart::free(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::info {get partition information} {VXWMemPart::info\( \)} {VXWMemPart::info(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::options {set the debug options for memory partition} {VXWMemPart::options\( \)} {VXWMemPart::options(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::realloc {reallocate a block of memory in partition} {VXWMemPart::realloc\( \)} {VXWMemPart::realloc(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMemPart::show {show partition blocks and statistics} {VXWMemPart::show\( \)} {VXWMemPart::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::VXWMsgQ {create and initialize a message queue} {VXWMsgQ::VXWMsgQ\( \)} {VXWMsgQ::VXWMsgQ(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::VXWMsgQ {build message-queue object from ID} {VXWMsgQ::VXWMsgQ;1\( \)} {VXWMsgQ::VXWMsgQ(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::~VXWMsgQ {delete message queue} {VXWMsgQ::~VXWMsgQ\( \)} {VXWMsgQ::~VXWMsgQ(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::send {send a message to message queue} {VXWMsgQ::send\( \)} {VXWMsgQ::send(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::receive {receive a message from message queue} {VXWMsgQ::receive\( \)} {VXWMsgQ::receive(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::numMsgs {report the number of messages queued} {VXWMsgQ::numMsgs\( \)} {VXWMsgQ::numMsgs(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::info {get information about message queue} {VXWMsgQ::info\( \)} {VXWMsgQ::info(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::show {show information about a message queue} {VXWMsgQ::show\( \)} {VXWMsgQ::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::VXWRingBuf {create an empty ring buffer} {VXWRingBuf::VXWRingBuf\( \)} {VXWRingBuf::VXWRingBuf(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::VXWRingBuf {build ring-buffer object from existing ID} {VXWRingBuf::VXWRingBuf;1\( \)} {VXWRingBuf::VXWRingBuf(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::~VXWRingBuf {delete ring buffer} {VXWRingBuf::~VXWRingBuf\( \)} {VXWRingBuf::~VXWRingBuf(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::get {get characters from ring buffer} {VXWRingBuf::get\( \)} {VXWRingBuf::get(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::put {put bytes into ring buffer} {VXWRingBuf::put\( \)} {VXWRingBuf::put(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::flush {make ring buffer empty} {VXWRingBuf::flush\( \)} {VXWRingBuf::flush(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::freeBytes {determine the number of free bytes in ring buffer} {VXWRingBuf::freeBytes\( \)} {VXWRingBuf::freeBytes(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::isEmpty {test whether ring buffer is empty} {VXWRingBuf::isEmpty\( \)} {VXWRingBuf::isEmpty(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::isFull {test whether ring buffer is full (no more room)} {VXWRingBuf::isFull\( \)} {VXWRingBuf::isFull(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::moveAhead {advance ring pointer by bytes} {VXWRingBuf::moveAhead\( \)} {VXWRingBuf::moveAhead(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::nBytes {determine the number of bytes in ring buffer} {VXWRingBuf::nBytes\( \)} {VXWRingBuf::nBytes(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::putAhead {put a byte ahead in a ring buffer without moving ring pointers} {VXWRingBuf::putAhead\( \)} {VXWRingBuf::putAhead(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::VXWSem {build semaphore object from semaphore ID} {VXWSem::VXWSem\( \)} {VXWSem::VXWSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::~VXWSem {delete a semaphore} {VXWSem::~VXWSem\( \)} {VXWSem::~VXWSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::give {give a semaphore} {VXWSem::give\( \)} {VXWSem::give(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::take {take a semaphore} {VXWSem::take\( \)} {VXWSem::take(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::flush {unblock every task pended on a semaphore} {VXWSem::flush\( \)} {VXWSem::flush(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::id {reveal underlying semaphore ID} {VXWSem::id\( \)} {VXWSem::id(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::info {get a list of task IDs that are blocked on a semaphore} {VXWSem::info\( \)} {VXWSem::info(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSem::show {show information about a semaphore} {VXWSem::show\( \)} {VXWSem::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWCSem::VXWCSem {create and initialize a counting semaphore} {VXWCSem::VXWCSem\( \)} {VXWCSem::VXWCSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWBSem::VXWBSem {create and initialize a binary semaphore} {VXWBSem::VXWBSem\( \)} {VXWBSem::VXWBSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMSem::VXWMSem {create and initialize a mutual-exclusion semaphore} {VXWMSem::VXWMSem\( \)} {VXWMSem::VXWMSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMSem::giveForce {give a mutual-exclusion semaphore without restrictions} {VXWMSem::giveForce\( \)} {VXWMSem::giveForce(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmBSem::VXWSmBSem {create and initialize binary shared-memory semaphore (VxMP Option)} {VXWSmBSem::VXWSmBSem\( \)} {VXWSmBSem::VXWSmBSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmBSem::VXWSmBSem {build a binary shared-memory semaphore object (VxMP Option)} {VXWSmBSem::VXWSmBSem;1\( \)} {VXWSmBSem::VXWSmBSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmCSem::VXWSmCSem {create and initialize a shared memory counting semaphore (VxMP Option)} {VXWSmCSem::VXWSmCSem\( \)} {VXWSmCSem::VXWSmCSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmCSem::VXWSmCSem {build a shared-memory counting semaphore object (VxMP Option)} {VXWSmCSem::VXWSmCSem;1\( \)} {VXWSmCSem::VXWSmCSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMsgQ::VXWSmMsgQ {create and initialize a shared-memory message queue (VxMP Option)} {VXWSmMsgQ::VXWSmMsgQ\( \)} {VXWSmMsgQ::VXWSmMsgQ(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemPart::VXWSmMemPart {create a shared memory partition (VxMP Option)} {VXWSmMemPart::VXWSmMemPart\( \)} {VXWSmMemPart::VXWSmMemPart(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemBlock::VXWSmMemBlock {allocate a block of memory from the shared memory system partition (VxMP Option)} {VXWSmMemBlock::VXWSmMemBlock\( \)} {VXWSmMemBlock::VXWSmMemBlock(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemBlock::VXWSmMemBlock {allocate memory for an array from the shared memory system partition (VxMP Option)} {VXWSmMemBlock::VXWSmMemBlock;1\( \)} {VXWSmMemBlock::VXWSmMemBlock(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemBlock::~VXWSmMemBlock {free a shared memory system partition block of memory (VxMP Option)} {VXWSmMemBlock::~VXWSmMemBlock\( \)} {VXWSmMemBlock::~VXWSmMemBlock(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemBlock::baseAddress {address of shared-memory block} {VXWSmMemBlock::baseAddress\( \)} {VXWSmMemBlock::baseAddress(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmName::~VXWSmName {remove an object from the shared memory objects name database (VxMP Option)} {VXWSmName::~VXWSmName\( \)} {VXWSmName::~VXWSmName(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmName::nameSet {define a name string in the shared-memory name database (VxMP Option)} {VXWSmName::nameSet\( \)} {VXWSmName::nameSet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmName::nameGet {get name and type of a shared memory object (VxMP Option)} {VXWSmName::nameGet\( \)} {VXWSmName::nameGet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmName::nameGet {get name of a shared memory object (VxMP Option)} {VXWSmName::nameGet;1\( \)} {VXWSmName::nameGet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::VXWSymTab {create a symbol table} {VXWSymTab::VXWSymTab\( \)} {VXWSymTab::VXWSymTab(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::VXWSymTab {create a symbol-table object } {VXWSymTab::VXWSymTab;1\( \)} {VXWSymTab::VXWSymTab(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::~VXWSymTab {delete a symbol table} {VXWSymTab::~VXWSymTab\( \)} {VXWSymTab::~VXWSymTab(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::add {create and add a symbol to a symbol table, including a group number} {VXWSymTab::add\( \)} {VXWSymTab::add(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::each {call a routine to examine each entry in a symbol table} {VXWSymTab::each\( \)} {VXWSymTab::each(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::findByName {look up a symbol by name} {VXWSymTab::findByName\( \)} {VXWSymTab::findByName(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::findByNameAndType {look up a symbol by name and type} {VXWSymTab::findByNameAndType\( \)} {VXWSymTab::findByNameAndType(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::findByValue {look up a symbol by value} {VXWSymTab::findByValue\( \)} {VXWSymTab::findByValue(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::findByValueAndType {look up a symbol by value and type} {VXWSymTab::findByValueAndType\( \)} {VXWSymTab::findByValueAndType(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::remove {remove a symbol from a symbol table} {VXWSymTab::remove\( \)} {VXWSymTab::remove(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {initialize a task object} {VXWTask::VXWTask\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {create and spawn a task} {VXWTask::VXWTask;1\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {initialize a task with a specified stack} {VXWTask::VXWTask;2\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::~VXWTask {delete a task} {VXWTask::~VXWTask\( \)} {VXWTask::~VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::activate {activate a task} {VXWTask::activate\( \)} {VXWTask::activate(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::deleteForce {delete a task without restriction} {VXWTask::deleteForce\( \)} {VXWTask::deleteForce(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::envCreate {create a private environment} {VXWTask::envCreate\( \)} {VXWTask::envCreate(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::errNo {retrieve error status value} {VXWTask::errNo\( \)} {VXWTask::errNo(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::errNo {set error status value } {VXWTask::errNo;1\( \)} {VXWTask::errNo(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::id {reveal task ID } {VXWTask::id\( \)} {VXWTask::id(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::info {get information about a task} {VXWTask::info\( \)} {VXWTask::info(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::isReady {check if task is ready to run} {VXWTask::isReady\( \)} {VXWTask::isReady(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::isSuspended {check if task is suspended} {VXWTask::isSuspended\( \)} {VXWTask::isSuspended(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::kill {send a signal to task} {VXWTask::kill\( \)} {VXWTask::kill(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::name {get the name associated with a task ID} {VXWTask::name\( \)} {VXWTask::name(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::options {examine task options} {VXWTask::options\( \)} {VXWTask::options(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::options {change task options} {VXWTask::options;1\( \)} {VXWTask::options(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::priority {examine the priority of task} {VXWTask::priority\( \)} {VXWTask::priority(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::priority {change the priority of a task} {VXWTask::priority;1\( \)} {VXWTask::priority(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::registers {set a task's registers} {VXWTask::registers\( \)} {VXWTask::registers(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::registers {get task registers from the TCB} {VXWTask::registers;1\( \)} {VXWTask::registers(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::restart {restart task} {VXWTask::restart\( \)} {VXWTask::restart(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::resume {resume task} {VXWTask::resume\( \)} {VXWTask::resume(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::show {display the contents of task registers} {VXWTask::show\( \)} {VXWTask::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::show {display task information from TCBs} {VXWTask::show;1\( \)} {VXWTask::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::sigqueue {send a queued signal to task} {VXWTask::sigqueue\( \)} {VXWTask::sigqueue(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::SRSet {set the task status register (MC680x0, MIPS, i386/i486)} {VXWTask::SRSet\( \)} {VXWTask::SRSet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::statusString {get task status as a string} {VXWTask::statusString\( \)} {VXWTask::statusString(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::suspend {suspend task} {VXWTask::suspend\( \)} {VXWTask::suspend(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::tcb {get the task control block} {VXWTask::tcb\( \)} {VXWTask::tcb(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::varAdd {add a task variable to task} {VXWTask::varAdd\( \)} {VXWTask::varAdd(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::varDelete {remove a task variable from task} {VXWTask::varDelete\( \)} {VXWTask::varDelete(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::varGet {get the value of a task variable} {VXWTask::varGet\( \)} {VXWTask::varGet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::varInfo {get a list of task variables} {VXWTask::varInfo\( \)} {VXWTask::varInfo(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::varSet {set the value of a task variable} {VXWTask::varSet\( \)} {VXWTask::varSet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::VXWWd {construct a watchdog timer} {VXWWd::VXWWd\( \)} {VXWWd::VXWWd(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::VXWWd {construct a watchdog timer} {VXWWd::VXWWd;1\( \)} {VXWWd::VXWWd(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::~VXWWd {destroy a watchdog timer} {VXWWd::~VXWWd\( \)} {VXWWd::~VXWWd(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::cancel {cancel a currently counting watchdog} {VXWWd::cancel\( \)} {VXWWd::cancel(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::start {start a watchdog timer} {VXWWd::start\( \)} {VXWWd::start(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
mib2Init {initialize a MIB-II structure} {mib2Init\( \)} {mib2Init(\ )} {VxWorks Reference Manual} Libraries {} {}
mib2ErrorAdd {change a MIB-II error count} {mib2ErrorAdd\( \)} {mib2ErrorAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
endObjInit {initialize an END_OBJ structure} {endObjInit\( \)} {endObjInit(\ )} {VxWorks Reference Manual} Libraries {} {}
endObjFlagSet {set the `flags' member of an END_OBJ structure} {endObjFlagSet\( \)} {endObjFlagSet(\ )} {VxWorks Reference Manual} Libraries {} {}
endEtherAddressForm {form an Ethernet address into a packet} {endEtherAddressForm\( \)} {endEtherAddressForm(\ )} {VxWorks Reference Manual} Libraries {} {}
endEtherPacketDataGet {return the beginning of the packet data} {endEtherPacketDataGet\( \)} {endEtherPacketDataGet(\ )} {VxWorks Reference Manual} Libraries {} {}
endEtherPacketAddrGet {locate the addresses in a packet} {endEtherPacketAddrGet\( \)} {endEtherPacketAddrGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ln7990EndLoad {initialize the driver and device} {ln7990EndLoad\( \)} {ln7990EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ln7990InitParse {parse the initialization string} {ln7990InitParse\( \)} {ln7990InitParse(\ )} {VxWorks Reference Manual} Libraries {} {}
ln7990InitMem {initialize memory for Lance chip} {ln7990InitMem\( \)} {ln7990InitMem(\ )} {VxWorks Reference Manual} Libraries {} {}
ei82596EndLoad {initialize the driver and device} {ei82596EndLoad\( \)} {ei82596EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ne2000EndLoad {initialize the driver and device} {ne2000EndLoad\( \)} {ne2000EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ne2000Parse {parse the init string} {ne2000Parse\( \)} {ne2000Parse(\ )} {VxWorks Reference Manual} Libraries {} {}
endTok_r {get a token string (modified version)} {endTok_r\( \)} {endTok_r(\ )} {VxWorks Reference Manual} Libraries {} {}
dec21x40EndLoad {initialize the driver and device} {dec21x40EndLoad\( \)} {dec21x40EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
dec21140SromWordRead {read two bytes from the serial ROM} {dec21140SromWordRead\( \)} {dec21140SromWordRead(\ )} {VxWorks Reference Manual} Libraries {} {}
dec21x40PhyFind {Find the first PHY connected to DEC MII port.} {dec21x40PhyFind\( \)} {dec21x40PhyFind(\ )} {VxWorks Reference Manual} Libraries {} {}
dec21145SPIReadBack {Read all PHY registers out } {dec21145SPIReadBack\( \)} {dec21145SPIReadBack(\ )} {VxWorks Reference Manual} Libraries {} {}
sn83932EndLoad {initialize the driver and device} {sn83932EndLoad\( \)} {sn83932EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
dec21x4xEndLoad {initialize the driver and device} {dec21x4xEndLoad\( \)} {dec21x4xEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ntLoad {initialize the driver and device} {ntLoad\( \)} {ntLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ntParse {parse the init string} {ntParse\( \)} {ntParse(\ )} {VxWorks Reference Manual} Libraries {} {}
ntMemInit {initialize memory for the chip} {ntMemInit\( \)} {ntMemInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ntPollStart {start polled mode operations} {ntPollStart\( \)} {ntPollStart(\ )} {VxWorks Reference Manual} Libraries {} {}
ntPollStop {stop polled mode operations} {ntPollStop\( \)} {ntPollStop(\ )} {VxWorks Reference Manual} Libraries {} {}
ntInt {handle controller interrupt} {ntInt\( \)} {ntInt(\ )} {VxWorks Reference Manual} Libraries {} {}
fei82557EndLoad {initialize the driver and device} {fei82557EndLoad\( \)} {fei82557EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
fei82557DumpPrint {Display statistical counters} {fei82557DumpPrint\( \)} {fei82557DumpPrint(\ )} {VxWorks Reference Manual} Libraries {} {}
fei82557ErrCounterDump {dump statistical counters} {fei82557ErrCounterDump\( \)} {fei82557ErrCounterDump(\ )} {VxWorks Reference Manual} Libraries {} {}
iOlicomEndLoad {initialize the driver and device} {iOlicomEndLoad\( \)} {iOlicomEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
iOlicomIntHandle {interrupt service for card interrupts} {iOlicomIntHandle\( \)} {iOlicomIntHandle(\ )} {VxWorks Reference Manual} Libraries {} {}
elt3c509Load {initialize the driver and device} {elt3c509Load\( \)} {elt3c509Load(\ )} {VxWorks Reference Manual} Libraries {} {}
elt3c509Parse {parse the init string} {elt3c509Parse\( \)} {elt3c509Parse(\ )} {VxWorks Reference Manual} Libraries {} {}
motCpmEndLoad {initialize the driver and device} {motCpmEndLoad\( \)} {motCpmEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ln97xEndLoad {initialize the driver and device} {ln97xEndLoad\( \)} {ln97xEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ln97xInitParse {parse the initialization string} {ln97xInitParse\( \)} {ln97xInitParse(\ )} {VxWorks Reference Manual} Libraries {} {}
nicEndLoad {initialize the driver and device} {nicEndLoad\( \)} {nicEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
nicEvbInitParse {parse the initialization string} {nicEvbInitParse\( \)} {nicEvbInitParse(\ )} {VxWorks Reference Manual} Libraries {} {}
motFecEndLoad {initialize the driver and device} {motFecEndLoad\( \)} {motFecEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ultraLoad {initialize the driver and device} {ultraLoad\( \)} {ultraLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ultraParse {parse the init string} {ultraParse\( \)} {ultraParse(\ )} {VxWorks Reference Manual} Libraries {} {}
ultraMemInit {initialize memory for the chip} {ultraMemInit\( \)} {ultraMemInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ultraAddrFilterSet {set the address filter for multicast addresses} {ultraAddrFilterSet\( \)} {ultraAddrFilterSet(\ )} {VxWorks Reference Manual} Libraries {} {}
mb86960EndLoad {initialize the driver and device} {mb86960EndLoad\( \)} {mb86960EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
mb86960InitParse {parse the initialization string} {mb86960InitParse\( \)} {mb86960InitParse(\ )} {VxWorks Reference Manual} Libraries {} {}
mb86960MemInit {initialize memory for the chip} {mb86960MemInit\( \)} {mb86960MemInit(\ )} {VxWorks Reference Manual} Libraries {} {}
el3c90xEndLoad {initialize the driver and device} {el3c90xEndLoad\( \)} {el3c90xEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
el3c90xInitParse {parse the initialization string} {el3c90xInitParse\( \)} {el3c90xInitParse(\ )} {VxWorks Reference Manual} Libraries {} {}
mbcEndLoad {initialize the driver and device} {mbcEndLoad\( \)} {mbcEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
mbcParse {parse the init string} {mbcParse\( \)} {mbcParse(\ )} {VxWorks Reference Manual} Libraries {} {}
mbcMemInit {initialize memory for the chip} {mbcMemInit\( \)} {mbcMemInit(\ )} {VxWorks Reference Manual} Libraries {} {}
mbcAddrFilterSet {set the address filter for multicast addresses} {mbcAddrFilterSet\( \)} {mbcAddrFilterSet(\ )} {VxWorks Reference Manual} Libraries {} {}
miiPhyInit {initialize and configure the PHY devices} {miiPhyInit\( \)} {miiPhyInit(\ )} {VxWorks Reference Manual} Libraries {} {}
miiPhyUnInit {uninitialize a PHY} {miiPhyUnInit\( \)} {miiPhyUnInit(\ )} {VxWorks Reference Manual} Libraries {} {}
miiPhyOptFuncSet {set the pointer to the MII optional registers handler} {miiPhyOptFuncSet\( \)} {miiPhyOptFuncSet(\ )} {VxWorks Reference Manual} Libraries {} {}
miiLibInit {initialize the MII library} {miiLibInit\( \)} {miiLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
miiLibUnInit {uninitialize the MII library} {miiLibUnInit\( \)} {miiLibUnInit(\ )} {VxWorks Reference Manual} Libraries {} {}
miiShow {show routine for MII library} {miiShow\( \)} {miiShow(\ )} {VxWorks Reference Manual} Libraries {} {}
miiRegsGet {get the contents of MII registers} {miiRegsGet\( \)} {miiRegsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
motFccEndLoad {initialize the driver and device} {motFccEndLoad\( \)} {motFccEndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ns83902EndLoad {initialize the driver and device} {ns83902EndLoad\( \)} {ns83902EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
ns83902InitParse {parse the initialization string} {ns83902InitParse\( \)} {ns83902InitParse(\ )} {VxWorks Reference Manual} Libraries {} {}
ns83902RegShow {prints the current value of the NIC registers} {ns83902RegShow\( \)} {ns83902RegShow(\ )} {VxWorks Reference Manual} Libraries {} {}
sh7615EndLoad {initialize the driver and device} {sh7615EndLoad\( \)} {sh7615EndLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
sh7615EndParse {parse the init string} {sh7615EndParse\( \)} {sh7615EndParse(\ )} {VxWorks Reference Manual} Libraries {} {}
sh7615EndMemInit {initialize memory for the chip} {sh7615EndMemInit\( \)} {sh7615EndMemInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dp83843SingleBitRead {reads a single bit value from the dp83843} {dp83843SingleBitRead\( \)} {dp83843SingleBitRead(\ )} {VxWorks Reference Manual} Libraries {} {}
dp83843RegPrint {reads all the dp83843 registers and print the value} {dp83843RegPrint\( \)} {dp83843RegPrint(\ )} {VxWorks Reference Manual} Libraries {} {}
fdDrv {initialize the floppy disk driver} {fdDrv\( \)} {fdDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
fdDevCreate {create a device for a floppy disk} {fdDevCreate\( \)} {fdDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
fdRawio {provide raw I/O access} {fdRawio\( \)} {fdRawio(\ )} {VxWorks Reference Manual} Libraries {} {}
smcFdc37b78xDevCreate {set correct IO port addresses for Super I/O chip} {smcFdc37b78xDevCreate\( \)} {smcFdc37b78xDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
smcFdc37b78xInit {initializes Super I/O chip Library} {smcFdc37b78xInit\( \)} {smcFdc37b78xInit(\ )} {VxWorks Reference Manual} Libraries {} {}
smcFdc37b78xKbdInit {initializes the keyboard controller} {smcFdc37b78xKbdInit\( \)} {smcFdc37b78xKbdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cpmattach {publish the `cpm' network interface and initialize the driver} {cpmattach\( \)} {cpmattach(\ )} {VxWorks Reference Manual} Libraries {} {}
cpmStartOutput {output packet to network interface device} {cpmStartOutput\( \)} {cpmStartOutput(\ )} {VxWorks Reference Manual} Libraries {} {}
eiattach {publish the `ei' network interface and initialize the driver and device} {eiattach\( \)} {eiattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
fnattach {publish the `fn' network interface and initialize the driver and device} {fnattach\( \)} {fnattach(\ )} {VxWorks Reference Manual} Libraries {} {}
lnattach {publish the `ln' network interface and initialize driver structures} {lnattach\( \)} {lnattach(\ )} {VxWorks Reference Manual} Libraries {} {}
lnPciattach {publish the `lnPci' network interface and initialize the driver and device} {lnPciattach\( \)} {lnPciattach(\ )} {VxWorks Reference Manual} Libraries {} {}
loattach {publish the `lo' network interface and initialize the driver and pseudo-device} {loattach\( \)} {loattach(\ )} {VxWorks Reference Manual} Libraries {} {}
slipInit {initialize a SLIP interface} {slipInit\( \)} {slipInit(\ )} {VxWorks Reference Manual} Libraries {} {}
slipBaudSet {set the baud rate for a SLIP interface} {slipBaudSet\( \)} {slipBaudSet(\ )} {VxWorks Reference Manual} Libraries {} {}
slattach {publish the `sl' network interface and initialize the driver and device} {slattach\( \)} {slattach(\ )} {VxWorks Reference Manual} Libraries {} {}
slipDelete {delete a SLIP interface} {slipDelete\( \)} {slipDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
smIfAttach {publish the `sm' interface and initialize the driver and device} {smIfAttach\( \)} {smIfAttach(\ )} {VxWorks Reference Manual} Libraries {} {}
snattach {publish the `sn' network interface and initialize the driver and device} {snattach\( \)} {snattach(\ )} {VxWorks Reference Manual} Libraries {} {}
elcattach {publish the `elc' network interface and initialize the driver and device} {elcattach\( \)} {elcattach(\ )} {VxWorks Reference Manual} Libraries {} {}
elcPut {copy a packet to the interface.} {elcPut\( \)} {elcPut(\ )} {VxWorks Reference Manual} Libraries {} {}
elcShow {display statistics for the SMC 8013WC `elc' network interface} {elcShow\( \)} {elcShow(\ )} {VxWorks Reference Manual} Libraries {} {}
dcattach {publish the `dc' network interface.} {dcattach\( \)} {dcattach(\ )} {VxWorks Reference Manual} Libraries {} {}
dcReadAllRom {read entire serial rom} {dcReadAllRom\( \)} {dcReadAllRom(\ )} {VxWorks Reference Manual} Libraries {} {}
dcViewRom {display lines of serial ROM for dec21140} {dcViewRom\( \)} {dcViewRom(\ )} {VxWorks Reference Manual} Libraries {} {}
dcCsrShow {display dec 21040/21140 status registers 0 thru 15} {dcCsrShow\( \)} {dcCsrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
ultraattach {publish `ultra' interface and initialize device} {ultraattach\( \)} {ultraattach(\ )} {VxWorks Reference Manual} Libraries {} {}
ultraPut {copy a packet to the interface.} {ultraPut\( \)} {ultraPut(\ )} {VxWorks Reference Manual} Libraries {} {}
ultraShow {display statistics for the `ultra' network interface} {ultraShow\( \)} {ultraShow(\ )} {VxWorks Reference Manual} Libraries {} {}
eexattach {publish the `eex' network interface and initialize the driver and device} {eexattach\( \)} {eexattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eexTxStartup {start output on the chip} {eexTxStartup\( \)} {eexTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
feiattach {publish the `fei' network interface} {feiattach\( \)} {feiattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eltattach {publish the `elt' interface and initialize the driver and device} {eltattach\( \)} {eltattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eltTxOutputStart {start output on the board} {eltTxOutputStart\( \)} {eltTxOutputStart(\ )} {VxWorks Reference Manual} Libraries {} {}
eltShow {display statistics for the 3C509 `elt' network interface} {eltShow\( \)} {eltShow(\ )} {VxWorks Reference Manual} Libraries {} {}
eneattach {publish the `ene' network interface and initialize the driver and device} {eneattach\( \)} {eneattach(\ )} {VxWorks Reference Manual} Libraries {} {}
enePut {copy a packet to the interface.} {enePut\( \)} {enePut(\ )} {VxWorks Reference Manual} Libraries {} {}
eneShow {display statistics for the NE2000 `ene' network interface} {eneShow\( \)} {eneShow(\ )} {VxWorks Reference Manual} Libraries {} {}
ulipInit {initialize the ULIP interface (VxSim)} {ulipInit\( \)} {ulipInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ulattach {attach a ULIP interface to a list of network interfaces (VxSim)} {ulattach\( \)} {ulattach(\ )} {VxWorks Reference Manual} Libraries {} {}
ulipDelete {delete a ULIP interface (VxSim)} {ulipDelete\( \)} {ulipDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
ulStartOutput {push packets onto "interface"} {ulStartOutput\( \)} {ulStartOutput(\ )} {VxWorks Reference Manual} Libraries {} {}
ulipDebugSet {Set debug flag in UNIX's ULIP driver} {ulipDebugSet\( \)} {ulipDebugSet(\ )} {VxWorks Reference Manual} Libraries {} {}
esmcattach {publish the `esmc' network interface and initialize the driver.} {esmcattach\( \)} {esmcattach(\ )} {VxWorks Reference Manual} Libraries {} {}
esmcPut {copy a packet to the interface.} {esmcPut\( \)} {esmcPut(\ )} {VxWorks Reference Manual} Libraries {} {}
esmcShow {display statistics for the `esmc' network interface} {esmcShow\( \)} {esmcShow(\ )} {VxWorks Reference Manual} Libraries {} {}
mbcattach {publish the `mbc' network interface and initialize the driver} {mbcattach\( \)} {mbcattach(\ )} {VxWorks Reference Manual} Libraries {} {}
mbcStartOutput {output packet to network interface device} {mbcStartOutput\( \)} {mbcStartOutput(\ )} {VxWorks Reference Manual} Libraries {} {}
mbcIntr {network interface interrupt handler} {mbcIntr\( \)} {mbcIntr(\ )} {VxWorks Reference Manual} Libraries {} {}
eihkattach {publish the `ei' network interface and initialize the driver and device} {eihkattach\( \)} {eihkattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
eiInt {entry point for handling interrupts from the 82596} {eiInt\( \)} {eiInt(\ )} {VxWorks Reference Manual} Libraries {} {}
nicEvbattach {publish and initialize the `nicEvb' network interface driver} {nicEvbattach\( \)} {nicEvbattach(\ )} {VxWorks Reference Manual} Libraries {} {}
nicTxStartup {the driver's actual output routine} {nicTxStartup\( \)} {nicTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
csAttach {publish the `cs' network interface and initialize the driver.} {csAttach\( \)} {csAttach(\ )} {VxWorks Reference Manual} Libraries {} {}
csShow {shows statistics for the `cs' network interface} {csShow\( \)} {csShow(\ )} {VxWorks Reference Manual} Libraries {} {}
eiattach {publish the `ei' network interface and initialize the driver and device} {eiattach\( \)} {eiattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
lptDrv {initialize the LPT driver} {lptDrv\( \)} {lptDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
lptDevCreate {create a device for an LPT port} {lptDevCreate\( \)} {lptDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
lptShow {show LPT statistics} {lptShow\( \)} {lptShow(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciLibInit {intializes PIIX4 device library} {iPiix4PciLibInit\( \)} {iPiix4PciLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciDevCreate {creates the PIIX4 device } {iPiix4PciDevCreate\( \)} {iPiix4PciDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciKbdInit {initializes the PCI-ISA/IDE bridge } {iPiix4PciKbdInit\( \)} {iPiix4PciKbdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciFdInit {initializes the floppy disk device} {iPiix4PciFdInit\( \)} {iPiix4PciFdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciAtaInit {low level initialization of ATA device } {iPiix4PciAtaInit\( \)} {iPiix4PciAtaInit(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciIntrRoute {Route PIRQ[A:D]} {iPiix4PciIntrRoute\( \)} {iPiix4PciIntrRoute(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciGetIntr {give device an interrupt level to use} {iPiix4PciGetIntr\( \)} {iPiix4PciGetIntr(\ )} {VxWorks Reference Manual} Libraries {} {}
iPiix4PciGetHandle {give caller a handle for given device information} {iPiix4PciGetHandle\( \)} {iPiix4PciGetHandle(\ )} {VxWorks Reference Manual} Libraries {} {}
mb87030CtrlCreate {create a control structure for an MB87030 SPC} {mb87030CtrlCreate\( \)} {mb87030CtrlCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
mb87030CtrlInit {initialize a control structure for an MB87030 SPC} {mb87030CtrlInit\( \)} {mb87030CtrlInit(\ )} {VxWorks Reference Manual} Libraries {} {}
mb87030Show {display the values of all readable MB87030 SPC registers} {mb87030Show\( \)} {mb87030Show(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr5390CtrlInit {initialize the user-specified fields in an ASC structure} {ncr5390CtrlInit\( \)} {ncr5390CtrlInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr5390Show {display the values of all readable NCR5390 chip registers} {ncr5390Show\( \)} {ncr5390Show(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr5390CtrlCreate {create a control structure for an NCR 53C90 ASC} {ncr5390CtrlCreate\( \)} {ncr5390CtrlCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr5390CtrlCreateScsi2 {create a control structure for an NCR 53C90 ASC} {ncr5390CtrlCreateScsi2\( \)} {ncr5390CtrlCreateScsi2(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710CtrlCreate {create a control structure for an NCR 53C710 SIOP} {ncr710CtrlCreate\( \)} {ncr710CtrlCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710CtrlInit {initialize a control structure for an NCR 53C710 SIOP} {ncr710CtrlInit\( \)} {ncr710CtrlInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710SetHwRegister {set hardware-dependent registers for the NCR 53C710 SIOP} {ncr710SetHwRegister\( \)} {ncr710SetHwRegister(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710Show {display the values of all readable NCR 53C710 SIOP registers} {ncr710Show\( \)} {ncr710Show(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710CtrlCreateScsi2 {create a control structure for the NCR 53C710 SIOP} {ncr710CtrlCreateScsi2\( \)} {ncr710CtrlCreateScsi2(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710CtrlInitScsi2 {initialize a control structure for the NCR 53C710 SIOP} {ncr710CtrlInitScsi2\( \)} {ncr710CtrlInitScsi2(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710SetHwRegisterScsi2 {set hardware-dependent registers for the NCR 53C710} {ncr710SetHwRegisterScsi2\( \)} {ncr710SetHwRegisterScsi2(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710ShowScsi2 {display the values of all readable NCR 53C710 SIOP registers} {ncr710ShowScsi2\( \)} {ncr710ShowScsi2(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr810CtrlCreate {create a control structure for the NCR 53C8xx SIOP} {ncr810CtrlCreate\( \)} {ncr810CtrlCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr810CtrlInit {initialize a control structure for the NCR 53C8xx SIOP} {ncr810CtrlInit\( \)} {ncr810CtrlInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr810SetHwRegister {set hardware-dependent registers for the NCR 53C8xx SIOP} {ncr810SetHwRegister\( \)} {ncr810SetHwRegister(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr810Show {display values of all readable NCR 53C8xx SIOP registers} {ncr810Show\( \)} {ncr810Show(\ )} {VxWorks Reference Manual} Libraries {} {}
wd33c93CtrlInit {initialize the user-specified fields in an SBIC structure} {wd33c93CtrlInit\( \)} {wd33c93CtrlInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wd33c93Show {display the values of all readable WD33C93 chip registers} {wd33c93Show\( \)} {wd33c93Show(\ )} {VxWorks Reference Manual} Libraries {} {}
aic7880CtrlCreate {create a control structure for the AIC 7880} {aic7880CtrlCreate\( \)} {aic7880CtrlCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
aic7880ScbCompleted {successfully completed execution of a client thread} {aic7880ScbCompleted\( \)} {aic7880ScbCompleted(\ )} {VxWorks Reference Manual} Libraries {} {}
aic7880EnableFast20 {enable double speed SCSI data transfers} {aic7880EnableFast20\( \)} {aic7880EnableFast20(\ )} {VxWorks Reference Manual} Libraries {} {}
aic7880dFifoThresholdSet {set the data FIFO threshold.} {aic7880dFifoThresholdSet\( \)} {aic7880dFifoThresholdSet(\ )} {VxWorks Reference Manual} Libraries {} {}
aic7880GetNumOfBuses {perform a PCI bus scan} {aic7880GetNumOfBuses\( \)} {aic7880GetNumOfBuses(\ )} {VxWorks Reference Manual} Libraries {} {}
aic7880ReadConfig {read from PCI config space} {aic7880ReadConfig\( \)} {aic7880ReadConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
aic7880WriteConfig {read to PCI config space} {aic7880WriteConfig\( \)} {aic7880WriteConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
wd33c93CtrlCreate {create and partially initialize a WD33C93 SBIC structure} {wd33c93CtrlCreate\( \)} {wd33c93CtrlCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
wd33c93CtrlCreateScsi2 {create and partially initialize an SBIC structure} {wd33c93CtrlCreateScsi2\( \)} {wd33c93CtrlCreateScsi2(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710SingleStep {perform a single-step } {ncr710SingleStep\( \)} {ncr710SingleStep(\ )} {VxWorks Reference Manual} Libraries {} {}
ncr710StepEnable {enable/disable script single-step } {ncr710StepEnable\( \)} {ncr710StepEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895CtrlCreate {create a structure for a SYM895 device.} {sym895CtrlCreate\( \)} {sym895CtrlCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895CtrlInit {initialize a SCSI Controller Structure.} {sym895CtrlInit\( \)} {sym895CtrlInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895HwInit {hardware initialization for the 895 Chip.} {sym895HwInit\( \)} {sym895HwInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895SetHwOptions {sets the Sym895 chip Options.} {sym895SetHwOptions\( \)} {sym895SetHwOptions(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895Intr {interrupt service routine for the SCSI Controller.} {sym895Intr\( \)} {sym895Intr(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895Show {display values of all readable SYM 53C8xx SIOP registers.} {sym895Show\( \)} {sym895Show(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895GPIOConfig {configures general purpose pins GPIO 0-4.} {sym895GPIOConfig\( \)} {sym895GPIOConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895GPIOCtrl {controls general purpose pins GPIO 0-4.} {sym895GPIOCtrl\( \)} {sym895GPIOCtrl(\ )} {VxWorks Reference Manual} Libraries {} {}
sym895Loopback {This routine performs loopback diagnotics on 895 chip.} {sym895Loopback\( \)} {sym895Loopback(\ )} {VxWorks Reference Manual} Libraries {} {}
z8530DevInit {intialize a Z8530_DUSART} {z8530DevInit\( \)} {z8530DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
z8530IntWr {handle a transmitter interrupt} {z8530IntWr\( \)} {z8530IntWr(\ )} {VxWorks Reference Manual} Libraries {} {}
z8530IntRd {handle a reciever interrupt} {z8530IntRd\( \)} {z8530IntRd(\ )} {VxWorks Reference Manual} Libraries {} {}
z8530IntEx {handle error interrupts} {z8530IntEx\( \)} {z8530IntEx(\ )} {VxWorks Reference Manual} Libraries {} {}
z8530Int {handle all interrupts in one vector} {z8530Int\( \)} {z8530Int(\ )} {VxWorks Reference Manual} Libraries {} {}
i8250HrdInit {initialize the chip} {i8250HrdInit\( \)} {i8250HrdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
i8250Int {handle a receiver/transmitter interrupt} {i8250Int\( \)} {i8250Int(\ )} {VxWorks Reference Manual} Libraries {} {}
m68360DevInit {initialize the SCC} {m68360DevInit\( \)} {m68360DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m68360Int {handle an SCC interrupt} {m68360Int\( \)} {m68360Int(\ )} {VxWorks Reference Manual} Libraries {} {}
cd2400HrdInit {initialize the chip} {cd2400HrdInit\( \)} {cd2400HrdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cd2400IntRx {handle receiver interrupts} {cd2400IntRx\( \)} {cd2400IntRx(\ )} {VxWorks Reference Manual} Libraries {} {}
cd2400IntTx {handle transmitter interrupts} {cd2400IntTx\( \)} {cd2400IntTx(\ )} {VxWorks Reference Manual} Libraries {} {}
cd2400Int {handle special status interrupts} {cd2400Int\( \)} {cd2400Int(\ )} {VxWorks Reference Manual} Libraries {} {}
m68562HrdInit {initialize the DUSCC} {m68562HrdInit\( \)} {m68562HrdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m68562RxTxErrInt {handle a receiver/transmitter error interrupt} {m68562RxTxErrInt\( \)} {m68562RxTxErrInt(\ )} {VxWorks Reference Manual} Libraries {} {}
m68562RxInt {handle a receiver interrupt} {m68562RxInt\( \)} {m68562RxInt(\ )} {VxWorks Reference Manual} Libraries {} {}
m68562TxInt {handle a transmitter interrupt} {m68562TxInt\( \)} {m68562TxInt(\ )} {VxWorks Reference Manual} Libraries {} {}
m68332DevInit {initialize the SCC} {m68332DevInit\( \)} {m68332DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m68332Int {handle an SCC interrupt} {m68332Int\( \)} {m68332Int(\ )} {VxWorks Reference Manual} Libraries {} {}
mb86940DevInit {install the driver function table} {mb86940DevInit\( \)} {mb86940DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ns16550DevInit {intialize an NS16550 channel} {ns16550DevInit\( \)} {ns16550DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ns16550IntWr {handle a transmitter interrupt } {ns16550IntWr\( \)} {ns16550IntWr(\ )} {VxWorks Reference Manual} Libraries {} {}
ns16550IntRd {handle a receiver interrupt } {ns16550IntRd\( \)} {ns16550IntRd(\ )} {VxWorks Reference Manual} Libraries {} {}
ns16550IntEx {miscellaneous interrupt processing} {ns16550IntEx\( \)} {ns16550IntEx(\ )} {VxWorks Reference Manual} Libraries {} {}
ns16550Int {interrupt level processing} {ns16550Int\( \)} {ns16550Int(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101DSIUDevInit {initialization of the NVR4101DSIU DSIU.} {nvr4101DSIUDevInit\( \)} {nvr4101DSIUDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101DSIUInt {interrupt level processing} {nvr4101DSIUInt\( \)} {nvr4101DSIUInt(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101DSIUIntMask {Mask interrupts from the DSIU.} {nvr4101DSIUIntMask\( \)} {nvr4101DSIUIntMask(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101DSIUIntUnmask {Unmask interrupts from the DSIU.} {nvr4101DSIUIntUnmask\( \)} {nvr4101DSIUIntUnmask(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101SIUDevInit {initialization of the NVR4101SIU SIU.} {nvr4101SIUDevInit\( \)} {nvr4101SIUDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101SIUInt {interrupt level processing} {nvr4101SIUInt\( \)} {nvr4101SIUInt(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101SIUIntMask {Mask interrupts from the SIU.} {nvr4101SIUIntMask\( \)} {nvr4101SIUIntMask(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101SIUIntUnmask {Unmask interrupts from the SIU.} {nvr4101SIUIntUnmask\( \)} {nvr4101SIUIntUnmask(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4101SIUCharToTxWord {Translate character to output word format.} {nvr4101SIUCharToTxWord\( \)} {nvr4101SIUCharToTxWord(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4102DSIUDevInit {initialization of the NVR4102DSIU DSIU.} {nvr4102DSIUDevInit\( \)} {nvr4102DSIUDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4102DSIUInt {interrupt level processing} {nvr4102DSIUInt\( \)} {nvr4102DSIUInt(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4102DSIUIntMask {Mask interrupts from the DSIU.} {nvr4102DSIUIntMask\( \)} {nvr4102DSIUIntMask(\ )} {VxWorks Reference Manual} Libraries {} {}
nvr4102DSIUIntUnmask {Unmask interrupts from the DSIU.} {nvr4102DSIUIntUnmask\( \)} {nvr4102DSIUIntUnmask(\ )} {VxWorks Reference Manual} Libraries {} {}
ppc403DummyCallback {dummy callback routine} {ppc403DummyCallback\( \)} {ppc403DummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
ppc403DevInit {initialize the serial port unit} {ppc403DevInit\( \)} {ppc403DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ppc403IntWr {handle a transmitter interrupt} {ppc403IntWr\( \)} {ppc403IntWr(\ )} {VxWorks Reference Manual} Libraries {} {}
ppc403IntRd {handle a receiver interrupt} {ppc403IntRd\( \)} {ppc403IntRd(\ )} {VxWorks Reference Manual} Libraries {} {}
ppc403IntEx {handle error interrupts} {ppc403IntEx\( \)} {ppc403IntEx(\ )} {VxWorks Reference Manual} Libraries {} {}
ppc860DevInit {initialize the SMC} {ppc860DevInit\( \)} {ppc860DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ppc860Int {handle an SMC interrupt} {ppc860Int\( \)} {ppc860Int(\ )} {VxWorks Reference Manual} Libraries {} {}
evbNs16550HrdInit {initialize the NS 16550 chip} {evbNs16550HrdInit\( \)} {evbNs16550HrdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
evbNs16550Int {handle a receiver/transmitter interrupt for the NS 16550 chip} {evbNs16550Int\( \)} {evbNs16550Int(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681DevInit {intialize a M68681_DUART} {m68681DevInit\( \)} {m68681DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681DevInit2 {intialize a M68681_DUART, part 2} {m68681DevInit2\( \)} {m68681DevInit2(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681ImrSetClr {set and clear bits in the DUART interrupt-mask register} {m68681ImrSetClr\( \)} {m68681ImrSetClr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681Imr {return the current contents of the DUART interrupt-mask register} {m68681Imr\( \)} {m68681Imr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681AcrSetClr {set and clear bits in the DUART auxiliary control register} {m68681AcrSetClr\( \)} {m68681AcrSetClr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681Acr {return the contents of the DUART auxiliary control register} {m68681Acr\( \)} {m68681Acr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681OprSetClr {set and clear bits in the DUART output port register} {m68681OprSetClr\( \)} {m68681OprSetClr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681Opr {return the current state of the DUART output port register} {m68681Opr\( \)} {m68681Opr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681OpcrSetClr {set and clear bits in the DUART output port configuration register} {m68681OpcrSetClr\( \)} {m68681OpcrSetClr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681Opcr {return the state of the DUART output port configuration register} {m68681Opcr\( \)} {m68681Opcr(\ )} {VxWorks Reference Manual} Libraries {} {}
m68681Int {handle all DUART interrupts in one vector} {m68681Int\( \)} {m68681Int(\ )} {VxWorks Reference Manual} Libraries {} {}
m68302SioInit {initialize a M68302_CP} {m68302SioInit\( \)} {m68302SioInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m68302SioInit2 {initialize a M68302_CP (part 2)} {m68302SioInit2\( \)} {m68302SioInit2(\ )} {VxWorks Reference Manual} Libraries {} {}
m68901DevInit {initialize a M68901_CHAN structure} {m68901DevInit\( \)} {m68901DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
n72001DevInit {intialize a N72001_MPSC} {n72001DevInit\( \)} {n72001DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
n72001IntWr {handle a transmitter interrupt} {n72001IntWr\( \)} {n72001IntWr(\ )} {VxWorks Reference Manual} Libraries {} {}
n72001IntRd {handle a reciever interrupt} {n72001IntRd\( \)} {n72001IntRd(\ )} {VxWorks Reference Manual} Libraries {} {}
n72001Int {interrupt level processing} {n72001Int\( \)} {n72001Int(\ )} {VxWorks Reference Manual} Libraries {} {}
sab82532DevInit {intialize an SAB82532 channel} {sab82532DevInit\( \)} {sab82532DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sab82532Int {interrupt level processing} {sab82532Int\( \)} {sab82532Int(\ )} {VxWorks Reference Manual} Libraries {} {}
st16552DevInit {initialise an ST16552 channel} {st16552DevInit\( \)} {st16552DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
st16552IntWr {handle a transmitter interrupt} {st16552IntWr\( \)} {st16552IntWr(\ )} {VxWorks Reference Manual} Libraries {} {}
st16552IntRd {handle a receiver interrupt} {st16552IntRd\( \)} {st16552IntRd(\ )} {VxWorks Reference Manual} Libraries {} {}
st16552IntEx {miscellaneous interrupt processing} {st16552IntEx\( \)} {st16552IntEx(\ )} {VxWorks Reference Manual} Libraries {} {}
st16552Int {interrupt level processing} {st16552Int\( \)} {st16552Int(\ )} {VxWorks Reference Manual} Libraries {} {}
st16552MuxInt {multiplexed interrupt level processing} {st16552MuxInt\( \)} {st16552MuxInt(\ )} {VxWorks Reference Manual} Libraries {} {}
ambaDevInit {initialise an AMBA channel} {ambaDevInit\( \)} {ambaDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ambaIntTx {handle a transmitter interrupt } {ambaIntTx\( \)} {ambaIntTx(\ )} {VxWorks Reference Manual} Libraries {} {}
ambaIntRx {handle a receiver interrupt } {ambaIntRx\( \)} {ambaIntRx(\ )} {VxWorks Reference Manual} Libraries {} {}
sa1100DevInit {initialise an SA1100 channel} {sa1100DevInit\( \)} {sa1100DevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sa1100Int {handle an interrupt} {sa1100Int\( \)} {sa1100Int(\ )} {VxWorks Reference Manual} Libraries {} {}
unixDevInit {initialize a UNIX_DUSART} {unixDevInit\( \)} {unixDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
unixDevInit2 {enable interrupts} {unixDevInit2\( \)} {unixDevInit2(\ )} {VxWorks Reference Manual} Libraries {} {}
unixIntRcv {handle a channel's receive-character interrupt.} {unixIntRcv\( \)} {unixIntRcv(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
winDevInit {initialize a WIN_CHAN} {winDevInit\( \)} {winDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
winDevInit2 {initialize a WIN_CHAN, part 2} {winDevInit2\( \)} {winDevInit2(\ )} {VxWorks Reference Manual} Libraries {} {}
winIntRcv {handle a channel's receive-character interrupt} {winIntRcv\( \)} {winIntRcv(\ )} {VxWorks Reference Manual} Libraries {} {}
winIntTx {transmit a single character.} {winIntTx\( \)} {winIntTx(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireDevInit {intialize a COLDFIRE_CHAN} {coldfireDevInit\( \)} {coldfireDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireDevInit2 {intialize a COLDFIRE_CHAN, part 2} {coldfireDevInit2\( \)} {coldfireDevInit2(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireImrSetClr {set and clear bits in the UART's interrupt mask register} {coldfireImrSetClr\( \)} {coldfireImrSetClr(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireImr {return current interrupt mask register contents} {coldfireImr\( \)} {coldfireImr(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireAcrSetClr {set and clear bits in the UART's aux control register} {coldfireAcrSetClr\( \)} {coldfireAcrSetClr(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireAcr {return aux control register contents} {coldfireAcr\( \)} {coldfireAcr(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireOprSetClr {set and clear bits in the output port register} {coldfireOprSetClr\( \)} {coldfireOprSetClr(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireOpr {return the current state of the output register} {coldfireOpr\( \)} {coldfireOpr(\ )} {VxWorks Reference Manual} Libraries {} {}
coldfireInt {handle all interrupts in one vector} {coldfireInt\( \)} {coldfireInt(\ )} {VxWorks Reference Manual} Libraries {} {}
shSciDevInit {initialize a on-chip serial communication interface} {shSciDevInit\( \)} {shSciDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
shSciIntRcv {handle a channel's receive-character interrupt.} {shSciIntRcv\( \)} {shSciIntRcv(\ )} {VxWorks Reference Manual} Libraries {} {}
shSciIntTx {handle a channels transmitter-ready interrupt.} {shSciIntTx\( \)} {shSciIntTx(\ )} {VxWorks Reference Manual} Libraries {} {}
shSciIntErr {handle a channel's error interrupt.} {shSciIntErr\( \)} {shSciIntErr(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
shScifDevInit {initialize a on-chip serial communication interface} {shScifDevInit\( \)} {shScifDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
shScifIntRcv {handle a channel's receive-character interrupt.} {shScifIntRcv\( \)} {shScifIntRcv(\ )} {VxWorks Reference Manual} Libraries {} {}
shScifIntTx {handle a channels transmitter-ready interrupt.} {shScifIntTx\( \)} {shScifIntTx(\ )} {VxWorks Reference Manual} Libraries {} {}
shScifIntErr {handle a channel's error interrupt.} {shScifIntErr\( \)} {shScifIntErr(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsShowAll {show device information on all socket interfaces } {tffsShowAll\( \)} {tffsShowAll(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsShow {show device information on a specific socket interface } {tffsShow\( \)} {tffsShow(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsBootImagePut {write to the boot-image region of the flash device} {tffsBootImagePut\( \)} {tffsBootImagePut(\ )} {VxWorks Reference Manual} Libraries {} {}
ctB69000VgaInit {initializes the B69000 chip and loads font in memory.} {ctB69000VgaInit\( \)} {ctB69000VgaInit(\ )} {VxWorks Reference Manual} Libraries {} {}
vgaInit {initializes the VGA chip and loads font in memory.} {vgaInit\( \)} {vgaInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbVioDrv {initialize the tty driver for a WDB agent} {wdbVioDrv\( \)} {wdbVioDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbUlipPktDevInit {initialize the WDB agent's communication functions for ULIP} {wdbUlipPktDevInit\( \)} {wdbUlipPktDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbSlipPktDevInit {initialize a SLIP packet device for a WDB agent} {wdbSlipPktDevInit\( \)} {wdbSlipPktDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbNetromPktDevInit {initialize a NETROM packet device for the WDB agent} {wdbNetromPktDevInit\( \)} {wdbNetromPktDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbPipePktDevInit {initialize a pipe packet device.} {wdbPipePktDevInit\( \)} {wdbPipePktDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbTsfsDrv {initialize the TSFS device driver for a WDB agent} {wdbTsfsDrv\( \)} {wdbTsfsDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
trgLibInit {initialize the triggering library} {trgLibInit\( \)} {trgLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
trgWorkQReset {Resets the trigger work queue task and queue} {trgWorkQReset\( \)} {trgWorkQReset(\ )} {VxWorks Reference Manual} Libraries {} {}
trgAdd {add a new trigger to the trigger list} {trgAdd\( \)} {trgAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
trgDelete {delete a trigger from the trigger list} {trgDelete\( \)} {trgDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
trgOn {set triggering on} {trgOn\( \)} {trgOn(\ )} {VxWorks Reference Manual} Libraries {} {}
trgOff {set triggering off} {trgOff\( \)} {trgOff(\ )} {VxWorks Reference Manual} Libraries {} {}
trgEnable {enable a trigger} {trgEnable\( \)} {trgEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
trgDisable {turn a trigger off} {trgDisable\( \)} {trgDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
trgChainSet {chains two triggers} {trgChainSet\( \)} {trgChainSet(\ )} {VxWorks Reference Manual} Libraries {} {}
trgEvent {trigger a user-defined event } {trgEvent\( \)} {trgEvent(\ )} {VxWorks Reference Manual} Libraries {} {}
trgShowInit {initialize the trigger show facility} {trgShowInit\( \)} {trgShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
trgShow {show trigger information } {trgShow\( \)} {trgShow(\ )} {VxWorks Reference Manual} Libraries {} {}
wvTmrRegister {register a timestamp timer (WindView)} {wvTmrRegister\( \)} {wvTmrRegister(\ )} {VxWorks Reference Manual} Libraries {} {}
fileUploadPathLibInit {initialize the wvFileUploadPathLib library (Windview)} {fileUploadPathLibInit\( \)} {fileUploadPathLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
fileUploadPathCreate {create a file for depositing event data (Windview)} {fileUploadPathCreate\( \)} {fileUploadPathCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
fileUploadPathClose {close the event-destination file (WindView)} {fileUploadPathClose\( \)} {fileUploadPathClose(\ )} {VxWorks Reference Manual} Libraries {} {}
fileUploadPathWrite {write to the event-destination file (WindView)} {fileUploadPathWrite\( \)} {fileUploadPathWrite(\ )} {VxWorks Reference Manual} Libraries {} {}
sockUploadPathLibInit {initialize wvSockUploadPathLib library (Windview)} {sockUploadPathLibInit\( \)} {sockUploadPathLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sockUploadPathCreate {establish an upload path to the host using a socket (Windview)} {sockUploadPathCreate\( \)} {sockUploadPathCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
sockUploadPathClose {close the socket upload path (Windview)} {sockUploadPathClose\( \)} {sockUploadPathClose(\ )} {VxWorks Reference Manual} Libraries {} {}
sockUploadPathWrite {write to the socket upload path (Windview)} {sockUploadPathWrite\( \)} {sockUploadPathWrite(\ )} {VxWorks Reference Manual} Libraries {} {}
tsfsUploadPathLibInit {initialize wvTsfsUploadPathLib library (Windview)} {tsfsUploadPathLibInit\( \)} {tsfsUploadPathLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tsfsUploadPathCreate {open an upload path to the host using a TSFS socket (Windview)} {tsfsUploadPathCreate\( \)} {tsfsUploadPathCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
tsfsUploadPathClose {close the TSFS-socket upload path (Windview)} {tsfsUploadPathClose\( \)} {tsfsUploadPathClose(\ )} {VxWorks Reference Manual} Libraries {} {}
tsfsUploadPathWrite {write to the TSFS upload path (Windview)} {tsfsUploadPathWrite\( \)} {tsfsUploadPathWrite(\ )} {VxWorks Reference Manual} Libraries {} {}
wvLibInit {initialize wvLib - first step (WindView)} {wvLibInit\( \)} {wvLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wvLibInit2 {initialize wvLib - final step (WindView)} {wvLibInit2\( \)} {wvLibInit2(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtLogInit {initialize an event log (WindView)} {wvEvtLogInit\( \)} {wvEvtLogInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtLogStart {start logging events to the buffer (WindView)} {wvEvtLogStart\( \)} {wvEvtLogStart(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtLogStop {stop logging events to the buffer (WindView)} {wvEvtLogStop\( \)} {wvEvtLogStop(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtClassSet {set the class of events to log (WindView)} {wvEvtClassSet\( \)} {wvEvtClassSet(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtClassGet {get the current set of classes being logged (WindView)} {wvEvtClassGet\( \)} {wvEvtClassGet(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtClassClear {clear the specified class of events from those being logged (WindView)} {wvEvtClassClear\( \)} {wvEvtClassClear(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtClassClearAll {clear all classes of events from those logged (WindView)} {wvEvtClassClearAll\( \)} {wvEvtClassClearAll(\ )} {VxWorks Reference Manual} Libraries {} {}
wvObjInstModeSet {set object instrumentation on/off (WindView)} {wvObjInstModeSet\( \)} {wvObjInstModeSet(\ )} {VxWorks Reference Manual} Libraries {} {}
wvObjInst {instrument objects (WindView)} {wvObjInst\( \)} {wvObjInst(\ )} {VxWorks Reference Manual} Libraries {} {}
wvSigInst {instrument signals (WindView)} {wvSigInst\( \)} {wvSigInst(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvent {log a user-defined event (WindView)} {wvEvent\( \)} {wvEvent(\ )} {VxWorks Reference Manual} Libraries {} {}
wvUploadStart {start upload of events to the host (WindView)} {wvUploadStart\( \)} {wvUploadStart(\ )} {VxWorks Reference Manual} Libraries {} {}
wvUploadStop {stop upload of events to host (WindView)} {wvUploadStop\( \)} {wvUploadStop(\ )} {VxWorks Reference Manual} Libraries {} {}
wvUploadTaskConfig {set priority and stacksize of 'tWVUpload' task (WindView)} {wvUploadTaskConfig\( \)} {wvUploadTaskConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
wvLogHeaderCreate {create the event-log header (WindView)} {wvLogHeaderCreate\( \)} {wvLogHeaderCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
wvLogHeaderUpload {transfer the log header to the host (WindView)} {wvLogHeaderUpload\( \)} {wvLogHeaderUpload(\ )} {VxWorks Reference Manual} Libraries {} {}
wvEvtBufferGet {return the ID of the WindView event buffer (WindView)} {wvEvtBufferGet\( \)} {wvEvtBufferGet(\ )} {VxWorks Reference Manual} Libraries {} {}
wvTaskNamesPreserve {preserve an extra copy of task name events (WindView)} {wvTaskNamesPreserve\( \)} {wvTaskNamesPreserve(\ )} {VxWorks Reference Manual} Libraries {} {}
wvTaskNamesUpload {upload preserved task name events (WindView)} {wvTaskNamesUpload\( \)} {wvTaskNamesUpload(\ )} {VxWorks Reference Manual} Libraries {} {}
assert {put diagnostics into programs (ANSI)} {assert\( \)} {assert(\ )} {VxWorks Reference Manual} Libraries {} {}
isalnum {test whether a character is alphanumeric (ANSI)} {isalnum\( \)} {isalnum(\ )} {VxWorks Reference Manual} Libraries {} {}
isalpha {test whether a character is a letter (ANSI)} {isalpha\( \)} {isalpha(\ )} {VxWorks Reference Manual} Libraries {} {}
iscntrl {test whether a character is a control character (ANSI)} {iscntrl\( \)} {iscntrl(\ )} {VxWorks Reference Manual} Libraries {} {}
isdigit {test whether a character is a decimal digit (ANSI)} {isdigit\( \)} {isdigit(\ )} {VxWorks Reference Manual} Libraries {} {}
isgraph {test whether a character is a printing, non-white-space character (ANSI)} {isgraph\( \)} {isgraph(\ )} {VxWorks Reference Manual} Libraries {} {}
islower {test whether a character is a lower-case letter (ANSI)} {islower\( \)} {islower(\ )} {VxWorks Reference Manual} Libraries {} {}
isprint {test whether a character is printable, including the space character (ANSI)} {isprint\( \)} {isprint(\ )} {VxWorks Reference Manual} Libraries {} {}
ispunct {test whether a character is punctuation (ANSI)} {ispunct\( \)} {ispunct(\ )} {VxWorks Reference Manual} Libraries {} {}
isspace {test whether a character is a white-space character (ANSI)} {isspace\( \)} {isspace(\ )} {VxWorks Reference Manual} Libraries {} {}
isupper {test whether a character is an upper-case letter (ANSI)} {isupper\( \)} {isupper(\ )} {VxWorks Reference Manual} Libraries {} {}
isxdigit {test whether a character is a hexadecimal digit (ANSI)} {isxdigit\( \)} {isxdigit(\ )} {VxWorks Reference Manual} Libraries {} {}
tolower {convert an upper-case letter to its lower-case equivalent (ANSI)} {tolower\( \)} {tolower(\ )} {VxWorks Reference Manual} Libraries {} {}
toupper {convert a lower-case letter to its upper-case equivalent (ANSI)} {toupper\( \)} {toupper(\ )} {VxWorks Reference Manual} Libraries {} {}
localeconv {set the components of an object with type `lconv' (ANSI)} {localeconv\( \)} {localeconv(\ )} {VxWorks Reference Manual} Libraries {} {}
setlocale {set the appropriate locale (ANSI)} {setlocale\( \)} {setlocale(\ )} {VxWorks Reference Manual} Libraries {} {}
asin {compute an arc sine (ANSI)} {asin\( \)} {asin(\ )} {VxWorks Reference Manual} Libraries {} {}
acos {compute an arc cosine (ANSI)} {acos\( \)} {acos(\ )} {VxWorks Reference Manual} Libraries {} {}
atan {compute an arc tangent (ANSI)} {atan\( \)} {atan(\ )} {VxWorks Reference Manual} Libraries {} {}
atan2 {compute the arc tangent of y/x (ANSI)} {atan2\( \)} {atan2(\ )} {VxWorks Reference Manual} Libraries {} {}
ceil {compute the smallest integer greater than or equal to a specified value (ANSI)} {ceil\( \)} {ceil(\ )} {VxWorks Reference Manual} Libraries {} {}
cosh {compute a hyperbolic cosine (ANSI)} {cosh\( \)} {cosh(\ )} {VxWorks Reference Manual} Libraries {} {}
exp {compute an exponential value (ANSI)} {exp\( \)} {exp(\ )} {VxWorks Reference Manual} Libraries {} {}
fabs {compute an absolute value (ANSI)} {fabs\( \)} {fabs(\ )} {VxWorks Reference Manual} Libraries {} {}
floor {compute the largest integer less than or equal to a specified value (ANSI)} {floor\( \)} {floor(\ )} {VxWorks Reference Manual} Libraries {} {}
fmod {compute the remainder of x/y (ANSI)} {fmod\( \)} {fmod(\ )} {VxWorks Reference Manual} Libraries {} {}
frexp {break a floating-point number into a normalized fraction and power of 2 (ANSI)} {frexp\( \)} {frexp(\ )} {VxWorks Reference Manual} Libraries {} {}
ldexp {multiply a number by an integral power of 2 (ANSI)} {ldexp\( \)} {ldexp(\ )} {VxWorks Reference Manual} Libraries {} {}
log {compute a natural logarithm (ANSI)} {log\( \)} {log(\ )} {VxWorks Reference Manual} Libraries {} {}
log10 {compute a base-10 logarithm (ANSI)} {log10\( \)} {log10(\ )} {VxWorks Reference Manual} Libraries {} {}
modf {separate a floating-point number into integer and fraction parts (ANSI)} {modf\( \)} {modf(\ )} {VxWorks Reference Manual} Libraries {} {}
pow {compute the value of a number raised to a specified power (ANSI)} {pow\( \)} {pow(\ )} {VxWorks Reference Manual} Libraries {} {}
sin {compute a sine (ANSI)} {sin\( \)} {sin(\ )} {VxWorks Reference Manual} Libraries {} {}
cos {compute a cosine (ANSI)} {cos\( \)} {cos(\ )} {VxWorks Reference Manual} Libraries {} {}
sinh {compute a hyperbolic sine (ANSI)} {sinh\( \)} {sinh(\ )} {VxWorks Reference Manual} Libraries {} {}
sqrt {compute a non-negative square root (ANSI)} {sqrt\( \)} {sqrt(\ )} {VxWorks Reference Manual} Libraries {} {}
tan {compute a tangent (ANSI)} {tan\( \)} {tan(\ )} {VxWorks Reference Manual} Libraries {} {}
tanh {compute a hyperbolic tangent (ANSI)} {tanh\( \)} {tanh(\ )} {VxWorks Reference Manual} Libraries {} {}
setjmp {save the calling environment in a `jmp_buf' argument (ANSI)} {setjmp\( \)} {setjmp(\ )} {VxWorks Reference Manual} Libraries {} {}
longjmp {perform non-local goto by restoring saved environment (ANSI) } {longjmp\( \)} {longjmp(\ )} {VxWorks Reference Manual} Libraries {} {}
va_start {initialize a `va_list' object for use by va_arg() and va_end()} {va_start\( \)} {va_start(\ )} {VxWorks Reference Manual} Libraries {} {}
va_arg {expand to an expression having the type and value of the call's next argument} {va_arg\( \)} {va_arg(\ )} {VxWorks Reference Manual} Libraries {} {}
va_end {facilitate a normal return from a routine using a `va_list' object} {va_end\( \)} {va_end(\ )} {VxWorks Reference Manual} Libraries {} {}
clearerr {clear end-of-file and error flags for a stream (ANSI)} {clearerr\( \)} {clearerr(\ )} {VxWorks Reference Manual} Libraries {} {}
fclose {close a stream (ANSI)} {fclose\( \)} {fclose(\ )} {VxWorks Reference Manual} Libraries {} {}
fdopen {open a file specified by a file descriptor (POSIX)} {fdopen\( \)} {fdopen(\ )} {VxWorks Reference Manual} Libraries {} {}
feof {test the end-of-file indicator for a stream (ANSI)} {feof\( \)} {feof(\ )} {VxWorks Reference Manual} Libraries {} {}
ferror {test the error indicator for a file pointer (ANSI)} {ferror\( \)} {ferror(\ )} {VxWorks Reference Manual} Libraries {} {}
fflush {flush a stream (ANSI)} {fflush\( \)} {fflush(\ )} {VxWorks Reference Manual} Libraries {} {}
fgetc {return the next character from a stream (ANSI)} {fgetc\( \)} {fgetc(\ )} {VxWorks Reference Manual} Libraries {} {}
fgetpos {store the current value of the file position indicator for a stream (ANSI)} {fgetpos\( \)} {fgetpos(\ )} {VxWorks Reference Manual} Libraries {} {}
fgets {read a specified number of characters from a stream (ANSI)} {fgets\( \)} {fgets(\ )} {VxWorks Reference Manual} Libraries {} {}
fileno {return the file descriptor for a stream (POSIX)} {fileno\( \)} {fileno(\ )} {VxWorks Reference Manual} Libraries {} {}
fopen {open a file specified by name (ANSI)} {fopen\( \)} {fopen(\ )} {VxWorks Reference Manual} Libraries {} {}
fprintf {write a formatted string to a stream (ANSI)} {fprintf\( \)} {fprintf(\ )} {VxWorks Reference Manual} Libraries {} {}
fputc {write a character to a stream (ANSI)} {fputc\( \)} {fputc(\ )} {VxWorks Reference Manual} Libraries {} {}
fputs {write a string to a stream (ANSI)} {fputs\( \)} {fputs(\ )} {VxWorks Reference Manual} Libraries {} {}
fread {read data into an array (ANSI)} {fread\( \)} {fread(\ )} {VxWorks Reference Manual} Libraries {} {}
freopen {open a file specified by name (ANSI)} {freopen\( \)} {freopen(\ )} {VxWorks Reference Manual} Libraries {} {}
fscanf {read and convert characters from a stream (ANSI)} {fscanf\( \)} {fscanf(\ )} {VxWorks Reference Manual} Libraries {} {}
fseek {set the file position indicator for a stream (ANSI)} {fseek\( \)} {fseek(\ )} {VxWorks Reference Manual} Libraries {} {}
fsetpos {set the file position indicator for a stream (ANSI)} {fsetpos\( \)} {fsetpos(\ )} {VxWorks Reference Manual} Libraries {} {}
ftell {return the current value of the file position indicator for a stream (ANSI)} {ftell\( \)} {ftell(\ )} {VxWorks Reference Manual} Libraries {} {}
fwrite {write from a specified array (ANSI)} {fwrite\( \)} {fwrite(\ )} {VxWorks Reference Manual} Libraries {} {}
getc {return the next character from a stream (ANSI)} {getc\( \)} {getc(\ )} {VxWorks Reference Manual} Libraries {} {}
getchar {return the next character from the standard input stream (ANSI)} {getchar\( \)} {getchar(\ )} {VxWorks Reference Manual} Libraries {} {}
gets {read characters from the standard input stream (ANSI)} {gets\( \)} {gets(\ )} {VxWorks Reference Manual} Libraries {} {}
getw {read the next word (32-bit integer) from a stream} {getw\( \)} {getw(\ )} {VxWorks Reference Manual} Libraries {} {}
perror {map an error number in `errno' to an error message (ANSI)} {perror\( \)} {perror(\ )} {VxWorks Reference Manual} Libraries {} {}
putc {write a character to a stream (ANSI)} {putc\( \)} {putc(\ )} {VxWorks Reference Manual} Libraries {} {}
putchar {write a character to the standard output stream (ANSI)} {putchar\( \)} {putchar(\ )} {VxWorks Reference Manual} Libraries {} {}
puts {write a string to the standard output stream (ANSI)} {puts\( \)} {puts(\ )} {VxWorks Reference Manual} Libraries {} {}
putw {write a word (32-bit integer) to a stream} {putw\( \)} {putw(\ )} {VxWorks Reference Manual} Libraries {} {}
rewind {set the file position indicator to the beginning of a file (ANSI)} {rewind\( \)} {rewind(\ )} {VxWorks Reference Manual} Libraries {} {}
scanf {read and convert characters from the standard input stream (ANSI)} {scanf\( \)} {scanf(\ )} {VxWorks Reference Manual} Libraries {} {}
setbuf {specify the buffering for a stream (ANSI)} {setbuf\( \)} {setbuf(\ )} {VxWorks Reference Manual} Libraries {} {}
setbuffer {specify buffering for a stream} {setbuffer\( \)} {setbuffer(\ )} {VxWorks Reference Manual} Libraries {} {}
setlinebuf {set line buffering for standard output or standard error} {setlinebuf\( \)} {setlinebuf(\ )} {VxWorks Reference Manual} Libraries {} {}
setvbuf {specify buffering for a stream (ANSI)} {setvbuf\( \)} {setvbuf(\ )} {VxWorks Reference Manual} Libraries {} {}
stdioInit {initialize standard I/O support} {stdioInit\( \)} {stdioInit(\ )} {VxWorks Reference Manual} Libraries {} {}
stdioFp {return the standard input/output/error FILE of the current task} {stdioFp\( \)} {stdioFp(\ )} {VxWorks Reference Manual} Libraries {} {}
stdioShowInit {initialize the standard I/O show facility} {stdioShowInit\( \)} {stdioShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
stdioShow {display file pointer internals} {stdioShow\( \)} {stdioShow(\ )} {VxWorks Reference Manual} Libraries {} {}
tmpfile {create a temporary binary file (Unimplemented) (ANSI)} {tmpfile\( \)} {tmpfile(\ )} {VxWorks Reference Manual} Libraries {} {}
tmpnam {generate a temporary file name (ANSI)} {tmpnam\( \)} {tmpnam(\ )} {VxWorks Reference Manual} Libraries {} {}
ungetc {push a character back into an input stream (ANSI)} {ungetc\( \)} {ungetc(\ )} {VxWorks Reference Manual} Libraries {} {}
vfprintf {write a formatted string to a stream (ANSI)} {vfprintf\( \)} {vfprintf(\ )} {VxWorks Reference Manual} Libraries {} {}
abort {cause abnormal program termination (ANSI)} {abort\( \)} {abort(\ )} {VxWorks Reference Manual} Libraries {} {}
abs {compute the absolute value of an integer (ANSI)} {abs\( \)} {abs(\ )} {VxWorks Reference Manual} Libraries {} {}
atexit {call a function at program termination (Unimplemented) (ANSI)} {atexit\( \)} {atexit(\ )} {VxWorks Reference Manual} Libraries {} {}
atof {convert a string to a `double' (ANSI)} {atof\( \)} {atof(\ )} {VxWorks Reference Manual} Libraries {} {}
atoi {convert a string to an `int' (ANSI)} {atoi\( \)} {atoi(\ )} {VxWorks Reference Manual} Libraries {} {}
atol {convert a string to a `long' (ANSI)} {atol\( \)} {atol(\ )} {VxWorks Reference Manual} Libraries {} {}
bsearch {perform a binary search (ANSI)} {bsearch\( \)} {bsearch(\ )} {VxWorks Reference Manual} Libraries {} {}
div {compute a quotient and remainder (ANSI)} {div\( \)} {div(\ )} {VxWorks Reference Manual} Libraries {} {}
div_r {compute a quotient and remainder (reentrant)} {div_r\( \)} {div_r(\ )} {VxWorks Reference Manual} Libraries {} {}
labs {compute the absolute value of a `long' (ANSI)} {labs\( \)} {labs(\ )} {VxWorks Reference Manual} Libraries {} {}
ldiv {compute the quotient and remainder of the division (ANSI)} {ldiv\( \)} {ldiv(\ )} {VxWorks Reference Manual} Libraries {} {}
ldiv_r {compute a quotient and remainder (reentrant)} {ldiv_r\( \)} {ldiv_r(\ )} {VxWorks Reference Manual} Libraries {} {}
mblen {calculate the length of a multibyte character (Unimplemented) (ANSI)} {mblen\( \)} {mblen(\ )} {VxWorks Reference Manual} Libraries {} {}
mbtowc {convert a multibyte character to a wide character (Unimplemented) (ANSI)} {mbtowc\( \)} {mbtowc(\ )} {VxWorks Reference Manual} Libraries {} {}
wctomb {convert a wide character to a multibyte character (Unimplemented) (ANSI)} {wctomb\( \)} {wctomb(\ )} {VxWorks Reference Manual} Libraries {} {}
mbstowcs {convert a series of multibyte char's to wide char's (Unimplemented) (ANSI)} {mbstowcs\( \)} {mbstowcs(\ )} {VxWorks Reference Manual} Libraries {} {}
wcstombs {convert a series of wide char's to multibyte char's (Unimplemented) (ANSI)} {wcstombs\( \)} {wcstombs(\ )} {VxWorks Reference Manual} Libraries {} {}
qsort {sort an array of objects (ANSI)} {qsort\( \)} {qsort(\ )} {VxWorks Reference Manual} Libraries {} {}
rand {generate a pseudo-random integer between 0 and RAND_MAX (ANSI)} {rand\( \)} {rand(\ )} {VxWorks Reference Manual} Libraries {} {}
srand {reset the value of the seed used to generate random numbers (ANSI)} {srand\( \)} {srand(\ )} {VxWorks Reference Manual} Libraries {} {}
strtod {convert the initial portion of a string to a double (ANSI) } {strtod\( \)} {strtod(\ )} {VxWorks Reference Manual} Libraries {} {}
strtol {convert a string to a long integer (ANSI)} {strtol\( \)} {strtol(\ )} {VxWorks Reference Manual} Libraries {} {}
strtoul {convert a string to an unsigned long integer (ANSI)} {strtoul\( \)} {strtoul(\ )} {VxWorks Reference Manual} Libraries {} {}
system {pass a string to a command processor (Unimplemented) (ANSI)} {system\( \)} {system(\ )} {VxWorks Reference Manual} Libraries {} {}
memchr {search a block of memory for a character (ANSI)} {memchr\( \)} {memchr(\ )} {VxWorks Reference Manual} Libraries {} {}
memcmp {compare two blocks of memory (ANSI)} {memcmp\( \)} {memcmp(\ )} {VxWorks Reference Manual} Libraries {} {}
memcpy {copy memory from one location to another (ANSI)} {memcpy\( \)} {memcpy(\ )} {VxWorks Reference Manual} Libraries {} {}
memmove {copy memory from one location to another (ANSI)} {memmove\( \)} {memmove(\ )} {VxWorks Reference Manual} Libraries {} {}
memset {set a block of memory (ANSI)} {memset\( \)} {memset(\ )} {VxWorks Reference Manual} Libraries {} {}
strcat {concatenate one string to another (ANSI)} {strcat\( \)} {strcat(\ )} {VxWorks Reference Manual} Libraries {} {}
strchr {find the first occurrence of a character in a string (ANSI)} {strchr\( \)} {strchr(\ )} {VxWorks Reference Manual} Libraries {} {}
strcmp {compare two strings lexicographically (ANSI)} {strcmp\( \)} {strcmp(\ )} {VxWorks Reference Manual} Libraries {} {}
strcoll {compare two strings as appropriate to LC_COLLATE (ANSI)} {strcoll\( \)} {strcoll(\ )} {VxWorks Reference Manual} Libraries {} {}
strcpy {copy one string to another (ANSI)} {strcpy\( \)} {strcpy(\ )} {VxWorks Reference Manual} Libraries {} {}
strcspn {return the string length up to the first character from a given set (ANSI)} {strcspn\( \)} {strcspn(\ )} {VxWorks Reference Manual} Libraries {} {}
strerror_r {map an error number to an error string (POSIX)} {strerror_r\( \)} {strerror_r(\ )} {VxWorks Reference Manual} Libraries {} {}
strerror {map an error number to an error string (ANSI)} {strerror\( \)} {strerror(\ )} {VxWorks Reference Manual} Libraries {} {}
strlen {determine the length of a string (ANSI)} {strlen\( \)} {strlen(\ )} {VxWorks Reference Manual} Libraries {} {}
strncat {concatenate characters from one string to another (ANSI)} {strncat\( \)} {strncat(\ )} {VxWorks Reference Manual} Libraries {} {}
strncmp {compare the first characters of two strings (ANSI)} {strncmp\( \)} {strncmp(\ )} {VxWorks Reference Manual} Libraries {} {}
strncpy {copy characters from one string to another (ANSI)} {strncpy\( \)} {strncpy(\ )} {VxWorks Reference Manual} Libraries {} {}
strpbrk {find the first occurrence in a string of a character from a given set (ANSI)} {strpbrk\( \)} {strpbrk(\ )} {VxWorks Reference Manual} Libraries {} {}
strrchr {find the last occurrence of a character in a string (ANSI)} {strrchr\( \)} {strrchr(\ )} {VxWorks Reference Manual} Libraries {} {}
strspn {return the string length up to the first character not in a given set (ANSI)} {strspn\( \)} {strspn(\ )} {VxWorks Reference Manual} Libraries {} {}
strstr {find the first occurrence of a substring in a string (ANSI)} {strstr\( \)} {strstr(\ )} {VxWorks Reference Manual} Libraries {} {}
strtok {break down a string into tokens (ANSI)} {strtok\( \)} {strtok(\ )} {VxWorks Reference Manual} Libraries {} {}
strtok_r {break down a string into tokens (reentrant) (POSIX)} {strtok_r\( \)} {strtok_r(\ )} {VxWorks Reference Manual} Libraries {} {}
strxfrm {transform up to characters of into (ANSI)} {strxfrm\( \)} {strxfrm(\ )} {VxWorks Reference Manual} Libraries {} {}
asctime {convert broken-down time into a string (ANSI)} {asctime\( \)} {asctime(\ )} {VxWorks Reference Manual} Libraries {} {}
asctime_r {convert broken-down time into a string (POSIX)} {asctime_r\( \)} {asctime_r(\ )} {VxWorks Reference Manual} Libraries {} {}
clock {determine the processor time in use (ANSI)} {clock\( \)} {clock(\ )} {VxWorks Reference Manual} Libraries {} {}
ctime {convert time in seconds into a string (ANSI)} {ctime\( \)} {ctime(\ )} {VxWorks Reference Manual} Libraries {} {}
ctime_r {convert time in seconds into a string (POSIX)} {ctime_r\( \)} {ctime_r(\ )} {VxWorks Reference Manual} Libraries {} {}
difftime {compute the difference between two calendar times (ANSI)} {difftime\( \)} {difftime(\ )} {VxWorks Reference Manual} Libraries {} {}
gmtime {convert calendar time into UTC broken-down time (ANSI)} {gmtime\( \)} {gmtime(\ )} {VxWorks Reference Manual} Libraries {} {}
gmtime_r {convert calendar time into broken-down time (POSIX)} {gmtime_r\( \)} {gmtime_r(\ )} {VxWorks Reference Manual} Libraries {} {}
localtime {convert calendar time into broken-down time (ANSI)} {localtime\( \)} {localtime(\ )} {VxWorks Reference Manual} Libraries {} {}
localtime_r {convert calendar time into broken-down time (POSIX)} {localtime_r\( \)} {localtime_r(\ )} {VxWorks Reference Manual} Libraries {} {}
mktime {convert broken-down time into calendar time (ANSI)} {mktime\( \)} {mktime(\ )} {VxWorks Reference Manual} Libraries {} {}
strftime {convert broken-down time into a formatted string (ANSI)} {strftime\( \)} {strftime(\ )} {VxWorks Reference Manual} Libraries {} {}
time {determine the current calendar time (ANSI)} {time\( \)} {time(\ )} {VxWorks Reference Manual} Libraries {} {}
pppInit {initialize a PPP network interface} {pppInit\( \)} {pppInit(\ )} {VxWorks Reference Manual} Libraries {} {}
pppDelete {delete a PPP network interface} {pppDelete\( \)} {pppDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
pppInfoShow {display PPP link status information} {pppInfoShow\( \)} {pppInfoShow(\ )} {VxWorks Reference Manual} Libraries {} {}
pppInfoGet {get PPP link status information} {pppInfoGet\( \)} {pppInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
pppstatShow {display PPP link statistics} {pppstatShow\( \)} {pppstatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
pppstatGet {get PPP link statistics} {pppstatGet\( \)} {pppstatGet(\ )} {VxWorks Reference Manual} Libraries {} {}
pppSecretShow {display the PPP authentication secrets table} {pppSecretShow\( \)} {pppSecretShow(\ )} {VxWorks Reference Manual} Libraries {} {}
pppSecretAdd {add a secret to the PPP authentication secrets table} {pppSecretAdd\( \)} {pppSecretAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
pppSecretDelete {delete a secret from the PPP authentication secrets table} {pppSecretDelete\( \)} {pppSecretDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
pppHookAdd {add a hook routine on a unit basis} {pppHookAdd\( \)} {pppHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
pppHookDelete {delete a hook routine on a unit basis} {pppHookDelete\( \)} {pppHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvInit {initialize the resolver library } {resolvInit\( \)} {resolvInit(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvGetHostByName {query the DNS server for the IP address of a host} {resolvGetHostByName\( \)} {resolvGetHostByName(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvGetHostByAddr {query the DNS server for the host name of an IP address} {resolvGetHostByAddr\( \)} {resolvGetHostByAddr(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvParamsSet {set the parameters which control the resolver library} {resolvParamsSet\( \)} {resolvParamsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvParamsGet {get the parameters which control the resolver library} {resolvParamsGet\( \)} {resolvParamsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvDNExpand {expand a DNS compressed name from a DNS packet} {resolvDNExpand\( \)} {resolvDNExpand(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvDNComp {compress a DNS name in a DNS packet} {resolvDNComp\( \)} {resolvDNComp(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvQuery {construct a query, send it, wait for a response} {resolvQuery\( \)} {resolvQuery(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvMkQuery {create all types of DNS queries} {resolvMkQuery\( \)} {resolvMkQuery(\ )} {VxWorks Reference Manual} Libraries {} {}
resolvSend {send a pre-formatted query and return the answer} {resolvSend\( \)} {resolvSend(\ )} {VxWorks Reference Manual} Libraries {} {}
arpAdd {create or modify an ARP table entry} {arpAdd\( \)} {arpAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
arpDelete {remove an ARP table entry} {arpDelete\( \)} {arpDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
arpFlush {flush all entries in the system ARP table} {arpFlush\( \)} {arpFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
bootpParamsGet {retrieve boot parameters using BOOTP} {bootpParamsGet\( \)} {bootpParamsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
bootpMsgSend {send a BOOTP request message} {bootpMsgSend\( \)} {bootpMsgSend(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcShowInit {initialize the DHCP show facility} {dhcpcShowInit\( \)} {dhcpcShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcServerShow {display current DHCP server} {dhcpcServerShow\( \)} {dhcpcServerShow(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcTimersShow {display current lease timers} {dhcpcTimersShow\( \)} {dhcpcTimersShow(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcParamsShow {display current lease parameters} {dhcpcParamsShow\( \)} {dhcpcParamsShow(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcLibInit {DHCP client library initialization} {dhcpcLibInit\( \)} {dhcpcLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcInit {assign network interface and setup lease request} {dhcpcInit\( \)} {dhcpcInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcEventHookAdd {add a routine to handle configuration parameters} {dhcpcEventHookAdd\( \)} {dhcpcEventHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcEventHookDelete {remove the configuration parameters handler} {dhcpcEventHookDelete\( \)} {dhcpcEventHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcCacheHookAdd {add a routine to store and retrieve lease data} {dhcpcCacheHookAdd\( \)} {dhcpcCacheHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcCacheHookDelete {delete a lease data storage routine} {dhcpcCacheHookDelete\( \)} {dhcpcCacheHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcBind {obtain a set of network configuration parameters with DHCP} {dhcpcBind\( \)} {dhcpcBind(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcVerify {renew an established lease} {dhcpcVerify\( \)} {dhcpcVerify(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcRelease {relinquish specified lease} {dhcpcRelease\( \)} {dhcpcRelease(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcInformGet {obtain additional configuration parameters with DHCP} {dhcpcInformGet\( \)} {dhcpcInformGet(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcShutdown {disable DHCP client library} {dhcpcShutdown\( \)} {dhcpcShutdown(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcOptionGet {retrieve an option provided to a client and store in a buffer} {dhcpcOptionGet\( \)} {dhcpcOptionGet(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcServerGet {retrieve the current DHCP server} {dhcpcServerGet\( \)} {dhcpcServerGet(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcTimerGet {retrieve current lease timers} {dhcpcTimerGet\( \)} {dhcpcTimerGet(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcParamsGet {retrieve current configuration parameters} {dhcpcParamsGet\( \)} {dhcpcParamsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcBootInit {set up the DHCP client parameters and data structures} {dhcpcBootInit\( \)} {dhcpcBootInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcBootBind {initialize the network with DHCP at boot time} {dhcpcBootBind\( \)} {dhcpcBootBind(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpcBootInformGet {obtain additional configuration parameters with DHCP} {dhcpcBootInformGet\( \)} {dhcpcBootInformGet(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpsInit {set up the DHCP server parameters and data structures} {dhcpsInit\( \)} {dhcpsInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpsLeaseEntryAdd {add another entry to the address pool} {dhcpsLeaseEntryAdd\( \)} {dhcpsLeaseEntryAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpsLeaseHookAdd {assign a permanent lease storage hook for the server} {dhcpsLeaseHookAdd\( \)} {dhcpsLeaseHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
dhcpsAddressHookAdd {assign a permanent address storage hook for the server} {dhcpsAddressHookAdd\( \)} {dhcpsAddressHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
etherOutput {send a packet on an Ethernet interface} {etherOutput\( \)} {etherOutput(\ )} {VxWorks Reference Manual} Libraries {} {}
etherInputHookAdd {add a routine to receive all Ethernet input packets} {etherInputHookAdd\( \)} {etherInputHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
etherInputHookDelete {delete a network interface input hook routine} {etherInputHookDelete\( \)} {etherInputHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
etherOutputHookAdd {add a routine to receive all Ethernet output packets} {etherOutputHookAdd\( \)} {etherOutputHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
etherOutputHookDelete {delete a network interface output hook routine} {etherOutputHookDelete\( \)} {etherOutputHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
etherAddrResolve {find an Ethernet address for a specified Internet address} {etherAddrResolve\( \)} {etherAddrResolve(\ )} {VxWorks Reference Manual} Libraries {} {}
etherTypeGet {get the type from an ethernet packet} {etherTypeGet\( \)} {etherTypeGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpCommand {send an FTP command and get the reply} {ftpCommand\( \)} {ftpCommand(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpXfer {initiate a transfer via FTP} {ftpXfer\( \)} {ftpXfer(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpReplyGet {get an FTP command reply} {ftpReplyGet\( \)} {ftpReplyGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpHookup {get a control connection to the FTP server on a specified host} {ftpHookup\( \)} {ftpHookup(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpLogin {log in to a remote FTP server} {ftpLogin\( \)} {ftpLogin(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpDataConnInit {initialize an FTP data connection} {ftpDataConnInit\( \)} {ftpDataConnInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpDataConnGet {get a completed FTP data connection} {ftpDataConnGet\( \)} {ftpDataConnGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpLs {list directory contents via FTP} {ftpLs\( \)} {ftpLs(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpdInit {initialize the FTP server task} {ftpdInit\( \)} {ftpdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ftpdDelete {terminate the FTP server task} {ftpdDelete\( \)} {ftpdDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
hostTblInit {initialize the network host table} {hostTblInit\( \)} {hostTblInit(\ )} {VxWorks Reference Manual} Libraries {} {}
hostAdd {add a host to the host table} {hostAdd\( \)} {hostAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
hostDelete {delete a host from the host table} {hostDelete\( \)} {hostDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
hostGetByName {look up a host in the host table by its name} {hostGetByName\( \)} {hostGetByName(\ )} {VxWorks Reference Manual} Libraries {} {}
hostGetByAddr {look up a host in the host table by its Internet address} {hostGetByAddr\( \)} {hostGetByAddr(\ )} {VxWorks Reference Manual} Libraries {} {}
sethostname {set the symbolic name of this machine} {sethostname\( \)} {sethostname(\ )} {VxWorks Reference Manual} Libraries {} {}
gethostname {get the symbolic name of this machine} {gethostname\( \)} {gethostname(\ )} {VxWorks Reference Manual} Libraries {} {}
ifAddrAdd {Add an interface address for a network interface} {ifAddrAdd\( \)} {ifAddrAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
ifAddrSet {set an interface address for a network interface} {ifAddrSet\( \)} {ifAddrSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifAddrGet {get the Internet address of a network interface} {ifAddrGet\( \)} {ifAddrGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifBroadcastSet {set the broadcast address for a network interface} {ifBroadcastSet\( \)} {ifBroadcastSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifBroadcastGet {get the broadcast address for a network interface} {ifBroadcastGet\( \)} {ifBroadcastGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifDstAddrSet {define an address for the other end of a point-to-point link} {ifDstAddrSet\( \)} {ifDstAddrSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifDstAddrGet {get the Internet address of a point-to-point peer} {ifDstAddrGet\( \)} {ifDstAddrGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifMaskSet {define a subnet for a network interface} {ifMaskSet\( \)} {ifMaskSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifMaskGet {get the subnet mask for a network interface} {ifMaskGet\( \)} {ifMaskGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifFlagChange {change the network interface flags} {ifFlagChange\( \)} {ifFlagChange(\ )} {VxWorks Reference Manual} Libraries {} {}
ifFlagSet {specify the flags for a network interface} {ifFlagSet\( \)} {ifFlagSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifFlagGet {get the network interface flags} {ifFlagGet\( \)} {ifFlagGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifMetricSet {specify a network interface hop count} {ifMetricSet\( \)} {ifMetricSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifMetricGet {get the metric for a network interface} {ifMetricGet\( \)} {ifMetricGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ifRouteDelete {delete routes associated with a network interface} {ifRouteDelete\( \)} {ifRouteDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
ifunit {map an interface name to an interface structure pointer} {ifunit\( \)} {ifunit(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_addr {convert a dot notation Internet address to a long integer} {inet_addr\( \)} {inet_addr(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_lnaof {get the local address (host number) from the Internet address} {inet_lnaof\( \)} {inet_lnaof(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_makeaddr_b {form an Internet address from network and host numbers} {inet_makeaddr_b\( \)} {inet_makeaddr_b(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_makeaddr {form an Internet address from network and host numbers} {inet_makeaddr\( \)} {inet_makeaddr(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_netof {return the network number from an Internet address} {inet_netof\( \)} {inet_netof(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_netof_string {extract the network address in dot notation} {inet_netof_string\( \)} {inet_netof_string(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_network {convert an Internet network number from string to address} {inet_network\( \)} {inet_network(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_ntoa_b {convert an network address to dot notation, store it in a buffer} {inet_ntoa_b\( \)} {inet_ntoa_b(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_ntoa {convert a network address to dotted decimal notation} {inet_ntoa\( \)} {inet_ntoa(\ )} {VxWorks Reference Manual} Libraries {} {}
inet_aton {convert a network address from dot notation, store in a structure} {inet_aton\( \)} {inet_aton(\ )} {VxWorks Reference Manual} Libraries {} {}
mountdInit {initialize the mount daemon} {mountdInit\( \)} {mountdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsExport {specify a file system to be NFS exported} {nfsExport\( \)} {nfsExport(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsUnexport {remove a file system from the list of exported file systems} {nfsUnexport\( \)} {nfsUnexport(\ )} {VxWorks Reference Manual} Libraries {} {}
netDrv {install the network remote file driver} {netDrv\( \)} {netDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
netDevCreate {create a remote file device} {netDevCreate\( \)} {netDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
netLibInit {initialize the network package} {netLibInit\( \)} {netLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
netTask {network task entry point} {netTask\( \)} {netTask(\ )} {VxWorks Reference Manual} Libraries {} {}
ifShow {display the attached network interfaces} {ifShow\( \)} {ifShow(\ )} {VxWorks Reference Manual} Libraries {} {}
inetstatShow {display all active connections for Internet protocol sockets} {inetstatShow\( \)} {inetstatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
ipstatShow {display IP statistics} {ipstatShow\( \)} {ipstatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
netPoolShow {show pool statistics} {netPoolShow\( \)} {netPoolShow(\ )} {VxWorks Reference Manual} Libraries {} {}
netStackDataPoolShow {show network stack data pool statistics} {netStackDataPoolShow\( \)} {netStackDataPoolShow(\ )} {VxWorks Reference Manual} Libraries {} {}
netStackSysPoolShow {show network stack system pool statistics} {netStackSysPoolShow\( \)} {netStackSysPoolShow(\ )} {VxWorks Reference Manual} Libraries {} {}
mbufShow {report mbuf statistics} {mbufShow\( \)} {mbufShow(\ )} {VxWorks Reference Manual} Libraries {} {}
netShowInit {initialize network show routines} {netShowInit\( \)} {netShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
arpShow {display entries in the system ARP table} {arpShow\( \)} {arpShow(\ )} {VxWorks Reference Manual} Libraries {} {}
arptabShow {display the known ARP entries} {arptabShow\( \)} {arptabShow(\ )} {VxWorks Reference Manual} Libraries {} {}
routestatShow {display routing statistics} {routestatShow\( \)} {routestatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
routeShow {display host and network routing tables} {routeShow\( \)} {routeShow(\ )} {VxWorks Reference Manual} Libraries {} {}
hostShow {display the host table} {hostShow\( \)} {hostShow(\ )} {VxWorks Reference Manual} Libraries {} {}
mRouteShow {print the entries of the routing table } {mRouteShow\( \)} {mRouteShow(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsdInit {initialize the NFS server} {nfsdInit\( \)} {nfsdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsdStatusGet {get the status of the NFS server} {nfsdStatusGet\( \)} {nfsdStatusGet(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsdStatusShow {show the status of the NFS server} {nfsdStatusShow\( \)} {nfsdStatusShow(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsDrv {install the NFS driver} {nfsDrv\( \)} {nfsDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsDrvNumGet {return the IO system driver number for the nfs driver} {nfsDrvNumGet\( \)} {nfsDrvNumGet(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsMount {mount an NFS file system} {nfsMount\( \)} {nfsMount(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsMountAll {mount all file systems exported by a specified host} {nfsMountAll\( \)} {nfsMountAll(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsDevShow {display the mounted NFS devices} {nfsDevShow\( \)} {nfsDevShow(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsUnmount {unmount an NFS device} {nfsUnmount\( \)} {nfsUnmount(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsDevListGet {create list of all the NFS devices in the system} {nfsDevListGet\( \)} {nfsDevListGet(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsDevInfoGet {read configuration information from the requested NFS device} {nfsDevInfoGet\( \)} {nfsDevInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsHelp {display the NFS help menu} {nfsHelp\( \)} {nfsHelp(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsExportShow {display the exported file systems of a remote host} {nfsExportShow\( \)} {nfsExportShow(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsAuthUnixPrompt {modify the NFS UNIX authentication parameters} {nfsAuthUnixPrompt\( \)} {nfsAuthUnixPrompt(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsAuthUnixShow {display the NFS UNIX authentication parameters} {nfsAuthUnixShow\( \)} {nfsAuthUnixShow(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsAuthUnixSet {set the NFS UNIX authentication parameters} {nfsAuthUnixSet\( \)} {nfsAuthUnixSet(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsAuthUnixGet {get the NFS UNIX authentication parameters} {nfsAuthUnixGet\( \)} {nfsAuthUnixGet(\ )} {VxWorks Reference Manual} Libraries {} {}
nfsIdSet {set the ID number of the NFS UNIX authentication parameters} {nfsIdSet\( \)} {nfsIdSet(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyArpLibInit {initialize proxy ARP} {proxyArpLibInit\( \)} {proxyArpLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyNetCreate {create a proxy ARP network} {proxyNetCreate\( \)} {proxyNetCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyNetDelete {delete a proxy network} {proxyNetDelete\( \)} {proxyNetDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyNetShow {show proxy ARP networks} {proxyNetShow\( \)} {proxyNetShow(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyPortFwdOn {enable broadcast forwarding for a particular port} {proxyPortFwdOn\( \)} {proxyPortFwdOn(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyPortFwdOff {disable broadcast forwarding for a particular port} {proxyPortFwdOff\( \)} {proxyPortFwdOff(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyPortShow {show enabled ports} {proxyPortShow\( \)} {proxyPortShow(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyReg {register a proxy client} {proxyReg\( \)} {proxyReg(\ )} {VxWorks Reference Manual} Libraries {} {}
proxyUnreg {unregister a proxy client} {proxyUnreg\( \)} {proxyUnreg(\ )} {VxWorks Reference Manual} Libraries {} {}
rcmd {execute a shell command on a remote machine} {rcmd\( \)} {rcmd(\ )} {VxWorks Reference Manual} Libraries {} {}
rresvport {open a socket with a privileged port bound to it} {rresvport\( \)} {rresvport(\ )} {VxWorks Reference Manual} Libraries {} {}
remCurIdGet {get the current user name and password} {remCurIdGet\( \)} {remCurIdGet(\ )} {VxWorks Reference Manual} Libraries {} {}
remCurIdSet {set the remote user name and password} {remCurIdSet\( \)} {remCurIdSet(\ )} {VxWorks Reference Manual} Libraries {} {}
iam {set the remote user name and password} {iam\( \)} {iam(\ )} {VxWorks Reference Manual} Libraries {} {}
whoami {display the current remote identity} {whoami\( \)} {whoami(\ )} {VxWorks Reference Manual} Libraries {} {}
bindresvport {bind a socket to a privileged IP port} {bindresvport\( \)} {bindresvport(\ )} {VxWorks Reference Manual} Libraries {} {}
rlogInit {initialize the remote login facility} {rlogInit\( \)} {rlogInit(\ )} {VxWorks Reference Manual} Libraries {} {}
rlogind {the VxWorks remote login daemon} {rlogind\( \)} {rlogind(\ )} {VxWorks Reference Manual} Libraries {} {}
rlogin {log in to a remote host} {rlogin\( \)} {rlogin(\ )} {VxWorks Reference Manual} Libraries {} {}
routeAdd {add a route} {routeAdd\( \)} {routeAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
routeNetAdd {add a route to a destination that is a network} {routeNetAdd\( \)} {routeNetAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
routeDelete {delete a route} {routeDelete\( \)} {routeDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
mRouteAdd {add multiple routes to the same destination } {mRouteAdd\( \)} {mRouteAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
mRouteEntryAdd {add a protocol-specific route to the routing table } {mRouteEntryAdd\( \)} {mRouteEntryAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
mRouteEntryDelete {delete route from the routing table } {mRouteEntryDelete\( \)} {mRouteEntryDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
mRouteDelete {delete a route from the routing table } {mRouteDelete\( \)} {mRouteDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
routeProtoPrioritySet {set the priority of routes added by the routing protocol } {routeProtoPrioritySet\( \)} {routeProtoPrioritySet(\ )} {VxWorks Reference Manual} Libraries {} {}
rpcInit {initialize the RPC package} {rpcInit\( \)} {rpcInit(\ )} {VxWorks Reference Manual} Libraries {} {}
rpcTaskInit {initialize a task's access to the RPC package} {rpcTaskInit\( \)} {rpcTaskInit(\ )} {VxWorks Reference Manual} Libraries {} {}
socket {open a socket} {socket\( \)} {socket(\ )} {VxWorks Reference Manual} Libraries {} {}
bind {bind a name to a socket} {bind\( \)} {bind(\ )} {VxWorks Reference Manual} Libraries {} {}
listen {enable connections to a socket} {listen\( \)} {listen(\ )} {VxWorks Reference Manual} Libraries {} {}
accept {accept a connection from a socket} {accept\( \)} {accept(\ )} {VxWorks Reference Manual} Libraries {} {}
connect {initiate a connection to a socket} {connect\( \)} {connect(\ )} {VxWorks Reference Manual} Libraries {} {}
connectWithTimeout {try to connect over a socket for a specified duration} {connectWithTimeout\( \)} {connectWithTimeout(\ )} {VxWorks Reference Manual} Libraries {} {}
sendto {send a message to a socket} {sendto\( \)} {sendto(\ )} {VxWorks Reference Manual} Libraries {} {}
send {send data to a socket} {send\( \)} {send(\ )} {VxWorks Reference Manual} Libraries {} {}
sendmsg {send a message to a socket} {sendmsg\( \)} {sendmsg(\ )} {VxWorks Reference Manual} Libraries {} {}
recvfrom {receive a message from a socket} {recvfrom\( \)} {recvfrom(\ )} {VxWorks Reference Manual} Libraries {} {}
recv {receive data from a socket} {recv\( \)} {recv(\ )} {VxWorks Reference Manual} Libraries {} {}
recvmsg {receive a message from a socket} {recvmsg\( \)} {recvmsg(\ )} {VxWorks Reference Manual} Libraries {} {}
setsockopt {set socket options} {setsockopt\( \)} {setsockopt(\ )} {VxWorks Reference Manual} Libraries {} {}
getsockopt {get socket options} {getsockopt\( \)} {getsockopt(\ )} {VxWorks Reference Manual} Libraries {} {}
getsockname {get a socket name} {getsockname\( \)} {getsockname(\ )} {VxWorks Reference Manual} Libraries {} {}
getpeername {get the name of a connected peer} {getpeername\( \)} {getpeername(\ )} {VxWorks Reference Manual} Libraries {} {}
shutdown {shut down a network connection} {shutdown\( \)} {shutdown(\ )} {VxWorks Reference Manual} Libraries {} {}
sntpcTimeGet {retrieve the current time from a remote source} {sntpcTimeGet\( \)} {sntpcTimeGet(\ )} {VxWorks Reference Manual} Libraries {} {}
sntpsClockSet {assign a routine to access the reference clock} {sntpsClockSet\( \)} {sntpsClockSet(\ )} {VxWorks Reference Manual} Libraries {} {}
sntpsNsecToFraction {convert portions of a second to NTP format} {sntpsNsecToFraction\( \)} {sntpsNsecToFraction(\ )} {VxWorks Reference Manual} Libraries {} {}
sntpsConfigSet {change SNTP server broadcast settings} {sntpsConfigSet\( \)} {sntpsConfigSet(\ )} {VxWorks Reference Manual} Libraries {} {}
telnetdInit {initialize the telnet services} {telnetdInit\( \)} {telnetdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
telnetdParserSet {specify a command interpreter for telnet sessions} {telnetdParserSet\( \)} {telnetdParserSet(\ )} {VxWorks Reference Manual} Libraries {} {}
telnetdStart {initialize the telnet services} {telnetdStart\( \)} {telnetdStart(\ )} {VxWorks Reference Manual} Libraries {} {}
telnetdExit {close an active telnet session} {telnetdExit\( \)} {telnetdExit(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpXfer {transfer a file via TFTP using a stream interface} {tftpXfer\( \)} {tftpXfer(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpCopy {transfer a file via TFTP} {tftpCopy\( \)} {tftpCopy(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpInit {initialize a TFTP session} {tftpInit\( \)} {tftpInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpModeSet {set the TFTP transfer mode} {tftpModeSet\( \)} {tftpModeSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpPeerSet {set the TFTP server address} {tftpPeerSet\( \)} {tftpPeerSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpPut {put a file to a remote system} {tftpPut\( \)} {tftpPut(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpGet {get a file from a remote system} {tftpGet\( \)} {tftpGet(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpInfoShow {get TFTP status information} {tftpInfoShow\( \)} {tftpInfoShow(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpQuit {quit a TFTP session} {tftpQuit\( \)} {tftpQuit(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpSend {send a TFTP message to the remote system} {tftpSend\( \)} {tftpSend(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpdInit {initialize the TFTP server task} {tftpdInit\( \)} {tftpdInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpdTask {TFTP server daemon task} {tftpdTask\( \)} {tftpdTask(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpdDirectoryAdd {add a directory to the access list} {tftpdDirectoryAdd\( \)} {tftpdDirectoryAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
tftpdDirectoryRemove {delete a directory from the access list} {tftpdDirectoryRemove\( \)} {tftpdDirectoryRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
m2Init {initialize the SNMP MIB-2 library } {m2Init\( \)} {m2Init(\ )} {VxWorks Reference Manual} Libraries {} {}
m2Delete {delete all the MIB-II library groups} {m2Delete\( \)} {m2Delete(\ )} {VxWorks Reference Manual} Libraries {} {}
m2SysInit {initialize MIB-II system-group routines} {m2SysInit\( \)} {m2SysInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m2SysGroupInfoGet {get system-group MIB-II variables} {m2SysGroupInfoGet\( \)} {m2SysGroupInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2SysGroupInfoSet {set system-group MIB-II variables to new values} {m2SysGroupInfoSet\( \)} {m2SysGroupInfoSet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2SysDelete {delete resources used to access the MIB-II system group} {m2SysDelete\( \)} {m2SysDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfAlloc {Allocate the structure for the interface table} {m2IfAlloc\( \)} {m2IfAlloc(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfFree {free an interface data structure} {m2IfFree\( \)} {m2IfFree(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfGenericPacketCount {Increment the interface packet counters } {m2IfGenericPacketCount\( \)} {m2IfGenericPacketCount(\ )} {VxWorks Reference Manual} Libraries {} {}
m2If8023PacketCount {Increment the interface packet counters for an 802.3} {m2If8023PacketCount\( \)} {m2If8023PacketCount(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfCounterUpdate {Increment interface counters } {m2IfCounterUpdate\( \)} {m2IfCounterUpdate(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfVariableUpdate {Update the contents of an interface non-counter object } {m2IfVariableUpdate\( \)} {m2IfVariableUpdate(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfPktCountRtnInstall {Install an interface packet counter routine} {m2IfPktCountRtnInstall\( \)} {m2IfPktCountRtnInstall(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfCtrUpdateRtnInstall {Install an interface counter update routine} {m2IfCtrUpdateRtnInstall\( \)} {m2IfCtrUpdateRtnInstall(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfVarUpdateRtnInstall {Install an interface variable update routine} {m2IfVarUpdateRtnInstall\( \)} {m2IfVarUpdateRtnInstall(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfInit {initialize MIB-II interface-group routines} {m2IfInit\( \)} {m2IfInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfTableUpdate {Insert or remove an entry in the ifTable} {m2IfTableUpdate\( \)} {m2IfTableUpdate(\ )} {VxWorks Reference Manual} Libraries {} {}
rcvAddrAdd {populate the rcvAddr fields for the ifRcvAddressTable} {rcvAddrAdd\( \)} {rcvAddrAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
rcvAddrAdd {add a physical address into the linked list} {rcvAddrAdd;1\( \)} {rcvAddrAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfTblEntryGet {get a MIB-II interface-group table entry} {m2IfTblEntryGet\( \)} {m2IfTblEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfDefaultValsGet {get the default values for the counters} {m2IfDefaultValsGet\( \)} {m2IfDefaultValsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfCommonValsGet {get the common values} {m2IfCommonValsGet\( \)} {m2IfCommonValsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfTblEntrySet {set the state of a MIB-II interface entry to UP or DOWN} {m2IfTblEntrySet\( \)} {m2IfTblEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfGroupInfoGet {get the MIB-II interface-group scalar variables} {m2IfGroupInfoGet\( \)} {m2IfGroupInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfStackEntryGet {get a MIB-II interface-group table entry} {m2IfStackEntryGet\( \)} {m2IfStackEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfStackEntrySet {modify the status of a relationship} {m2IfStackEntrySet\( \)} {m2IfStackEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfRcvAddrEntryGet {get the rcvAddress table entries for a given address} {m2IfRcvAddrEntryGet\( \)} {m2IfRcvAddrEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfRcvAddrEntrySet {modify the entries of the rcvAddressTable} {m2IfRcvAddrEntrySet\( \)} {m2IfRcvAddrEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IfDelete {delete all resources used to access the interface group} {m2IfDelete\( \)} {m2IfDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
nextIndex {the comparison routine for the AVL tree} {nextIndex\( \)} {nextIndex(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpInit {initialize MIB-II IP-group access} {m2IpInit\( \)} {m2IpInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpGroupInfoGet {get the MIB-II IP-group scalar variables} {m2IpGroupInfoGet\( \)} {m2IpGroupInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpGroupInfoSet {set MIB-II IP-group variables to new values} {m2IpGroupInfoSet\( \)} {m2IpGroupInfoSet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpAddrTblEntryGet {get an IP MIB-II address entry} {m2IpAddrTblEntryGet\( \)} {m2IpAddrTblEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpAtransTblEntryGet {get a MIB-II ARP table entry} {m2IpAtransTblEntryGet\( \)} {m2IpAtransTblEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpAtransTblEntrySet {add, modify, or delete a MIB-II ARP entry} {m2IpAtransTblEntrySet\( \)} {m2IpAtransTblEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpRouteTblEntryGet {get a MIB-2 routing table entry } {m2IpRouteTblEntryGet\( \)} {m2IpRouteTblEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpRouteTblEntrySet {set a MIB-II routing table entry} {m2IpRouteTblEntrySet\( \)} {m2IpRouteTblEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IpDelete {delete all resources used to access the IP group} {m2IpDelete\( \)} {m2IpDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IcmpInit {initialize MIB-II ICMP-group access} {m2IcmpInit\( \)} {m2IcmpInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IcmpGroupInfoGet {get the MIB-II ICMP-group global variables} {m2IcmpGroupInfoGet\( \)} {m2IcmpGroupInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2IcmpDelete {delete all resources used to access the ICMP group} {m2IcmpDelete\( \)} {m2IcmpDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
m2UdpInit {initialize MIB-II UDP-group access} {m2UdpInit\( \)} {m2UdpInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m2UdpGroupInfoGet {get MIB-II UDP-group scalar variables} {m2UdpGroupInfoGet\( \)} {m2UdpGroupInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2UdpTblEntryGet {get a UDP MIB-II entry from the UDP list of listeners} {m2UdpTblEntryGet\( \)} {m2UdpTblEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2UdpDelete {delete all resources used to access the UDP group} {m2UdpDelete\( \)} {m2UdpDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
m2TcpInit {initialize MIB-II TCP-group access} {m2TcpInit\( \)} {m2TcpInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m2TcpGroupInfoGet {get MIB-II TCP-group scalar variables} {m2TcpGroupInfoGet\( \)} {m2TcpGroupInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2TcpConnEntryGet {get a MIB-II TCP connection table entry} {m2TcpConnEntryGet\( \)} {m2TcpConnEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2TcpConnEntrySet {set a TCP connection to the closed state} {m2TcpConnEntrySet\( \)} {m2TcpConnEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2TcpDelete {delete all resources used to access the TCP group} {m2TcpDelete\( \)} {m2TcpDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufCreate {create an empty zbuf} {zbufCreate\( \)} {zbufCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufDelete {delete a zbuf} {zbufDelete\( \)} {zbufDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufInsert {insert a zbuf into another zbuf} {zbufInsert\( \)} {zbufInsert(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufInsertBuf {create a zbuf segment from a buffer and insert into a zbuf} {zbufInsertBuf\( \)} {zbufInsertBuf(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufInsertCopy {copy buffer data into a zbuf} {zbufInsertCopy\( \)} {zbufInsertCopy(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufExtractCopy {copy data from a zbuf to a buffer} {zbufExtractCopy\( \)} {zbufExtractCopy(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufCut {delete bytes from a zbuf} {zbufCut\( \)} {zbufCut(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSplit {split a zbuf into two separate zbufs} {zbufSplit\( \)} {zbufSplit(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufDup {duplicate a zbuf} {zbufDup\( \)} {zbufDup(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufLength {determine the length in bytes of a zbuf} {zbufLength\( \)} {zbufLength(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSegFind {find the zbuf segment containing a specified byte location} {zbufSegFind\( \)} {zbufSegFind(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSegNext {get the next segment in a zbuf} {zbufSegNext\( \)} {zbufSegNext(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSegPrev {get the previous segment in a zbuf} {zbufSegPrev\( \)} {zbufSegPrev(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSegData {determine the location of data in a zbuf segment} {zbufSegData\( \)} {zbufSegData(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSegLength {determine the length of a zbuf segment} {zbufSegLength\( \)} {zbufSegLength(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSockLibInit {initialize the zbuf socket interface library} {zbufSockLibInit\( \)} {zbufSockLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSockSend {send zbuf data to a TCP socket} {zbufSockSend\( \)} {zbufSockSend(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSockSendto {send a zbuf message to a UDP socket} {zbufSockSendto\( \)} {zbufSockSendto(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSockBufSend {create a zbuf from user data and send it to a TCP socket} {zbufSockBufSend\( \)} {zbufSockBufSend(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSockBufSendto {create a zbuf from a user message and send it to a UDP socket} {zbufSockBufSendto\( \)} {zbufSockBufSendto(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSockRecv {receive data in a zbuf from a TCP socket} {zbufSockRecv\( \)} {zbufSockRecv(\ )} {VxWorks Reference Manual} Libraries {} {}
zbufSockRecvfrom {receive a message in a zbuf from a UDP socket} {zbufSockRecvfrom\( \)} {zbufSockRecvfrom(\ )} {VxWorks Reference Manual} Libraries {} {}
pingLibInit {initialize the ping() utility} {pingLibInit\( \)} {pingLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ping {test that a remote host is reachable} {ping\( \)} {ping(\ )} {VxWorks Reference Manual} Libraries {} {}
etherMultiAdd {add multicast address to a multicast address list} {etherMultiAdd\( \)} {etherMultiAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
etherMultiDel {delete an Ethernet multicast address record} {etherMultiDel\( \)} {etherMultiDel(\ )} {VxWorks Reference Manual} Libraries {} {}
etherMultiGet {retrieve a table of multicast addresses from a driver} {etherMultiGet\( \)} {etherMultiGet(\ )} {VxWorks Reference Manual} Libraries {} {}
muxTkDrvCheck {checks if the device is a NPT or END interface} {muxTkDrvCheck\( \)} {muxTkDrvCheck(\ )} {VxWorks Reference Manual} Libraries {} {}
muxTkBind {bind an NPT protocol to a driver} {muxTkBind\( \)} {muxTkBind(\ )} {VxWorks Reference Manual} Libraries {} {}
muxTkReceive {Receive a packet from a NPT driver.} {muxTkReceive\( \)} {muxTkReceive(\ )} {VxWorks Reference Manual} Libraries {} {}
muxTkSend {send a packet out on a Toolkit or END network interface} {muxTkSend\( \)} {muxTkSend(\ )} {VxWorks Reference Manual} Libraries {} {}
muxTkPollSend {send a packet out in polled mode to an END or NPT interface} {muxTkPollSend\( \)} {muxTkPollSend(\ )} {VxWorks Reference Manual} Libraries {} {}
muxTkPollReceive {poll for a packet from a NPT or END driver} {muxTkPollReceive\( \)} {muxTkPollReceive(\ )} {VxWorks Reference Manual} Libraries {} {}
muxLibInit {initialize global state for the MUX} {muxLibInit\( \)} {muxLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
muxDevLoad {load a driver into the MUX} {muxDevLoad\( \)} {muxDevLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
muxDevStart {start a device by calling its start routine} {muxDevStart\( \)} {muxDevStart(\ )} {VxWorks Reference Manual} Libraries {} {}
muxDevStop {stop a device by calling its stop routine} {muxDevStop\( \)} {muxDevStop(\ )} {VxWorks Reference Manual} Libraries {} {}
muxShow {display configuration of devices registered with the MUX} {muxShow\( \)} {muxShow(\ )} {VxWorks Reference Manual} Libraries {} {}
muxBind {create a binding between a network service and and END} {muxBind\( \)} {muxBind(\ )} {VxWorks Reference Manual} Libraries {} {}
muxSend {send a packet out on a network interface} {muxSend\( \)} {muxSend(\ )} {VxWorks Reference Manual} Libraries {} {}
muxPollSend {send a packet on a network interface} {muxPollSend\( \)} {muxPollSend(\ )} {VxWorks Reference Manual} Libraries {} {}
muxPollReceive {poll for a packet from a device driver} {muxPollReceive\( \)} {muxPollReceive(\ )} {VxWorks Reference Manual} Libraries {} {}
muxIoctl {send control information to the MUX or to a device} {muxIoctl\( \)} {muxIoctl(\ )} {VxWorks Reference Manual} Libraries {} {}
muxMCastAddrAdd {add a multicast address to a device's multicast table } {muxMCastAddrAdd\( \)} {muxMCastAddrAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
muxMCastAddrDel {delete a multicast address from a device's multicast table} {muxMCastAddrDel\( \)} {muxMCastAddrDel(\ )} {VxWorks Reference Manual} Libraries {} {}
muxMCastAddrGet {get the multicast address table from the MUX/Driver} {muxMCastAddrGet\( \)} {muxMCastAddrGet(\ )} {VxWorks Reference Manual} Libraries {} {}
muxUnbind {detach a network service from the specified device} {muxUnbind\( \)} {muxUnbind(\ )} {VxWorks Reference Manual} Libraries {} {}
muxDevUnload {unloads a device from the MUX} {muxDevUnload\( \)} {muxDevUnload(\ )} {VxWorks Reference Manual} Libraries {} {}
muxLinkHeaderCreate {attach a link-level header to a packet} {muxLinkHeaderCreate\( \)} {muxLinkHeaderCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
muxAddressForm {form a frame with a link-layer address} {muxAddressForm\( \)} {muxAddressForm(\ )} {VxWorks Reference Manual} Libraries {} {}
muxPacketDataGet {return the data from a packet} {muxPacketDataGet\( \)} {muxPacketDataGet(\ )} {VxWorks Reference Manual} Libraries {} {}
muxPacketAddrGet {get addressing information from a packet} {muxPacketAddrGet\( \)} {muxPacketAddrGet(\ )} {VxWorks Reference Manual} Libraries {} {}
endFindByName {find a device using its string name} {endFindByName\( \)} {endFindByName(\ )} {VxWorks Reference Manual} Libraries {} {}
muxDevExists {tests whether a device is already loaded into the MUX} {muxDevExists\( \)} {muxDevExists(\ )} {VxWorks Reference Manual} Libraries {} {}
muxAddrResFuncAdd {add an address resolution function} {muxAddrResFuncAdd\( \)} {muxAddrResFuncAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
muxAddrResFuncGet {get the address resolution function for ifType/protocol} {muxAddrResFuncGet\( \)} {muxAddrResFuncGet(\ )} {VxWorks Reference Manual} Libraries {} {}
muxAddrResFuncDel {delete an address resolution function} {muxAddrResFuncDel\( \)} {muxAddrResFuncDel(\ )} {VxWorks Reference Manual} Libraries {} {}
ipAttach {a generic attach routine for the TCP/IP network stack} {ipAttach\( \)} {ipAttach(\ )} {VxWorks Reference Manual} Libraries {} {}
ipDetach {a generic detach routine for the TCP/IP network stack} {ipDetach\( \)} {ipDetach(\ )} {VxWorks Reference Manual} Libraries {} {}
igmpShowInit {initialize IGMP show routines} {igmpShowInit\( \)} {igmpShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
igmpstatShow {display statistics for IGMP} {igmpstatShow\( \)} {igmpstatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
icmpShowInit {initialize ICMP show routines} {icmpShowInit\( \)} {icmpShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
icmpstatShow {display statistics for ICMP} {icmpstatShow\( \)} {icmpstatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
tcpShowInit {initialize TCP show routines} {tcpShowInit\( \)} {tcpShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tcpDebugShow {display debugging information for the TCP protocol} {tcpDebugShow\( \)} {tcpDebugShow(\ )} {VxWorks Reference Manual} Libraries {} {}
tcpstatShow {display all statistics for the TCP protocol} {tcpstatShow\( \)} {tcpstatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
udpShowInit {initialize UDP show routines} {udpShowInit\( \)} {udpShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
udpstatShow {display statistics for the UDP protocol} {udpstatShow\( \)} {udpstatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
ipFilterLibInit {initialize ip filter facility} {ipFilterLibInit\( \)} {ipFilterLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ipFilterHookAdd {add a routine to receive all internet protocol packets} {ipFilterHookAdd\( \)} {ipFilterHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
ipFilterHookDelete {delete a ip filter hook routine} {ipFilterHookDelete\( \)} {ipFilterHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
netBufLibInit {initialize netBufLib} {netBufLibInit\( \)} {netBufLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
netPoolInit {initialize a netBufLib-managed memory pool} {netPoolInit\( \)} {netPoolInit(\ )} {VxWorks Reference Manual} Libraries {} {}
netPoolDelete {delete a memory pool} {netPoolDelete\( \)} {netPoolDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkFree {free an `mBlk' back to its memory pool} {netMblkFree\( \)} {netMblkFree(\ )} {VxWorks Reference Manual} Libraries {} {}
netClBlkFree {free a `clBlk'-cluster construct back to the memory pool} {netClBlkFree\( \)} {netClBlkFree(\ )} {VxWorks Reference Manual} Libraries {} {}
netClFree {free a cluster back to the memory pool} {netClFree\( \)} {netClFree(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkClFree {free an `mBlk'-`clBlk'-cluster construct} {netMblkClFree\( \)} {netMblkClFree(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkClChainFree {free a chain of `mBlk'-`clBlk'-cluster constructs} {netMblkClChainFree\( \)} {netMblkClChainFree(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkGet {get an `mBlk' from a memory pool} {netMblkGet\( \)} {netMblkGet(\ )} {VxWorks Reference Manual} Libraries {} {}
netClBlkGet {get a `clBlk'} {netClBlkGet\( \)} {netClBlkGet(\ )} {VxWorks Reference Manual} Libraries {} {}
netClusterGet {get a cluster from the specified cluster pool} {netClusterGet\( \)} {netClusterGet(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkClGet {get a `clBlk'-cluster and join it to the specified `mBlk'} {netMblkClGet\( \)} {netMblkClGet(\ )} {VxWorks Reference Manual} Libraries {} {}
netTupleGet {get an `mBlk'-`clBlk'-cluster} {netTupleGet\( \)} {netTupleGet(\ )} {VxWorks Reference Manual} Libraries {} {}
netClBlkJoin {join a cluster to a `clBlk' structure } {netClBlkJoin\( \)} {netClBlkJoin(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkClJoin {join an `mBlk' to a `clBlk'-cluster construct} {netMblkClJoin\( \)} {netMblkClJoin(\ )} {VxWorks Reference Manual} Libraries {} {}
netClPoolIdGet {return a CL_POOL_ID for a specified buffer size } {netClPoolIdGet\( \)} {netClPoolIdGet(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkToBufCopy {copy data from an `mBlk' to a buffer} {netMblkToBufCopy\( \)} {netMblkToBufCopy(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkDup {duplicate an `mBlk'} {netMblkDup\( \)} {netMblkDup(\ )} {VxWorks Reference Manual} Libraries {} {}
netMblkChainDup {duplicate an `mBlk' chain} {netMblkChainDup\( \)} {netMblkChainDup(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheLibInit {initialize the cache library for a processor architecture} {cacheLibInit\( \)} {cacheLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheEnable {enable the specified cache} {cacheEnable\( \)} {cacheEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheDisable {disable the specified cache} {cacheDisable\( \)} {cacheDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheLock {lock all or part of a specified cache} {cacheLock\( \)} {cacheLock(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheUnlock {unlock all or part of a specified cache} {cacheUnlock\( \)} {cacheUnlock(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheFlush {flush all or some of a specified cache} {cacheFlush\( \)} {cacheFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheInvalidate {invalidate all or some of a specified cache} {cacheInvalidate\( \)} {cacheInvalidate(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheClear {clear all or some entries from a cache} {cacheClear\( \)} {cacheClear(\ )} {VxWorks Reference Manual} Libraries {} {}
cachePipeFlush {flush processor write buffers to memory} {cachePipeFlush\( \)} {cachePipeFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheTextUpdate {synchronize the instruction and data caches} {cacheTextUpdate\( \)} {cacheTextUpdate(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheDmaMalloc {allocate a cache-safe buffer for DMA devices and drivers} {cacheDmaMalloc\( \)} {cacheDmaMalloc(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheDmaFree {free the buffer acquired with cacheDmaMalloc()} {cacheDmaFree\( \)} {cacheDmaFree(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheDrvFlush {flush the data cache for drivers} {cacheDrvFlush\( \)} {cacheDrvFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheDrvInvalidate {invalidate data cache for drivers} {cacheDrvInvalidate\( \)} {cacheDrvInvalidate(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheDrvVirtToPhys {translate a virtual address for drivers} {cacheDrvVirtToPhys\( \)} {cacheDrvVirtToPhys(\ )} {VxWorks Reference Manual} Libraries {} {}
cacheDrvPhysToVirt {translate a physical address for drivers} {cacheDrvPhysToVirt\( \)} {cacheDrvPhysToVirt(\ )} {VxWorks Reference Manual} Libraries {} {}
clock_getres {get the clock resolution (POSIX)} {clock_getres\( \)} {clock_getres(\ )} {VxWorks Reference Manual} Libraries {} {}
clock_setres {set the clock resolution} {clock_setres\( \)} {clock_setres(\ )} {VxWorks Reference Manual} Libraries {} {}
clock_gettime {get the current time of the clock (POSIX)} {clock_gettime\( \)} {clock_gettime(\ )} {VxWorks Reference Manual} Libraries {} {}
clock_settime {set the clock to a specified time (POSIX)} {clock_settime\( \)} {clock_settime(\ )} {VxWorks Reference Manual} Libraries {} {}
opendir {open a directory for searching (POSIX)} {opendir\( \)} {opendir(\ )} {VxWorks Reference Manual} Libraries {} {}
readdir {read one entry from a directory (POSIX)} {readdir\( \)} {readdir(\ )} {VxWorks Reference Manual} Libraries {} {}
rewinddir {reset position to the start of a directory (POSIX)} {rewinddir\( \)} {rewinddir(\ )} {VxWorks Reference Manual} Libraries {} {}
closedir {close a directory (POSIX)} {closedir\( \)} {closedir(\ )} {VxWorks Reference Manual} Libraries {} {}
fstat {get file status information (POSIX)} {fstat\( \)} {fstat(\ )} {VxWorks Reference Manual} Libraries {} {}
stat {get file status information using a pathname (POSIX)} {stat\( \)} {stat(\ )} {VxWorks Reference Manual} Libraries {} {}
fstatfs {get file status information (POSIX)} {fstatfs\( \)} {fstatfs(\ )} {VxWorks Reference Manual} Libraries {} {}
statfs {get file status information using a pathname (POSIX)} {statfs\( \)} {statfs(\ )} {VxWorks Reference Manual} Libraries {} {}
utime {update time on a file} {utime\( \)} {utime(\ )} {VxWorks Reference Manual} Libraries {} {}
dspInit {initialize dsp support} {dspInit\( \)} {dspInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dspShowInit {initialize the dsp show facility} {dspShowInit\( \)} {dspShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
dspTaskRegsShow {print the contents of a task's dsp registers} {dspTaskRegsShow\( \)} {dspTaskRegsShow(\ )} {VxWorks Reference Manual} Libraries {} {}
envLibInit {initialize environment variable facility} {envLibInit\( \)} {envLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
envPrivateCreate {create a private environment} {envPrivateCreate\( \)} {envPrivateCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
envPrivateDestroy {destroy a private environment} {envPrivateDestroy\( \)} {envPrivateDestroy(\ )} {VxWorks Reference Manual} Libraries {} {}
putenv {set an environment variable} {putenv\( \)} {putenv(\ )} {VxWorks Reference Manual} Libraries {} {}
getenv {get an environment variable (ANSI)} {getenv\( \)} {getenv(\ )} {VxWorks Reference Manual} Libraries {} {}
envShow {display the environment for a task} {envShow\( \)} {envShow(\ )} {VxWorks Reference Manual} Libraries {} {}
errnoGet {get the error status value of the calling task} {errnoGet\( \)} {errnoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
errnoOfTaskGet {get the error status value of a specified task} {errnoOfTaskGet\( \)} {errnoOfTaskGet(\ )} {VxWorks Reference Manual} Libraries {} {}
errnoSet {set the error status value of the calling task} {errnoSet\( \)} {errnoSet(\ )} {VxWorks Reference Manual} Libraries {} {}
errnoOfTaskSet {set the error status value of a specified task} {errnoOfTaskSet\( \)} {errnoOfTaskSet(\ )} {VxWorks Reference Manual} Libraries {} {}
excInit {initialize the exception handling package} {excInit\( \)} {excInit(\ )} {VxWorks Reference Manual} Libraries {} {}
excHookAdd {specify a routine to be called with exceptions} {excHookAdd\( \)} {excHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
excTask {handle task-level exceptions} {excTask\( \)} {excTask(\ )} {VxWorks Reference Manual} Libraries {} {}
fioLibInit {initialize the formatted I/O support library} {fioLibInit\( \)} {fioLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
printf {write a formatted string to the standard output stream (ANSI)} {printf\( \)} {printf(\ )} {VxWorks Reference Manual} Libraries {} {}
printErr {write a formatted string to the standard error stream} {printErr\( \)} {printErr(\ )} {VxWorks Reference Manual} Libraries {} {}
fdprintf {write a formatted string to a file descriptor} {fdprintf\( \)} {fdprintf(\ )} {VxWorks Reference Manual} Libraries {} {}
sprintf {write a formatted string to a buffer (ANSI)} {sprintf\( \)} {sprintf(\ )} {VxWorks Reference Manual} Libraries {} {}
vprintf {write a string formatted with a variable argument list to standard output (ANSI)} {vprintf\( \)} {vprintf(\ )} {VxWorks Reference Manual} Libraries {} {}
vfdprintf {write a string formatted with a variable argument list to a file descriptor} {vfdprintf\( \)} {vfdprintf(\ )} {VxWorks Reference Manual} Libraries {} {}
vsprintf {write a string formatted with a variable argument list to a buffer (ANSI)} {vsprintf\( \)} {vsprintf(\ )} {VxWorks Reference Manual} Libraries {} {}
fioFormatV {convert a format string} {fioFormatV\( \)} {fioFormatV(\ )} {VxWorks Reference Manual} Libraries {} {}
fioRead {read a buffer} {fioRead\( \)} {fioRead(\ )} {VxWorks Reference Manual} Libraries {} {}
fioRdString {read a string from a file} {fioRdString\( \)} {fioRdString(\ )} {VxWorks Reference Manual} Libraries {} {}
sscanf {read and convert characters from an ASCII string (ANSI)} {sscanf\( \)} {sscanf(\ )} {VxWorks Reference Manual} Libraries {} {}
floatInit {initialize floating-point I/O support} {floatInit\( \)} {floatInit(\ )} {VxWorks Reference Manual} Libraries {} {}
fppInit {initialize floating-point coprocessor support} {fppInit\( \)} {fppInit(\ )} {VxWorks Reference Manual} Libraries {} {}
fppShowInit {initialize the floating-point show facility} {fppShowInit\( \)} {fppShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
fppTaskRegsShow {print the contents of a task's floating-point registers} {fppTaskRegsShow\( \)} {fppTaskRegsShow(\ )} {VxWorks Reference Manual} Libraries {} {}
intContext {determine if the current state is in interrupt or task context} {intContext\( \)} {intContext(\ )} {VxWorks Reference Manual} Libraries {} {}
intCount {get the current interrupt nesting depth} {intCount\( \)} {intCount(\ )} {VxWorks Reference Manual} Libraries {} {}
creat {create a file} {creat\( \)} {creat(\ )} {VxWorks Reference Manual} Libraries {} {}
unlink {delete a file (POSIX)} {unlink\( \)} {unlink(\ )} {VxWorks Reference Manual} Libraries {} {}
remove {remove a file (ANSI)} {remove\( \)} {remove(\ )} {VxWorks Reference Manual} Libraries {} {}
open {open a file} {open\( \)} {open(\ )} {VxWorks Reference Manual} Libraries {} {}
close {close a file} {close\( \)} {close(\ )} {VxWorks Reference Manual} Libraries {} {}
rename {change the name of a file} {rename\( \)} {rename(\ )} {VxWorks Reference Manual} Libraries {} {}
read {read bytes from a file or device} {read\( \)} {read(\ )} {VxWorks Reference Manual} Libraries {} {}
write {write bytes to a file} {write\( \)} {write(\ )} {VxWorks Reference Manual} Libraries {} {}
ioctl {perform an I/O control function} {ioctl\( \)} {ioctl(\ )} {VxWorks Reference Manual} Libraries {} {}
lseek {set a file read/write pointer} {lseek\( \)} {lseek(\ )} {VxWorks Reference Manual} Libraries {} {}
ioDefPathSet {set the current default path} {ioDefPathSet\( \)} {ioDefPathSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ioDefPathGet {get the current default path} {ioDefPathGet\( \)} {ioDefPathGet(\ )} {VxWorks Reference Manual} Libraries {} {}
chdir {set the current default path} {chdir\( \)} {chdir(\ )} {VxWorks Reference Manual} Libraries {} {}
getcwd {get the current default path (POSIX)} {getcwd\( \)} {getcwd(\ )} {VxWorks Reference Manual} Libraries {} {}
getwd {get the current default path} {getwd\( \)} {getwd(\ )} {VxWorks Reference Manual} Libraries {} {}
ioGlobalStdSet {set the file descriptor for global standard input/output/error} {ioGlobalStdSet\( \)} {ioGlobalStdSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ioGlobalStdGet {get the file descriptor for global standard input/output/error} {ioGlobalStdGet\( \)} {ioGlobalStdGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ioTaskStdSet {set the file descriptor for task standard input/output/error} {ioTaskStdSet\( \)} {ioTaskStdSet(\ )} {VxWorks Reference Manual} Libraries {} {}
ioTaskStdGet {get the file descriptor for task standard input/output/error} {ioTaskStdGet\( \)} {ioTaskStdGet(\ )} {VxWorks Reference Manual} Libraries {} {}
isatty {return whether the underlying driver is a tty device} {isatty\( \)} {isatty(\ )} {VxWorks Reference Manual} Libraries {} {}
iosInit {initialize the I/O system} {iosInit\( \)} {iosInit(\ )} {VxWorks Reference Manual} Libraries {} {}
iosDrvInstall {install an I/O driver} {iosDrvInstall\( \)} {iosDrvInstall(\ )} {VxWorks Reference Manual} Libraries {} {}
iosDrvRemove {remove an I/O driver} {iosDrvRemove\( \)} {iosDrvRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
iosDevAdd {add a device to the I/O system} {iosDevAdd\( \)} {iosDevAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
iosDevDelete {delete a device from the I/O system} {iosDevDelete\( \)} {iosDevDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
iosDevFind {find an I/O device in the device list} {iosDevFind\( \)} {iosDevFind(\ )} {VxWorks Reference Manual} Libraries {} {}
iosFdValue {validate an open file descriptor and return the driver-specific value} {iosFdValue\( \)} {iosFdValue(\ )} {VxWorks Reference Manual} Libraries {} {}
iosShowInit {initialize the I/O system show facility} {iosShowInit\( \)} {iosShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
iosDrvShow {display a list of system drivers} {iosDrvShow\( \)} {iosDrvShow(\ )} {VxWorks Reference Manual} Libraries {} {}
iosDevShow {display the list of devices in the system} {iosDevShow\( \)} {iosDevShow(\ )} {VxWorks Reference Manual} Libraries {} {}
iosFdShow {display a list of file descriptor names in the system} {iosFdShow\( \)} {iosFdShow(\ )} {VxWorks Reference Manual} Libraries {} {}
logInit {initialize message logging library} {logInit\( \)} {logInit(\ )} {VxWorks Reference Manual} Libraries {} {}
logMsg {log a formatted error message} {logMsg\( \)} {logMsg(\ )} {VxWorks Reference Manual} Libraries {} {}
logFdSet {set the primary logging file descriptor} {logFdSet\( \)} {logFdSet(\ )} {VxWorks Reference Manual} Libraries {} {}
logFdAdd {add a logging file descriptor} {logFdAdd\( \)} {logFdAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
logFdDelete {delete a logging file descriptor} {logFdDelete\( \)} {logFdDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
logTask {message-logging support task} {logTask\( \)} {logTask(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartOptionsSet {set the debug options for a memory partition} {memPartOptionsSet\( \)} {memPartOptionsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
memalign {allocate aligned memory } {memalign\( \)} {memalign(\ )} {VxWorks Reference Manual} Libraries {} {}
valloc {allocate memory on a page boundary } {valloc\( \)} {valloc(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartRealloc {reallocate a block of memory in a specified partition} {memPartRealloc\( \)} {memPartRealloc(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartFindMax {find the size of the largest available free block} {memPartFindMax\( \)} {memPartFindMax(\ )} {VxWorks Reference Manual} Libraries {} {}
memOptionsSet {set the debug options for the system memory partition} {memOptionsSet\( \)} {memOptionsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
calloc {allocate space for an array (ANSI)} {calloc\( \)} {calloc(\ )} {VxWorks Reference Manual} Libraries {} {}
realloc {reallocate a block of memory (ANSI)} {realloc\( \)} {realloc(\ )} {VxWorks Reference Manual} Libraries {} {}
cfree {free a block of memory} {cfree\( \)} {cfree(\ )} {VxWorks Reference Manual} Libraries {} {}
memFindMax {find the largest free block in the system memory partition} {memFindMax\( \)} {memFindMax(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartCreate {create a memory partition} {memPartCreate\( \)} {memPartCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartAddToPool {add memory to a memory partition} {memPartAddToPool\( \)} {memPartAddToPool(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartAlignedAlloc {allocate aligned memory from a partition} {memPartAlignedAlloc\( \)} {memPartAlignedAlloc(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartAlloc {allocate a block of memory from a partition} {memPartAlloc\( \)} {memPartAlloc(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartFree {free a block of memory in a partition} {memPartFree\( \)} {memPartFree(\ )} {VxWorks Reference Manual} Libraries {} {}
memAddToPool {add memory to the system memory partition} {memAddToPool\( \)} {memAddToPool(\ )} {VxWorks Reference Manual} Libraries {} {}
malloc {allocate a block of memory from the system memory partition (ANSI)} {malloc\( \)} {malloc(\ )} {VxWorks Reference Manual} Libraries {} {}
free {free a block of memory (ANSI)} {free\( \)} {free(\ )} {VxWorks Reference Manual} Libraries {} {}
memShowInit {initialize the memory partition show facility} {memShowInit\( \)} {memShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
memShow {show system memory partition blocks and statistics} {memShow\( \)} {memShow(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartShow {show partition blocks and statistics} {memPartShow\( \)} {memPartShow(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartInfoGet {get partition information} {memPartInfoGet\( \)} {memPartInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
ntPassFsDevInit {associate a device with ntPassFs file system functions} {ntPassFsDevInit\( \)} {ntPassFsDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ntPassFsInit {prepare to use the ntPassFs library} {ntPassFsInit\( \)} {ntPassFsInit(\ )} {VxWorks Reference Manual} Libraries {} {}
pipeDrv {initialize the pipe driver} {pipeDrv\( \)} {pipeDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
pipeDevCreate {create a pipe device} {pipeDevCreate\( \)} {pipeDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
ptyDrv {initialize the pseudo-terminal driver} {ptyDrv\( \)} {ptyDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
ptyDevCreate {create a pseudo terminal} {ptyDevCreate\( \)} {ptyDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
ptyDevRemove {destroy a pseudo terminal} {ptyDevRemove\( \)} {ptyDevRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
reboot {reset network devices and transfer control to boot ROMs} {reboot\( \)} {reboot(\ )} {VxWorks Reference Manual} Libraries {} {}
rebootHookAdd {add a routine to be called at reboot} {rebootHookAdd\( \)} {rebootHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
rt11FsDevInit {initialize the rt11Fs device descriptor} {rt11FsDevInit\( \)} {rt11FsDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
rt11FsInit {prepare to use the rt11Fs library} {rt11FsInit\( \)} {rt11FsInit(\ )} {VxWorks Reference Manual} Libraries {} {}
rt11FsMkfs {initialize a device and create an rt11Fs file system} {rt11FsMkfs\( \)} {rt11FsMkfs(\ )} {VxWorks Reference Manual} Libraries {} {}
rt11FsDateSet {set the rt11Fs file system date} {rt11FsDateSet\( \)} {rt11FsDateSet(\ )} {VxWorks Reference Manual} Libraries {} {}
rt11FsReadyChange {notify rt11Fs of a change in ready status} {rt11FsReadyChange\( \)} {rt11FsReadyChange(\ )} {VxWorks Reference Manual} Libraries {} {}
rt11FsModeChange {modify the mode of an rt11Fs volume} {rt11FsModeChange\( \)} {rt11FsModeChange(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiPhysDevDelete {delete a SCSI physical-device structure} {scsiPhysDevDelete\( \)} {scsiPhysDevDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiPhysDevCreate {create a SCSI physical device structure} {scsiPhysDevCreate\( \)} {scsiPhysDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiPhysDevIdGet {return a pointer to a SCSI_PHYS_DEV structure} {scsiPhysDevIdGet\( \)} {scsiPhysDevIdGet(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiAutoConfig {configure all devices connected to a SCSI controller} {scsiAutoConfig\( \)} {scsiAutoConfig(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiShow {list the physical devices attached to a SCSI controller} {scsiShow\( \)} {scsiShow(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiBlkDevCreate {define a logical partition on a SCSI block device} {scsiBlkDevCreate\( \)} {scsiBlkDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiBlkDevInit {initialize fields in a SCSI logical partition} {scsiBlkDevInit\( \)} {scsiBlkDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiBlkDevShow {show the BLK_DEV structures on a specified physical device} {scsiBlkDevShow\( \)} {scsiBlkDevShow(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiBusReset {pulse the reset signal on the SCSI bus} {scsiBusReset\( \)} {scsiBusReset(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiIoctl {perform a device-specific I/O control function} {scsiIoctl\( \)} {scsiIoctl(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiFormatUnit {issue a FORMAT_UNIT command to a SCSI device} {scsiFormatUnit\( \)} {scsiFormatUnit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiModeSelect {issue a MODE_SELECT command to a SCSI device} {scsiModeSelect\( \)} {scsiModeSelect(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiModeSense {issue a MODE_SENSE command to a SCSI device} {scsiModeSense\( \)} {scsiModeSense(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiReadCapacity {issue a READ_CAPACITY command to a SCSI device} {scsiReadCapacity\( \)} {scsiReadCapacity(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiRdSecs {read sector(s) from a SCSI block device} {scsiRdSecs\( \)} {scsiRdSecs(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiWrtSecs {write sector(s) to a SCSI block device} {scsiWrtSecs\( \)} {scsiWrtSecs(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiTestUnitRdy {issue a TEST_UNIT_READY command to a SCSI device} {scsiTestUnitRdy\( \)} {scsiTestUnitRdy(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiInquiry {issue an INQUIRY command to a SCSI device} {scsiInquiry\( \)} {scsiInquiry(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiReqSense {issue a REQUEST_SENSE command to a SCSI device and read results} {scsiReqSense\( \)} {scsiReqSense(\ )} {VxWorks Reference Manual} Libraries {} {}
cdromFsInit {initialize cdromFsLib} {cdromFsInit\( \)} {cdromFsInit(\ )} {VxWorks Reference Manual} Libraries {} {}
cdromFsVolConfigShow {show the volume configuration information} {cdromFsVolConfigShow\( \)} {cdromFsVolConfigShow(\ )} {VxWorks Reference Manual} Libraries {} {}
cdromFsDevCreate {create a cdromFsLib device} {cdromFsDevCreate\( \)} {cdromFsDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
scsi2IfInit {initialize the SCSI-2 interface to scsiLib} {scsi2IfInit\( \)} {scsi2IfInit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiTargetOptionsSet {set options for one or all SCSI targets} {scsiTargetOptionsSet\( \)} {scsiTargetOptionsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiTargetOptionsGet {get options for one or all SCSI targets} {scsiTargetOptionsGet\( \)} {scsiTargetOptionsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiPhysDevShow {show status information for a physical device} {scsiPhysDevShow\( \)} {scsiPhysDevShow(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiCacheSynchronize {synchronize the caches for data coherency} {scsiCacheSynchronize\( \)} {scsiCacheSynchronize(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiIdentMsgBuild {build an identification message} {scsiIdentMsgBuild\( \)} {scsiIdentMsgBuild(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiIdentMsgParse {parse an identification message} {scsiIdentMsgParse\( \)} {scsiIdentMsgParse(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMsgOutComplete {perform post-processing after a SCSI message is sent} {scsiMsgOutComplete\( \)} {scsiMsgOutComplete(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMsgOutReject {perform post-processing when an outgoing message is rejected} {scsiMsgOutReject\( \)} {scsiMsgOutReject(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMsgInComplete {handle a complete SCSI message received from the target} {scsiMsgInComplete\( \)} {scsiMsgInComplete(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiSyncXferNegotiate {initiate or continue negotiating transfer parameters} {scsiSyncXferNegotiate\( \)} {scsiSyncXferNegotiate(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiWideXferNegotiate {initiate or continue negotiating wide parameters} {scsiWideXferNegotiate\( \)} {scsiWideXferNegotiate(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiThreadInit {perform generic SCSI thread initialization} {scsiThreadInit\( \)} {scsiThreadInit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiCacheSnoopEnable {inform SCSI that hardware snooping of caches is enabled} {scsiCacheSnoopEnable\( \)} {scsiCacheSnoopEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiCacheSnoopDisable {inform SCSI that hardware snooping of caches is disabled} {scsiCacheSnoopDisable\( \)} {scsiCacheSnoopDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiStartStopUnit {issue a START_STOP_UNIT command to a SCSI device} {scsiStartStopUnit\( \)} {scsiStartStopUnit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiReserve {issue a RESERVE command to a SCSI device} {scsiReserve\( \)} {scsiReserve(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiRelease {issue a RELEASE command to a SCSI device} {scsiRelease\( \)} {scsiRelease(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiSeqDevCreate {create a SCSI sequential device} {scsiSeqDevCreate\( \)} {scsiSeqDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiErase {issue an ERASE command to a SCSI device} {scsiErase\( \)} {scsiErase(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiTapeModeSelect {issue a MODE_SELECT command to a SCSI tape device} {scsiTapeModeSelect\( \)} {scsiTapeModeSelect(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiTapeModeSense {issue a MODE_SENSE command to a SCSI tape device} {scsiTapeModeSense\( \)} {scsiTapeModeSense(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiSeqReadBlockLimits {issue a READ_BLOCK_LIMITS command to a SCSI device} {scsiSeqReadBlockLimits\( \)} {scsiSeqReadBlockLimits(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiRdTape {read bytes or blocks from a SCSI tape device} {scsiRdTape\( \)} {scsiRdTape(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiWrtTape {write data to a SCSI tape device} {scsiWrtTape\( \)} {scsiWrtTape(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiRewind {issue a REWIND command to a SCSI device} {scsiRewind\( \)} {scsiRewind(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiReserveUnit {issue a RESERVE UNIT command to a SCSI device} {scsiReserveUnit\( \)} {scsiReserveUnit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiReleaseUnit {issue a RELEASE UNIT command to a SCSI device} {scsiReleaseUnit\( \)} {scsiReleaseUnit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiLoadUnit {issue a LOAD/UNLOAD command to a SCSI device} {scsiLoadUnit\( \)} {scsiLoadUnit(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiWrtFileMarks {write file marks to a SCSI sequential device} {scsiWrtFileMarks\( \)} {scsiWrtFileMarks(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiSpace {move the tape on a specified physical SCSI device} {scsiSpace\( \)} {scsiSpace(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiSeqStatusCheck {detect a change in media} {scsiSeqStatusCheck\( \)} {scsiSeqStatusCheck(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiSeqIoctl {perform an I/O control function for sequential access devices} {scsiSeqIoctl\( \)} {scsiSeqIoctl(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMgrEventNotify {notify the SCSI manager of a SCSI (controller) event} {scsiMgrEventNotify\( \)} {scsiMgrEventNotify(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMgrBusReset {handle a controller-bus reset event } {scsiMgrBusReset\( \)} {scsiMgrBusReset(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMgrCtrlEvent {send an event to the SCSI controller state machine} {scsiMgrCtrlEvent\( \)} {scsiMgrCtrlEvent(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMgrThreadEvent {send an event to the thread state machine} {scsiMgrThreadEvent\( \)} {scsiMgrThreadEvent(\ )} {VxWorks Reference Manual} Libraries {} {}
scsiMgrShow {show status information for the SCSI manager} {scsiMgrShow\( \)} {scsiMgrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
selectInit {initialize the select facility} {selectInit\( \)} {selectInit(\ )} {VxWorks Reference Manual} Libraries {} {}
select {pend on a set of file descriptors} {select\( \)} {select(\ )} {VxWorks Reference Manual} Libraries {} {}
selWakeup {wake up a task pended in select()} {selWakeup\( \)} {selWakeup(\ )} {VxWorks Reference Manual} Libraries {} {}
selWakeupAll {wake up all tasks in a select() wake-up list} {selWakeupAll\( \)} {selWakeupAll(\ )} {VxWorks Reference Manual} Libraries {} {}
selNodeAdd {add a wake-up node to a select() wake-up list} {selNodeAdd\( \)} {selNodeAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
selNodeDelete {find and delete a node from a select() wake-up list} {selNodeDelete\( \)} {selNodeDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
selWakeupListInit {initialize a select() wake-up list} {selWakeupListInit\( \)} {selWakeupListInit(\ )} {VxWorks Reference Manual} Libraries {} {}
selWakeupListLen {get the number of nodes in a select() wake-up list} {selWakeupListLen\( \)} {selWakeupListLen(\ )} {VxWorks Reference Manual} Libraries {} {}
selWakeupType {get the type of a select() wake-up node} {selWakeupType\( \)} {selWakeupType(\ )} {VxWorks Reference Manual} Libraries {} {}
sigInit {initialize the signal facilities} {sigInit\( \)} {sigInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sigqueueInit {initialize the queued signal facilities} {sigqueueInit\( \)} {sigqueueInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sigemptyset {initialize a signal set with no signals included (POSIX)} {sigemptyset\( \)} {sigemptyset(\ )} {VxWorks Reference Manual} Libraries {} {}
sigfillset {initialize a signal set with all signals included (POSIX)} {sigfillset\( \)} {sigfillset(\ )} {VxWorks Reference Manual} Libraries {} {}
sigaddset {add a signal to a signal set (POSIX)} {sigaddset\( \)} {sigaddset(\ )} {VxWorks Reference Manual} Libraries {} {}
sigdelset {delete a signal from a signal set (POSIX)} {sigdelset\( \)} {sigdelset(\ )} {VxWorks Reference Manual} Libraries {} {}
sigismember {test to see if a signal is in a signal set (POSIX)} {sigismember\( \)} {sigismember(\ )} {VxWorks Reference Manual} Libraries {} {}
signal {specify the handler associated with a signal} {signal\( \)} {signal(\ )} {VxWorks Reference Manual} Libraries {} {}
sigaction {examine and/or specify the action associated with a signal (POSIX)} {sigaction\( \)} {sigaction(\ )} {VxWorks Reference Manual} Libraries {} {}
sigprocmask {examine and/or change the signal mask (POSIX)} {sigprocmask\( \)} {sigprocmask(\ )} {VxWorks Reference Manual} Libraries {} {}
sigpending {retrieve the set of pending signals blocked from delivery (POSIX)} {sigpending\( \)} {sigpending(\ )} {VxWorks Reference Manual} Libraries {} {}
sigsuspend {suspend the task until delivery of a signal (POSIX)} {sigsuspend\( \)} {sigsuspend(\ )} {VxWorks Reference Manual} Libraries {} {}
pause {suspend the task until delivery of a signal (POSIX)} {pause\( \)} {pause(\ )} {VxWorks Reference Manual} Libraries {} {}
sigtimedwait {wait for a signal} {sigtimedwait\( \)} {sigtimedwait(\ )} {VxWorks Reference Manual} Libraries {} {}
sigwaitinfo {wait for real-time signals} {sigwaitinfo\( \)} {sigwaitinfo(\ )} {VxWorks Reference Manual} Libraries {} {}
sigvec {install a signal handler} {sigvec\( \)} {sigvec(\ )} {VxWorks Reference Manual} Libraries {} {}
sigsetmask {set the signal mask} {sigsetmask\( \)} {sigsetmask(\ )} {VxWorks Reference Manual} Libraries {} {}
sigblock {add to a set of blocked signals} {sigblock\( \)} {sigblock(\ )} {VxWorks Reference Manual} Libraries {} {}
raise {send a signal to the caller's task} {raise\( \)} {raise(\ )} {VxWorks Reference Manual} Libraries {} {}
kill {send a signal to a task (POSIX)} {kill\( \)} {kill(\ )} {VxWorks Reference Manual} Libraries {} {}
sigqueue {send a queued signal to a task} {sigqueue\( \)} {sigqueue(\ )} {VxWorks Reference Manual} Libraries {} {}
memPartSmCreate {create a shared memory partition (VxMP Option)} {memPartSmCreate\( \)} {memPartSmCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemAddToPool {add memory to the shared memory system partition (VxMP Option)} {smMemAddToPool\( \)} {smMemAddToPool(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemOptionsSet {set the debug options for the shared memory system partition (VxMP Option)} {smMemOptionsSet\( \)} {smMemOptionsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemMalloc {allocate a block of memory from the shared memory system partition (VxMP Option)} {smMemMalloc\( \)} {smMemMalloc(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemCalloc {allocate memory for an array from the shared memory system partition (VxMP Option)} {smMemCalloc\( \)} {smMemCalloc(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemRealloc {reallocate a block of memory from the shared memory system partition (VxMP Option)} {smMemRealloc\( \)} {smMemRealloc(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemFree {free a shared memory system partition block of memory (VxMP Option)} {smMemFree\( \)} {smMemFree(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemFindMax {find the largest free block in the shared memory system partition (VxMP Option)} {smMemFindMax\( \)} {smMemFindMax(\ )} {VxWorks Reference Manual} Libraries {} {}
smMemShow {show the shared memory system partition blocks and statistics (VxMP Option)} {smMemShow\( \)} {smMemShow(\ )} {VxWorks Reference Manual} Libraries {} {}
smNameAdd {add a name to the shared memory name database (VxMP Option)} {smNameAdd\( \)} {smNameAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
smNameFind {look up a shared memory object by name (VxMP Option)} {smNameFind\( \)} {smNameFind(\ )} {VxWorks Reference Manual} Libraries {} {}
smNameFindByValue {look up a shared memory object by value (VxMP Option)} {smNameFindByValue\( \)} {smNameFindByValue(\ )} {VxWorks Reference Manual} Libraries {} {}
smNameRemove {remove an object from the shared memory objects name database (VxMP Option)} {smNameRemove\( \)} {smNameRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
smNameShow {show the contents of the shared memory objects name database (VxMP Option)} {smNameShow\( \)} {smNameShow(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjLibInit {install the shared memory objects facility (VxMP Option)} {smObjLibInit\( \)} {smObjLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjSetup {initialize the shared memory objects facility (VxMP Option)} {smObjSetup\( \)} {smObjSetup(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjInit {initialize a shared memory objects descriptor (VxMP Option)} {smObjInit\( \)} {smObjInit(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjAttach {attach the calling CPU to the shared memory objects facility (VxMP Option)} {smObjAttach\( \)} {smObjAttach(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjLocalToGlobal {convert a local address to a global address (VxMP Option)} {smObjLocalToGlobal\( \)} {smObjLocalToGlobal(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjGlobalToLocal {convert a global address to a local address (VxMP Option)} {smObjGlobalToLocal\( \)} {smObjGlobalToLocal(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjTimeoutLogEnable {enable/disable logging of failed attempts to take a spin-lock (VxMP Option)} {smObjTimeoutLogEnable\( \)} {smObjTimeoutLogEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
smObjShow {display the current status of shared memory objects (VxMP Option)} {smObjShow\( \)} {smObjShow(\ )} {VxWorks Reference Manual} Libraries {} {}
symLibInit {initialize the symbol table library} {symLibInit\( \)} {symLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
symTblCreate {create a symbol table} {symTblCreate\( \)} {symTblCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
symTblDelete {delete a symbol table} {symTblDelete\( \)} {symTblDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
symAdd {create and add a symbol to a symbol table, including a group number} {symAdd\( \)} {symAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
symRemove {remove a symbol from a symbol table} {symRemove\( \)} {symRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
symFindByName {look up a symbol by name} {symFindByName\( \)} {symFindByName(\ )} {VxWorks Reference Manual} Libraries {} {}
symFindByNameAndType {look up a symbol by name and type} {symFindByNameAndType\( \)} {symFindByNameAndType(\ )} {VxWorks Reference Manual} Libraries {} {}
symFindByValue {look up a symbol by value} {symFindByValue\( \)} {symFindByValue(\ )} {VxWorks Reference Manual} Libraries {} {}
symFindByValueAndType {look up a symbol by value and type} {symFindByValueAndType\( \)} {symFindByValueAndType(\ )} {VxWorks Reference Manual} Libraries {} {}
symEach {call a routine to examine each entry in a symbol table} {symEach\( \)} {symEach(\ )} {VxWorks Reference Manual} Libraries {} {}
taskHookInit {initialize task hook facilities} {taskHookInit\( \)} {taskHookInit(\ )} {VxWorks Reference Manual} Libraries {} {}
taskCreateHookAdd {add a routine to be called at every task create} {taskCreateHookAdd\( \)} {taskCreateHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
taskCreateHookDelete {delete a previously added task create routine} {taskCreateHookDelete\( \)} {taskCreateHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSwitchHookAdd {add a routine to be called at every task switch} {taskSwitchHookAdd\( \)} {taskSwitchHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSwitchHookDelete {delete a previously added task switch routine} {taskSwitchHookDelete\( \)} {taskSwitchHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
taskDeleteHookAdd {add a routine to be called at every task delete} {taskDeleteHookAdd\( \)} {taskDeleteHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
taskDeleteHookDelete {delete a previously added task delete routine} {taskDeleteHookDelete\( \)} {taskDeleteHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
taskHookShowInit {initialize the task hook show facility} {taskHookShowInit\( \)} {taskHookShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
taskCreateHookShow {show the list of task create routines} {taskCreateHookShow\( \)} {taskCreateHookShow(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSwitchHookShow {show the list of task switch routines} {taskSwitchHookShow\( \)} {taskSwitchHookShow(\ )} {VxWorks Reference Manual} Libraries {} {}
taskDeleteHookShow {show the list of task delete routines} {taskDeleteHookShow\( \)} {taskDeleteHookShow(\ )} {VxWorks Reference Manual} Libraries {} {}
tapeFsDevInit {associate a sequential device with tape volume functions} {tapeFsDevInit\( \)} {tapeFsDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tapeFsInit {initialize the tape volume library} {tapeFsInit\( \)} {tapeFsInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tapeFsReadyChange {notify tapeFsLib of a change in ready status} {tapeFsReadyChange\( \)} {tapeFsReadyChange(\ )} {VxWorks Reference Manual} Libraries {} {}
tapeFsVolUnmount {disable a tape device volume} {tapeFsVolUnmount\( \)} {tapeFsVolUnmount(\ )} {VxWorks Reference Manual} Libraries {} {}
taskVarInit {initialize the task variables facility} {taskVarInit\( \)} {taskVarInit(\ )} {VxWorks Reference Manual} Libraries {} {}
taskVarAdd {add a task variable to a task} {taskVarAdd\( \)} {taskVarAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
taskVarDelete {remove a task variable from a task} {taskVarDelete\( \)} {taskVarDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
taskVarGet {get the value of a task variable} {taskVarGet\( \)} {taskVarGet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskVarSet {set the value of a task variable} {taskVarSet\( \)} {taskVarSet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskVarInfo {get a list of task variables of a task} {taskVarInfo\( \)} {taskVarInfo(\ )} {VxWorks Reference Manual} Libraries {} {}
timer_cancel {cancel a timer} {timer_cancel\( \)} {timer_cancel(\ )} {VxWorks Reference Manual} Libraries {} {}
timer_connect {connect a user routine to the timer signal} {timer_connect\( \)} {timer_connect(\ )} {VxWorks Reference Manual} Libraries {} {}
timer_create {allocate a timer using the specified clock for a timing base (POSIX)} {timer_create\( \)} {timer_create(\ )} {VxWorks Reference Manual} Libraries {} {}
timer_delete {remove a previously created timer (POSIX)} {timer_delete\( \)} {timer_delete(\ )} {VxWorks Reference Manual} Libraries {} {}
timer_gettime {get the remaining time before expiration and the reload value (POSIX)} {timer_gettime\( \)} {timer_gettime(\ )} {VxWorks Reference Manual} Libraries {} {}
timer_getoverrun {return the timer expiration overrun (POSIX)} {timer_getoverrun\( \)} {timer_getoverrun(\ )} {VxWorks Reference Manual} Libraries {} {}
timer_settime {set the time until the next expiration and arm timer (POSIX)} {timer_settime\( \)} {timer_settime(\ )} {VxWorks Reference Manual} Libraries {} {}
nanosleep {suspend the current task until the time interval elapses (POSIX)} {nanosleep\( \)} {nanosleep(\ )} {VxWorks Reference Manual} Libraries {} {}
tyDevInit {initialize the tty device descriptor} {tyDevInit\( \)} {tyDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tyDevRemove {remove the tty device descriptor} {tyDevRemove\( \)} {tyDevRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
tyAbortFuncSet {set the abort function} {tyAbortFuncSet\( \)} {tyAbortFuncSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tyAbortSet {change the abort character} {tyAbortSet\( \)} {tyAbortSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tyBackspaceSet {change the backspace character} {tyBackspaceSet\( \)} {tyBackspaceSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tyDeleteLineSet {change the line-delete character} {tyDeleteLineSet\( \)} {tyDeleteLineSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tyEOFSet {change the end-of-file character} {tyEOFSet\( \)} {tyEOFSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tyMonitorTrapSet {change the trap-to-monitor character} {tyMonitorTrapSet\( \)} {tyMonitorTrapSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tyIoctl {handle device control requests} {tyIoctl\( \)} {tyIoctl(\ )} {VxWorks Reference Manual} Libraries {} {}
tyWrite {do a task-level write for a tty device} {tyWrite\( \)} {tyWrite(\ )} {VxWorks Reference Manual} Libraries {} {}
tyRead {do a task-level read for a tty device} {tyRead\( \)} {tyRead(\ )} {VxWorks Reference Manual} Libraries {} {}
tyITx {interrupt-level output} {tyITx\( \)} {tyITx(\ )} {VxWorks Reference Manual} Libraries {} {}
tyIRd {interrupt-level input} {tyIRd\( \)} {tyIRd(\ )} {VxWorks Reference Manual} Libraries {} {}
vmBaseLibInit {initialize base virtual memory support} {vmBaseLibInit\( \)} {vmBaseLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
vmBaseGlobalMapInit {initialize global mapping} {vmBaseGlobalMapInit\( \)} {vmBaseGlobalMapInit(\ )} {VxWorks Reference Manual} Libraries {} {}
vmBaseStateSet {change the state of a block of virtual memory} {vmBaseStateSet\( \)} {vmBaseStateSet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmBasePageSizeGet {return the page size} {vmBasePageSizeGet\( \)} {vmBasePageSizeGet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmLibInit {initialize the virtual memory support module (VxVMI Option)} {vmLibInit\( \)} {vmLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
vmGlobalMapInit {initialize global mapping (VxVMI Option)} {vmGlobalMapInit\( \)} {vmGlobalMapInit(\ )} {VxWorks Reference Manual} Libraries {} {}
vmContextCreate {create a new virtual memory context (VxVMI Option)} {vmContextCreate\( \)} {vmContextCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
vmContextDelete {delete a virtual memory context (VxVMI Option)} {vmContextDelete\( \)} {vmContextDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
vmStateSet {change the state of a block of virtual memory (VxVMI Option)} {vmStateSet\( \)} {vmStateSet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmStateGet {get the state of a page of virtual memory (VxVMI Option)} {vmStateGet\( \)} {vmStateGet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmMap {map physical space into virtual space (VxVMI Option)} {vmMap\( \)} {vmMap(\ )} {VxWorks Reference Manual} Libraries {} {}
vmGlobalMap {map physical pages to virtual space in shared global virtual memory (VxVMI Option)} {vmGlobalMap\( \)} {vmGlobalMap(\ )} {VxWorks Reference Manual} Libraries {} {}
vmGlobalInfoGet {get global virtual memory information (VxVMI Option)} {vmGlobalInfoGet\( \)} {vmGlobalInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmPageBlockSizeGet {get the architecture-dependent page block size (VxVMI Option)} {vmPageBlockSizeGet\( \)} {vmPageBlockSizeGet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmTranslate {translate a virtual address to a physical address (VxVMI Option)} {vmTranslate\( \)} {vmTranslate(\ )} {VxWorks Reference Manual} Libraries {} {}
vmPageSizeGet {return the page size (VxVMI Option)} {vmPageSizeGet\( \)} {vmPageSizeGet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmCurrentGet {get the current virtual memory context (VxVMI Option)} {vmCurrentGet\( \)} {vmCurrentGet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmCurrentSet {set the current virtual memory context (VxVMI Option)} {vmCurrentSet\( \)} {vmCurrentSet(\ )} {VxWorks Reference Manual} Libraries {} {}
vmEnable {enable or disable virtual memory (VxVMI Option)} {vmEnable\( \)} {vmEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
vmTextProtect {write-protect a text segment (VxVMI Option)} {vmTextProtect\( \)} {vmTextProtect(\ )} {VxWorks Reference Manual} Libraries {} {}
vmShowInit {include virtual memory show facility (VxVMI Option)} {vmShowInit\( \)} {vmShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
vmContextShow {display the translation table for a context (VxVMI Option)} {vmContextShow\( \)} {vmContextShow(\ )} {VxWorks Reference Manual} Libraries {} {}
passFsDevInit {associate a device with passFs file system functions} {passFsDevInit\( \)} {passFsDevInit(\ )} {VxWorks Reference Manual} Libraries {} {}
passFsInit {prepare to use the passFs library} {passFsInit\( \)} {passFsInit(\ )} {VxWorks Reference Manual} Libraries {} {}
unixDrv {install UNIX disk driver} {unixDrv\( \)} {unixDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
unixDiskDevCreate {create a UNIX disk device} {unixDiskDevCreate\( \)} {unixDiskDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
unixDiskInit {initialize a dosFs disk on top of UNIX} {unixDiskInit\( \)} {unixDiskInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ttyDrv {initialize the tty driver} {ttyDrv\( \)} {ttyDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
ttyDevCreate {create a VxWorks device for a serial channel} {ttyDevCreate\( \)} {ttyDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
ledOpen {create a new line-editor ID} {ledOpen\( \)} {ledOpen(\ )} {VxWorks Reference Manual} Libraries {} {}
ledClose {discard the line-editor ID} {ledClose\( \)} {ledClose(\ )} {VxWorks Reference Manual} Libraries {} {}
ledRead {read a line with line-editing} {ledRead\( \)} {ledRead(\ )} {VxWorks Reference Manual} Libraries {} {}
ledControl {change the line-editor ID parameters} {ledControl\( \)} {ledControl(\ )} {VxWorks Reference Manual} Libraries {} {}
loadModule {load an object module into memory} {loadModule\( \)} {loadModule(\ )} {VxWorks Reference Manual} Libraries {} {}
loadModuleAt {load an object module into memory} {loadModuleAt\( \)} {loadModuleAt(\ )} {VxWorks Reference Manual} Libraries {} {}
loginInit {initialize the login table} {loginInit\( \)} {loginInit(\ )} {VxWorks Reference Manual} Libraries {} {}
loginUserAdd {add a user to the login table} {loginUserAdd\( \)} {loginUserAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
loginUserDelete {delete a user entry from the login table} {loginUserDelete\( \)} {loginUserDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
loginUserVerify {verify a user name and password in the login table} {loginUserVerify\( \)} {loginUserVerify(\ )} {VxWorks Reference Manual} Libraries {} {}
loginUserShow {display the user login table} {loginUserShow\( \)} {loginUserShow(\ )} {VxWorks Reference Manual} Libraries {} {}
loginPrompt {display a login prompt and validate a user entry} {loginPrompt\( \)} {loginPrompt(\ )} {VxWorks Reference Manual} Libraries {} {}
loginStringSet {change the login string} {loginStringSet\( \)} {loginStringSet(\ )} {VxWorks Reference Manual} Libraries {} {}
loginEncryptInstall {install an encryption routine} {loginEncryptInstall\( \)} {loginEncryptInstall(\ )} {VxWorks Reference Manual} Libraries {} {}
loginDefaultEncrypt {default password encryption routine} {loginDefaultEncrypt\( \)} {loginDefaultEncrypt(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleCreate {create and initialize a module} {moduleCreate\( \)} {moduleCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleDelete {delete module ID information (use unld() to reclaim space)} {moduleDelete\( \)} {moduleDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleShow {show the current status for all the loaded modules} {moduleShow\( \)} {moduleShow(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleSegGet {get (delete and return) the first segment from a module} {moduleSegGet\( \)} {moduleSegGet(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleSegFirst {find the first segment in a module} {moduleSegFirst\( \)} {moduleSegFirst(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleSegNext {find the next segment in a module} {moduleSegNext\( \)} {moduleSegNext(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleCreateHookAdd {add a routine to be called when a module is added} {moduleCreateHookAdd\( \)} {moduleCreateHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleCreateHookDelete {delete a previously added module create hook routine} {moduleCreateHookDelete\( \)} {moduleCreateHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleFindByName {find a module by name} {moduleFindByName\( \)} {moduleFindByName(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleFindByNameAndPath {find a module by file name and path} {moduleFindByNameAndPath\( \)} {moduleFindByNameAndPath(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleFindByGroup {find a module by group number} {moduleFindByGroup\( \)} {moduleFindByGroup(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleIdListGet {get a list of loaded modules} {moduleIdListGet\( \)} {moduleIdListGet(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleInfoGet {get information about an object module} {moduleInfoGet\( \)} {moduleInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleCheck {verify checksums on all modules} {moduleCheck\( \)} {moduleCheck(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleNameGet {get the name associated with a module ID} {moduleNameGet\( \)} {moduleNameGet(\ )} {VxWorks Reference Manual} Libraries {} {}
moduleFlagsGet {get the flags associated with a module ID} {moduleFlagsGet\( \)} {moduleFlagsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
shellInit {start the shell} {shellInit\( \)} {shellInit(\ )} {VxWorks Reference Manual} Libraries {} {}
shell {the shell entry point} {shell\( \)} {shell(\ )} {VxWorks Reference Manual} Libraries {} {}
shellScriptAbort {signal the shell to stop processing a script} {shellScriptAbort\( \)} {shellScriptAbort(\ )} {VxWorks Reference Manual} Libraries {} {}
shellHistory {display or set the size of shell history} {shellHistory\( \)} {shellHistory(\ )} {VxWorks Reference Manual} Libraries {} {}
shellPromptSet {change the shell prompt} {shellPromptSet\( \)} {shellPromptSet(\ )} {VxWorks Reference Manual} Libraries {} {}
shellOrigStdSet {set the shell's default input/output/error file descriptors} {shellOrigStdSet\( \)} {shellOrigStdSet(\ )} {VxWorks Reference Manual} Libraries {} {}
shellLock {lock access to the shell} {shellLock\( \)} {shellLock(\ )} {VxWorks Reference Manual} Libraries {} {}
spyLibInit {initialize task cpu utilization tool package} {spyLibInit\( \)} {spyLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
timexInit {include the execution timer library} {timexInit\( \)} {timexInit(\ )} {VxWorks Reference Manual} Libraries {} {}
timexClear {clear the list of function calls to be timed} {timexClear\( \)} {timexClear(\ )} {VxWorks Reference Manual} Libraries {} {}
timexFunc {specify functions to be timed} {timexFunc\( \)} {timexFunc(\ )} {VxWorks Reference Manual} Libraries {} {}
timexHelp {display synopsis of execution timer facilities} {timexHelp\( \)} {timexHelp(\ )} {VxWorks Reference Manual} Libraries {} {}
timex {time a single execution of a function or functions} {timex\( \)} {timex(\ )} {VxWorks Reference Manual} Libraries {} {}
timexN {time repeated executions of a function or group of functions} {timexN\( \)} {timexN(\ )} {VxWorks Reference Manual} Libraries {} {}
timexPost {specify functions to be called after timing} {timexPost\( \)} {timexPost(\ )} {VxWorks Reference Manual} Libraries {} {}
timexPre {specify functions to be called prior to timing} {timexPre\( \)} {timexPre(\ )} {VxWorks Reference Manual} Libraries {} {}
timexShow {display the list of function calls to be timed} {timexShow\( \)} {timexShow(\ )} {VxWorks Reference Manual} Libraries {} {}
unld {unload an object module by specifying a file name or module ID} {unld\( \)} {unld(\ )} {VxWorks Reference Manual} Libraries {} {}
unldByModuleId {unload an object module by specifying a module ID} {unldByModuleId\( \)} {unldByModuleId(\ )} {VxWorks Reference Manual} Libraries {} {}
unldByNameAndPath {unload an object module by specifying a name and path} {unldByNameAndPath\( \)} {unldByNameAndPath(\ )} {VxWorks Reference Manual} Libraries {} {}
unldByGroup {unload an object module by specifying a group number} {unldByGroup\( \)} {unldByGroup(\ )} {VxWorks Reference Manual} Libraries {} {}
reld {reload an object module} {reld\( \)} {reld(\ )} {VxWorks Reference Manual} Libraries {} {}
dbgHelp {display debugging help menu} {dbgHelp\( \)} {dbgHelp(\ )} {VxWorks Reference Manual} Libraries {} {}
dbgInit {initialize the local debugging package} {dbgInit\( \)} {dbgInit(\ )} {VxWorks Reference Manual} Libraries {} {}
b {set or display breakpoints} {b\( \)} {b(\ )} {VxWorks Reference Manual} Libraries {} {}
e {set or display eventpoints (WindView)} {e\( \)} {e(\ )} {VxWorks Reference Manual} Libraries {} {}
bh {set a hardware breakpoint} {bh\( \)} {bh(\ )} {VxWorks Reference Manual} Libraries {} {}
bd {delete a breakpoint} {bd\( \)} {bd(\ )} {VxWorks Reference Manual} Libraries {} {}
bdall {delete all breakpoints} {bdall\( \)} {bdall(\ )} {VxWorks Reference Manual} Libraries {} {}
c {continue from a breakpoint} {c\( \)} {c(\ )} {VxWorks Reference Manual} Libraries {} {}
cret {continue until the current subroutine returns} {cret\( \)} {cret(\ )} {VxWorks Reference Manual} Libraries {} {}
s {single-step a task} {s\( \)} {s(\ )} {VxWorks Reference Manual} Libraries {} {}
so {single-step, but step over a subroutine} {so\( \)} {so(\ )} {VxWorks Reference Manual} Libraries {} {}
l {disassemble and display a specified number of instructions} {l\( \)} {l(\ )} {VxWorks Reference Manual} Libraries {} {}
tt {display a stack trace of a task} {tt\( \)} {tt(\ )} {VxWorks Reference Manual} Libraries {} {}
aioPxLibInit {initialize the asynchronous I/O (AIO) library} {aioPxLibInit\( \)} {aioPxLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
aio_read {initiate an asynchronous read (POSIX)} {aio_read\( \)} {aio_read(\ )} {VxWorks Reference Manual} Libraries {} {}
aio_write {initiate an asynchronous write (POSIX)} {aio_write\( \)} {aio_write(\ )} {VxWorks Reference Manual} Libraries {} {}
lio_listio {initiate a list of asynchronous I/O requests (POSIX)} {lio_listio\( \)} {lio_listio(\ )} {VxWorks Reference Manual} Libraries {} {}
aio_suspend {wait for asynchronous I/O request(s) (POSIX)} {aio_suspend\( \)} {aio_suspend(\ )} {VxWorks Reference Manual} Libraries {} {}
aio_fsync {asynchronous file synchronization (POSIX)} {aio_fsync\( \)} {aio_fsync(\ )} {VxWorks Reference Manual} Libraries {} {}
aio_error {retrieve error status of asynchronous I/O operation (POSIX)} {aio_error\( \)} {aio_error(\ )} {VxWorks Reference Manual} Libraries {} {}
aio_return {retrieve return status of asynchronous I/O operation (POSIX)} {aio_return\( \)} {aio_return(\ )} {VxWorks Reference Manual} Libraries {} {}
aioShow {show AIO requests } {aioShow\( \)} {aioShow(\ )} {VxWorks Reference Manual} Libraries {} {}
aioSysInit {initialize the AIO system driver} {aioSysInit\( \)} {aioSysInit(\ )} {VxWorks Reference Manual} Libraries {} {}
mlockall {lock all pages used by a process into memory (POSIX)} {mlockall\( \)} {mlockall(\ )} {VxWorks Reference Manual} Libraries {} {}
munlockall {unlock all pages used by a process (POSIX)} {munlockall\( \)} {munlockall(\ )} {VxWorks Reference Manual} Libraries {} {}
mlock {lock specified pages into memory (POSIX)} {mlock\( \)} {mlock(\ )} {VxWorks Reference Manual} Libraries {} {}
munlock {unlock specified pages (POSIX)} {munlock\( \)} {munlock(\ )} {VxWorks Reference Manual} Libraries {} {}
mqPxLibInit {initialize the POSIX message queue library} {mqPxLibInit\( \)} {mqPxLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_open {open a message queue (POSIX)} {mq_open\( \)} {mq_open(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_receive {receive a message from a message queue (POSIX)} {mq_receive\( \)} {mq_receive(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_send {send a message to a message queue (POSIX)} {mq_send\( \)} {mq_send(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_close {close a message queue (POSIX)} {mq_close\( \)} {mq_close(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_unlink {remove a message queue (POSIX)} {mq_unlink\( \)} {mq_unlink(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_notify {notify a task that a message is available on a queue (POSIX)} {mq_notify\( \)} {mq_notify(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_setattr {set message queue attributes (POSIX)} {mq_setattr\( \)} {mq_setattr(\ )} {VxWorks Reference Manual} Libraries {} {}
mq_getattr {get message queue attributes (POSIX)} {mq_getattr\( \)} {mq_getattr(\ )} {VxWorks Reference Manual} Libraries {} {}
mqPxShowInit {initialize the POSIX message queue show facility} {mqPxShowInit\( \)} {mqPxShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
semPxShowInit {initialize the POSIX semaphore show facility} {semPxShowInit\( \)} {semPxShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_setparam {set a task's priority (POSIX)} {sched_setparam\( \)} {sched_setparam(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_getparam {get the scheduling parameters for a specified task (POSIX)} {sched_getparam\( \)} {sched_getparam(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_setscheduler {set scheduling policy and scheduling parameters (POSIX)} {sched_setscheduler\( \)} {sched_setscheduler(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_getscheduler {get the current scheduling policy (POSIX)} {sched_getscheduler\( \)} {sched_getscheduler(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_yield {relinquish the CPU (POSIX)} {sched_yield\( \)} {sched_yield(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_get_priority_max {get the maximum priority (POSIX)} {sched_get_priority_max\( \)} {sched_get_priority_max(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_get_priority_min {get the minimum priority (POSIX)} {sched_get_priority_min\( \)} {sched_get_priority_min(\ )} {VxWorks Reference Manual} Libraries {} {}
sched_rr_get_interval {get the current time slice (POSIX)} {sched_rr_get_interval\( \)} {sched_rr_get_interval(\ )} {VxWorks Reference Manual} Libraries {} {}
semPxLibInit {initialize POSIX semaphore support} {semPxLibInit\( \)} {semPxLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_init {initialize an unnamed semaphore (POSIX)} {sem_init\( \)} {sem_init(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_destroy {destroy an unnamed semaphore (POSIX)} {sem_destroy\( \)} {sem_destroy(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_open {initialize/open a named semaphore (POSIX)} {sem_open\( \)} {sem_open(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_close {close a named semaphore (POSIX)} {sem_close\( \)} {sem_close(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_unlink {remove a named semaphore (POSIX)} {sem_unlink\( \)} {sem_unlink(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_wait {lock (take) a semaphore, blocking if not available (POSIX)} {sem_wait\( \)} {sem_wait(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_trywait {lock (take) a semaphore, returning error if unavailable (POSIX)} {sem_trywait\( \)} {sem_trywait(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_post {unlock (give) a semaphore (POSIX)} {sem_post\( \)} {sem_post(\ )} {VxWorks Reference Manual} Libraries {} {}
sem_getvalue {get the value of a semaphore (POSIX)} {sem_getvalue\( \)} {sem_getvalue(\ )} {VxWorks Reference Manual} Libraries {} {}
ftruncate {truncate a file (POSIX)} {ftruncate\( \)} {ftruncate(\ )} {VxWorks Reference Manual} Libraries {} {}
ripLibInit {initialize the RIP routing library} {ripLibInit\( \)} {ripLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
ripRouteShow {display the internal routing table maintained by RIP} {ripRouteShow\( \)} {ripRouteShow(\ )} {VxWorks Reference Manual} Libraries {} {}
ripAuthHookAdd {add an authentication hook to a RIP interface} {ripAuthHookAdd\( \)} {ripAuthHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
ripAuthHookDelete {remove an authentication hook from a RIP interface} {ripAuthHookDelete\( \)} {ripAuthHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
ripAuthHook {sample authentication hook} {ripAuthHook\( \)} {ripAuthHook(\ )} {VxWorks Reference Manual} Libraries {} {}
ripLeakHookAdd {add a hook to bypass the RIP and kernel routing tables} {ripLeakHookAdd\( \)} {ripLeakHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
ripLeakHookDelete {remove a table bypass hook from a RIP interface} {ripLeakHookDelete\( \)} {ripLeakHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
ripSendHookAdd {add an update filter to a RIP interface} {ripSendHookAdd\( \)} {ripSendHookAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
ripSendHookDelete {remove an update filter from a RIP interface} {ripSendHookDelete\( \)} {ripSendHookDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
ripIfSearch {add new interfaces to the internal list} {ripIfSearch\( \)} {ripIfSearch(\ )} {VxWorks Reference Manual} Libraries {} {}
ripIfReset {alter the RIP configuration after an interface changes} {ripIfReset\( \)} {ripIfReset(\ )} {VxWorks Reference Manual} Libraries {} {}
ripFilterEnable {activate strict border gateway filtering} {ripFilterEnable\( \)} {ripFilterEnable(\ )} {VxWorks Reference Manual} Libraries {} {}
ripFilterDisable {prevent strict border gateway filtering} {ripFilterDisable\( \)} {ripFilterDisable(\ )} {VxWorks Reference Manual} Libraries {} {}
ripShutdown {terminate all RIP processing} {ripShutdown\( \)} {ripShutdown(\ )} {VxWorks Reference Manual} Libraries {} {}
ripDebugLevelSet {specify amount of debugging output} {ripDebugLevelSet\( \)} {ripDebugLevelSet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2RipInit {initialize the RIP MIB support} {m2RipInit\( \)} {m2RipInit(\ )} {VxWorks Reference Manual} Libraries {} {}
m2RipDelete {delete the RIP MIB support} {m2RipDelete\( \)} {m2RipDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
m2RipGlobalCountersGet {get MIB-II RIP-group global counters} {m2RipGlobalCountersGet\( \)} {m2RipGlobalCountersGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2RipIfStatEntryGet {get MIB-II RIP-group interface entry} {m2RipIfStatEntryGet\( \)} {m2RipIfStatEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2RipIfConfEntryGet {get MIB-II RIP-group interface entry} {m2RipIfConfEntryGet\( \)} {m2RipIfConfEntryGet(\ )} {VxWorks Reference Manual} Libraries {} {}
m2RipIfConfEntrySet {set MIB-II RIP-group interface entry} {m2RipIfConfEntrySet\( \)} {m2RipIfConfEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdPktProcess {process a packet returned by the transport} {snmpdPktProcess\( \)} {snmpdPktProcess(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdLog {log messages from the SNMP agent } {snmpdLog\( \)} {snmpdLog(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdViewEntrySet {install an entry in the view table} {snmpdViewEntrySet\( \)} {snmpdViewEntrySet(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdViewEntryRemove {remove an entry from the view table} {snmpdViewEntryRemove\( \)} {snmpdViewEntryRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdTreeAdd {dynamically add a subtree to the SNMP agent MIB tree} {snmpdTreeAdd\( \)} {snmpdTreeAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdTreeRemove {dynamically remove part of the SNMP agent MIB tree} {snmpdTreeRemove\( \)} {snmpdTreeRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdTrapSend {general interface to trap facilities} {snmpdTrapSend\( \)} {snmpdTrapSend(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdInitFinish {complete the initialization of the agent} {snmpdInitFinish\( \)} {snmpdInitFinish(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdExit {exit the SNMP agent} {snmpdExit\( \)} {snmpdExit(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdContinue {continue processing of an SNMP packet} {snmpdContinue\( \)} {snmpdContinue(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdGroupByGetprocAndInstance {gather set of similar variable bindings} {snmpdGroupByGetprocAndInstance\( \)} {snmpdGroupByGetprocAndInstance(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdVbRowExtract {extract required pieces of a row for a `set' operation} {snmpdVbRowExtract\( \)} {snmpdVbRowExtract(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdVbExtractRowLoose {incrementally extract pieces of a row for a set } {snmpdVbExtractRowLoose\( \)} {snmpdVbExtractRowLoose(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdPktLockGet {lock an SNMP packet } {snmpdPktLockGet\( \)} {snmpdPktLockGet(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpIoInit {initialization routine for SNMP transport endpoint} {snmpIoInit\( \)} {snmpIoInit(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpIoWrite {write a packet to the transport} {snmpIoWrite\( \)} {snmpIoWrite(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpIoClose {close the transport endpoint.} {snmpIoClose\( \)} {snmpIoClose(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpIoMain {main SNMP I/O routine} {snmpIoMain\( \)} {snmpIoMain(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpIoTrapSend {send a standard SNMP or MIB-II trap} {snmpIoTrapSend\( \)} {snmpIoTrapSend(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpIoCommunityValidate {sample community validation routine} {snmpIoCommunityValidate\( \)} {snmpIoCommunityValidate(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdMemoryAlloc {allocate memory for the SNMP agent} {snmpdMemoryAlloc\( \)} {snmpdMemoryAlloc(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpdMemoryFree {free memory allocated by the SNMP agent} {snmpdMemoryFree\( \)} {snmpdMemoryFree(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpSubEncode {encode a packet for transmission to master agent or subagent} {snmpSubEncode\( \)} {snmpSubEncode(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerAsync {asynchronous message processing routine for the subagent} {snmpSaHandlerAsync\( \)} {snmpSaHandlerAsync(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerWR {provide snmpSaHandlerAsync() functionality synchronously} {snmpSaHandlerWR\( \)} {snmpSaHandlerWR(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerContinue {subagent continuation function} {snmpSaHandlerContinue\( \)} {snmpSaHandlerContinue(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerFinish {encode packet for subagent IO completion} {snmpSaHandlerFinish\( \)} {snmpSaHandlerFinish(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerCleanup {cleanup routine for subagent} {snmpSaHandlerCleanup\( \)} {snmpSaHandlerCleanup(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterHandlerAsync {process messages from the subagent asynchronously} {snmpMasterHandlerAsync\( \)} {snmpMasterHandlerAsync(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterHandlerWR {synchronous version of snmpMasterHandlerAsync()} {snmpMasterHandlerWR\( \)} {snmpMasterHandlerWR(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterQueryHandler {handles replies from the subagent} {snmpMasterQueryHandler\( \)} {snmpMasterQueryHandler(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterCleanup {free up resources after a query times out} {snmpMasterCleanup\( \)} {snmpMasterCleanup(\ )} {VxWorks Reference Manual} Libraries {} {}
masterIoInit {create the IPC mechanism at the SNMP master agent} {masterIoInit\( \)} {masterIoInit(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpMonitorSpawn {spawn 'tMonQue' to run snmpQueMonitor()} {snmpMonitorSpawn\( \)} {snmpMonitorSpawn(\ )} {VxWorks Reference Manual} Libraries {} {}
masterIpcComp {transmit a completion of transmission message} {masterIpcComp\( \)} {masterIpcComp(\ )} {VxWorks Reference Manual} Libraries {} {}
masterIoWrite {send the encoded buffer to the subagent} {masterIoWrite\( \)} {masterIoWrite(\ )} {VxWorks Reference Manual} Libraries {} {}
masterIpcSend {send a message to a subagent} {masterIpcSend\( \)} {masterIpcSend(\ )} {VxWorks Reference Manual} Libraries {} {}
masterIpcRcv {wait for a reply from the subagent} {masterIpcRcv\( \)} {masterIpcRcv(\ )} {VxWorks Reference Manual} Libraries {} {}
masterIpcAyt {check the status of the IPC link} {masterIpcAyt\( \)} {masterIpcAyt(\ )} {VxWorks Reference Manual} Libraries {} {}
masterIpcFree {free the IPC resources allocated by the SNMP master agent} {masterIpcFree\( \)} {masterIpcFree(\ )} {VxWorks Reference Manual} Libraries {} {}
masterQueCleanup {free resources allocated for SNMP master agent} {masterQueCleanup\( \)} {masterQueCleanup(\ )} {VxWorks Reference Manual} Libraries {} {}
snmpSaInit {initialize the subagent} {snmpSaInit\( \)} {snmpSaInit(\ )} {VxWorks Reference Manual} Libraries {} {}
saIoWrite {send a packet to the master agent's message queue} {saIoWrite\( \)} {saIoWrite(\ )} {VxWorks Reference Manual} Libraries {} {}
saIpcFree {free the specified IPC mechanism} {saIpcFree\( \)} {saIpcFree(\ )} {VxWorks Reference Manual} Libraries {} {}
saMsgBuild {build and encode a message and send it to the master agent} {saMsgBuild\( \)} {saMsgBuild(\ )} {VxWorks Reference Manual} Libraries {} {}
hdrBlkBuild {create the header block and the demuxer information} {hdrBlkBuild\( \)} {hdrBlkBuild(\ )} {VxWorks Reference Manual} Libraries {} {}
envoy_now {return the number of clock ticks elapsed since the timer was set} {envoy_now\( \)} {envoy_now(\ )} {VxWorks Reference Manual} Libraries {} {}
envoy_call_timer {execute the specified function when the timer expires} {envoy_call_timer\( \)} {envoy_call_timer(\ )} {VxWorks Reference Manual} Libraries {} {}
ip_to_rlist {convert an IP address to an array of OID components} {ip_to_rlist\( \)} {ip_to_rlist(\ )} {VxWorks Reference Manual} Libraries {} {}
oidcmp {compare two object identifiers} {oidcmp\( \)} {oidcmp(\ )} {VxWorks Reference Manual} Libraries {} {}
oidcmp2 {compare two object identifiers} {oidcmp2\( \)} {oidcmp2(\ )} {VxWorks Reference Manual} Libraries {} {}
oid_to_ip {convert an object identifier to an IP address} {oid_to_ip\( \)} {oid_to_ip(\ )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Unsigned_Integer {bind an unsigned-integer variable} {SNMP_Bind_Unsigned_Integer\( \)} {SNMP_Bind_Unsigned_Integer(\ )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Integer {bind an integer variable} {SNMP_Bind_Integer\( \)} {SNMP_Bind_Integer(\ )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_IP_Address {bind an IP address variable} {SNMP_Bind_IP_Address\( \)} {SNMP_Bind_IP_Address(\ )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Object_ID {bind an object-identifier variable} {SNMP_Bind_Object_ID\( \)} {SNMP_Bind_Object_ID(\ )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_String {bind a string variable} {SNMP_Bind_String\( \)} {SNMP_Bind_String(\ )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_64_Unsigned_Integer {bind a 64-bit unsigned-integer variable} {SNMP_Bind_64_Unsigned_Integer\( \)} {SNMP_Bind_64_Unsigned_Integer(\ )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Null {bind a null-valued variable} {SNMP_Bind_Null\( \)} {SNMP_Bind_Null(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferClone {make a copy of an extended buffer } {EBufferClone\( \)} {EBufferClone(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferClean {release dynamic memory in an extended buffer} {EBufferClean\( \)} {EBufferClean(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferInitialize {place an extended buffer in a known state} {EBufferInitialize\( \)} {EBufferInitialize(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferSetup {attach an empty memory buffer to an extended buffer} {EBufferSetup\( \)} {EBufferSetup(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferPreLoad {attach a full memory buffer to an extended buffer} {EBufferPreLoad\( \)} {EBufferPreLoad(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferNext {return a pointer to the next unused byte of the buffer memory} {EBufferNext\( \)} {EBufferNext(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferStart {return a pointer to the first byte in the buffer memory} {EBufferStart\( \)} {EBufferStart(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferUsed {return the number of used bytes in the buffer memory} {EBufferUsed\( \)} {EBufferUsed(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferReset {reset the extended buffer} {EBufferReset\( \)} {EBufferReset(\ )} {VxWorks Reference Manual} Libraries {} {}
EBufferRemaining {return the number of unused bytes remaining in buffer memory} {EBufferRemaining\( \)} {EBufferRemaining(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_started {indicate that a `getproc' operation has begun} {getproc_started\( \)} {getproc_started(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_good {indicate successful completion of a `getproc' procedure} {getproc_good\( \)} {getproc_good(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_error {indicate that a `getproc' operation encountered an error} {getproc_error\( \)} {getproc_error(\ )} {VxWorks Reference Manual} Libraries {} {}
nextproc_started {indicate that a `nextproc' operation has begun} {nextproc_started\( \)} {nextproc_started(\ )} {VxWorks Reference Manual} Libraries {} {}
nextproc_good {indicate successful completion of a `nextproc' procedure} {nextproc_good\( \)} {nextproc_good(\ )} {VxWorks Reference Manual} Libraries {} {}
nextproc_no_next {indicate that there exists no next instance } {nextproc_no_next\( \)} {nextproc_no_next(\ )} {VxWorks Reference Manual} Libraries {} {}
nextproc_error {indicate that a `nextproc' operation encountered an error} {nextproc_error\( \)} {nextproc_error(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_int32 {indicate retrieval of a 32-bit integer} {getproc_got_int32\( \)} {getproc_got_int32(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_uint32 {indicate retrieval of a 32-bit unsigned integer} {getproc_got_uint32\( \)} {getproc_got_uint32(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_ip_address {indicate retrieval of an IP address} {getproc_got_ip_address\( \)} {getproc_got_ip_address(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_empty {indicate retrieval of a null value} {getproc_got_empty\( \)} {getproc_got_empty(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_string {indicate retrieval of a string} {getproc_got_string\( \)} {getproc_got_string(\ )} {VxWorks Reference Manual} Libraries {} {}
testproc_started {indicate that a `testproc' operation has begun} {testproc_started\( \)} {testproc_started(\ )} {VxWorks Reference Manual} Libraries {} {}
testproc_good {indicate successful completion of a `testproc' procedure} {testproc_good\( \)} {testproc_good(\ )} {VxWorks Reference Manual} Libraries {} {}
testproc_error {indicate that a `testproc' operation encountered an error} {testproc_error\( \)} {testproc_error(\ )} {VxWorks Reference Manual} Libraries {} {}
setproc_started {indicate that a `setproc' operation has begun} {setproc_started\( \)} {setproc_started(\ )} {VxWorks Reference Manual} Libraries {} {}
setproc_good {indicates successful completion of a `setproc' procedure} {setproc_good\( \)} {setproc_good(\ )} {VxWorks Reference Manual} Libraries {} {}
setproc_error {indicate that a `setproc' operation encountered an error} {setproc_error\( \)} {setproc_error(\ )} {VxWorks Reference Manual} Libraries {} {}
undoproc_started {indicate that an `undoproc' operation has begun} {undoproc_started\( \)} {undoproc_started(\ )} {VxWorks Reference Manual} Libraries {} {}
undoproc_good {indicates successful completion of an `undoproc' operation} {undoproc_good\( \)} {undoproc_good(\ )} {VxWorks Reference Manual} Libraries {} {}
undoproc_error {indicate that an `undproc' operation encountered an error} {undoproc_error\( \)} {undoproc_error(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_uint64 {indicate retrieval of a 64-bit unsigned integer} {getproc_got_uint64\( \)} {getproc_got_uint64(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_uint64_high_low {indicate retrieval of a 64-bit unsigned} {getproc_got_uint64_high_low\( \)} {getproc_got_uint64_high_low(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_nosuchins {indicates that no such instance exists} {getproc_nosuchins\( \)} {getproc_nosuchins(\ )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_object_id {indicate retrieval of an object identifier} {getproc_got_object_id\( \)} {getproc_got_object_id(\ )} {VxWorks Reference Manual} Libraries {} {}
nextproc_next_instance {install instance part of next instance} {nextproc_next_instance\( \)} {nextproc_next_instance(\ )} {VxWorks Reference Manual} Libraries {} {}
autopushAdd {add a list of automatically pushed STREAMS modules (STREAMS Option)} {autopushAdd\( \)} {autopushAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
autopushDelete {delete autopush information for a device (STREAMS Option)} {autopushDelete\( \)} {autopushDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
autopushGet {get autopush information for a device (STREAMS Option)} {autopushGet\( \)} {autopushGet(\ )} {VxWorks Reference Manual} Libraries {} {}
strace {print STREAMS trace messages (STREAMS Option)} {strace\( \)} {strace(\ )} {VxWorks Reference Manual} Libraries {} {}
straceStop {stop the strace() task (STREAMS Option)} {straceStop\( \)} {straceStop(\ )} {VxWorks Reference Manual} Libraries {} {}
strerr {STREAMS error logger task (STREAMS Option)} {strerr\( \)} {strerr(\ )} {VxWorks Reference Manual} Libraries {} {}
strerrStop {stop the strerr() task (STREAMS Option)} {strerrStop\( \)} {strerrStop(\ )} {VxWorks Reference Manual} Libraries {} {}
strmSockProtoAdd {add a new transport-protocol entry to STREAMS sockets (STREAMS Option)} {strmSockProtoAdd\( \)} {strmSockProtoAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
strmSockProtoDelete {remove a protocol entry from the table (STREAMS Option)} {strmSockProtoDelete\( \)} {strmSockProtoDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
strmSockDevNameGet {get the transport-provider device name (STREAMS Option)} {strmSockDevNameGet\( \)} {strmSockDevNameGet(\ )} {VxWorks Reference Manual} Libraries {} {}
strmDebugInit {include STREAMS debugging facility in VxWorks (STREAMS Option)} {strmDebugInit\( \)} {strmDebugInit(\ )} {VxWorks Reference Manual} Libraries {} {}
strmOpenStreamsShow {display all open streams in the STREAMS subsystem (STREAMS Option)} {strmOpenStreamsShow\( \)} {strmOpenStreamsShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmQueueShow {display all queues in a particular stream (STREAMS Option)} {strmQueueShow\( \)} {strmQueueShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmBandShow {display messages in a particular band (STREAMS Option)} {strmBandShow\( \)} {strmBandShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmMessageShow {display information about all messages in a stream (STREAMS Option)} {strmMessageShow\( \)} {strmMessageShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmQueueStatShow {display statistics about queues system-wide (STREAMS Option)} {strmQueueStatShow\( \)} {strmQueueStatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmMsgStatShow {display statistics about system-wide usage of message blocks (STREAMS Option)} {strmMsgStatShow\( \)} {strmMsgStatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmStatShow {display statistics about streams (STREAMS Option)} {strmStatShow\( \)} {strmStatShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmDriverModShow {list configuration information for modules and devices (STREAMS Option)} {strmDriverModShow\( \)} {strmDriverModShow(\ )} {VxWorks Reference Manual} Libraries {} {}
strmDriverAdd {add a STREAMS driver into the STREAMS subsystem (STREAMS Option)} {strmDriverAdd\( \)} {strmDriverAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
strmModuleAdd {add a STREAMS module to the STREAMS subsystem (STREAMS Option)} {strmModuleAdd\( \)} {strmModuleAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
strmTimeout {execute a routine in a specified length of time (STREAMS Option)} {strmTimeout\( \)} {strmTimeout(\ )} {VxWorks Reference Manual} Libraries {} {}
strmUntimeout {cancel previous strmTimeout() call (STREAMS Option)} {strmUntimeout\( \)} {strmUntimeout(\ )} {VxWorks Reference Manual} Libraries {} {}
strmSleep {suspend task execution pending occurrence of an event (STREAMS Option)} {strmSleep\( \)} {strmSleep(\ )} {VxWorks Reference Manual} Libraries {} {}
strmWakeup {resume suspended task execution (STREAMS Option)} {strmWakeup\( \)} {strmWakeup(\ )} {VxWorks Reference Manual} Libraries {} {}
strmSyncWriteAccess {access a shared data structure for synchronous writing (STREAMS Option)} {strmSyncWriteAccess\( \)} {strmSyncWriteAccess(\ )} {VxWorks Reference Manual} Libraries {} {}
strmWeld {connect the `q_next' pointers of arbitrary streams (STREAMS Option)} {strmWeld\( \)} {strmWeld(\ )} {VxWorks Reference Manual} Libraries {} {}
strmUnWeld {set the `q_next' pointers of streams queues to NULL (STREAMS Option)} {strmUnWeld\( \)} {strmUnWeld(\ )} {VxWorks Reference Manual} Libraries {} {}
strmPipe {create an intertask channel (STREAMS Option)} {strmPipe\( \)} {strmPipe(\ )} {VxWorks Reference Manual} Libraries {} {}
strmMkfifo {create a STREAMS FIFO (STREAMS Option)} {strmMkfifo\( \)} {strmMkfifo(\ )} {VxWorks Reference Manual} Libraries {} {}
mps_fd_to_sth {return the Stream Head pointer for a given fd} {mps_fd_to_sth\( \)} {mps_fd_to_sth(\ )} {VxWorks Reference Manual} Libraries {} {}
dlpiInit {initialize the DLPI driver} {dlpiInit\( \)} {dlpiInit(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsDrv {initialize the TrueFFS system} {tffsDrv\( \)} {tffsDrv(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsDevCreate {create a TrueFFS block device suitable for use with dosFs} {tffsDevCreate\( \)} {tffsDevCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsDevOptionsSet {set TrueFFS volume options} {tffsDevOptionsSet\( \)} {tffsDevOptionsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsDevFormat {format a flash device for use with TrueFFS} {tffsDevFormat\( \)} {tffsDevFormat(\ )} {VxWorks Reference Manual} Libraries {} {}
tffsRawio {low level I/O access to flash components} {tffsRawio\( \)} {tffsRawio(\ )} {VxWorks Reference Manual} Libraries {} {}
bcmp {compare one buffer to another} {bcmp\( \)} {bcmp(\ )} {VxWorks Reference Manual} Libraries {} {}
binvert {invert the order of bytes in a buffer} {binvert\( \)} {binvert(\ )} {VxWorks Reference Manual} Libraries {} {}
bswap {swap buffers} {bswap\( \)} {bswap(\ )} {VxWorks Reference Manual} Libraries {} {}
swab {swap bytes} {swab\( \)} {swab(\ )} {VxWorks Reference Manual} Libraries {} {}
uswab {swap bytes with buffers that are not necessarily aligned} {uswab\( \)} {uswab(\ )} {VxWorks Reference Manual} Libraries {} {}
bzero {zero out a buffer} {bzero\( \)} {bzero(\ )} {VxWorks Reference Manual} Libraries {} {}
bcopy {copy one buffer to another} {bcopy\( \)} {bcopy(\ )} {VxWorks Reference Manual} Libraries {} {}
bcopyBytes {copy one buffer to another one byte at a time} {bcopyBytes\( \)} {bcopyBytes(\ )} {VxWorks Reference Manual} Libraries {} {}
bcopyWords {copy one buffer to another one word at a time} {bcopyWords\( \)} {bcopyWords(\ )} {VxWorks Reference Manual} Libraries {} {}
bcopyLongs {copy one buffer to another one long word at a time} {bcopyLongs\( \)} {bcopyLongs(\ )} {VxWorks Reference Manual} Libraries {} {}
bfill {fill a buffer with a specified character} {bfill\( \)} {bfill(\ )} {VxWorks Reference Manual} Libraries {} {}
bfillBytes {fill buffer with a specified character one byte at a time} {bfillBytes\( \)} {bfillBytes(\ )} {VxWorks Reference Manual} Libraries {} {}
index {find the first occurrence of a character in a string} {index\( \)} {index(\ )} {VxWorks Reference Manual} Libraries {} {}
rindex {find the last occurrence of a character in a string} {rindex\( \)} {rindex(\ )} {VxWorks Reference Manual} Libraries {} {}
bootStringToStruct {interpret the boot parameters from the boot line} {bootStringToStruct\( \)} {bootStringToStruct(\ )} {VxWorks Reference Manual} Libraries {} {}
bootStructToString {construct a boot line} {bootStructToString\( \)} {bootStructToString(\ )} {VxWorks Reference Manual} Libraries {} {}
bootParamsShow {display boot line parameters} {bootParamsShow\( \)} {bootParamsShow(\ )} {VxWorks Reference Manual} Libraries {} {}
bootParamsPrompt {prompt for boot line parameters} {bootParamsPrompt\( \)} {bootParamsPrompt(\ )} {VxWorks Reference Manual} Libraries {} {}
bootLeaseExtract {extract the lease information from an Internet address} {bootLeaseExtract\( \)} {bootLeaseExtract(\ )} {VxWorks Reference Manual} Libraries {} {}
bootNetmaskExtract {extract the net mask field from an Internet address} {bootNetmaskExtract\( \)} {bootNetmaskExtract(\ )} {VxWorks Reference Manual} Libraries {} {}
bootBpAnchorExtract {extract a backplane address from a device field} {bootBpAnchorExtract\( \)} {bootBpAnchorExtract(\ )} {VxWorks Reference Manual} Libraries {} {}
lstInit {initialize a list descriptor} {lstInit\( \)} {lstInit(\ )} {VxWorks Reference Manual} Libraries {} {}
lstAdd {add a node to the end of a list} {lstAdd\( \)} {lstAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
lstConcat {concatenate two lists} {lstConcat\( \)} {lstConcat(\ )} {VxWorks Reference Manual} Libraries {} {}
lstCount {report the number of nodes in a list} {lstCount\( \)} {lstCount(\ )} {VxWorks Reference Manual} Libraries {} {}
lstDelete {delete a specified node from a list} {lstDelete\( \)} {lstDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
lstExtract {extract a sublist from a list} {lstExtract\( \)} {lstExtract(\ )} {VxWorks Reference Manual} Libraries {} {}
lstFirst {find first node in list} {lstFirst\( \)} {lstFirst(\ )} {VxWorks Reference Manual} Libraries {} {}
lstGet {delete and return the first node from a list} {lstGet\( \)} {lstGet(\ )} {VxWorks Reference Manual} Libraries {} {}
lstInsert {insert a node in a list after a specified node} {lstInsert\( \)} {lstInsert(\ )} {VxWorks Reference Manual} Libraries {} {}
lstLast {find the last node in a list} {lstLast\( \)} {lstLast(\ )} {VxWorks Reference Manual} Libraries {} {}
lstNext {find the next node in a list} {lstNext\( \)} {lstNext(\ )} {VxWorks Reference Manual} Libraries {} {}
lstNth {find the Nth node in a list} {lstNth\( \)} {lstNth(\ )} {VxWorks Reference Manual} Libraries {} {}
lstPrevious {find the previous node in a list} {lstPrevious\( \)} {lstPrevious(\ )} {VxWorks Reference Manual} Libraries {} {}
lstNStep {find a list node steps away from a specified node} {lstNStep\( \)} {lstNStep(\ )} {VxWorks Reference Manual} Libraries {} {}
lstFind {find a node in a list} {lstFind\( \)} {lstFind(\ )} {VxWorks Reference Manual} Libraries {} {}
lstFree {free up a list} {lstFree\( \)} {lstFree(\ )} {VxWorks Reference Manual} Libraries {} {}
rngCreate {create an empty ring buffer} {rngCreate\( \)} {rngCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
rngDelete {delete a ring buffer} {rngDelete\( \)} {rngDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
rngFlush {make a ring buffer empty} {rngFlush\( \)} {rngFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
rngBufGet {get characters from a ring buffer} {rngBufGet\( \)} {rngBufGet(\ )} {VxWorks Reference Manual} Libraries {} {}
rngBufPut {put bytes into a ring buffer} {rngBufPut\( \)} {rngBufPut(\ )} {VxWorks Reference Manual} Libraries {} {}
rngIsEmpty {test if a ring buffer is empty} {rngIsEmpty\( \)} {rngIsEmpty(\ )} {VxWorks Reference Manual} Libraries {} {}
rngIsFull {test if a ring buffer is full (no more room)} {rngIsFull\( \)} {rngIsFull(\ )} {VxWorks Reference Manual} Libraries {} {}
rngFreeBytes {determine the number of free bytes in a ring buffer} {rngFreeBytes\( \)} {rngFreeBytes(\ )} {VxWorks Reference Manual} Libraries {} {}
rngNBytes {determine the number of bytes in a ring buffer} {rngNBytes\( \)} {rngNBytes(\ )} {VxWorks Reference Manual} Libraries {} {}
rngPutAhead {put a byte ahead in a ring buffer without moving ring pointers} {rngPutAhead\( \)} {rngPutAhead(\ )} {VxWorks Reference Manual} Libraries {} {}
rngMoveAhead {advance a ring pointer by bytes} {rngMoveAhead\( \)} {rngMoveAhead(\ )} {VxWorks Reference Manual} Libraries {} {}
inflate {inflate compressed code} {inflate\( \)} {inflate(\ )} {VxWorks Reference Manual} Libraries {} {}
wvRBuffMgrPrioritySet {set the priority of the WindView rBuff manager (WindView)} {wvRBuffMgrPrioritySet\( \)} {wvRBuffMgrPrioritySet(\ )} {VxWorks Reference Manual} Libraries {} {}
distIfShow {display information about the installed interface adapter} {distIfShow\( \)} {distIfShow(\ )} {VxWorks Reference Manual} Libraries {} {}
distNameAdd {add an entry to the distributed name database} {distNameAdd\( \)} {distNameAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
distNameFind {find an object by name in the local database } {distNameFind\( \)} {distNameFind(\ )} {VxWorks Reference Manual} Libraries {} {}
distNameFindByValueAndType {look up an object by value and type} {distNameFindByValueAndType\( \)} {distNameFindByValueAndType(\ )} {VxWorks Reference Manual} Libraries {} {}
distNameRemove {remove an entry from the distributed name database} {distNameRemove\( \)} {distNameRemove(\ )} {VxWorks Reference Manual} Libraries {} {}
distNameShow {display the entire distributed name database} {distNameShow\( \)} {distNameShow(\ )} {VxWorks Reference Manual} Libraries {} {}
distNameFilterShow {display the distributed name database filtered by type} {distNameFilterShow\( \)} {distNameFilterShow(\ )} {VxWorks Reference Manual} Libraries {} {}
distInit {initialize and bootstrap the current node} {distInit\( \)} {distInit(\ )} {VxWorks Reference Manual} Libraries {} {}
distCtl {perform a distributed objects control function} {distCtl\( \)} {distCtl(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistCreate {create a distributed message queue} {msgQDistCreate\( \)} {msgQDistCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistSend {send a message to a distributed message queue} {msgQDistSend\( \)} {msgQDistSend(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistReceive {receive a message from a distributed message queue} {msgQDistReceive\( \)} {msgQDistReceive(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistNumMsgs {get the number of messages in a distributed message queue} {msgQDistNumMsgs\( \)} {msgQDistNumMsgs(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistShowInit {initialize the distributed message queue show package} {msgQDistShowInit\( \)} {msgQDistShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistGrpAdd {add a distributed message queue to a group} {msgQDistGrpAdd\( \)} {msgQDistGrpAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistGrpDelete {delete a distributed message queue from a group} {msgQDistGrpDelete\( \)} {msgQDistGrpDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDistGrpShow {display all or one group with its members} {msgQDistGrpShow\( \)} {msgQDistGrpShow(\ )} {VxWorks Reference Manual} Libraries {} {}
distTBufAlloc {allocate a telegram buffer from the pool of buffers} {distTBufAlloc\( \)} {distTBufAlloc(\ )} {VxWorks Reference Manual} Libraries {} {}
distTBufFree {return a telegram buffer to the pool of buffers} {distTBufFree\( \)} {distTBufFree(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbUserEvtLibInit {include the WDB user event library } {wdbUserEvtLibInit\( \)} {wdbUserEvtLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbUserEvtPost {post a user event string to host tools.} {wdbUserEvtPost\( \)} {wdbUserEvtPost(\ )} {VxWorks Reference Manual} Libraries {} {}
wdbSystemSuspend {suspend the system.} {wdbSystemSuspend\( \)} {wdbSystemSuspend(\ )} {VxWorks Reference Manual} Libraries {} {}
kernelInit {initialize the kernel} {kernelInit\( \)} {kernelInit(\ )} {VxWorks Reference Manual} Libraries {} {}
kernelVersion {return the kernel revision string} {kernelVersion\( \)} {kernelVersion(\ )} {VxWorks Reference Manual} Libraries {} {}
kernelTimeSlice {enable round-robin selection} {kernelTimeSlice\( \)} {kernelTimeSlice(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQCreate {create and initialize a message queue} {msgQCreate\( \)} {msgQCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQDelete {delete a message queue} {msgQDelete\( \)} {msgQDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQSend {send a message to a message queue} {msgQSend\( \)} {msgQSend(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQReceive {receive a message from a message queue} {msgQReceive\( \)} {msgQReceive(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQNumMsgs {get the number of messages queued to a message queue} {msgQNumMsgs\( \)} {msgQNumMsgs(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQShowInit {initialize the message queue show facility} {msgQShowInit\( \)} {msgQShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQInfoGet {get information about a message queue} {msgQInfoGet\( \)} {msgQInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQShow {show information about a message queue} {msgQShow\( \)} {msgQShow(\ )} {VxWorks Reference Manual} Libraries {} {}
msgQSmCreate {create and initialize a shared memory message queue (VxMP Option)} {msgQSmCreate\( \)} {msgQSmCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
semBCreate {create and initialize a binary semaphore} {semBCreate\( \)} {semBCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
semCCreate {create and initialize a counting semaphore} {semCCreate\( \)} {semCCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
semGive {give a semaphore} {semGive\( \)} {semGive(\ )} {VxWorks Reference Manual} Libraries {} {}
semTake {take a semaphore} {semTake\( \)} {semTake(\ )} {VxWorks Reference Manual} Libraries {} {}
semFlush {unblock every task pended on a semaphore} {semFlush\( \)} {semFlush(\ )} {VxWorks Reference Manual} Libraries {} {}
semDelete {delete a semaphore} {semDelete\( \)} {semDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
semMCreate {create and initialize a mutual-exclusion semaphore} {semMCreate\( \)} {semMCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
semMGiveForce {give a mutual-exclusion semaphore without restrictions} {semMGiveForce\( \)} {semMGiveForce(\ )} {VxWorks Reference Manual} Libraries {} {}
semCreate {create and initialize a release 4.x binary semaphore} {semCreate\( \)} {semCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
semInit {initialize a static binary semaphore} {semInit\( \)} {semInit(\ )} {VxWorks Reference Manual} Libraries {} {}
semClear {take a release 4.x semaphore, if the semaphore is available} {semClear\( \)} {semClear(\ )} {VxWorks Reference Manual} Libraries {} {}
semShowInit {initialize the semaphore show facility} {semShowInit\( \)} {semShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
semInfo {get a list of task IDs that are blocked on a semaphore} {semInfo\( \)} {semInfo(\ )} {VxWorks Reference Manual} Libraries {} {}
semShow {show information about a semaphore} {semShow\( \)} {semShow(\ )} {VxWorks Reference Manual} Libraries {} {}
semBSmCreate {create and initialize a shared memory binary semaphore (VxMP Option)} {semBSmCreate\( \)} {semBSmCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
semCSmCreate {create and initialize a shared memory counting semaphore (VxMP Option)} {semCSmCreate\( \)} {semCSmCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
taskOptionsSet {change task options} {taskOptionsSet\( \)} {taskOptionsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskOptionsGet {examine task options} {taskOptionsGet\( \)} {taskOptionsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskRegsGet {get a task's registers from the TCB} {taskRegsGet\( \)} {taskRegsGet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskRegsSet {set a task's registers} {taskRegsSet\( \)} {taskRegsSet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskName {get the name associated with a task ID} {taskName\( \)} {taskName(\ )} {VxWorks Reference Manual} Libraries {} {}
taskNameToId {look up the task ID associated with a task name} {taskNameToId\( \)} {taskNameToId(\ )} {VxWorks Reference Manual} Libraries {} {}
taskIdDefault {set the default task ID} {taskIdDefault\( \)} {taskIdDefault(\ )} {VxWorks Reference Manual} Libraries {} {}
taskIsReady {check if a task is ready to run} {taskIsReady\( \)} {taskIsReady(\ )} {VxWorks Reference Manual} Libraries {} {}
taskIsSuspended {check if a task is suspended} {taskIsSuspended\( \)} {taskIsSuspended(\ )} {VxWorks Reference Manual} Libraries {} {}
taskIdListGet {get a list of active task IDs} {taskIdListGet\( \)} {taskIdListGet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSpawn {spawn a task} {taskSpawn\( \)} {taskSpawn(\ )} {VxWorks Reference Manual} Libraries {} {}
taskInit {initialize a task with a stack at a specified address} {taskInit\( \)} {taskInit(\ )} {VxWorks Reference Manual} Libraries {} {}
taskActivate {activate a task that has been initialized} {taskActivate\( \)} {taskActivate(\ )} {VxWorks Reference Manual} Libraries {} {}
exit {exit a task (ANSI)} {exit\( \)} {exit(\ )} {VxWorks Reference Manual} Libraries {} {}
taskDelete {delete a task} {taskDelete\( \)} {taskDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
taskDeleteForce {delete a task without restriction} {taskDeleteForce\( \)} {taskDeleteForce(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSuspend {suspend a task} {taskSuspend\( \)} {taskSuspend(\ )} {VxWorks Reference Manual} Libraries {} {}
taskResume {resume a task} {taskResume\( \)} {taskResume(\ )} {VxWorks Reference Manual} Libraries {} {}
taskRestart {restart a task} {taskRestart\( \)} {taskRestart(\ )} {VxWorks Reference Manual} Libraries {} {}
taskPrioritySet {change the priority of a task} {taskPrioritySet\( \)} {taskPrioritySet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskPriorityGet {examine the priority of a task} {taskPriorityGet\( \)} {taskPriorityGet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskLock {disable task rescheduling} {taskLock\( \)} {taskLock(\ )} {VxWorks Reference Manual} Libraries {} {}
taskUnlock {enable task rescheduling} {taskUnlock\( \)} {taskUnlock(\ )} {VxWorks Reference Manual} Libraries {} {}
taskSafe {make the calling task safe from deletion} {taskSafe\( \)} {taskSafe(\ )} {VxWorks Reference Manual} Libraries {} {}
taskUnsafe {make the calling task unsafe from deletion} {taskUnsafe\( \)} {taskUnsafe(\ )} {VxWorks Reference Manual} Libraries {} {}
taskDelay {delay a task from executing} {taskDelay\( \)} {taskDelay(\ )} {VxWorks Reference Manual} Libraries {} {}
taskIdSelf {get the task ID of a running task} {taskIdSelf\( \)} {taskIdSelf(\ )} {VxWorks Reference Manual} Libraries {} {}
taskIdVerify {verify the existence of a task} {taskIdVerify\( \)} {taskIdVerify(\ )} {VxWorks Reference Manual} Libraries {} {}
taskTcb {get the task control block for a task ID} {taskTcb\( \)} {taskTcb(\ )} {VxWorks Reference Manual} Libraries {} {}
taskShowInit {initialize the task show routine facility} {taskShowInit\( \)} {taskShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
taskInfoGet {get information about a task} {taskInfoGet\( \)} {taskInfoGet(\ )} {VxWorks Reference Manual} Libraries {} {}
taskShow {display task information from TCBs} {taskShow\( \)} {taskShow(\ )} {VxWorks Reference Manual} Libraries {} {}
taskRegsShow {display the contents of a task's registers} {taskRegsShow\( \)} {taskRegsShow(\ )} {VxWorks Reference Manual} Libraries {} {}
taskStatusString {get a task's status as a string} {taskStatusString\( \)} {taskStatusString(\ )} {VxWorks Reference Manual} Libraries {} {}
tickAnnounce {announce a clock tick to the kernel} {tickAnnounce\( \)} {tickAnnounce(\ )} {VxWorks Reference Manual} Libraries {} {}
tickSet {set the value of the kernel's tick counter} {tickSet\( \)} {tickSet(\ )} {VxWorks Reference Manual} Libraries {} {}
tickGet {get the value of the kernel's tick counter} {tickGet\( \)} {tickGet(\ )} {VxWorks Reference Manual} Libraries {} {}
wdCreate {create a watchdog timer} {wdCreate\( \)} {wdCreate(\ )} {VxWorks Reference Manual} Libraries {} {}
wdDelete {delete a watchdog timer} {wdDelete\( \)} {wdDelete(\ )} {VxWorks Reference Manual} Libraries {} {}
wdStart {start a watchdog timer} {wdStart\( \)} {wdStart(\ )} {VxWorks Reference Manual} Libraries {} {}
wdCancel {cancel a currently counting watchdog} {wdCancel\( \)} {wdCancel(\ )} {VxWorks Reference Manual} Libraries {} {}
wdShowInit {initialize the watchdog show facility} {wdShowInit\( \)} {wdShowInit(\ )} {VxWorks Reference Manual} Libraries {} {}
wdShow {show information about a watchdog} {wdShow\( \)} {wdShow(\ )} {VxWorks Reference Manual} Libraries {} {}
symSyncLibInit {initialize host/target symbol table synchronization} {symSyncLibInit\( \)} {symSyncLibInit(\ )} {VxWorks Reference Manual} Libraries {} {}
symSyncTimeoutSet {set WTX timeout } {symSyncTimeoutSet\( \)} {symSyncTimeoutSet(\ )} {VxWorks Reference Manual} Libraries {} {}
psrShow {display the meaning of a specified PSR value, symbolically (ARM)} {psrShow;1\( \)} {psrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
r0 {return the contents of general register r0 (also r1-r15) (SH)} {r0;1\( \)} {r0(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {default run-time support for operator new (nothrow) (C++)} {operator new;1\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {run-time support for operator new with placement (C++)} {operator new;2\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
VXWModule::VXWModule {load an object module at specified memory addresses} {VXWModule::VXWModule;1\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {load an object module into memory} {VXWModule::VXWModule;2\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {create and initialize an object module} {VXWModule::VXWModule;3\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::VXWList {initialize a list as a copy of another} {VXWList::VXWList;1\( \)} {VXWList::VXWList(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::VXWMsgQ {build message-queue object from ID} {VXWMsgQ::VXWMsgQ;1\( \)} {VXWMsgQ::VXWMsgQ(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::VXWRingBuf {build ring-buffer object from existing ID} {VXWRingBuf::VXWRingBuf;1\( \)} {VXWRingBuf::VXWRingBuf(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmBSem::VXWSmBSem {build a binary shared-memory semaphore object (VxMP Option)} {VXWSmBSem::VXWSmBSem;1\( \)} {VXWSmBSem::VXWSmBSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmCSem::VXWSmCSem {build a shared-memory counting semaphore object (VxMP Option)} {VXWSmCSem::VXWSmCSem;1\( \)} {VXWSmCSem::VXWSmCSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemBlock::VXWSmMemBlock {allocate memory for an array from the shared memory system partition (VxMP Option)} {VXWSmMemBlock::VXWSmMemBlock;1\( \)} {VXWSmMemBlock::VXWSmMemBlock(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmName::nameGet {get name of a shared memory object (VxMP Option)} {VXWSmName::nameGet;1\( \)} {VXWSmName::nameGet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::VXWSymTab {create a symbol-table object } {VXWSymTab::VXWSymTab;1\( \)} {VXWSymTab::VXWSymTab(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {create and spawn a task} {VXWTask::VXWTask;1\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {initialize a task with a specified stack} {VXWTask::VXWTask;2\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::errNo {set error status value } {VXWTask::errNo;1\( \)} {VXWTask::errNo(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::options {change task options} {VXWTask::options;1\( \)} {VXWTask::options(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::priority {change the priority of a task} {VXWTask::priority;1\( \)} {VXWTask::priority(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::registers {get task registers from the TCB} {VXWTask::registers;1\( \)} {VXWTask::registers(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::show {display task information from TCBs} {VXWTask::show;1\( \)} {VXWTask::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::VXWWd {construct a watchdog timer} {VXWWd::VXWWd;1\( \)} {VXWWd::VXWWd(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
eiattach {publish the `ei' network interface and initialize the driver and device} {eiattach\( \)} {eiattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
asin {compute an arc sine (ANSI)} {asin\( \)} {asin(\ )} {VxWorks Reference Manual} Libraries {} {}
acos {compute an arc cosine (ANSI)} {acos\( \)} {acos(\ )} {VxWorks Reference Manual} Libraries {} {}
atan {compute an arc tangent (ANSI)} {atan\( \)} {atan(\ )} {VxWorks Reference Manual} Libraries {} {}
atan2 {compute the arc tangent of y/x (ANSI)} {atan2\( \)} {atan2(\ )} {VxWorks Reference Manual} Libraries {} {}
ceil {compute the smallest integer greater than or equal to a specified value (ANSI)} {ceil\( \)} {ceil(\ )} {VxWorks Reference Manual} Libraries {} {}
cosh {compute a hyperbolic cosine (ANSI)} {cosh\( \)} {cosh(\ )} {VxWorks Reference Manual} Libraries {} {}
exp {compute an exponential value (ANSI)} {exp\( \)} {exp(\ )} {VxWorks Reference Manual} Libraries {} {}
fabs {compute an absolute value (ANSI)} {fabs\( \)} {fabs(\ )} {VxWorks Reference Manual} Libraries {} {}
floor {compute the largest integer less than or equal to a specified value (ANSI)} {floor\( \)} {floor(\ )} {VxWorks Reference Manual} Libraries {} {}
fmod {compute the remainder of x/y (ANSI)} {fmod\( \)} {fmod(\ )} {VxWorks Reference Manual} Libraries {} {}
log {compute a natural logarithm (ANSI)} {log\( \)} {log(\ )} {VxWorks Reference Manual} Libraries {} {}
log10 {compute a base-10 logarithm (ANSI)} {log10\( \)} {log10(\ )} {VxWorks Reference Manual} Libraries {} {}
pow {compute the value of a number raised to a specified power (ANSI)} {pow\( \)} {pow(\ )} {VxWorks Reference Manual} Libraries {} {}
sin {compute a sine (ANSI)} {sin\( \)} {sin(\ )} {VxWorks Reference Manual} Libraries {} {}
cos {compute a cosine (ANSI)} {cos\( \)} {cos(\ )} {VxWorks Reference Manual} Libraries {} {}
sinh {compute a hyperbolic sine (ANSI)} {sinh\( \)} {sinh(\ )} {VxWorks Reference Manual} Libraries {} {}
sqrt {compute a non-negative square root (ANSI)} {sqrt\( \)} {sqrt(\ )} {VxWorks Reference Manual} Libraries {} {}
tan {compute a tangent (ANSI)} {tan\( \)} {tan(\ )} {VxWorks Reference Manual} Libraries {} {}
tanh {compute a hyperbolic tangent (ANSI)} {tanh\( \)} {tanh(\ )} {VxWorks Reference Manual} Libraries {} {}
rcvAddrAdd {add a physical address into the linked list} {rcvAddrAdd;1\( \)} {rcvAddrAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
psrShow {display the meaning of a specified PSR value, symbolically (ARM)} {psrShow;1\( \)} {psrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
r0 {return the contents of general register r0 (also r1-r15) (SH)} {r0;1\( \)} {r0(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {default run-time support for operator new (nothrow) (C++)} {operator new;1\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {run-time support for operator new with placement (C++)} {operator new;2\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
VXWModule::VXWModule {load an object module at specified memory addresses} {VXWModule::VXWModule;1\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {load an object module into memory} {VXWModule::VXWModule;2\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {create and initialize an object module} {VXWModule::VXWModule;3\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::VXWList {initialize a list as a copy of another} {VXWList::VXWList;1\( \)} {VXWList::VXWList(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::VXWMsgQ {build message-queue object from ID} {VXWMsgQ::VXWMsgQ;1\( \)} {VXWMsgQ::VXWMsgQ(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::VXWRingBuf {build ring-buffer object from existing ID} {VXWRingBuf::VXWRingBuf;1\( \)} {VXWRingBuf::VXWRingBuf(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmBSem::VXWSmBSem {build a binary shared-memory semaphore object (VxMP Option)} {VXWSmBSem::VXWSmBSem;1\( \)} {VXWSmBSem::VXWSmBSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmCSem::VXWSmCSem {build a shared-memory counting semaphore object (VxMP Option)} {VXWSmCSem::VXWSmCSem;1\( \)} {VXWSmCSem::VXWSmCSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemBlock::VXWSmMemBlock {allocate memory for an array from the shared memory system partition (VxMP Option)} {VXWSmMemBlock::VXWSmMemBlock;1\( \)} {VXWSmMemBlock::VXWSmMemBlock(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmName::nameGet {get name of a shared memory object (VxMP Option)} {VXWSmName::nameGet;1\( \)} {VXWSmName::nameGet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::VXWSymTab {create a symbol-table object } {VXWSymTab::VXWSymTab;1\( \)} {VXWSymTab::VXWSymTab(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {create and spawn a task} {VXWTask::VXWTask;1\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {initialize a task with a specified stack} {VXWTask::VXWTask;2\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::errNo {set error status value } {VXWTask::errNo;1\( \)} {VXWTask::errNo(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::options {change task options} {VXWTask::options;1\( \)} {VXWTask::options(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::priority {change the priority of a task} {VXWTask::priority;1\( \)} {VXWTask::priority(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::registers {get task registers from the TCB} {VXWTask::registers;1\( \)} {VXWTask::registers(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::show {display task information from TCBs} {VXWTask::show;1\( \)} {VXWTask::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::VXWWd {construct a watchdog timer} {VXWWd::VXWWd;1\( \)} {VXWWd::VXWWd(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
eiattach {publish the `ei' network interface and initialize the driver and device} {eiattach\( \)} {eiattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
asin {compute an arc sine (ANSI)} {asin\( \)} {asin(\ )} {VxWorks Reference Manual} Libraries {} {}
acos {compute an arc cosine (ANSI)} {acos\( \)} {acos(\ )} {VxWorks Reference Manual} Libraries {} {}
atan {compute an arc tangent (ANSI)} {atan\( \)} {atan(\ )} {VxWorks Reference Manual} Libraries {} {}
atan2 {compute the arc tangent of y/x (ANSI)} {atan2\( \)} {atan2(\ )} {VxWorks Reference Manual} Libraries {} {}
ceil {compute the smallest integer greater than or equal to a specified value (ANSI)} {ceil\( \)} {ceil(\ )} {VxWorks Reference Manual} Libraries {} {}
cosh {compute a hyperbolic cosine (ANSI)} {cosh\( \)} {cosh(\ )} {VxWorks Reference Manual} Libraries {} {}
exp {compute an exponential value (ANSI)} {exp\( \)} {exp(\ )} {VxWorks Reference Manual} Libraries {} {}
fabs {compute an absolute value (ANSI)} {fabs\( \)} {fabs(\ )} {VxWorks Reference Manual} Libraries {} {}
floor {compute the largest integer less than or equal to a specified value (ANSI)} {floor\( \)} {floor(\ )} {VxWorks Reference Manual} Libraries {} {}
fmod {compute the remainder of x/y (ANSI)} {fmod\( \)} {fmod(\ )} {VxWorks Reference Manual} Libraries {} {}
log {compute a natural logarithm (ANSI)} {log\( \)} {log(\ )} {VxWorks Reference Manual} Libraries {} {}
log10 {compute a base-10 logarithm (ANSI)} {log10\( \)} {log10(\ )} {VxWorks Reference Manual} Libraries {} {}
pow {compute the value of a number raised to a specified power (ANSI)} {pow\( \)} {pow(\ )} {VxWorks Reference Manual} Libraries {} {}
sin {compute a sine (ANSI)} {sin\( \)} {sin(\ )} {VxWorks Reference Manual} Libraries {} {}
cos {compute a cosine (ANSI)} {cos\( \)} {cos(\ )} {VxWorks Reference Manual} Libraries {} {}
sinh {compute a hyperbolic sine (ANSI)} {sinh\( \)} {sinh(\ )} {VxWorks Reference Manual} Libraries {} {}
sqrt {compute a non-negative square root (ANSI)} {sqrt\( \)} {sqrt(\ )} {VxWorks Reference Manual} Libraries {} {}
tan {compute a tangent (ANSI)} {tan\( \)} {tan(\ )} {VxWorks Reference Manual} Libraries {} {}
tanh {compute a hyperbolic tangent (ANSI)} {tanh\( \)} {tanh(\ )} {VxWorks Reference Manual} Libraries {} {}
rcvAddrAdd {add a physical address into the linked list} {rcvAddrAdd;1\( \)} {rcvAddrAdd(\ )} {VxWorks Reference Manual} Libraries {} {}
psrShow {display the meaning of a specified PSR value, symbolically (ARM)} {psrShow;1\( \)} {psrShow(\ )} {VxWorks Reference Manual} Libraries {} {}
r0 {return the contents of general register r0 (also r1-r15) (SH)} {r0;1\( \)} {r0(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {default run-time support for operator new (nothrow) (C++)} {operator new;1\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
{operator new} {run-time support for operator new with placement (C++)} {operator new;2\( \)} {operator new(\ )} {VxWorks Reference Manual} Libraries {} {}
VXWModule::VXWModule {load an object module at specified memory addresses} {VXWModule::VXWModule;1\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {load an object module into memory} {VXWModule::VXWModule;2\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWModule::VXWModule {create and initialize an object module} {VXWModule::VXWModule;3\( \)} {VXWModule::VXWModule(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWList::VXWList {initialize a list as a copy of another} {VXWList::VXWList;1\( \)} {VXWList::VXWList(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWMsgQ::VXWMsgQ {build message-queue object from ID} {VXWMsgQ::VXWMsgQ;1\( \)} {VXWMsgQ::VXWMsgQ(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWRingBuf::VXWRingBuf {build ring-buffer object from existing ID} {VXWRingBuf::VXWRingBuf;1\( \)} {VXWRingBuf::VXWRingBuf(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmBSem::VXWSmBSem {build a binary shared-memory semaphore object (VxMP Option)} {VXWSmBSem::VXWSmBSem;1\( \)} {VXWSmBSem::VXWSmBSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmCSem::VXWSmCSem {build a shared-memory counting semaphore object (VxMP Option)} {VXWSmCSem::VXWSmCSem;1\( \)} {VXWSmCSem::VXWSmCSem(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmMemBlock::VXWSmMemBlock {allocate memory for an array from the shared memory system partition (VxMP Option)} {VXWSmMemBlock::VXWSmMemBlock;1\( \)} {VXWSmMemBlock::VXWSmMemBlock(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSmName::nameGet {get name of a shared memory object (VxMP Option)} {VXWSmName::nameGet;1\( \)} {VXWSmName::nameGet(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWSymTab::VXWSymTab {create a symbol-table object } {VXWSymTab::VXWSymTab;1\( \)} {VXWSymTab::VXWSymTab(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {create and spawn a task} {VXWTask::VXWTask;1\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::VXWTask {initialize a task with a specified stack} {VXWTask::VXWTask;2\( \)} {VXWTask::VXWTask(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::errNo {set error status value } {VXWTask::errNo;1\( \)} {VXWTask::errNo(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::options {change task options} {VXWTask::options;1\( \)} {VXWTask::options(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::priority {change the priority of a task} {VXWTask::priority;1\( \)} {VXWTask::priority(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::registers {get task registers from the TCB} {VXWTask::registers;1\( \)} {VXWTask::registers(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWTask::show {display task information from TCBs} {VXWTask::show;1\( \)} {VXWTask::show(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
VXWWd::VXWWd {construct a watchdog timer} {VXWWd::VXWWd;1\( \)} {VXWWd::VXWWd(\ )} {VxWorks Reference Manual} {Wind Foundation Classes} {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
eiattach {publish the `ei' network interface and initialize the driver and device} {eiattach\( \)} {eiattach(\ )} {VxWorks Reference Manual} Libraries {} {}
eiTxStartup {start output on the chip} {eiTxStartup\( \)} {eiTxStartup(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
dummyCallback {dummy callback routine.} {dummyCallback\( \)} {dummyCallback(\ )} {VxWorks Reference Manual} Libraries {} {}
asin {compute an arc sine (ANSI)} {asin\( \)} {asin(\ )} {VxWorks Reference Manual} Libraries {} {}
acos {compute an arc cosine (ANSI)} {acos\( \)} {acos(\ )} {VxWorks Reference Manual} Libraries {} {}
atan {compute an arc tangent (ANSI)} {atan\( \)} {atan(\ )} {VxWorks Reference Manual} Libraries {} {}
atan2 {compute the arc tangent of y/x (ANSI)} {atan2\( \)} {atan2(\ )} {VxWorks Reference Manual} Libraries {} {}
ceil {compute the smallest integer greater than or equal to a specified value (ANSI)} {ceil\( \)} {ceil(\ )} {VxWorks Reference Manual} Libraries {} {}
cosh {compute a hyperbolic cosine (ANSI)} {cosh\( \)} {cosh(\ )} {VxWorks Reference Manual} Libraries {} {}
exp {compute an exponential value (ANSI)} {exp\( \)} {exp(\ )} {VxWorks Reference Manual} Libraries {} {}
fabs {compute an absolute value (ANSI)} {fabs\( \)} {fabs(\ )} {VxWorks Reference Manual} Libraries {} {}
floor {compute the largest integer less than or equal to a specified value (ANSI)} {floor\( \)} {floor(\ )} {VxWorks Reference Manual} Libraries {} {}
fmod {compute the remainder of x/y (ANSI)} {fmod\( \)} {fmod(\ )} {VxWorks Reference Manual} Libraries {} {}
log {compute a natural logarithm (ANSI)} {log\( \)} {log(\ )} {VxWorks Reference Manual} Libraries {} {}
log10 {compute a base-10 logarithm (ANSI)} {log10\( \)} {log10(\ )} {VxWorks Reference Manual} Libraries {} {}
pow {compute the value of a number raised to a specified power (ANSI)} {pow\( \)} {pow(\ )} {VxWorks Reference Manual} Libraries {} {}
sin {compute a sine (ANSI)} {sin\( \)} {sin(\ )} {VxWorks Reference Manual} Libraries {} {}
cos {compute a cosine (ANSI)} {cos\( \)} {cos(\ )} {VxWorks Reference Manual} Libraries {} {}
sinh {compute a hyperbolic sine (ANSI)} {sinh\( \)} {sinh(\ )} {VxWorks Reference Manual} Libraries {} {}
sqrt {compute a non-negative square root (ANSI)} {sqrt\( \)} {sqrt(\ )} {VxWorks Reference Manual} Libraries {} {}
tan {compute a tangent (ANSI)} {tan\( \)} {tan(\ )} {VxWorks Reference Manual} Libraries {} {}
tanh {compute a hyperbolic tangent (ANSI)} {tanh\( \)} {tanh(\ )} {VxWorks Reference Manual} Libraries {} {}
rcvAddrAdd {add a physical address into the linked list} {rcvAddrAdd;1\( \)} {rcvAddrAdd(\ )} {VxWorks Reference Manual} Libraries {} {}