VxWorks

开发平台：

MultiPlatform

RTN：源码内容

tyIRd {interrupt-level input} {tyIRd( )} {<a href="./tyLib.html#tyIRd">tyIRd</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmBaseLibInit {initialize base virtual memory support} {vmBaseLibInit( )} {<a href="./vmBaseLib.html#vmBaseLibInit">vmBaseLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmBaseGlobalMapInit {initialize global mapping} {vmBaseGlobalMapInit( )} {<a href="./vmBaseLib.html#vmBaseGlobalMapInit">vmBaseGlobalMapInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmBaseStateSet {change the state of a block of virtual memory} {vmBaseStateSet( )} {<a href="./vmBaseLib.html#vmBaseStateSet">vmBaseStateSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmBasePageSizeGet {return the page size} {vmBasePageSizeGet( )} {<a href="./vmBaseLib.html#vmBasePageSizeGet">vmBasePageSizeGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmLibInit {initialize the virtual memory support module (VxVMI Option)} {vmLibInit( )} {<a href="./vmLib.html#vmLibInit">vmLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmGlobalMapInit {initialize global mapping (VxVMI Option)} {vmGlobalMapInit( )} {<a href="./vmLib.html#vmGlobalMapInit">vmGlobalMapInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmContextCreate {create a new virtual memory context (VxVMI Option)} {vmContextCreate( )} {<a href="./vmLib.html#vmContextCreate">vmContextCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmContextDelete {delete a virtual memory context (VxVMI Option)} {vmContextDelete( )} {<a href="./vmLib.html#vmContextDelete">vmContextDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmStateSet {change the state of a block of virtual memory (VxVMI Option)} {vmStateSet( )} {<a href="./vmLib.html#vmStateSet">vmStateSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmStateGet {get the state of a page of virtual memory (VxVMI Option)} {vmStateGet( )} {<a href="./vmLib.html#vmStateGet">vmStateGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmMap {map physical space into virtual space (VxVMI Option)} {vmMap( )} {<a href="./vmLib.html#vmMap">vmMap</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmGlobalMap {map physical pages to virtual space in shared global virtual memory (VxVMI Option)} {vmGlobalMap( )} {<a href="./vmLib.html#vmGlobalMap">vmGlobalMap</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmGlobalInfoGet {get global virtual memory information (VxVMI Option)} {vmGlobalInfoGet( )} {<a href="./vmLib.html#vmGlobalInfoGet">vmGlobalInfoGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmPageBlockSizeGet {get the architecture-dependent page block size (VxVMI Option)} {vmPageBlockSizeGet( )} {<a href="./vmLib.html#vmPageBlockSizeGet">vmPageBlockSizeGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmTranslate {translate a virtual address to a physical address (VxVMI Option)} {vmTranslate( )} {<a href="./vmLib.html#vmTranslate">vmTranslate</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmPageSizeGet {return the page size (VxVMI Option)} {vmPageSizeGet( )} {<a href="./vmLib.html#vmPageSizeGet">vmPageSizeGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmCurrentGet {get the current virtual memory context (VxVMI Option)} {vmCurrentGet( )} {<a href="./vmLib.html#vmCurrentGet">vmCurrentGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmCurrentSet {set the current virtual memory context (VxVMI Option)} {vmCurrentSet( )} {<a href="./vmLib.html#vmCurrentSet">vmCurrentSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmEnable {enable or disable virtual memory (VxVMI Option)} {vmEnable( )} {<a href="./vmLib.html#vmEnable">vmEnable</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmTextProtect {write-protect a text segment (VxVMI Option)} {vmTextProtect( )} {<a href="./vmLib.html#vmTextProtect">vmTextProtect</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmShowInit {include virtual memory show facility (VxVMI Option)} {vmShowInit( )} {<a href="./vmShow.html#vmShowInit">vmShowInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
vmContextShow {display the translation table for a context (VxVMI Option)} {vmContextShow( )} {<a href="./vmShow.html#vmContextShow">vmContextShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
passFsDevInit {associate a device with passFs file system functions} {passFsDevInit( )} {<a href="./passFsLib.html#passFsDevInit">passFsDevInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
passFsInit {prepare to use the passFs library} {passFsInit( )} {<a href="./passFsLib.html#passFsInit">passFsInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
unixDrv {install UNIX disk driver} {unixDrv( )} {<a href="./unixDrv.html#unixDrv">unixDrv</a>( )} {VxWorks Reference Manual} Libraries {} {}
unixDiskDevCreate {create a UNIX disk device} {unixDiskDevCreate( )} {<a href="./unixDrv.html#unixDiskDevCreate">unixDiskDevCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
unixDiskInit {initialize a dosFs disk on top of UNIX} {unixDiskInit( )} {<a href="./unixDrv.html#unixDiskInit">unixDiskInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
ttyDrv {initialize the tty driver} {ttyDrv( )} {<a href="./ttyDrv.html#ttyDrv">ttyDrv</a>( )} {VxWorks Reference Manual} Libraries {} {}
ttyDevCreate {create a VxWorks device for a serial channel} {ttyDevCreate( )} {<a href="./ttyDrv.html#ttyDevCreate">ttyDevCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfGeneralGroupGet {get values of OSPF general group objects (OSPF Option)} {m2OspfGeneralGroupGet( )} {<a href="./ospfLib.html#m2OspfGeneralGroupGet">m2OspfGeneralGroupGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfGeneralGroupSet {set values of OSPF general group objects (OSPF Option)} {m2OspfGeneralGroupSet( )} {<a href="./ospfLib.html#m2OspfGeneralGroupSet">m2OspfGeneralGroupSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfAreaEntryGet {get an entry from the OSPF area table (OSPF Option)} {m2OspfAreaEntryGet( )} {<a href="./ospfLib.html#m2OspfAreaEntryGet">m2OspfAreaEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfAreaEntrySet {set values in an OSPF area entry (OSPF Option)} {m2OspfAreaEntrySet( )} {<a href="./ospfLib.html#m2OspfAreaEntrySet">m2OspfAreaEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfStubAreaEntryGet {get an OSPF stub area entry (OSPF Option)} {m2OspfStubAreaEntryGet( )} {<a href="./ospfLib.html#m2OspfStubAreaEntryGet">m2OspfStubAreaEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfStubAreaEntrySet {set values in an OSPF stub area entry (OSPF Option)} {m2OspfStubAreaEntrySet( )} {<a href="./ospfLib.html#m2OspfStubAreaEntrySet">m2OspfStubAreaEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfLsdbEntryGet {get an OSPF link state database entry (OSPF Option)} {m2OspfLsdbEntryGet( )} {<a href="./ospfLib.html#m2OspfLsdbEntryGet">m2OspfLsdbEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfAreaRangeEntryGet {get an OSPF area range entry (OSPF Option)} {m2OspfAreaRangeEntryGet( )} {<a href="./ospfLib.html#m2OspfAreaRangeEntryGet">m2OspfAreaRangeEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfAreaRangeEntrySet {set values in an OSPF area range entry (OSPF Option)} {m2OspfAreaRangeEntrySet( )} {<a href="./ospfLib.html#m2OspfAreaRangeEntrySet">m2OspfAreaRangeEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfHostEntryGet {get an OSPF host entry (OSPF Option) } {m2OspfHostEntryGet( )} {<a href="./ospfLib.html#m2OspfHostEntryGet">m2OspfHostEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfHostEntrySet {set values in an OSPF host entry (OSPF Option)} {m2OspfHostEntrySet( )} {<a href="./ospfLib.html#m2OspfHostEntrySet">m2OspfHostEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfIfEntryGet {get an OSPF interface entry (OSPF Option) } {m2OspfIfEntryGet( )} {<a href="./ospfLib.html#m2OspfIfEntryGet">m2OspfIfEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfIfEntrySet {set values in an OSPF interface entry (OSPF Option)} {m2OspfIfEntrySet( )} {<a href="./ospfLib.html#m2OspfIfEntrySet">m2OspfIfEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfIfMetricEntryGet {get an OSPF interface metric entry (OSPF Option) } {m2OspfIfMetricEntryGet( )} {<a href="./ospfLib.html#m2OspfIfMetricEntryGet">m2OspfIfMetricEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfIfMetricEntrySet {set OSPF interface metric entry values (OSPF Option)} {m2OspfIfMetricEntrySet( )} {<a href="./ospfLib.html#m2OspfIfMetricEntrySet">m2OspfIfMetricEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfVirtIfEntryGet {get an OSPF virtual interface entry (OSPF Option)} {m2OspfVirtIfEntryGet( )} {<a href="./ospfLib.html#m2OspfVirtIfEntryGet">m2OspfVirtIfEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfVirtIfEntrySet {set OSPF virtual interface entry values (OSPF Option)} {m2OspfVirtIfEntrySet( )} {<a href="./ospfLib.html#m2OspfVirtIfEntrySet">m2OspfVirtIfEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfNbrEntryGet {get an OSPF neighbor entry (OSPF Option) } {m2OspfNbrEntryGet( )} {<a href="./ospfLib.html#m2OspfNbrEntryGet">m2OspfNbrEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfNbrEntrySet {set values in an OSPF neighbor entry (OSPF Option)} {m2OspfNbrEntrySet( )} {<a href="./ospfLib.html#m2OspfNbrEntrySet">m2OspfNbrEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
m2OspfVirtNbrEntryGet {get an OSPF virtual neighbor entry (OSPF Option)} {m2OspfVirtNbrEntryGet( )} {<a href="./ospfLib.html#m2OspfVirtNbrEntryGet">m2OspfVirtNbrEntryGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
ospfExtRouteAdd {import external route into OSPF domain (OSPF Option)} {ospfExtRouteAdd( )} {<a href="./ospfLib.html#ospfExtRouteAdd">ospfExtRouteAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
ospfExtRouteDelete {delete external route imported into OSPF (OSPF Option)} {ospfExtRouteDelete( )} {<a href="./ospfLib.html#ospfExtRouteDelete">ospfExtRouteDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
ospfInit {function to initialize OSPF routing (OSPF Option) } {ospfInit( )} {<a href="./ospfLib.html#ospfInit">ospfInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
ospfNbmaDstAdd {add NBMA destination} {ospfNbmaDstAdd( )} {<a href="./ospfLib.html#ospfNbmaDstAdd">ospfNbmaDstAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
ospfNbmaDstDelete {delete NBMA destination} {ospfNbmaDstDelete( )} {<a href="./ospfLib.html#ospfNbmaDstDelete">ospfNbmaDstDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
ospfTerminate {free OSPF resources and delete OSPF tasks} {ospfTerminate( )} {<a href="./ospfLib.html#ospfTerminate">ospfTerminate</a>( )} {VxWorks Reference Manual} Libraries {} {}
ledOpen {create a new line-editor ID} {ledOpen( )} {<a href="./ledLib.html#ledOpen">ledOpen</a>( )} {VxWorks Reference Manual} Libraries {} {}
ledClose {discard the line-editor ID} {ledClose( )} {<a href="./ledLib.html#ledClose">ledClose</a>( )} {VxWorks Reference Manual} Libraries {} {}
ledRead {read a line with line-editing} {ledRead( )} {<a href="./ledLib.html#ledRead">ledRead</a>( )} {VxWorks Reference Manual} Libraries {} {}
ledControl {change the line-editor ID parameters} {ledControl( )} {<a href="./ledLib.html#ledControl">ledControl</a>( )} {VxWorks Reference Manual} Libraries {} {}
loadModule {load an object module into memory} {loadModule( )} {<a href="./loadLib.html#loadModule">loadModule</a>( )} {VxWorks Reference Manual} Libraries {} {}
loadModuleAt {load an object module into memory} {loadModuleAt( )} {<a href="./loadLib.html#loadModuleAt">loadModuleAt</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginInit {initialize the login table} {loginInit( )} {<a href="./loginLib.html#loginInit">loginInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginUserAdd {add a user to the login table} {loginUserAdd( )} {<a href="./loginLib.html#loginUserAdd">loginUserAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginUserDelete {delete a user entry from the login table} {loginUserDelete( )} {<a href="./loginLib.html#loginUserDelete">loginUserDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginUserVerify {verify a user name and password in the login table} {loginUserVerify( )} {<a href="./loginLib.html#loginUserVerify">loginUserVerify</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginUserShow {display the user login table} {loginUserShow( )} {<a href="./loginLib.html#loginUserShow">loginUserShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginPrompt {display a login prompt and validate a user entry} {loginPrompt( )} {<a href="./loginLib.html#loginPrompt">loginPrompt</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginStringSet {change the login string} {loginStringSet( )} {<a href="./loginLib.html#loginStringSet">loginStringSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginEncryptInstall {install an encryption routine} {loginEncryptInstall( )} {<a href="./loginLib.html#loginEncryptInstall">loginEncryptInstall</a>( )} {VxWorks Reference Manual} Libraries {} {}
loginDefaultEncrypt {default password encryption routine} {loginDefaultEncrypt( )} {<a href="./loginLib.html#loginDefaultEncrypt">loginDefaultEncrypt</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleCreate {create and initialize a module} {moduleCreate( )} {<a href="./moduleLib.html#moduleCreate">moduleCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleDelete {delete module ID information (use unld() to reclaim space)} {moduleDelete( )} {<a href="./moduleLib.html#moduleDelete">moduleDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleShow {show the current status for all the loaded modules} {moduleShow( )} {<a href="./moduleLib.html#moduleShow">moduleShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleSegGet {get (delete and return) the first segment from a module} {moduleSegGet( )} {<a href="./moduleLib.html#moduleSegGet">moduleSegGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleSegFirst {find the first segment in a module} {moduleSegFirst( )} {<a href="./moduleLib.html#moduleSegFirst">moduleSegFirst</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleSegNext {find the next segment in a module} {moduleSegNext( )} {<a href="./moduleLib.html#moduleSegNext">moduleSegNext</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleCreateHookAdd {add a routine to be called when a module is added} {moduleCreateHookAdd( )} {<a href="./moduleLib.html#moduleCreateHookAdd">moduleCreateHookAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleCreateHookDelete {delete a previously added module create hook routine} {moduleCreateHookDelete( )} {<a href="./moduleLib.html#moduleCreateHookDelete">moduleCreateHookDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleFindByName {find a module by name} {moduleFindByName( )} {<a href="./moduleLib.html#moduleFindByName">moduleFindByName</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleFindByNameAndPath {find a module by file name and path} {moduleFindByNameAndPath( )} {<a href="./moduleLib.html#moduleFindByNameAndPath">moduleFindByNameAndPath</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleFindByGroup {find a module by group number} {moduleFindByGroup( )} {<a href="./moduleLib.html#moduleFindByGroup">moduleFindByGroup</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleIdListGet {get a list of loaded modules} {moduleIdListGet( )} {<a href="./moduleLib.html#moduleIdListGet">moduleIdListGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleInfoGet {get information about an object module} {moduleInfoGet( )} {<a href="./moduleLib.html#moduleInfoGet">moduleInfoGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleCheck {verify checksums on all modules} {moduleCheck( )} {<a href="./moduleLib.html#moduleCheck">moduleCheck</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleNameGet {get the name associated with a module ID} {moduleNameGet( )} {<a href="./moduleLib.html#moduleNameGet">moduleNameGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
moduleFlagsGet {get the flags associated with a module ID} {moduleFlagsGet( )} {<a href="./moduleLib.html#moduleFlagsGet">moduleFlagsGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
shellInit {start the shell} {shellInit( )} {<a href="./shellLib.html#shellInit">shellInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
shell {the shell entry point} {shell( )} {<a href="./shellLib.html#shell">shell</a>( )} {VxWorks Reference Manual} Libraries {} {}
shellScriptAbort {signal the shell to stop processing a script} {shellScriptAbort( )} {<a href="./shellLib.html#shellScriptAbort">shellScriptAbort</a>( )} {VxWorks Reference Manual} Libraries {} {}
shellHistory {display or set the size of shell history} {shellHistory( )} {<a href="./shellLib.html#shellHistory">shellHistory</a>( )} {VxWorks Reference Manual} Libraries {} {}
shellPromptSet {change the shell prompt} {shellPromptSet( )} {<a href="./shellLib.html#shellPromptSet">shellPromptSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
shellOrigStdSet {set the shell's default input/output/error file descriptors} {shellOrigStdSet( )} {<a href="./shellLib.html#shellOrigStdSet">shellOrigStdSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
shellLock {lock access to the shell} {shellLock( )} {<a href="./shellLib.html#shellLock">shellLock</a>( )} {VxWorks Reference Manual} Libraries {} {}
spyLibInit {initialize task cpu utilization tool package} {spyLibInit( )} {<a href="./spyLib.html#spyLibInit">spyLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexInit {include the execution timer library} {timexInit( )} {<a href="./timexLib.html#timexInit">timexInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexClear {clear the list of function calls to be timed} {timexClear( )} {<a href="./timexLib.html#timexClear">timexClear</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexFunc {specify functions to be timed} {timexFunc( )} {<a href="./timexLib.html#timexFunc">timexFunc</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexHelp {display synopsis of execution timer facilities} {timexHelp( )} {<a href="./timexLib.html#timexHelp">timexHelp</a>( )} {VxWorks Reference Manual} Libraries {} {}
timex {time a single execution of a function or functions} {timex( )} {<a href="./timexLib.html#timex">timex</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexN {time repeated executions of a function or group of functions} {timexN( )} {<a href="./timexLib.html#timexN">timexN</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexPost {specify functions to be called after timing} {timexPost( )} {<a href="./timexLib.html#timexPost">timexPost</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexPre {specify functions to be called prior to timing} {timexPre( )} {<a href="./timexLib.html#timexPre">timexPre</a>( )} {VxWorks Reference Manual} Libraries {} {}
timexShow {display the list of function calls to be timed} {timexShow( )} {<a href="./timexLib.html#timexShow">timexShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
unld {unload an object module by specifying a file name or module ID} {unld( )} {<a href="./unldLib.html#unld">unld</a>( )} {VxWorks Reference Manual} Libraries {} {}
unldByModuleId {unload an object module by specifying a module ID} {unldByModuleId( )} {<a href="./unldLib.html#unldByModuleId">unldByModuleId</a>( )} {VxWorks Reference Manual} Libraries {} {}
unldByNameAndPath {unload an object module by specifying a name and path} {unldByNameAndPath( )} {<a href="./unldLib.html#unldByNameAndPath">unldByNameAndPath</a>( )} {VxWorks Reference Manual} Libraries {} {}
unldByGroup {unload an object module by specifying a group number} {unldByGroup( )} {<a href="./unldLib.html#unldByGroup">unldByGroup</a>( )} {VxWorks Reference Manual} Libraries {} {}
reld {reload an object module} {reld( )} {<a href="./unldLib.html#reld">reld</a>( )} {VxWorks Reference Manual} Libraries {} {}
dbgHelp {display debugging help menu} {dbgHelp( )} {<a href="./dbgLib.html#dbgHelp">dbgHelp</a>( )} {VxWorks Reference Manual} Libraries {} {}
dbgInit {initialize the local debugging package} {dbgInit( )} {<a href="./dbgLib.html#dbgInit">dbgInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
b {set or display breakpoints} {b( )} {<a href="./dbgLib.html#b">b</a>( )} {VxWorks Reference Manual} Libraries {} {}
e {set or display eventpoints (WindView)} {e( )} {<a href="./dbgLib.html#e">e</a>( )} {VxWorks Reference Manual} Libraries {} {}
bh {set a hardware breakpoint} {bh( )} {<a href="./dbgLib.html#bh">bh</a>( )} {VxWorks Reference Manual} Libraries {} {}
bd {delete a breakpoint} {bd( )} {<a href="./dbgLib.html#bd">bd</a>( )} {VxWorks Reference Manual} Libraries {} {}
bdall {delete all breakpoints} {bdall( )} {<a href="./dbgLib.html#bdall">bdall</a>( )} {VxWorks Reference Manual} Libraries {} {}
c {continue from a breakpoint} {c( )} {<a href="./dbgLib.html#c">c</a>( )} {VxWorks Reference Manual} Libraries {} {}
cret {continue until the current subroutine returns} {cret( )} {<a href="./dbgLib.html#cret">cret</a>( )} {VxWorks Reference Manual} Libraries {} {}
s {single-step a task} {s( )} {<a href="./dbgLib.html#s">s</a>( )} {VxWorks Reference Manual} Libraries {} {}
so {single-step, but step over a subroutine} {so( )} {<a href="./dbgLib.html#so">so</a>( )} {VxWorks Reference Manual} Libraries {} {}
l {disassemble and display a specified number of instructions} {l( )} {<a href="./dbgLib.html#l">l</a>( )} {VxWorks Reference Manual} Libraries {} {}
tt {display a stack trace of a task} {tt( )} {<a href="./dbgLib.html#tt">tt</a>( )} {VxWorks Reference Manual} Libraries {} {}
aioPxLibInit {initialize the asynchronous I/O (AIO) library} {aioPxLibInit( )} {<a href="./aioPxLib.html#aioPxLibInit">aioPxLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
aio_read {initiate an asynchronous read (POSIX)} {aio_read( )} {<a href="./aioPxLib.html#aio_read">aio_read</a>( )} {VxWorks Reference Manual} Libraries {} {}
aio_write {initiate an asynchronous write (POSIX)} {aio_write( )} {<a href="./aioPxLib.html#aio_write">aio_write</a>( )} {VxWorks Reference Manual} Libraries {} {}
lio_listio {initiate a list of asynchronous I/O requests (POSIX)} {lio_listio( )} {<a href="./aioPxLib.html#lio_listio">lio_listio</a>( )} {VxWorks Reference Manual} Libraries {} {}
aio_suspend {wait for asynchronous I/O request(s) (POSIX)} {aio_suspend( )} {<a href="./aioPxLib.html#aio_suspend">aio_suspend</a>( )} {VxWorks Reference Manual} Libraries {} {}
aio_fsync {asynchronous file synchronization (POSIX)} {aio_fsync( )} {<a href="./aioPxLib.html#aio_fsync">aio_fsync</a>( )} {VxWorks Reference Manual} Libraries {} {}
aio_error {retrieve error status of asynchronous I/O operation (POSIX)} {aio_error( )} {<a href="./aioPxLib.html#aio_error">aio_error</a>( )} {VxWorks Reference Manual} Libraries {} {}
aio_return {retrieve return status of asynchronous I/O operation (POSIX)} {aio_return( )} {<a href="./aioPxLib.html#aio_return">aio_return</a>( )} {VxWorks Reference Manual} Libraries {} {}
aioShow {show AIO requests } {aioShow( )} {<a href="./aioPxShow.html#aioShow">aioShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
aioSysInit {initialize the AIO system driver} {aioSysInit( )} {<a href="./aioSysDrv.html#aioSysInit">aioSysInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
mlockall {lock all pages used by a process into memory (POSIX)} {mlockall( )} {<a href="./mmanPxLib.html#mlockall">mlockall</a>( )} {VxWorks Reference Manual} Libraries {} {}
munlockall {unlock all pages used by a process (POSIX)} {munlockall( )} {<a href="./mmanPxLib.html#munlockall">munlockall</a>( )} {VxWorks Reference Manual} Libraries {} {}
mlock {lock specified pages into memory (POSIX)} {mlock( )} {<a href="./mmanPxLib.html#mlock">mlock</a>( )} {VxWorks Reference Manual} Libraries {} {}
munlock {unlock specified pages (POSIX)} {munlock( )} {<a href="./mmanPxLib.html#munlock">munlock</a>( )} {VxWorks Reference Manual} Libraries {} {}
mqPxLibInit {initialize the POSIX message queue library} {mqPxLibInit( )} {<a href="./mqPxLib.html#mqPxLibInit">mqPxLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_open {open a message queue (POSIX)} {mq_open( )} {<a href="./mqPxLib.html#mq_open">mq_open</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_receive {receive a message from a message queue (POSIX)} {mq_receive( )} {<a href="./mqPxLib.html#mq_receive">mq_receive</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_send {send a message to a message queue (POSIX)} {mq_send( )} {<a href="./mqPxLib.html#mq_send">mq_send</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_close {close a message queue (POSIX)} {mq_close( )} {<a href="./mqPxLib.html#mq_close">mq_close</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_unlink {remove a message queue (POSIX)} {mq_unlink( )} {<a href="./mqPxLib.html#mq_unlink">mq_unlink</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_notify {notify a task that a message is available on a queue (POSIX)} {mq_notify( )} {<a href="./mqPxLib.html#mq_notify">mq_notify</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_setattr {set message queue attributes (POSIX)} {mq_setattr( )} {<a href="./mqPxLib.html#mq_setattr">mq_setattr</a>( )} {VxWorks Reference Manual} Libraries {} {}
mq_getattr {get message queue attributes (POSIX)} {mq_getattr( )} {<a href="./mqPxLib.html#mq_getattr">mq_getattr</a>( )} {VxWorks Reference Manual} Libraries {} {}
mqPxShowInit {initialize the POSIX message queue show facility} {mqPxShowInit( )} {<a href="./mqPxShow.html#mqPxShowInit">mqPxShowInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
semPxShowInit {initialize the POSIX semaphore show facility} {semPxShowInit( )} {<a href="./semPxShow.html#semPxShowInit">semPxShowInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_setparam {set a task's priority (POSIX)} {sched_setparam( )} {<a href="./schedPxLib.html#sched_setparam">sched_setparam</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_getparam {get the scheduling parameters for a specified task (POSIX)} {sched_getparam( )} {<a href="./schedPxLib.html#sched_getparam">sched_getparam</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_setscheduler {set scheduling policy and scheduling parameters (POSIX)} {sched_setscheduler( )} {<a href="./schedPxLib.html#sched_setscheduler">sched_setscheduler</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_getscheduler {get the current scheduling policy (POSIX)} {sched_getscheduler( )} {<a href="./schedPxLib.html#sched_getscheduler">sched_getscheduler</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_yield {relinquish the CPU (POSIX)} {sched_yield( )} {<a href="./schedPxLib.html#sched_yield">sched_yield</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_get_priority_max {get the maximum priority (POSIX)} {sched_get_priority_max( )} {<a href="./schedPxLib.html#sched_get_priority_max">sched_get_priority_max</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_get_priority_min {get the minimum priority (POSIX)} {sched_get_priority_min( )} {<a href="./schedPxLib.html#sched_get_priority_min">sched_get_priority_min</a>( )} {VxWorks Reference Manual} Libraries {} {}
sched_rr_get_interval {get the current time slice (POSIX)} {sched_rr_get_interval( )} {<a href="./schedPxLib.html#sched_rr_get_interval">sched_rr_get_interval</a>( )} {VxWorks Reference Manual} Libraries {} {}
semPxLibInit {initialize POSIX semaphore support} {semPxLibInit( )} {<a href="./semPxLib.html#semPxLibInit">semPxLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_init {initialize an unnamed semaphore (POSIX)} {sem_init( )} {<a href="./semPxLib.html#sem_init">sem_init</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_destroy {destroy an unnamed semaphore (POSIX)} {sem_destroy( )} {<a href="./semPxLib.html#sem_destroy">sem_destroy</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_open {initialize/open a named semaphore (POSIX)} {sem_open( )} {<a href="./semPxLib.html#sem_open">sem_open</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_close {close a named semaphore (POSIX)} {sem_close( )} {<a href="./semPxLib.html#sem_close">sem_close</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_unlink {remove a named semaphore (POSIX)} {sem_unlink( )} {<a href="./semPxLib.html#sem_unlink">sem_unlink</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_wait {lock (take) a semaphore, blocking if not available (POSIX)} {sem_wait( )} {<a href="./semPxLib.html#sem_wait">sem_wait</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_trywait {lock (take) a semaphore, returning error if unavailable (POSIX)} {sem_trywait( )} {<a href="./semPxLib.html#sem_trywait">sem_trywait</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_post {unlock (give) a semaphore (POSIX)} {sem_post( )} {<a href="./semPxLib.html#sem_post">sem_post</a>( )} {VxWorks Reference Manual} Libraries {} {}
sem_getvalue {get the value of a semaphore (POSIX)} {sem_getvalue( )} {<a href="./semPxLib.html#sem_getvalue">sem_getvalue</a>( )} {VxWorks Reference Manual} Libraries {} {}
ftruncate {truncate a file (POSIX)} {ftruncate( )} {<a href="./ftruncate.html#ftruncate">ftruncate</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripLibInit {initialize the RIP routing library} {ripLibInit( )} {<a href="./ripLib.html#ripLibInit">ripLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripRouteShow {display the internal routing table maintained by RIP} {ripRouteShow( )} {<a href="./ripLib.html#ripRouteShow">ripRouteShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripAuthHookAdd {add an authentication hook to a RIP interface} {ripAuthHookAdd( )} {<a href="./ripLib.html#ripAuthHookAdd">ripAuthHookAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripAuthHookDelete {remove an authentication hook from a RIP interface} {ripAuthHookDelete( )} {<a href="./ripLib.html#ripAuthHookDelete">ripAuthHookDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripAuthHook {sample authentication hook} {ripAuthHook( )} {<a href="./ripLib.html#ripAuthHook">ripAuthHook</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripLeakHookAdd {add a hook to bypass the RIP and kernel routing tables} {ripLeakHookAdd( )} {<a href="./ripLib.html#ripLeakHookAdd">ripLeakHookAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripLeakHookDelete {remove a table bypass hook from a RIP interface} {ripLeakHookDelete( )} {<a href="./ripLib.html#ripLeakHookDelete">ripLeakHookDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripSendHookAdd {add an update filter to a RIP interface} {ripSendHookAdd( )} {<a href="./ripLib.html#ripSendHookAdd">ripSendHookAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripSendHookDelete {remove an update filter from a RIP interface} {ripSendHookDelete( )} {<a href="./ripLib.html#ripSendHookDelete">ripSendHookDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripIfSearch {add new interfaces to the internal list} {ripIfSearch( )} {<a href="./ripLib.html#ripIfSearch">ripIfSearch</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripIfReset {alter the RIP configuration after an interface changes} {ripIfReset( )} {<a href="./ripLib.html#ripIfReset">ripIfReset</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripFilterEnable {activate strict border gateway filtering} {ripFilterEnable( )} {<a href="./ripLib.html#ripFilterEnable">ripFilterEnable</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripFilterDisable {prevent strict border gateway filtering} {ripFilterDisable( )} {<a href="./ripLib.html#ripFilterDisable">ripFilterDisable</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripShutdown {terminate all RIP processing} {ripShutdown( )} {<a href="./ripLib.html#ripShutdown">ripShutdown</a>( )} {VxWorks Reference Manual} Libraries {} {}
ripDebugLevelSet {specify amount of debugging output} {ripDebugLevelSet( )} {<a href="./ripLib.html#ripDebugLevelSet">ripDebugLevelSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdPktProcess {process a packet returned by the transport} {snmpdPktProcess( )} {<a href="./snmpdLib.html#snmpdPktProcess">snmpdPktProcess</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdLog {log messages from the SNMP agent } {snmpdLog( )} {<a href="./snmpdLib.html#snmpdLog">snmpdLog</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdViewEntrySet {install an entry in the view table} {snmpdViewEntrySet( )} {<a href="./snmpdLib.html#snmpdViewEntrySet">snmpdViewEntrySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdViewEntryRemove {remove an entry from the view table} {snmpdViewEntryRemove( )} {<a href="./snmpdLib.html#snmpdViewEntryRemove">snmpdViewEntryRemove</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdTreeAdd {dynamically add a subtree to the SNMP agent MIB tree} {snmpdTreeAdd( )} {<a href="./snmpdLib.html#snmpdTreeAdd">snmpdTreeAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdTreeRemove {dynamically remove part of the SNMP agent MIB tree} {snmpdTreeRemove( )} {<a href="./snmpdLib.html#snmpdTreeRemove">snmpdTreeRemove</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdTrapSend {general interface to trap facilities} {snmpdTrapSend( )} {<a href="./snmpdLib.html#snmpdTrapSend">snmpdTrapSend</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdInitFinish {complete the initialization of the agent} {snmpdInitFinish( )} {<a href="./snmpdLib.html#snmpdInitFinish">snmpdInitFinish</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdExit {exit the SNMP agent} {snmpdExit( )} {<a href="./snmpdLib.html#snmpdExit">snmpdExit</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdContinue {continue processing of an SNMP packet} {snmpdContinue( )} {<a href="./snmpdLib.html#snmpdContinue">snmpdContinue</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdGroupByGetprocAndInstance {gather set of similar variable bindings} {snmpdGroupByGetprocAndInstance( )} {<a href="./snmpdLib.html#snmpdGroupByGetprocAndInstance">snmpdGroupByGetprocAndInstance</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdVbRowExtract {extract required pieces of a row for a `set' operation} {snmpdVbRowExtract( )} {<a href="./snmpdLib.html#snmpdVbRowExtract">snmpdVbRowExtract</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdVbExtractRowLoose {incrementally extract pieces of a row for a set } {snmpdVbExtractRowLoose( )} {<a href="./snmpdLib.html#snmpdVbExtractRowLoose">snmpdVbExtractRowLoose</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdPktLockGet {lock an SNMP packet } {snmpdPktLockGet( )} {<a href="./snmpdLib.html#snmpdPktLockGet">snmpdPktLockGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpIoInit {initialization routine for SNMP transport endpoint} {snmpIoInit( )} {<a href="./snmpIoLib.html#snmpIoInit">snmpIoInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpIoWrite {write a packet to the transport} {snmpIoWrite( )} {<a href="./snmpIoLib.html#snmpIoWrite">snmpIoWrite</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpIoClose {close the transport endpoint.} {snmpIoClose( )} {<a href="./snmpIoLib.html#snmpIoClose">snmpIoClose</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpIoMain {main SNMP I/O routine} {snmpIoMain( )} {<a href="./snmpIoLib.html#snmpIoMain">snmpIoMain</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpIoTrapSend {send a standard SNMP or MIB-II trap} {snmpIoTrapSend( )} {<a href="./snmpIoLib.html#snmpIoTrapSend">snmpIoTrapSend</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpIoCommunityValidate {sample community validation routine} {snmpIoCommunityValidate( )} {<a href="./snmpIoLib.html#snmpIoCommunityValidate">snmpIoCommunityValidate</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdMemoryAlloc {allocate memory for the SNMP agent} {snmpdMemoryAlloc( )} {<a href="./snmpIoLib.html#snmpdMemoryAlloc">snmpdMemoryAlloc</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpdMemoryFree {free memory allocated by the SNMP agent} {snmpdMemoryFree( )} {<a href="./snmpIoLib.html#snmpdMemoryFree">snmpdMemoryFree</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpSubEncode {encode a packet for transmission to master agent or subagent} {snmpSubEncode( )} {<a href="./subagentLib.html#snmpSubEncode">snmpSubEncode</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerAsync {asynchronous message processing routine for the subagent} {snmpSaHandlerAsync( )} {<a href="./subagentLib.html#snmpSaHandlerAsync">snmpSaHandlerAsync</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerWR {provide snmpSaHandlerAsync() functionality synchronously} {snmpSaHandlerWR( )} {<a href="./subagentLib.html#snmpSaHandlerWR">snmpSaHandlerWR</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerContinue {subagent continuation function} {snmpSaHandlerContinue( )} {<a href="./subagentLib.html#snmpSaHandlerContinue">snmpSaHandlerContinue</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerFinish {encode packet for subagent IO completion} {snmpSaHandlerFinish( )} {<a href="./subagentLib.html#snmpSaHandlerFinish">snmpSaHandlerFinish</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpSaHandlerCleanup {cleanup routine for subagent} {snmpSaHandlerCleanup( )} {<a href="./subagentLib.html#snmpSaHandlerCleanup">snmpSaHandlerCleanup</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterHandlerAsync {process messages from the subagent asynchronously} {snmpMasterHandlerAsync( )} {<a href="./subagentLib.html#snmpMasterHandlerAsync">snmpMasterHandlerAsync</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterHandlerWR {synchronous version of snmpMasterHandlerAsync()} {snmpMasterHandlerWR( )} {<a href="./subagentLib.html#snmpMasterHandlerWR">snmpMasterHandlerWR</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterQueryHandler {handles replies from the subagent} {snmpMasterQueryHandler( )} {<a href="./subagentLib.html#snmpMasterQueryHandler">snmpMasterQueryHandler</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpMasterCleanup {free up resources after a query times out} {snmpMasterCleanup( )} {<a href="./subagentLib.html#snmpMasterCleanup">snmpMasterCleanup</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterIoInit {create the IPC mechanism at the SNMP master agent} {masterIoInit( )} {<a href="./masterIoLib.html#masterIoInit">masterIoInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpMonitorSpawn {spawn 'tMonQue' to run snmpQueMonitor()} {snmpMonitorSpawn( )} {<a href="./masterIoLib.html#snmpMonitorSpawn">snmpMonitorSpawn</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterIpcComp {transmit a completion of transmission message} {masterIpcComp( )} {<a href="./masterIoLib.html#masterIpcComp">masterIpcComp</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterIoWrite {send the encoded buffer to the subagent} {masterIoWrite( )} {<a href="./masterIoLib.html#masterIoWrite">masterIoWrite</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterIpcSend {send a message to a subagent} {masterIpcSend( )} {<a href="./masterIoLib.html#masterIpcSend">masterIpcSend</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterIpcRcv {wait for a reply from the subagent} {masterIpcRcv( )} {<a href="./masterIoLib.html#masterIpcRcv">masterIpcRcv</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterIpcAyt {check the status of the IPC link} {masterIpcAyt( )} {<a href="./masterIoLib.html#masterIpcAyt">masterIpcAyt</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterIpcFree {free the IPC resources allocated by the SNMP master agent} {masterIpcFree( )} {<a href="./masterIoLib.html#masterIpcFree">masterIpcFree</a>( )} {VxWorks Reference Manual} Libraries {} {}
masterQueCleanup {free resources allocated for SNMP master agent} {masterQueCleanup( )} {<a href="./masterIoLib.html#masterQueCleanup">masterQueCleanup</a>( )} {VxWorks Reference Manual} Libraries {} {}
snmpSaInit {initialize the subagent} {snmpSaInit( )} {<a href="./saIoLib.html#snmpSaInit">snmpSaInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
saIoWrite {send a packet to the master agent's message queue} {saIoWrite( )} {<a href="./saIoLib.html#saIoWrite">saIoWrite</a>( )} {VxWorks Reference Manual} Libraries {} {}
saIpcFree {free the specified IPC mechanism} {saIpcFree( )} {<a href="./saIoLib.html#saIpcFree">saIpcFree</a>( )} {VxWorks Reference Manual} Libraries {} {}
saMsgBuild {build and encode a message and send it to the master agent} {saMsgBuild( )} {<a href="./saIoLib.html#saMsgBuild">saMsgBuild</a>( )} {VxWorks Reference Manual} Libraries {} {}
hdrBlkBuild {create the header block and the demuxer information} {hdrBlkBuild( )} {<a href="./saIoLib.html#hdrBlkBuild">hdrBlkBuild</a>( )} {VxWorks Reference Manual} Libraries {} {}
envoy_now {return the number of clock ticks elapsed since the timer was set} {envoy_now( )} {<a href="./saIoLib.html#envoy_now">envoy_now</a>( )} {VxWorks Reference Manual} Libraries {} {}
envoy_call_timer {execute the specified function when the timer expires} {envoy_call_timer( )} {<a href="./saIoLib.html#envoy_call_timer">envoy_call_timer</a>( )} {VxWorks Reference Manual} Libraries {} {}
ip_to_rlist {convert an IP address to an array of OID components} {ip_to_rlist( )} {<a href="./snmpAuxLib.html#ip_to_rlist">ip_to_rlist</a>( )} {VxWorks Reference Manual} Libraries {} {}
oidcmp {compare two object identifiers} {oidcmp( )} {<a href="./snmpAuxLib.html#oidcmp">oidcmp</a>( )} {VxWorks Reference Manual} Libraries {} {}
oidcmp2 {compare two object identifiers} {oidcmp2( )} {<a href="./snmpAuxLib.html#oidcmp2">oidcmp2</a>( )} {VxWorks Reference Manual} Libraries {} {}
oid_to_ip {convert an object identifier to an IP address} {oid_to_ip( )} {<a href="./snmpAuxLib.html#oid_to_ip">oid_to_ip</a>( )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Unsigned_Integer {bind an unsigned-integer variable} {SNMP_Bind_Unsigned_Integer( )} {<a href="./snmpBindLib.html#SNMP_Bind_Unsigned_Integer">SNMP_Bind_Unsigned_Integer</a>( )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Integer {bind an integer variable} {SNMP_Bind_Integer( )} {<a href="./snmpBindLib.html#SNMP_Bind_Integer">SNMP_Bind_Integer</a>( )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_IP_Address {bind an IP address variable} {SNMP_Bind_IP_Address( )} {<a href="./snmpBindLib.html#SNMP_Bind_IP_Address">SNMP_Bind_IP_Address</a>( )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Object_ID {bind an object-identifier variable} {SNMP_Bind_Object_ID( )} {<a href="./snmpBindLib.html#SNMP_Bind_Object_ID">SNMP_Bind_Object_ID</a>( )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_String {bind a string variable} {SNMP_Bind_String( )} {<a href="./snmpBindLib.html#SNMP_Bind_String">SNMP_Bind_String</a>( )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_64_Unsigned_Integer {bind a 64-bit unsigned-integer variable} {SNMP_Bind_64_Unsigned_Integer( )} {<a href="./snmpBindLib.html#SNMP_Bind_64_Unsigned_Integer">SNMP_Bind_64_Unsigned_Integer</a>( )} {VxWorks Reference Manual} Libraries {} {}
SNMP_Bind_Null {bind a null-valued variable} {SNMP_Bind_Null( )} {<a href="./snmpBindLib.html#SNMP_Bind_Null">SNMP_Bind_Null</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferClone {make a copy of an extended buffer } {EBufferClone( )} {<a href="./snmpEbufLib.html#EBufferClone">EBufferClone</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferClean {release dynamic memory in an extended buffer} {EBufferClean( )} {<a href="./snmpEbufLib.html#EBufferClean">EBufferClean</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferInitialize {place an extended buffer in a known state} {EBufferInitialize( )} {<a href="./snmpEbufLib.html#EBufferInitialize">EBufferInitialize</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferSetup {attach an empty memory buffer to an extended buffer} {EBufferSetup( )} {<a href="./snmpEbufLib.html#EBufferSetup">EBufferSetup</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferPreLoad {attach a full memory buffer to an extended buffer} {EBufferPreLoad( )} {<a href="./snmpEbufLib.html#EBufferPreLoad">EBufferPreLoad</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferNext {return a pointer to the next unused byte of the buffer memory} {EBufferNext( )} {<a href="./snmpEbufLib.html#EBufferNext">EBufferNext</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferStart {return a pointer to the first byte in the buffer memory} {EBufferStart( )} {<a href="./snmpEbufLib.html#EBufferStart">EBufferStart</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferUsed {return the number of used bytes in the buffer memory} {EBufferUsed( )} {<a href="./snmpEbufLib.html#EBufferUsed">EBufferUsed</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferReset {reset the extended buffer} {EBufferReset( )} {<a href="./snmpEbufLib.html#EBufferReset">EBufferReset</a>( )} {VxWorks Reference Manual} Libraries {} {}
EBufferRemaining {return the number of unused bytes remaining in buffer memory} {EBufferRemaining( )} {<a href="./snmpEbufLib.html#EBufferRemaining">EBufferRemaining</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_started {indicate that a `getproc' operation has begun} {getproc_started( )} {<a href="./snmpProcLib.html#getproc_started">getproc_started</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_good {indicate successful completion of a `getproc' procedure} {getproc_good( )} {<a href="./snmpProcLib.html#getproc_good">getproc_good</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_error {indicate that a `getproc' operation encountered an error} {getproc_error( )} {<a href="./snmpProcLib.html#getproc_error">getproc_error</a>( )} {VxWorks Reference Manual} Libraries {} {}
nextproc_started {indicate that a `nextproc' operation has begun} {nextproc_started( )} {<a href="./snmpProcLib.html#nextproc_started">nextproc_started</a>( )} {VxWorks Reference Manual} Libraries {} {}
nextproc_good {indicate successful completion of a `nextproc' procedure} {nextproc_good( )} {<a href="./snmpProcLib.html#nextproc_good">nextproc_good</a>( )} {VxWorks Reference Manual} Libraries {} {}
nextproc_no_next {indicate that there exists no next instance } {nextproc_no_next( )} {<a href="./snmpProcLib.html#nextproc_no_next">nextproc_no_next</a>( )} {VxWorks Reference Manual} Libraries {} {}
nextproc_error {indicate that a `nextproc' operation encountered an error} {nextproc_error( )} {<a href="./snmpProcLib.html#nextproc_error">nextproc_error</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_int32 {indicate retrieval of a 32-bit integer} {getproc_got_int32( )} {<a href="./snmpProcLib.html#getproc_got_int32">getproc_got_int32</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_uint32 {indicate retrieval of a 32-bit unsigned integer} {getproc_got_uint32( )} {<a href="./snmpProcLib.html#getproc_got_uint32">getproc_got_uint32</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_ip_address {indicate retrieval of an IP address} {getproc_got_ip_address( )} {<a href="./snmpProcLib.html#getproc_got_ip_address">getproc_got_ip_address</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_empty {indicate retrieval of a null value} {getproc_got_empty( )} {<a href="./snmpProcLib.html#getproc_got_empty">getproc_got_empty</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_string {indicate retrieval of a string} {getproc_got_string( )} {<a href="./snmpProcLib.html#getproc_got_string">getproc_got_string</a>( )} {VxWorks Reference Manual} Libraries {} {}
testproc_started {indicate that a `testproc' operation has begun} {testproc_started( )} {<a href="./snmpProcLib.html#testproc_started">testproc_started</a>( )} {VxWorks Reference Manual} Libraries {} {}
testproc_good {indicate successful completion of a `testproc' procedure} {testproc_good( )} {<a href="./snmpProcLib.html#testproc_good">testproc_good</a>( )} {VxWorks Reference Manual} Libraries {} {}
testproc_error {indicate that a `testproc' operation encountered an error} {testproc_error( )} {<a href="./snmpProcLib.html#testproc_error">testproc_error</a>( )} {VxWorks Reference Manual} Libraries {} {}
setproc_started {indicate that a `setproc' operation has begun} {setproc_started( )} {<a href="./snmpProcLib.html#setproc_started">setproc_started</a>( )} {VxWorks Reference Manual} Libraries {} {}
setproc_good {indicates successful completion of a `setproc' procedure} {setproc_good( )} {<a href="./snmpProcLib.html#setproc_good">setproc_good</a>( )} {VxWorks Reference Manual} Libraries {} {}
setproc_error {indicate that a `setproc' operation encountered an error} {setproc_error( )} {<a href="./snmpProcLib.html#setproc_error">setproc_error</a>( )} {VxWorks Reference Manual} Libraries {} {}
undoproc_started {indicate that an `undoproc' operation has begun} {undoproc_started( )} {<a href="./snmpProcLib.html#undoproc_started">undoproc_started</a>( )} {VxWorks Reference Manual} Libraries {} {}
undoproc_good {indicates successful completion of an `undoproc' operation} {undoproc_good( )} {<a href="./snmpProcLib.html#undoproc_good">undoproc_good</a>( )} {VxWorks Reference Manual} Libraries {} {}
undoproc_error {indicate that an `undproc' operation encountered an error} {undoproc_error( )} {<a href="./snmpProcLib.html#undoproc_error">undoproc_error</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_uint64 {indicate retrieval of a 64-bit unsigned integer} {getproc_got_uint64( )} {<a href="./snmpProcLib.html#getproc_got_uint64">getproc_got_uint64</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_uint64_high_low {indicate retrieval of a 64-bit unsigned} {getproc_got_uint64_high_low( )} {<a href="./snmpProcLib.html#getproc_got_uint64_high_low">getproc_got_uint64_high_low</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_nosuchins {indicates that no such instance exists} {getproc_nosuchins( )} {<a href="./snmpProcLib.html#getproc_nosuchins">getproc_nosuchins</a>( )} {VxWorks Reference Manual} Libraries {} {}
getproc_got_object_id {indicate retrieval of an object identifier} {getproc_got_object_id( )} {<a href="./snmpProcLib.html#getproc_got_object_id">getproc_got_object_id</a>( )} {VxWorks Reference Manual} Libraries {} {}
nextproc_next_instance {install instance part of next instance} {nextproc_next_instance( )} {<a href="./snmpProcLib.html#nextproc_next_instance">nextproc_next_instance</a>( )} {VxWorks Reference Manual} Libraries {} {}
autopushAdd {add a list of automatically pushed STREAMS modules (STREAMS Option)} {autopushAdd( )} {<a href="./autopushLib.html#autopushAdd">autopushAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
autopushDelete {delete autopush information for a device (STREAMS Option)} {autopushDelete( )} {<a href="./autopushLib.html#autopushDelete">autopushDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
autopushGet {get autopush information for a device (STREAMS Option)} {autopushGet( )} {<a href="./autopushLib.html#autopushGet">autopushGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
strace {print STREAMS trace messages (STREAMS Option)} {strace( )} {<a href="./straceLib.html#strace">strace</a>( )} {VxWorks Reference Manual} Libraries {} {}
straceStop {stop the strace() task (STREAMS Option)} {straceStop( )} {<a href="./straceLib.html#straceStop">straceStop</a>( )} {VxWorks Reference Manual} Libraries {} {}
strerr {STREAMS error logger task (STREAMS Option)} {strerr( )} {<a href="./strerrLib.html#strerr">strerr</a>( )} {VxWorks Reference Manual} Libraries {} {}
strerrStop {stop the strerr() task (STREAMS Option)} {strerrStop( )} {<a href="./strerrLib.html#strerrStop">strerrStop</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmSockProtoAdd {add a new transport-protocol entry to STREAMS sockets (STREAMS Option)} {strmSockProtoAdd( )} {<a href="./strmSockLib.html#strmSockProtoAdd">strmSockProtoAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmSockProtoDelete {remove a protocol entry from the table (STREAMS Option)} {strmSockProtoDelete( )} {<a href="./strmSockLib.html#strmSockProtoDelete">strmSockProtoDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmSockDevNameGet {get the transport-provider device name (STREAMS Option)} {strmSockDevNameGet( )} {<a href="./strmSockLib.html#strmSockDevNameGet">strmSockDevNameGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmDebugInit {include STREAMS debugging facility in VxWorks (STREAMS Option)} {strmDebugInit( )} {<a href="./strmShow.html#strmDebugInit">strmDebugInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmOpenStreamsShow {display all open streams in the STREAMS subsystem (STREAMS Option)} {strmOpenStreamsShow( )} {<a href="./strmShow.html#strmOpenStreamsShow">strmOpenStreamsShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmQueueShow {display all queues in a particular stream (STREAMS Option)} {strmQueueShow( )} {<a href="./strmShow.html#strmQueueShow">strmQueueShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmBandShow {display messages in a particular band (STREAMS Option)} {strmBandShow( )} {<a href="./strmShow.html#strmBandShow">strmBandShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmMessageShow {display information about all messages in a stream (STREAMS Option)} {strmMessageShow( )} {<a href="./strmShow.html#strmMessageShow">strmMessageShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmQueueStatShow {display statistics about queues system-wide (STREAMS Option)} {strmQueueStatShow( )} {<a href="./strmShow.html#strmQueueStatShow">strmQueueStatShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmMsgStatShow {display statistics about system-wide usage of message blocks (STREAMS Option)} {strmMsgStatShow( )} {<a href="./strmShow.html#strmMsgStatShow">strmMsgStatShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmStatShow {display statistics about streams (STREAMS Option)} {strmStatShow( )} {<a href="./strmShow.html#strmStatShow">strmStatShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmDriverModShow {list configuration information for modules and devices (STREAMS Option)} {strmDriverModShow( )} {<a href="./strmShow.html#strmDriverModShow">strmDriverModShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmDriverAdd {add a STREAMS driver into the STREAMS subsystem (STREAMS Option)} {strmDriverAdd( )} {<a href="./strmLib.html#strmDriverAdd">strmDriverAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmModuleAdd {add a STREAMS module to the STREAMS subsystem (STREAMS Option)} {strmModuleAdd( )} {<a href="./strmLib.html#strmModuleAdd">strmModuleAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmTimeout {execute a routine in a specified length of time (STREAMS Option)} {strmTimeout( )} {<a href="./strmLib.html#strmTimeout">strmTimeout</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmUntimeout {cancel previous strmTimeout() call (STREAMS Option)} {strmUntimeout( )} {<a href="./strmLib.html#strmUntimeout">strmUntimeout</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmSleep {suspend task execution pending occurrence of an event (STREAMS Option)} {strmSleep( )} {<a href="./strmLib.html#strmSleep">strmSleep</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmWakeup {resume suspended task execution (STREAMS Option)} {strmWakeup( )} {<a href="./strmLib.html#strmWakeup">strmWakeup</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmSyncWriteAccess {access a shared data structure for synchronous writing (STREAMS Option)} {strmSyncWriteAccess( )} {<a href="./strmLib.html#strmSyncWriteAccess">strmSyncWriteAccess</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmWeld {connect the `q_next' pointers of arbitrary streams (STREAMS Option)} {strmWeld( )} {<a href="./strmLib.html#strmWeld">strmWeld</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmUnWeld {set the `q_next' pointers of streams queues to NULL (STREAMS Option)} {strmUnWeld( )} {<a href="./strmLib.html#strmUnWeld">strmUnWeld</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmPipe {create an intertask channel (STREAMS Option)} {strmPipe( )} {<a href="./strmLib.html#strmPipe">strmPipe</a>( )} {VxWorks Reference Manual} Libraries {} {}
strmMkfifo {create a STREAMS FIFO (STREAMS Option)} {strmMkfifo( )} {<a href="./strmLib.html#strmMkfifo">strmMkfifo</a>( )} {VxWorks Reference Manual} Libraries {} {}
mps_fd_to_sth {return the Stream Head pointer for a given fd} {mps_fd_to_sth( )} {<a href="./strmLib.html#mps_fd_to_sth">mps_fd_to_sth</a>( )} {VxWorks Reference Manual} Libraries {} {}
dlpiInit {initialize the DLPI driver} {dlpiInit( )} {<a href="./dlpiLib.html#dlpiInit">dlpiInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
tffsDrv {initialize the TrueFFS system} {tffsDrv( )} {<a href="./tffsDrv.html#tffsDrv">tffsDrv</a>( )} {VxWorks Reference Manual} Libraries {} {}
tffsDevCreate {create a TrueFFS block device suitable for use with dosFs} {tffsDevCreate( )} {<a href="./tffsDrv.html#tffsDevCreate">tffsDevCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
tffsDevOptionsSet {set TrueFFS volume options} {tffsDevOptionsSet( )} {<a href="./tffsDrv.html#tffsDevOptionsSet">tffsDevOptionsSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
tffsDevFormat {format a flash device for use with TrueFFS} {tffsDevFormat( )} {<a href="./tffsDrv.html#tffsDevFormat">tffsDevFormat</a>( )} {VxWorks Reference Manual} Libraries {} {}
tffsRawio {low level I/O access to flash components} {tffsRawio( )} {<a href="./tffsDrv.html#tffsRawio">tffsRawio</a>( )} {VxWorks Reference Manual} Libraries {} {}
help {print a synopsis of selected routines} {help( )} {<a href="./usrLib.html#help">help</a>( )} {VxWorks Reference Manual} Libraries {} {}
netHelp {print a synopsis of network routines} {netHelp( )} {<a href="./usrLib.html#netHelp">netHelp</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootChange {change the boot line} {bootChange( )} {<a href="./usrLib.html#bootChange">bootChange</a>( )} {VxWorks Reference Manual} Libraries {} {}
periodRun {call a function periodically} {periodRun( )} {<a href="./usrLib.html#periodRun">periodRun</a>( )} {VxWorks Reference Manual} Libraries {} {}
period {spawn a task to call a function periodically} {period( )} {<a href="./usrLib.html#period">period</a>( )} {VxWorks Reference Manual} Libraries {} {}
repeatRun {call a function repeatedly} {repeatRun( )} {<a href="./usrLib.html#repeatRun">repeatRun</a>( )} {VxWorks Reference Manual} Libraries {} {}
repeat {spawn a task to call a function repeatedly} {repeat( )} {<a href="./usrLib.html#repeat">repeat</a>( )} {VxWorks Reference Manual} Libraries {} {}
sp {spawn a task with default parameters} {sp( )} {<a href="./usrLib.html#sp">sp</a>( )} {VxWorks Reference Manual} Libraries {} {}
checkStack {print a summary of each task's stack usage} {checkStack( )} {<a href="./usrLib.html#checkStack">checkStack</a>( )} {VxWorks Reference Manual} Libraries {} {}
i {print a summary of each task's TCB} {i( )} {<a href="./usrLib.html#i">i</a>( )} {VxWorks Reference Manual} Libraries {} {}
ti {print complete information from a task's TCB} {ti( )} {<a href="./usrLib.html#ti">ti</a>( )} {VxWorks Reference Manual} Libraries {} {}
show {print information on a specified object} {show( )} {<a href="./usrLib.html#show">show</a>( )} {VxWorks Reference Manual} Libraries {} {}
ts {suspend a task} {ts( )} {<a href="./usrLib.html#ts">ts</a>( )} {VxWorks Reference Manual} Libraries {} {}
tr {resume a task} {tr( )} {<a href="./usrLib.html#tr">tr</a>( )} {VxWorks Reference Manual} Libraries {} {}
td {delete a task} {td( )} {<a href="./usrLib.html#td">td</a>( )} {VxWorks Reference Manual} Libraries {} {}
version {print VxWorks version information} {version( )} {<a href="./usrLib.html#version">version</a>( )} {VxWorks Reference Manual} Libraries {} {}
m {modify memory} {m( )} {<a href="./usrLib.html#m">m</a>( )} {VxWorks Reference Manual} Libraries {} {}
d {display memory} {d( )} {<a href="./usrLib.html#d">d</a>( )} {VxWorks Reference Manual} Libraries {} {}
cd {change the default directory} {cd( )} {<a href="./usrLib.html#cd">cd</a>( )} {VxWorks Reference Manual} Libraries {} {}
pwd {print the current default directory} {pwd( )} {<a href="./usrLib.html#pwd">pwd</a>( )} {VxWorks Reference Manual} Libraries {} {}
copy {copy <in> (or stdin) to <out> (or stdout)} {copy( )} {<a href="./usrLib.html#copy">copy</a>( )} {VxWorks Reference Manual} Libraries {} {}
copyStreams {copy from/to specified streams} {copyStreams( )} {<a href="./usrLib.html#copyStreams">copyStreams</a>( )} {VxWorks Reference Manual} Libraries {} {}
diskFormat {format a disk} {diskFormat( )} {<a href="./usrLib.html#diskFormat">diskFormat</a>( )} {VxWorks Reference Manual} Libraries {} {}
diskInit {initialize a file system on a block device} {diskInit( )} {<a href="./usrLib.html#diskInit">diskInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
squeeze {reclaim fragmented free space on an RT-11 volume} {squeeze( )} {<a href="./usrLib.html#squeeze">squeeze</a>( )} {VxWorks Reference Manual} Libraries {} {}
ld {load an object module into memory} {ld( )} {<a href="./usrLib.html#ld">ld</a>( )} {VxWorks Reference Manual} Libraries {} {}
ls {list the contents of a directory} {ls( )} {<a href="./usrLib.html#ls">ls</a>( )} {VxWorks Reference Manual} Libraries {} {}
ll {do a long listing of directory contents} {ll( )} {<a href="./usrLib.html#ll">ll</a>( )} {VxWorks Reference Manual} Libraries {} {}
lsOld {list the contents of an RT-11 directory} {lsOld( )} {<a href="./usrLib.html#lsOld">lsOld</a>( )} {VxWorks Reference Manual} Libraries {} {}
mkdir {make a directory} {mkdir( )} {<a href="./usrLib.html#mkdir">mkdir</a>( )} {VxWorks Reference Manual} Libraries {} {}
rmdir {remove a directory} {rmdir( )} {<a href="./usrLib.html#rmdir">rmdir</a>( )} {VxWorks Reference Manual} Libraries {} {}
rm {remove a file} {rm( )} {<a href="./usrLib.html#rm">rm</a>( )} {VxWorks Reference Manual} Libraries {} {}
devs {list all system-known devices} {devs( )} {<a href="./usrLib.html#devs">devs</a>( )} {VxWorks Reference Manual} Libraries {} {}
lkup {list symbols} {lkup( )} {<a href="./usrLib.html#lkup">lkup</a>( )} {VxWorks Reference Manual} Libraries {} {}
lkAddr {list symbols whose values are near a specified value} {lkAddr( )} {<a href="./usrLib.html#lkAddr">lkAddr</a>( )} {VxWorks Reference Manual} Libraries {} {}
mRegs {modify registers} {mRegs( )} {<a href="./usrLib.html#mRegs">mRegs</a>( )} {VxWorks Reference Manual} Libraries {} {}
pc {return the contents of the program counter} {pc( )} {<a href="./usrLib.html#pc">pc</a>( )} {VxWorks Reference Manual} Libraries {} {}
printErrno {print the definition of a specified error status value} {printErrno( )} {<a href="./usrLib.html#printErrno">printErrno</a>( )} {VxWorks Reference Manual} Libraries {} {}
printLogo {print the VxWorks logo} {printLogo( )} {<a href="./usrLib.html#printLogo">printLogo</a>( )} {VxWorks Reference Manual} Libraries {} {}
logout {log out of the VxWorks system} {logout( )} {<a href="./usrLib.html#logout">logout</a>( )} {VxWorks Reference Manual} Libraries {} {}
h {display or set the size of shell history} {h( )} {<a href="./usrLib.html#h">h</a>( )} {VxWorks Reference Manual} Libraries {} {}
spyReport {display task activity data} {spyReport( )} {<a href="./usrLib.html#spyReport">spyReport</a>( )} {VxWorks Reference Manual} Libraries {} {}
spyTask {run periodic task activity reports} {spyTask( )} {<a href="./usrLib.html#spyTask">spyTask</a>( )} {VxWorks Reference Manual} Libraries {} {}
spy {begin periodic task activity reports} {spy( )} {<a href="./usrLib.html#spy">spy</a>( )} {VxWorks Reference Manual} Libraries {} {}
spyClkStart {start collecting task activity data} {spyClkStart( )} {<a href="./usrLib.html#spyClkStart">spyClkStart</a>( )} {VxWorks Reference Manual} Libraries {} {}
spyClkStop {stop collecting task activity data} {spyClkStop( )} {<a href="./usrLib.html#spyClkStop">spyClkStop</a>( )} {VxWorks Reference Manual} Libraries {} {}
spyStop {stop spying and reporting} {spyStop( )} {<a href="./usrLib.html#spyStop">spyStop</a>( )} {VxWorks Reference Manual} Libraries {} {}
spyHelp {display task monitoring help menu} {spyHelp( )} {<a href="./usrLib.html#spyHelp">spyHelp</a>( )} {VxWorks Reference Manual} Libraries {} {}
memDrv {install a memory driver} {memDrv( )} {<a href="./memDrv.html#memDrv">memDrv</a>( )} {VxWorks Reference Manual} Libraries {} {}
memDevCreate {create a memory device} {memDevCreate( )} {<a href="./memDrv.html#memDevCreate">memDevCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
memDevCreateDir {create a memory device for multiple files} {memDevCreateDir( )} {<a href="./memDrv.html#memDevCreateDir">memDevCreateDir</a>( )} {VxWorks Reference Manual} Libraries {} {}
memDevDelete {delete a memory device} {memDevDelete( )} {<a href="./memDrv.html#memDevDelete">memDevDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
ramDrv {prepare a RAM disk driver for use (optional)} {ramDrv( )} {<a href="./ramDrv.html#ramDrv">ramDrv</a>( )} {VxWorks Reference Manual} Libraries {} {}
ramDevCreate {create a RAM disk device} {ramDevCreate( )} {<a href="./ramDrv.html#ramDevCreate">ramDevCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
bcmp {compare one buffer to another} {bcmp( )} {<a href="./bLib.html#bcmp">bcmp</a>( )} {VxWorks Reference Manual} Libraries {} {}
binvert {invert the order of bytes in a buffer} {binvert( )} {<a href="./bLib.html#binvert">binvert</a>( )} {VxWorks Reference Manual} Libraries {} {}
bswap {swap buffers} {bswap( )} {<a href="./bLib.html#bswap">bswap</a>( )} {VxWorks Reference Manual} Libraries {} {}
swab {swap bytes} {swab( )} {<a href="./bLib.html#swab">swab</a>( )} {VxWorks Reference Manual} Libraries {} {}
uswab {swap bytes with buffers that are not necessarily aligned} {uswab( )} {<a href="./bLib.html#uswab">uswab</a>( )} {VxWorks Reference Manual} Libraries {} {}
bzero {zero out a buffer} {bzero( )} {<a href="./bLib.html#bzero">bzero</a>( )} {VxWorks Reference Manual} Libraries {} {}
bcopy {copy one buffer to another} {bcopy( )} {<a href="./bLib.html#bcopy">bcopy</a>( )} {VxWorks Reference Manual} Libraries {} {}
bcopyBytes {copy one buffer to another one byte at a time} {bcopyBytes( )} {<a href="./bLib.html#bcopyBytes">bcopyBytes</a>( )} {VxWorks Reference Manual} Libraries {} {}
bcopyWords {copy one buffer to another one word at a time} {bcopyWords( )} {<a href="./bLib.html#bcopyWords">bcopyWords</a>( )} {VxWorks Reference Manual} Libraries {} {}
bcopyLongs {copy one buffer to another one long word at a time} {bcopyLongs( )} {<a href="./bLib.html#bcopyLongs">bcopyLongs</a>( )} {VxWorks Reference Manual} Libraries {} {}
bfill {fill a buffer with a specified character} {bfill( )} {<a href="./bLib.html#bfill">bfill</a>( )} {VxWorks Reference Manual} Libraries {} {}
bfillBytes {fill buffer with a specified character one byte at a time} {bfillBytes( )} {<a href="./bLib.html#bfillBytes">bfillBytes</a>( )} {VxWorks Reference Manual} Libraries {} {}
index {find the first occurrence of a character in a string} {index( )} {<a href="./bLib.html#index">index</a>( )} {VxWorks Reference Manual} Libraries {} {}
rindex {find the last occurrence of a character in a string} {rindex( )} {<a href="./bLib.html#rindex">rindex</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootStringToStruct {interpret the boot parameters from the boot line} {bootStringToStruct( )} {<a href="./bootLib.html#bootStringToStruct">bootStringToStruct</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootStructToString {construct a boot line} {bootStructToString( )} {<a href="./bootLib.html#bootStructToString">bootStructToString</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootParamsShow {display boot line parameters} {bootParamsShow( )} {<a href="./bootLib.html#bootParamsShow">bootParamsShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootParamsPrompt {prompt for boot line parameters} {bootParamsPrompt( )} {<a href="./bootLib.html#bootParamsPrompt">bootParamsPrompt</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootLeaseExtract {extract the lease information from an Internet address} {bootLeaseExtract( )} {<a href="./bootLib.html#bootLeaseExtract">bootLeaseExtract</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootNetmaskExtract {extract the net mask field from an Internet address} {bootNetmaskExtract( )} {<a href="./bootLib.html#bootNetmaskExtract">bootNetmaskExtract</a>( )} {VxWorks Reference Manual} Libraries {} {}
bootBpAnchorExtract {extract a backplane address from a device field} {bootBpAnchorExtract( )} {<a href="./bootLib.html#bootBpAnchorExtract">bootBpAnchorExtract</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstInit {initialize a list descriptor} {lstInit( )} {<a href="./lstLib.html#lstInit">lstInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstAdd {add a node to the end of a list} {lstAdd( )} {<a href="./lstLib.html#lstAdd">lstAdd</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstConcat {concatenate two lists} {lstConcat( )} {<a href="./lstLib.html#lstConcat">lstConcat</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstCount {report the number of nodes in a list} {lstCount( )} {<a href="./lstLib.html#lstCount">lstCount</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstDelete {delete a specified node from a list} {lstDelete( )} {<a href="./lstLib.html#lstDelete">lstDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstExtract {extract a sublist from a list} {lstExtract( )} {<a href="./lstLib.html#lstExtract">lstExtract</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstFirst {find first node in list} {lstFirst( )} {<a href="./lstLib.html#lstFirst">lstFirst</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstGet {delete and return the first node from a list} {lstGet( )} {<a href="./lstLib.html#lstGet">lstGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstInsert {insert a node in a list after a specified node} {lstInsert( )} {<a href="./lstLib.html#lstInsert">lstInsert</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstLast {find the last node in a list} {lstLast( )} {<a href="./lstLib.html#lstLast">lstLast</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstNext {find the next node in a list} {lstNext( )} {<a href="./lstLib.html#lstNext">lstNext</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstNth {find the Nth node in a list} {lstNth( )} {<a href="./lstLib.html#lstNth">lstNth</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstPrevious {find the previous node in a list} {lstPrevious( )} {<a href="./lstLib.html#lstPrevious">lstPrevious</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstNStep {find a list node <nStep> steps away from a specified node} {lstNStep( )} {<a href="./lstLib.html#lstNStep">lstNStep</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstFind {find a node in a list} {lstFind( )} {<a href="./lstLib.html#lstFind">lstFind</a>( )} {VxWorks Reference Manual} Libraries {} {}
lstFree {free up a list} {lstFree( )} {<a href="./lstLib.html#lstFree">lstFree</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngCreate {create an empty ring buffer} {rngCreate( )} {<a href="./rngLib.html#rngCreate">rngCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngDelete {delete a ring buffer} {rngDelete( )} {<a href="./rngLib.html#rngDelete">rngDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngFlush {make a ring buffer empty} {rngFlush( )} {<a href="./rngLib.html#rngFlush">rngFlush</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngBufGet {get characters from a ring buffer} {rngBufGet( )} {<a href="./rngLib.html#rngBufGet">rngBufGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngBufPut {put bytes into a ring buffer} {rngBufPut( )} {<a href="./rngLib.html#rngBufPut">rngBufPut</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngIsEmpty {test if a ring buffer is empty} {rngIsEmpty( )} {<a href="./rngLib.html#rngIsEmpty">rngIsEmpty</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngIsFull {test if a ring buffer is full (no more room)} {rngIsFull( )} {<a href="./rngLib.html#rngIsFull">rngIsFull</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngFreeBytes {determine the number of free bytes in a ring buffer} {rngFreeBytes( )} {<a href="./rngLib.html#rngFreeBytes">rngFreeBytes</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngNBytes {determine the number of bytes in a ring buffer} {rngNBytes( )} {<a href="./rngLib.html#rngNBytes">rngNBytes</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngPutAhead {put a byte ahead in a ring buffer without moving ring pointers} {rngPutAhead( )} {<a href="./rngLib.html#rngPutAhead">rngPutAhead</a>( )} {VxWorks Reference Manual} Libraries {} {}
rngMoveAhead {advance a ring pointer by <n> bytes} {rngMoveAhead( )} {<a href="./rngLib.html#rngMoveAhead">rngMoveAhead</a>( )} {VxWorks Reference Manual} Libraries {} {}
inflate {inflate compressed code} {inflate( )} {<a href="./inflateLib.html#inflate">inflate</a>( )} {VxWorks Reference Manual} Libraries {} {}
wvRBuffMgrPrioritySet {set the priority of the WindView rBuff manager (WindView)} {wvRBuffMgrPrioritySet( )} {<a href="./rBuffLib.html#wvRBuffMgrPrioritySet">wvRBuffMgrPrioritySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdbUserEvtLibInit {include the WDB user event library } {wdbUserEvtLibInit( )} {<a href="./wdbUserEvtLib.html#wdbUserEvtLibInit">wdbUserEvtLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdbUserEvtPost {post a user event string to host tools.} {wdbUserEvtPost( )} {<a href="./wdbUserEvtLib.html#wdbUserEvtPost">wdbUserEvtPost</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdbSystemSuspend {suspend the system.} {wdbSystemSuspend( )} {<a href="./wdbLib.html#wdbSystemSuspend">wdbSystemSuspend</a>( )} {VxWorks Reference Manual} Libraries {} {}
kernelInit {initialize the kernel} {kernelInit( )} {<a href="./kernelLib.html#kernelInit">kernelInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
kernelVersion {return the kernel revision string} {kernelVersion( )} {<a href="./kernelLib.html#kernelVersion">kernelVersion</a>( )} {VxWorks Reference Manual} Libraries {} {}
kernelTimeSlice {enable round-robin selection} {kernelTimeSlice( )} {<a href="./kernelLib.html#kernelTimeSlice">kernelTimeSlice</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQCreate {create and initialize a message queue} {msgQCreate( )} {<a href="./msgQLib.html#msgQCreate">msgQCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQDelete {delete a message queue} {msgQDelete( )} {<a href="./msgQLib.html#msgQDelete">msgQDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQSend {send a message to a message queue} {msgQSend( )} {<a href="./msgQLib.html#msgQSend">msgQSend</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQReceive {receive a message from a message queue} {msgQReceive( )} {<a href="./msgQLib.html#msgQReceive">msgQReceive</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQNumMsgs {get the number of messages queued to a message queue} {msgQNumMsgs( )} {<a href="./msgQLib.html#msgQNumMsgs">msgQNumMsgs</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQShowInit {initialize the message queue show facility} {msgQShowInit( )} {<a href="./msgQShow.html#msgQShowInit">msgQShowInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQInfoGet {get information about a message queue} {msgQInfoGet( )} {<a href="./msgQShow.html#msgQInfoGet">msgQInfoGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQShow {show information about a message queue} {msgQShow( )} {<a href="./msgQShow.html#msgQShow">msgQShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
msgQSmCreate {create and initialize a shared memory message queue (VxMP Option)} {msgQSmCreate( )} {<a href="./msgQSmLib.html#msgQSmCreate">msgQSmCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
semBCreate {create and initialize a binary semaphore} {semBCreate( )} {<a href="./semBLib.html#semBCreate">semBCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
semCCreate {create and initialize a counting semaphore} {semCCreate( )} {<a href="./semCLib.html#semCCreate">semCCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
semGive {give a semaphore} {semGive( )} {<a href="./semLib.html#semGive">semGive</a>( )} {VxWorks Reference Manual} Libraries {} {}
semTake {take a semaphore} {semTake( )} {<a href="./semLib.html#semTake">semTake</a>( )} {VxWorks Reference Manual} Libraries {} {}
semFlush {unblock every task pended on a semaphore} {semFlush( )} {<a href="./semLib.html#semFlush">semFlush</a>( )} {VxWorks Reference Manual} Libraries {} {}
semDelete {delete a semaphore} {semDelete( )} {<a href="./semLib.html#semDelete">semDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
semMCreate {create and initialize a mutual-exclusion semaphore} {semMCreate( )} {<a href="./semMLib.html#semMCreate">semMCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
semMGiveForce {give a mutual-exclusion semaphore without restrictions} {semMGiveForce( )} {<a href="./semMLib.html#semMGiveForce">semMGiveForce</a>( )} {VxWorks Reference Manual} Libraries {} {}
semCreate {create and initialize a release 4.x binary semaphore} {semCreate( )} {<a href="./semOLib.html#semCreate">semCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
semInit {initialize a static binary semaphore} {semInit( )} {<a href="./semOLib.html#semInit">semInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
semClear {take a release 4.x semaphore, if the semaphore is available} {semClear( )} {<a href="./semOLib.html#semClear">semClear</a>( )} {VxWorks Reference Manual} Libraries {} {}
semShowInit {initialize the semaphore show facility} {semShowInit( )} {<a href="./semShow.html#semShowInit">semShowInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
semInfo {get a list of task IDs that are blocked on a semaphore} {semInfo( )} {<a href="./semShow.html#semInfo">semInfo</a>( )} {VxWorks Reference Manual} Libraries {} {}
semShow {show information about a semaphore} {semShow( )} {<a href="./semShow.html#semShow">semShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
semBSmCreate {create and initialize a shared memory binary semaphore (VxMP Option)} {semBSmCreate( )} {<a href="./semSmLib.html#semBSmCreate">semBSmCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
semCSmCreate {create and initialize a shared memory counting semaphore (VxMP Option)} {semCSmCreate( )} {<a href="./semSmLib.html#semCSmCreate">semCSmCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskOptionsSet {change task options} {taskOptionsSet( )} {<a href="./taskInfo.html#taskOptionsSet">taskOptionsSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskOptionsGet {examine task options} {taskOptionsGet( )} {<a href="./taskInfo.html#taskOptionsGet">taskOptionsGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskRegsGet {get a task's registers from the TCB} {taskRegsGet( )} {<a href="./taskInfo.html#taskRegsGet">taskRegsGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskRegsSet {set a task's registers} {taskRegsSet( )} {<a href="./taskInfo.html#taskRegsSet">taskRegsSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskName {get the name associated with a task ID} {taskName( )} {<a href="./taskInfo.html#taskName">taskName</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskNameToId {look up the task ID associated with a task name} {taskNameToId( )} {<a href="./taskInfo.html#taskNameToId">taskNameToId</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskIdDefault {set the default task ID} {taskIdDefault( )} {<a href="./taskInfo.html#taskIdDefault">taskIdDefault</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskIsReady {check if a task is ready to run} {taskIsReady( )} {<a href="./taskInfo.html#taskIsReady">taskIsReady</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskIsSuspended {check if a task is suspended} {taskIsSuspended( )} {<a href="./taskInfo.html#taskIsSuspended">taskIsSuspended</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskIdListGet {get a list of active task IDs} {taskIdListGet( )} {<a href="./taskInfo.html#taskIdListGet">taskIdListGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskSpawn {spawn a task} {taskSpawn( )} {<a href="./taskLib.html#taskSpawn">taskSpawn</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskInit {initialize a task with a stack at a specified address} {taskInit( )} {<a href="./taskLib.html#taskInit">taskInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskActivate {activate a task that has been initialized} {taskActivate( )} {<a href="./taskLib.html#taskActivate">taskActivate</a>( )} {VxWorks Reference Manual} Libraries {} {}
exit {exit a task (ANSI)} {exit( )} {<a href="./taskLib.html#exit">exit</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskDelete {delete a task} {taskDelete( )} {<a href="./taskLib.html#taskDelete">taskDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskDeleteForce {delete a task without restriction} {taskDeleteForce( )} {<a href="./taskLib.html#taskDeleteForce">taskDeleteForce</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskSuspend {suspend a task} {taskSuspend( )} {<a href="./taskLib.html#taskSuspend">taskSuspend</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskResume {resume a task} {taskResume( )} {<a href="./taskLib.html#taskResume">taskResume</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskRestart {restart a task} {taskRestart( )} {<a href="./taskLib.html#taskRestart">taskRestart</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskPrioritySet {change the priority of a task} {taskPrioritySet( )} {<a href="./taskLib.html#taskPrioritySet">taskPrioritySet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskPriorityGet {examine the priority of a task} {taskPriorityGet( )} {<a href="./taskLib.html#taskPriorityGet">taskPriorityGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskLock {disable task rescheduling} {taskLock( )} {<a href="./taskLib.html#taskLock">taskLock</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskUnlock {enable task rescheduling} {taskUnlock( )} {<a href="./taskLib.html#taskUnlock">taskUnlock</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskSafe {make the calling task safe from deletion} {taskSafe( )} {<a href="./taskLib.html#taskSafe">taskSafe</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskUnsafe {make the calling task unsafe from deletion} {taskUnsafe( )} {<a href="./taskLib.html#taskUnsafe">taskUnsafe</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskDelay {delay a task from executing} {taskDelay( )} {<a href="./taskLib.html#taskDelay">taskDelay</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskIdSelf {get the task ID of a running task} {taskIdSelf( )} {<a href="./taskLib.html#taskIdSelf">taskIdSelf</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskIdVerify {verify the existence of a task} {taskIdVerify( )} {<a href="./taskLib.html#taskIdVerify">taskIdVerify</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskTcb {get the task control block for a task ID} {taskTcb( )} {<a href="./taskLib.html#taskTcb">taskTcb</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskShowInit {initialize the task show routine facility} {taskShowInit( )} {<a href="./taskShow.html#taskShowInit">taskShowInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskInfoGet {get information about a task} {taskInfoGet( )} {<a href="./taskShow.html#taskInfoGet">taskInfoGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskShow {display task information from TCBs} {taskShow( )} {<a href="./taskShow.html#taskShow">taskShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskRegsShow {display the contents of a task's registers} {taskRegsShow( )} {<a href="./taskShow.html#taskRegsShow">taskRegsShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
taskStatusString {get a task's status as a string} {taskStatusString( )} {<a href="./taskShow.html#taskStatusString">taskStatusString</a>( )} {VxWorks Reference Manual} Libraries {} {}
tickAnnounce {announce a clock tick to the kernel} {tickAnnounce( )} {<a href="./tickLib.html#tickAnnounce">tickAnnounce</a>( )} {VxWorks Reference Manual} Libraries {} {}
tickSet {set the value of the kernel's tick counter} {tickSet( )} {<a href="./tickLib.html#tickSet">tickSet</a>( )} {VxWorks Reference Manual} Libraries {} {}
tickGet {get the value of the kernel's tick counter} {tickGet( )} {<a href="./tickLib.html#tickGet">tickGet</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdCreate {create a watchdog timer} {wdCreate( )} {<a href="./wdLib.html#wdCreate">wdCreate</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdDelete {delete a watchdog timer} {wdDelete( )} {<a href="./wdLib.html#wdDelete">wdDelete</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdStart {start a watchdog timer} {wdStart( )} {<a href="./wdLib.html#wdStart">wdStart</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdCancel {cancel a currently counting watchdog} {wdCancel( )} {<a href="./wdLib.html#wdCancel">wdCancel</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdShowInit {initialize the watchdog show facility} {wdShowInit( )} {<a href="./wdShow.html#wdShowInit">wdShowInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
wdShow {show information about a watchdog} {wdShow( )} {<a href="./wdShow.html#wdShow">wdShow</a>( )} {VxWorks Reference Manual} Libraries {} {}
symSyncLibInit {initialize host/target symbol table synchronization} {symSyncLibInit( )} {<a href="./symSyncLib.html#symSyncLibInit">symSyncLibInit</a>( )} {VxWorks Reference Manual} Libraries {} {}
symSyncTimeoutSet {set WTX timeout } {symSyncTimeoutSet( )} {<a href="./symSyncLib.html#symSyncTimeoutSet">symSyncTimeoutSet</a>( )} {VxWorks Reference Manual} Libraries {} {}