Appendix A. SGI Driver/Kernel API
Prev |  | Next

## Appendix A. SGI Driver/Kernel API

This appendix summarizes the SGI Driver/Kernel Authorized Programming Interface in tabular form. The data structures, entry points, and kernel functions are listed alphabetically with with clickable links to discussions in this book and to their reference pages. The tables also show which functions and structures are compatible with SVR4 and which are unique to IRIX.

The tables in this appendix are based on the reference pages in volume D. The reference pages in volume D constitute the formal, engineering definition of the Driver/Kernel API. When discussion in this book disagrees with the contents of a reference page, the reference page takes precedence (however, any such disagreement should be reported by using the Feedback menu of the Insight viewer).

- “Driver Exported Names” tabulates the names of data and functions that a driver must export.

- “Kernel Data Structures and Declarations” tabulates the objects used in the interface.

- “Kernel Functions” tabulates the IRIX kernel services used by drivers.

Each table in this appendix has a column headed “Versions.” The codes in this column have the following meanings:

SV | Syntactically and semantically portable from SVR4 UNIX, as documented in the UNIX SVR4.2 Device Driver Reference.
SV* | Syntactically portable from UNIX SVR4, but semantics may differ. Read the discussion and reference page carefully when porting.
5.3 | Portable from IRIX version 5.3.
5.3* | Portable from IRIX 5.3, but interface has changed in some detail or new ability has been added.
6.2 | Portable from IRIX version 6.2.
6.4 | Introduced in IRIX 6.4.

## Driver Exported Names

The kernel loader, `lboot`, recognizes certain exported names of static data and functional entry points. These exported names are summarized in Table A-1.

Table A-1. Driver Exported Names

Name | Summary | Discussed | Versions
--- | --- | --- | ---
attach() | Notify driver of device attachment. | “Entry Point attach()” in Chapter 7 | 6.4
`close(D2)` | Notify driver of final close of minor device. | “Entry Point close()” in Chapter 7 | SV, 5.3
detach() | Notify driver of removed device. | “Entry Point detach()” in Chapter 7 | 6.4
`devflag(D1)` | Show driver attributes to `lboot`. | “Driver Flag Constant” in Chapter 7 | SV*, 5.3*
`edtinit(D2)` | Initialize driver from VECTOR information (obsolete in 6.2). | “Entry Point edtinit()” in Chapter 7 | 5.3
`halt(D2)` | Notify driver of system shutdown. | “Entry Point halt()” in Chapter 7 | SV, 5.3
`info(D1)` | Show driver entries to STREAMS interface. | “Initialization Entry Points” in Chapter 22 | SV, 5.3
`init(D2)` | Initialize driver early in system startup. | “Entry Point init()” in Chapter 7 | SV*, 5.3
`intr(D2)` | Notify driver of device interrupt (obsolete). | “Interrupt Entry Point and Handler” in Chapter 7 | SV, 5.3
`ioctl(D2)` | Call driver to implement `ioctl`() call. | “Control Entry Point” in Chapter 7 | SV*, 5.3
`map(D2)` | Call driver to implement `mmap`(). | “Entry Point map()” in Chapter 7 | 5.3
`mmap(D2)` | Call driver to implement `mmap`() (SVR4). | “Entry Point mmap()” in Chapter 7 | SV*, 5.3
`open(D2)` | Call driver to open a device. | “Entry Point open()” in Chapter 7 | SV, 5.3
`print(D2)` | Call block driver to display filesystem error. | “Entry Point print()” in Chapter 7 | SV, 5.3
`put(D2)` | Call STREAMS driver to receive message. | “Put Functions wput() and rput()” in Chapter 22 | SV, 5.3
`read(D2)` | Call character driver to read data. | “Entry Points read() and write()” in Chapter 7 | SV, 5.3
reg() | Call driver to register for device handling. | “Entry Point reg()” in Chapter 7 | 6.4
`size(D2)` | Call block driver to get device capacity. | “Entry Point size()” in Chapter 7 | SV, 5.3
`srv(D2)` | Call driver to service queued messages. | “Service Functions rsrv() and wsrv()” in Chapter 22 | SV, 5.3
`start(D2)` | Initialize driver late in system startup. | “Entry Point start()” in Chapter 7 | SV, 5.3
`strategy(D2)` | Call block driver to read or write data. | “Entry Point strategy()” in Chapter 7 | SV*, 5.3
`unload(D2)` | Call loadable driver prior to unloading it. | “Entry Point unload()” in Chapter 7 | 5.3
unreg() | Call driver to unregister as a device handler. | “Entry Point reg()” in Chapter 7 | 6.4
`unmap(D2)` | Call driver to notify it of unmap() call. | “Entry Point unmap()” in Chapter 7 | 5.3
`write(D2)` | Call character driver to write data. | “Entry Points read() and write()” in Chapter 7 | SV, 5.3

The following reference pages have overview information on exported names: `intro(D1)` , `intro(D2)` , and `prefix(D1)` .

| Note: The following SVR4 exported names are not used in IRIX drivers: chpoll, _load, and _unload. The latter is replaced by pfx `load()` without the leading underscore.

## Kernel Data Structures and Declarations

The driver/kernel interface is based on shared use of certain data types and defined constant values. For general information on these interface objects, see the `intro(D4)` and `intro(D5)` reference pages.

The interface objects used by device drivers are summarized in Table A-2.

Table A-2. Device Driver Interface Objects

Name | Summary | Discussed | Versions
--- | --- | --- | ---
`alenlist(d4x)` | Address/length list. | “Address/Length Lists” in Chapter 8 | 6.4
`buf(D4)` | Block read/write request structure. | “Structure buf_t” in Chapter 8 | SV*, 5.3*
`eisa_dma_cb(D4)` | DMA command block for EISA slave DMA. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_buf(D4)` | DMA command buffer for EISA slave DMA. | “Programming Slave DMA” in Chapter 18 | 5.3
`errnos(D5)` | Error numbers valid for driver use. |  | SV*, 5.3
`iovec(D4)` | Describes an I/O buffer segment to the read or write entry points. | “Structure uio_t” in Chapter 8 | SV, 5.3
`signals(D5)` | Lists signal numbers valid for driver use. |  | SV*, 5.3
`uio(D4)` | Describes an I/O request to the read or write entry points. | “Structure uio_t” in Chapter 8 | SV*, 5.3
`hwgraph.intro(d4x)` | Hardware graph (hwgraph) vertexes and edges. | “Hardware Graph Types” in Chapter 8 | 6.4

| Note: The following data structures used in SVR4 drivers are not used in IRIX: dma_buf and dma_cb. The eisa_dma_buf and eisa_dma_cb structures are similar but are used only in EISA drivers.

The interface objects used by STREAMS drivers are summarized in Table A-3.

Table A-3. STREAMS Driver Interface Objects

Name | Summary | Discussed | Versions
--- | --- | --- | ---
`copyreq(D4)` | Copy request structure. |  | SV, 5.3
`copyresp(D4)` | Copy response structure. |  | SV, 5.3
`datab(D4)` | Message data block. |  | SV, 5.3
`free_rtn(D4)` | Describes a message-free routine. |  | SV, 5.3
`iocblk(D4)` | Describes ioctl() data or response. |  | SV, 5.3
`linkblk(D4)` | Describes multiplexed link. |  | SV, 5.3
`module_info(D4)` | Describes module attributes. |  | SV, 5.3
`msgb(D4)` | Describes all or part of a message. |  | SV, 5.3
`qinit(D4)` | Points to handlers and parameters for a queue. |  | SV, 5.3
`queue(D4)` | Describes a queue of messages. |  | SV, 5.3
`streamtab(D4)` | Points to the queues handled by a driver. |  | SV, 5.3
`stroptions(D4)` | Lists stream-head options. |  | SV, 5.3

## Kernel Functions

The IRIX kernel makes available the functions summarized in Table A-4.

Table A-4. Kernel Functions

Name | Summary | Text | Versions
--- | --- | --- | ---
`adjmsg(D3)` | Trim bytes from a message. | “Creating Alenlists” in Chapter 8 | SV, 5.3
alenlist_append() (`alenlist_ops(d3x)` ) | Add a specified address and length as an item to an existing alenlist. | “Loading Alenlists” in Chapter 8 | 6.4
alenlist_clear() (`alenlist_ops(d3x)` ) | Empty an alenlist. | “Loading Alenlists” in Chapter 8 | 6.4
alenlist_create() (`alenlist_ops(d3x)` ) | Create an empty alenlist. | “Creating Alenlists” in Chapter 8 | 6.4
alenlist_cursor_create() (`alenlist_ops(d3x)` ) | Create an alenlist cursor and associate it with a specified list. | “Using Alenlist Cursors” in Chapter 8 | 6.4
alenlist_cursor_destroy() (`alenlist_ops(d3x)` ) | Release memory of a cursor. | “Using Alenlist Cursors” in Chapter 8 | 6.4
alenlist_cursor_init() (`alenlist_ops(d3x)` ) | Set a cursor to point at a specified list item. | “Using Alenlist Cursors” in Chapter 8 | 6.4
alenlist_cursor_offset() (`alenlist_ops(d3x)` ) | Query the effective byte offset of a cursor in the buffer described by a list. | “Using Alenlist Cursors” in Chapter 8 | 6.4
alenlist_destroy() (`alenlist_ops(d3x)` ) | Release memory of an alenlist. | “Creating Alenlists” in Chapter 8 | 6.4
alenlist_get() (`alenlist_ops(d3x)` ) | Retrieve the next sequential address and length from a list. | “Creating Alenlists” in Chapter 8 | 6.4
`allocb(D3)` | Allocate a message block. |  | SV, 5.3
`ASSERT(D3)` | Debugging macro designed for use in the kernel (compare to `assert(3X)` ). | “Using ASSERT” in Chapter 10 | 5.3
`badaddr(D3)` | Test physical address for input. | “Testing Device Physical Addresses” in Chapter 8 | 5.3
`badaddr_val(D3)` | Test physical address for input and return the input value received. | “Testing Device Physical Addresses” in Chapter 8 | 6.2
`bcanput(D3)` | Test for flow control in a specified priority band. |  | SV, 5.3
`bcanputnext(D3)` | Test for flow control in a specified priority band. |  | SV, 5.3
`bcmp(D3)` | Compare data between kernel locations. | “Block Copy Functions” in Chapter 8 | SV, 5.3
`bcopy(D3)` | Copy data between locations in the kernel. | “Block Copy Functions” in Chapter 8 | SV, 5.3
`biodone(D3)` | Mark a buf_t as complete and wake any process waiting for it. | “Waiting for Block I/O to Complete” in Chapter 8 | SV, 5.3
`bioerror(D3)` | Manipulate error fields within a buf_t. | “Waiting for Block I/O to Complete” in Chapter 8 | SV, 5.3
`biowait(D3)` | Suspend process pending completion of block I/O. | “Waiting for Block I/O to Complete” in Chapter 8 | SV, 5.3
`bp_mapin(D3)` | Map buffer pages into kernel virtual address space. | “Managing Buffer Virtual Addresses” in Chapter 8 | SV, 5.3
`bp_mapout(D3)` | Release mapping of buffer pages. | “Managing Buffer Virtual Addresses” in Chapter 8 | SV, 5.3
`bptophys(D3)` | Get physical address of buffer data. | “Setting Up a DMA Transfer” in Chapter 8 | 5.3
`brelse(D3)` | Return a buffer to the system's free list. | “Allocating buf_t Objects and Buffers” in Chapter 8 | SV, 5.3
`btod(D3)` | Return number of 512-byte “sectors” in a byte count (round up). | “Working With Page and Sector Units” in Chapter 8 | 5.3
`btop(D3)` | Return number of I/O pages in a byte count (truncate). | “Working With Page and Sector Units” in Chapter 8 | SV, 5.3
`btopr(D3)` | Return number of I/O pages in a byte count (round up). | “Working With Page and Sector Units” in Chapter 8 | SV, 5.3
`bufcall(D3)` | Call a function when a buffer becomes available. |  | SV, 5.3
buf_to_alenlist() (`alenlist_ops(d3x)` ) | Fill an alenlist with entries that describe the buffer controlled by a buf_t object. | “Loading Alenlists” in Chapter 8 | 6.4
`bzero(D3)` | Clear kernel memory for a specified size. | “General Data Transfer” in Chapter 8 | SV, 5.3
`canput(D3)` | Test for room in a message queue. |  | SV, 5.3
`canputnext(D3)` | Test for room in a message queue. |  | SV, 5.3
`clrbuf(D3)` | Erase the contents of a buffer described by a buf_t. | “Managing Buffer Virtual Addresses” in Chapter 8 | SV, 5.3
`cmn_err(D3)` | Display an error message or panic the system. | “Using cmn_err” in Chapter 10 | SV*, 5.3
`copyb(D3)` | Copy a message block. |  | SV, 5.3
`copyin(D3)` | Copy data from user address space. | “General Data Transfer” in Chapter 8 | SV, 5.3
`copymsg(D3)` | Copy a message. |  | SV, 5.3
`copyout(D3)` | Copy data to user address space. | “General Data Transfer” in Chapter 8 | SV, 5.3
`cpsema(D3)` | Conditionally decrement a semaphore's state. | “Semaphores” in Chapter 8 | 5.3
`cvsema(D3)` | Conditionally increment a semaphore's state. | “Semaphores” in Chapter 8 | 5.3
`datamsg(D3)` | Test whether a message is a data message. |  | SV, 5.3
`delay(D3)` | Delay for a specified number of clock ticks. | “Waiting for Time to Pass” in Chapter 8 | SV, 5.3
device_admin_info_get() (`hwgraph.admin(d3x)` ) | Retrieve value set with DEVICE_ADMIN statement. | “Retrieving Administrator Attributes” in Chapter 8 | 6.4
device_controller_num_get() (`hwgraph.dev(d3x)` ) | Get controller number from first inventory record in a vertex. | “Attaching Inventory Information” in Chapter 8 | 6.4
device_controller_num_get() (`hwgraph.dev(d3x)` ) | Set controller number field only in first inventory record in a vertex. | “Attaching Inventory Information” in Chapter 8 | 6.4
device_driver_admin_info_get() (`hwgraph.admin(d3x)` ) | Retrieve value set with DRIVER_ADMIN statement. | “Retrieving Administrator Attributes” in Chapter 8 | 6.4
device_info_get() (`hwgraph.dev(d3x)` ) | Return device info pointer stored in vertex. | “Interrogating the hwgraph” in Chapter 8 | 6.4
device_info_set() (`hwgraph.dev(d3x)` ) | Store the address of device information in a vertex. | “Construction Functions” in Chapter 8 | 6.4
device_inventory_add() (`hwgraph.inv(d3x)` ) | Add hardware inventory data to a vertex. | “Attaching Inventory Information” in Chapter 8 | 6.4
device_inventory_get_next() (`hwgraph.inv(d3x)` ) | Read out inventory data from a vertex. | “Attaching Inventory Information” in Chapter 8 |
disable_sysad_parity() | Disable memory parity checking on SysAD bus. | “Memory Parity Workarounds” in Chapter 19 | 5.3
`dki_dcache_inval(D3)` | Invalidate the data cache for a given range of virtual addresses. | “Managing Memory for Cache Coherency” in Chapter 8 | 5.3
`dki_dcache_wb(D3)` | Write back the data cache for a given range of virtual addresses. | “Managing Memory for Cache Coherency” in Chapter 8 | 5.3
`dki_dcache_wbinval(D3)` | Write back and invalidate the data cache for a given range of virtual addresses. | “Managing Memory for Cache Coherency” in Chapter 8 | 5.3
`dma_map(D3)` | Load DMA mapping registers for an imminent transfer. |  | 5.3
`dma_mapbp(D3)` | Load DMA mapping registers for an imminent transfer. |  | 5.3
`dma_mapaddr(D3)` | Return the “bus virtual” address for a given map and address. |  | 5.3
`dma_mapalloc(D3)` | Allocate a DMA map. |  | 5.3
`dma_mapfree(D3)` | Free a DMA map. |  | 5.3
`drv_getparm(D3)` | Retrieve kernel state information. | “User Process Administration” in Chapter 8 | SV*, 5.3
`drv_hztousec(D3)` | Convert clock ticks to microseconds. | “Waiting for Time to Pass” in Chapter 8 | SV, 5.3
`drv_priv(D3)` | Test for privileged user. | “User Process Administration” in Chapter 8 | SV, 5.3
`drv_setparm(D3)` | Set kernel state information. | “User Process Administration” in Chapter 8 | SV, 5.3
`drv_usectohz(D3)` | Convert microseconds to clock ticks. | “Waiting for Time to Pass” in Chapter 8 | SV, 5.3
`drv_usecwait(D3)` | Busy-wait for a specified interval. | “Waiting for Time to Pass” in Chapter 8 | SV, 5.3
`dtimeout(D3)` | Schedule a function execute on a specified processor after a specified length of time. | “Waiting for Time to Pass” in Chapter 8 | 5.3
`dupb(D3)` | Duplicate a message block. |  | SV, 5.3
`dupmsg(D3)` | Duplicate a message. |  | SV, 5.3
`eisa_dma_disable(D3)` | Disable recognition of hardware requests on EISA DMA channel. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_enable(D3)` | Enable recognition of hardware requests on EISA DMA channel. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_free_buf(D3)` | Free a previously allocated EISA DMA buffer descriptor. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_free_cb(D3)` | Free a previously allocated EISA DMA command block. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_get_buf(D3)` | Allocate EISA DMA buffer descriptor. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_get_cb(D3)` | Allocate EISA DMA command block. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_prog(D3)` | Program EISA DMA operation for a subsequent software request. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_stop(D3)` | Stop software-initiated EISA DMA operation and release channel. | “Programming Slave DMA” in Chapter 18 | 5.3
`eisa_dma_swstart(D3)` | Initiate EISA DMA operation via software request. | “Programming Slave DMA” in Chapter 18 | 5.3
eisa_dmachan_alloc() | Allocate a DMA channel for EISA slave DMA. | “Allocating a DMA Channel” in Chapter 18 | 5.3
eisa_ivec_alloc() | Allocate an IRQ level for EISA. | “Allocating IRQs and Channels” in Chapter 18 | 5.3
eisa_ivec_set() | Associate a handler with an EISA IRQ. | “Allocating IRQs and Channels” in Chapter 18 | 5.3
`enableok(D3)` | Allow a queue to be serviced. |  | SV, 5.3
enable_sysad_parity() | Reenable parity checking on SysAD bus. | “Memory Parity Workarounds” in Chapter 19 | 5.3
`esballoc(D3)` | Allocate a message block using an externally-supplied buffer. |  | SV, 5.3
`esbbcall(D3)` | Call a function when an externally-supplied buffer can be allocated. |  | SV, 5.3
`etoimajor(D3)` | Convert external to internal major device number. | “Historical Use of the Device Numbers” in Chapter 8 | SV, 5.3
`fast_itimeout(D3)` | Same as itimeout() but takes an interval in “fast ticks.” | “Waiting for Time to Pass” in Chapter 8 | 6.2
fasthzto(D3) | Returns the value of a struct timeval as a count of “fast ticks.” | “Waiting for Time to Pass” in Chapter 8 | 6.2
`flushband(D3)` | Flush messages in a specified priority band. |  | SV, 5.3
`flushbus(D3)` | Make sure contents of the write buffer are flushed to the system bus. | “Managing Memory for Cache Coherency” in Chapter 8 | 5.3
`flushq(D3)` | Flush messages on a queue. |  | SV, 5.3
`freeb(D3)` | Free a message block. |  | SV, 5.3
`freemsg(D3)` | Free a message. |  | SV, 5.3
`freerbuf(D3)` | Free a buf_t with no buffer. | “Allocating buf_t Objects and Buffers” in Chapter 8 | SV, 5.3
`freesema(D3)` | Free the resources associated with a semaphore. | “Semaphores” in Chapter 8 | 5.3*
`freezestr(D3)` | Freeze the state of a stream. |  | SV, 5.3
`fubyte(D3)` | Load a byte from user space. | “General Data Transfer” in Chapter 8 | 5.3
`fuword(D3)` | Load a word from user space. | “General Data Transfer” in Chapter 8 | 5.3
`geteblk(D3)` | Get a buf_t with no buffer. | “Allocating buf_t Objects and Buffers” in Chapter 8 | SV, 5.3
`getemajor(D3)` | Get external major device number. | “Historical Use of the Device Numbers” in Chapter 8 | SV, 5.3
`geteminor(D3)` | Get external minor device number. | “Historical Use of the Device Numbers” in Chapter 8 | SV, 5.3
`geterror(D3)` | retrieve error number from a buffer header. | “Waiting for Block I/O to Complete” in Chapter 8 | SV, 5.3
`getmajor(D3)` | Get internal major device number (obsolete). | “Historical Use of the Device Numbers” in Chapter 8 | SV, 5.3
`getminor(D3)` | Get internal minor device number (obsolete). | “Historical Use of the Device Numbers” in Chapter 8 | SV, 5.3
`getnextpg(D3)` | Return pfdat structure for next page. | “Managing Buffer Virtual Addresses” in Chapter 8 | 5.3
`getq(D3)` | Get the next message from a queue. |  | SV, 5.3
`getrbuf(D3)` | Allocate a buf_t with no buffer. | “Allocating buf_t Objects and Buffers” in Chapter 8 | SV, 5.3
`hwcpin(D3)` | Copy data from device registers to kernel memory. | “General Data Transfer” in Chapter 8 | 5.3
`hwcpout(D3)` | Copy data from kernel memory to device registers. | “General Data Transfer” in Chapter 8 | 5.3
hwgraph_block_device_add() (`hwgraph.dev(d3x)` ) | Create block device special file under a specified vertex. | “Construction Functions” in Chapter 8 | 6.4
hwgraph_char_device_add() (`hwgraph.dev(d3x)` ) | Create a character device special file under a specified vertex. | “Construction Functions” in Chapter 8 | 6.4
hwgraph_edge_add() (`hwgraph.edge(d3x)` ) | Add a labelled edge between two vertexes. | “Construction Functions” in Chapter 8 | 6.4
hwgraph_edge_get() (`hwgraph.edge(d3x)` ) | Retrieve the vertex destination of a labelled edge (follow edge). | “Construction Functions” in Chapter 8 | 6.4
hwgraph_edge_remove() (`hwgraph.edge(d3x)` ) | Delete a labelled edge between two vertexes. | “Construction Functions” in Chapter 8 | 6.4
hwgraph_info_add_LBL() (`hwgraph.lblinfo(d3x)` ) | Attach a labelled attribute to a vertex. | “Attaching Information to Vertexes” in Chapter 8 | 6.4
hwgraph_info_export_LBL() (`hwgraph.lblinfo(d3x)` ) | Make an attribute visible to `attr_get(2)` . | “Attaching Information to Vertexes” in Chapter 8 | 6.4
hwgraph_info_get_LBL() (`hwgraph.lblinfo(d3x)` ) | Retrieve an attribute by name. | “Attaching Information to Vertexes” in Chapter 8 | 6.4
hwgraph_info_remove_LBL() (`hwgraph.lblinfo(d3x)` ) | Remove an attribute from a vertex. | “Attaching Information to Vertexes” in Chapter 8 | 6.4
hwgraph_info_replace_LBL() (`hwgraph.lblinfo(d3x)` ) | Replace the value of an attribute by name. | “Attaching Information to Vertexes” in Chapter 8 | 6.4
hwgraph_info_unexport_LBL() (`hwgraph.lblinfo(d3x)` ) | Make an attribute invisible. | “Attaching Information to Vertexes” in Chapter 8 | 6.4
hwgraph_traverse() (`hwgraph.edge(d3x)` ) | Follow a path of edges starting from a given vertex. | “Construction Functions” in Chapter 8 | 6.4
hwgraph_vertex_create() (`hwgraph.vertex(d3x)` ) | Create a new, empty vertex, and return its handle. | “Construction Functions” in Chapter 8 | 6.4
hwgraph_vertex_destroy() (`hwgraph.vertex(d3x)` ) | Deallocate a vertex. |  | 6.4
hwgraph_vertex_ref() (hwgraph.vertex(d3x)) | Increase the reference count of a vertex. |  | 6.4
hwgraph_vertex_unref() (`hwgraph.vertex(d3x)` ) | Decrease the reference count of a vertex. |  | 6.4
`initnsema(D3)` | Initialize a semaphore to a specified count. | “Semaphores” in Chapter 8 | 5.3
`initnsema_mutex(D3)` | Initialize a semaphore to a count of 1. | “Semaphores” in Chapter 8 | 5.3
`insq(D3)` | Insert a message into a queue. |  | SV, 5.3
`ip26_enable_ucmem(D3)` | Change memory mode on IP26 processor. | “Uncached Memory Access in the IP26 and IP28” in Chapter 1 | 6.2
`ip26_return_ucmem(D3)` | Change memory mode on IP26 processor. | “Uncached Memory Access in the IP26 and IP28” in Chapter 1 | SV, 5.3
is_sysad_parity_enabled() | Test for parity checking on SysAD bus. | “Memory Parity Workarounds” in Chapter 19 | 5.3
`itimeout(D3)` | Schedule a function to be executed after a specified number of clock ticks. | “Waiting for Time to Pass” in Chapter 8 | SV, 5.3
`itoemajor(D3)` | Convert internal to external major device number. | “Historical Use of the Device Numbers” in Chapter 8 | SV, 5.3
`kern_calloc(D3)` | Allocate and clear space from kernel memory. | “General-Purpose Allocation” in Chapter 8 | 5.3
`kern_free(D3)` | Free kernel memory space. | “General-Purpose Allocation” in Chapter 8 | 5.3
`kern_malloc(D3)` | Allocate kernel virtual memory. | “General-Purpose Allocation” in Chapter 8 | 5.3
`kmem_alloc(D3)` | Allocate space from kernel free memory. | “General-Purpose Allocation” in Chapter 8 | SV, 5.3
`kmem_free(D3)` | Free previously allocated kernel memory. | “General-Purpose Allocation” in Chapter 8 | SV, 5.3
`kmem_zalloc(D3)` | Allocate and clear space from kernel free memory. | “General-Purpose Allocation” in Chapter 8 | SV, 5.3
kvaddr_to_alenlist() (`alenlist_ops` (d3x)) | Fill an alenlist with entries that describe a buffer in kernel virtual address space. | “Loading Alenlists” in Chapter 8 | 6.2
`kvtophys(D3)` | Get physical address of kernel data. | “Converting Virtual Addresses to Physical” in Chapter 8 | 5.3
`linkb(D3)` | Concatenate two message blocks. |  | SV*, 5.3*
`LOCK(D3)` | Acquire a basic lock, waiting if necessary. | “Basic Locks” in Chapter 8 | SV*, 5.3*
`LOCK_ALLOC(D3)` | Allocate and initialize a basic lock. | “Basic Locks” in Chapter 8 | SV*, 5.3*
`LOCK_DEALLOC(D3)` | Deallocate an instance of a basic lock. | “Basic Locks” in Chapter 8 | SV*, 5.3*
`LOCK_INIT(D3)` | Initialize a basic lock that was allocated statically, or reinitialize an allocated lock. | “Basic Locks” in Chapter 8 | 6.2
`LOCK_DESTROY(D3)` | Uninitialize a basic lock that was allocated statically. | “Basic Locks” in Chapter 8 | 6.2
`makedevice(D3)` | Make device number from major and minor numbers. | “Historical Use of the Device Numbers” in Chapter 8 | SV, 5.3
`max(D3)` | Return the larger of two integers. |  | SV, 5.3
`min(D3)` | Return the lesser of two integers. |  | SV, 5.3
`msgdsize(D3)` | Return number of bytes of data in a message. |  | SV, 5.3
`msgpullup(D3)` | Concatenate bytes in a message. |  | SV, 5.3
`MUTEX_ALLOC(D3)` | Allocate and initialize a mutex lock. | “Using Mutex Locks” in Chapter 8 | 6.2
`MUTEX_DEALLOC(D3)` | Deinitialize and free a dynamically allocated mutex lock. | “Using Mutex Locks” in Chapter 8 | 6.2
`MUTEX_DESTROY(D3)` | Deinitialize a mutex lock. | “Using Mutex Locks” in Chapter 8 | 6.2
`MUTEX_INIT(D3)` | Initialize an existing mutex lock. | “Using Mutex Locks” in Chapter 8 | 6.2
`MUTEX_LOCK(D3)` | Claim a mutex lock. | “Using Mutex Locks” in Chapter 8 | 6.2
`MUTEX_MINE(D3)` | Test if a mutex lock is owned by this process. | “Using Mutex Locks” in Chapter 8 | 6.2
`MUTEX_OWNED(D3)` | Query if a mutex lock is available. | “Using Mutex Locks” in Chapter 8 | 6.5
`MUTEX_TRYLOCK(D3)` | Conditionally claim a mutex lock. | “Using Mutex Locks” in Chapter 8 | 6.2
`MUTEX_UNLOCK(D3)` | Release a mutex lock. | “Using Mutex Locks” in Chapter 8 | 6.2
`ngeteblk(D3)` | Allocate a buf_t and a buffer of specified size. | “Allocating buf_t Objects and Buffers” in Chapter 8 | SV, 5.3
`noenable(D3)` | Prevent a queue from being scheduled. |  | SV, 5.3
`OTHERQ(D3)` | Get a pointer to queue's partner queue. |  | SV, 5.3
pciio_dma_dev_get() (`pciio_get(d3)` ) | Get device vertex from DMA map. |  | 6.4
pciio_dma_slot_get() (`pciio_get(d3)` ) | Get slot number from DMA map. |  | 6.4
`pciio_dmaaddr_drain(D3)` | Ensure DMA is complete. |  | 6.5
`pciio_dmalist_drain(D3)` | Ensure DMA is complete. |  | 6.5
pciio_dmamap_addr() (`pciio_dma(d3)` ) | Set up DMA mapping for an address. |  | 6.3
pciio_dmamap_alloc() (`pciio_dma(d3)` ) | Allocate DMA map object. |  | 6.3
pciio_dmamap_done() (`pciio_dma(d3)` ) | Release mapping hardware associated with a map object. |  | 6.3
pciio_dmamap_drain() (`pciio_dma(d3)` ) | Ensure DMA is complete. |  | 6.5
pciio_dmamap_free() (`pciio_dma(d3)` ) | Release DMA map object. |  | 6.3
pciio_dmamap_list() (`pciio_dma(d3)` ) | Set up DMA mapping for a list of addresses. |  | 6.3
pciio_dmatrans_addr() (`pciio_dma(d3)` ) | Set up DMA mapping using fixed resources if available. |  | 6.3
pciio_dmatrans_list() (`pciio_dma(d3)` ) | Set up DMA mapping using fixed resources if available. |  | 6.3
pciio_driver_register() (`pciio(d3)` ) | Register driver to handle specific devices. |  | 6.3
pciio_driver_unregister() (`pciio(d3)` ) | Unregister driver as device handler. |  | 6.4
pciio_error_register() (`pciio_error(d3)` ) | Register error handler for device. |  | 6.4
pciio_info_bus_get() (`pciio_get(d3)` ) | Query PCI bus number for device. |  | 6.4
pciio_info_dev_get() (`pciio_get(d3)` ) | Query connection vertex for device. |  | 6.4
pciio_info_device_id_get() (`pciio_get(d3)` ) | Query PCI device ID for device. |  | 6.4
pciio_info_func_get() (`pciio_get(d3)` ) | Query interrupt function for device. |  | 6.4
pciio_info_get() (`pciio_get(d3)` ) | Get PCI info object for use in queries. |  | 6.4
pciio_info_slot_get() (`pciio_get(d3)` ) | Query bus slot number for device. |  | 6.4
pciio_info_vendor_id_get() (`pciio_get(d3)` ) | Query PCI vendor ID for device. |  | 6.4
pciio_intr_alloc() (`pciio_intr(d3)` ) | Allocate interrupt object. |  | 6.3
pciio_intr_connect() (`pciio_intr(d3)` ) | Enable interrupt and set handler. |  | 6.3
pciio_intr_cpu_get() (`pciio_get(d3)` ) | Query CPU handling interrupt from device. |  | 6.4
pciio_intr_dev_get() (`pciio_get(d3)` ) | Get device vertex from interrupt object. |  | 6.4
pciio_intr_disconnect() (`pciio_intr(d3)` ) | Disable interrupt and unregister handler. |  | 6.3
pciio_intr_free() (`pciio_intr(d3)` ) | Release interrupt object. |  | 6.4
pciio_iterate() (`pciio(d3)` ) | Call function for every attached device. |  | 6.4
pciio_pio_addr() (`pciio_pio(d3)` ) | Set up PIO mapping using map object. |  | 6.3
pciio_pio_dev_get() (`pciio_get(d3)` ) | Get device vertex from PIO map. |  | 6.4
pciio_pio_mapsz_get() (`pciio_get(d3)` ) | Get map size from PIO map object. |  | 6.4
pciio_pio_pciaddr_get() (`pciio_get(d3)` ) | Get target bus address from PIO map object. |  | 6.4
pciio_pio_slot_get() (`pciio_get(d3)` ) | Query bus slot number from PIO map. |  | 6.4
pciio_pio_space_get() (`pciio_get(d3)` ) | Query target bus address space from PIO map. |  | 6.4
pciio_piomap_addr() (`pciio_pio(d3)` ) | Set up PIO mapping using map object. |  | 6.3
pciio_piomap_alloc() (`pciio_pio(d3)` ) | Allocate PIO map object. |  | 6.3
pciio_piomap_done() (`pciio_pio(d3)` ) | Release mapping hardware associated with a PIO map. |  | 6.4
pciio_piomap_free() (`pciio_pio(d3)` ) | Release a PIO map object. |  | 6.3
pciio_piospace_alloc() (`pciio_pio(d3)` ) | Reserve PCI bus address space for a device. |  | 6.4
pciio_piospace_free() (`pciio_pio(d3)` ) | Release PCI bus address space. |  | 6.4
pciio_piotrans_addr() (`pciio_pio(d3)` ) | Set up PIO mapping using fixed resources if available. |  | 6.3
pciio_reset() (`pciio(d3)` ) | Activate reset line of PCI card. |  | 6.4
`pcmsg(D3)` | Test whether a message is a priority control message. |  | SV, 5.3
`phalloc(D3)` | Allocate and initialize a pollhead structure. | “Allocating pollhead Objects” in Chapter 8 | SV, 5.3
`phfree(D3)` | Free a pollhead structure. | “Allocating pollhead Objects” in Chapter 8 | SV, 5.3
`physiock(D3)` | Validate and issue a raw I/O request. | “Waiting for Block I/O to Complete” in Chapter 8 | SV, 5.3
`pio_andb_rmw(D3)` | Byte read-and-write. |  | 5.3
`pio_andh_rmw(D3)` | 16-bit read-and-write. |  | 5.3
`pio_andw_rmw(D3)` | 32-bit read-and-write. |  | 5.3
`pio_badaddr(D3)` | Check for bus error when reading an address. |  | 5.3
`pio_badaddr_val(D3)` | Check for bus error when reading an address and return the value read. |  | 5.3
`pio_bcopyin(D3)` | Copy data from a bus address to kernel's virtual space. |  | 5.3
`pio_bcopyout(D3)` | Copy data from kernel's virtual space to a bus address. |  | 5.3
`pio_mapaddr(D3)` | Convert a bus address to a virtual address. |  | 5.3
`pio_mapalloc(D3)` | Allocate a PIO map. |  | 5.3
`pio_mapfree(D3)` | Free a PIO map. |  | 5.3
`pio_orb_rmw(D3)` | Byte read-or-write. |  | 5.3
`pio_orh_rmw(D3)` | 16-bit read-or-write. |  | 5.3
`pio_orw_rmw(D3)` | 32-bit read-or-write. |  | 5.3
`pio_wbadaddr(D3)` | Check for bus error when writing to an address. |  | 5.3
`pio_wbadaddr_val(D3)` | Check for bus error when writing a specified value to an address. |  | 5.3
`pollwakeup(D3)` | Inform polling processes that an event has occurred. | “Use of pollwakeup()” in Chapter 7 | SV, 5.3
`pptophys(D3)` | Convert page pointer to physical address. | “Managing Buffer Virtual Addresses” in Chapter 8 | SV, 5.3
`proc_ref(D3)` | Obtain a reference to a process for signaling. | “User Process Administration” in Chapter 8 | SV, 5.3
`proc_signal(D3)` | Send a signal to a process. | “User Process Administration” in Chapter 8 | SV, 5.3
`proc_unref(D3)` | Release a reference to a process. | “User Process Administration” in Chapter 8 | SV, 5.3
`psema(D3)` | Perform a “P” or wait semaphore operation. | “Semaphores” in Chapter 8 | SV, 5.3
`ptob(D3)` | Convert size in pages to size in bytes. | “Working With Page and Sector Units” in Chapter 8 | SV, 5.3
`pullupmsg(D3)` | Concatenate bytes in a message. |  | SV, 5.3
`putbq(D3)` | Place a message at the head of a queue. |  | SV, 5.3
`putctl(D3)` | Send a control message to a queue. |  | SV, 5.3
`putctl1(D3)` | Send a control message with a one-byte parameter to a queue. |  | SV, 5.3
`putnext(D3)` | Send a message to the next queue. |  | SV, 5.3
`putnextctl(D3)` | Send a control message to a queue. |  | SV, 5.3
`putnextctl1(D3)` | Send a control message with a one-byte parameter to a queue. |  | SV, 5.3
`putq(D3)` | Put a message on a queue. |  | SV, 5.3
`qenable(D3)` | Schedule a queue's service routine to be run. |  | SV, 5.3
`qprocsoff(D3)` | Enable put and service routines. |  | SV, 5.3
`qprocson(D3)` | Disable put and service routines. |  | SV, 5.3
`qreply(D3)` | Send a message in the opposite direction in a stream. |  | SV, 5.3
`qsize(D3)` | Find the number of messages on a queue. |  | SV, 5.3
`RD(D3)` | Get a pointer to the read queue. |  | SV, 5.3
`rmvb(D3)` | Remove a message block from a message. |  | SV, 5.3
`rmvq(D3)` | Remove a message from a queue. |  | SV, 5.3
`RW_ALLOC(D3)` | Allocate and initialize a reader/writer lock. | “Reader/Writer Locks” in Chapter 8 | SV*, 5.3*
`RW_DEALLOC(D3)` | Deallocate a reader/writer lock. | “Reader/Writer Locks” in Chapter 8 | SV*, 5.3*
`RW_DESTROY(D3)` | Deinitialize an existing reader/writer lock. | “Reader/Writer Locks” in Chapter 8 | 6.2
`RW_INIT(D3)` | Initialize an existing reader/writer lock. | “Reader/Writer Locks” in Chapter 8 | 6.2
`RW_RDLOCK(D3)` | Acquire a reader/writer lock as reader, waiting if necessary. | “Reader/Writer Locks” in Chapter 8 | SV*, 5.3*
`RW_TRYRDLOCK(D3)` | Try to acquire a reader/writer lock as reader, returning a code if it is not free. | “Reader/Writer Locks” in Chapter 8 | SV*, 5.3*
`RW_TRYWRLOCK(D3)` | Try to acquire a reader/writer lock as writer, returning a code if it is not free. | “Reader/Writer Locks” in Chapter 8 | SV*, 5.3*
`RW_UNLOCK(D3)` | Release a reader/writer lock as reader or writer. | “Reader/Writer Locks” in Chapter 8 | SV*, 5.3*
`RW_WRLOCK(D3)` | Acquire a reader/writer lock as writer, waiting if necessary. | “Reader/Writer Locks” in Chapter 8 | SV*, 5.3*
`SAMESTR(D3)` | Test if next queue is of the same type. |  | SV, 5.3
scsi_abort() | Transmits a SCSI ABORT command. | “Overview of Host Adapter Functions” in Chapter 16 | 5.3*
`scsi_alloc(D3)` | Open a connection between a driver and a target device. | “Overview of Host Adapter Functions” in Chapter 16 | 5.3*
`scsi_command(D3)` | Transmit a SCSI command on the bus and return results. | “Overview of Host Adapter Functions” in Chapter 16 | 5.3*
`scsi_free(D3)` | Release connection to target device. | “Overview of Host Adapter Functions” in Chapter 16 | 5.3*
`scsi_info(D3)` | Issue the SCSI Inquiry command and return the results. | “Overview of Host Adapter Functions” in Chapter 16 | 5.3*
scsi_reset() | Resets the SCSI adapter or bus. | “Overview of Host Adapter Functions” in Chapter 16 | 5.3*
setgiovector() | Register a GIO interrupt handler. | “Writing a GIO Driver” in Chapter 19 | 5.3
setgioconfig() | Prepare a GIO slot for use. | “Configuring a Slot” in Chapter 19 | 5.3
`sgset(D3)` | Assign physical addresses to a vector of software scatter-gather registers. | “Converting Virtual Addresses to Physical” in Chapter 8 | 5.3
`sleep(D3)` | Suspend process execution pending occurrence of an event. | “Using sleep() and wakeup()” in Chapter 8 | SV, 5.3
`SLEEP_ALLOC(D3)` | Allocate and initialize a sleep lock. | “Using Sleep Locks” in Chapter 8 | SV*, 5.3*
`SLEEP_DEALLOC(D3)` | Deinitialize and deallocate a dynamically allocated sleep lock. | “Using Sleep Locks” in Chapter 8 | SV*, 5.3*
`SLEEP_DESTROY(D3)` | Deinitialize a sleep lock. | “Using Sleep Locks” in Chapter 8 | 6.2
`SLEEP_INIT(D3)` | Initialize an existing sleep lock. | “Using Sleep Locks” in Chapter 8 | 6.2
`SLEEP_LOCK(D3)` | Acquire a sleep lock, waiting if necessary until the lock is free. | “Using Sleep Locks” in Chapter 8 | SV*, 5.3*
`SLEEP_LOCKAVAIL(D3)` | Query whether a sleep lock is available. | “Using Sleep Locks” in Chapter 8 | SV*, 5.3*
`SLEEP_LOCK_SIG(D3)` | Acquire a sleep lock, waiting if necessary until the lock is free or a signal is received. | “Using Sleep Locks” in Chapter 8 | SV*, 5.3*
`SLEEP_TRYLOCK(D3)` | Try to acquire a sleep lock, returning a code if it is not free. | “Using Sleep Locks” in Chapter 8 | SV*, 5.3*
`SLEEP_UNLOCK(D3)` | Release a sleep lock. | “Using Sleep Locks” in Chapter 8 | SV*, 5.3*
`splbase(D3)` | Block no interrupts. | “Priority Level Functions” in Chapter 8 | SV, 5.3
`spltimeout(D3)` | Block only timeout interrupts. | “Priority Level Functions” in Chapter 8 | SV, 5.3
`spldisk(D3)` | Block disk interrupts. | “Priority Level Functions” in Chapter 8 | SV, 5.3
`splstr(D3)` | Block STREAMS interrupts. | “Priority Level Functions” in Chapter 8 | SV, 5.3
`spltty(D3)` | Block disk, VME, serial interrupts. | “Priority Level Functions” in Chapter 8 | SV, 5.3
`splhi(D3)` | Block all I/O interrupts. | “Priority Level Functions” in Chapter 8 | SV, 5.3
`spl0(D3)` | Same as `splbase`(). | “Priority Level Functions” in Chapter 8 | SV, 5.3
`splx(D3)` | Restore previous interrupt level. | “Priority Level Functions” in Chapter 8 | SV, 5.3
`strcat(D3)` | Append one string to another. |  | SV, 5.3
`strcpy(D3)` | Copy a string. |  | SV, 5.3
`streams_interrupt(D3)` | Synchronize interrupt-level function with STREAMS mechanism. |  | 5.3
`STREAMS_TIMEOUT(D3)` | Synchronize timeout with STREAMS mechanism. |  | 5.3
`strlen(D3)` | Return length of a string. |  | SV, 5.3
`strlog(D3)` | Submit messages to the log driver. |  | SV, 5.3
`strncmp(D3)` | Compare two strings for a specified length. |  | SV, 5.3
`strncpy(D3)` | Copy a string for a specified length. |  | SV, 5.3
`strqget(D3)` | Get information about a queue or band of the queue. |  | SV, 5.3
`strqset(D3)` | Change information about a queue or band of the queue. |  | SV, 5.3
`subyte(D3)` | Store a byte to user space. | “General Data Transfer” in Chapter 8 | 5.3
`suword(D3)` | Store a word to user space. | “General Data Transfer” in Chapter 8 | 5.3
`SV_ALLOC(D3)` | Allocate and initialize a synchronization variable. | “Using Synchronization Variables” in Chapter 8 | SV*, 5.3*
`SV_BROADCAST(D3)` | Wake all processes sleeping on a synchronization variable. | “Using Synchronization Variables” in Chapter 8 | SV*, 5.3*
`SV_DEALLOC(D3)` | Deinitialize and deallocate a synchronization variable. | “Using Synchronization Variables” in Chapter 8 | SV*, 5.3*
`SV_DESTROY(D3)` | Deinitialize a synchronization variable. | “Using Synchronization Variables” in Chapter 8 | 6.2
`SV_INIT(D3)` | Initialize an existing synchronization variable. | “Using Synchronization Variables” in Chapter 8 | 6.2
`SV_SIGNAL(D3)` | Wake one process sleeping on a synchronization variable. | “Using Synchronization Variables” in Chapter 8 | SV*, 5.3*
`SV_WAIT(D3)` | Sleep until a synchronization variable is signalled. | “Using Synchronization Variables” in Chapter 8 | SV*, 5.3*
`SV_WAIT_SIG(D3)` | Sleep until a synchronization variable is signalled or a signal is received. | “Using Synchronization Variables” in Chapter 8 | SV*, 5.3*
`timeout(D3)` | Schedule a function to be executed after a specified number of clock ticks. | “Waiting for Time to Pass” in Chapter 8 | SV, 5.3
`TRYLOCK(D3)` | Try to acquire a basic lock, returning a code if the lock is not currently free. | “Basic Locks” in Chapter 8 | SV*, 5.3*
`uiomove(D3)` | Copy data using uio_t. | “Transferring Data Through a uio_t Object” in Chapter 8 | SV, 5.3
`uiophysio(D3)` | Validate a raw I/O request and pass to a strategy function. | “Waiting for Block I/O to Complete” in Chapter 8 | 5.3
`unbufcall(D3)` | Cancel a pending bufcall request. |  | SV, 5.3
`undma(D3)` | Unlock physical memory in user space. | “Waiting for Block I/O to Complete” in Chapter 8 | 5.3
`unfreezestr(D3)` | Unfreeze the state of a stream. |  | SV, 5.3
`unlinkb(D3)` | Remove a message block from the head of a message. |  | SV, 5.3
`UNLOCK(D3)` | Release a basic lock. | “Basic Locks” in Chapter 8 | SV*, 5.3*
`untimeout(D3)` | Cancel a previous itimeout or fast_itimeout request. | “Waiting for Time to Pass” in Chapter 8 | SV*, 5.3*
`ureadc(D3)` | Copy a character to space described by uio_t. | “Transferring Data Through a uio_t Object” in Chapter 8 | SV, 5.3
`userdma(D3)` | Lock physical memory in user space. | “Waiting for Block I/O to Complete” in Chapter 8 | 5.3
userabi() | Get data sizes for the ABI of the user process (32- or 64-bit). | “Handling 32-Bit and 64-Bit Execution Models” in Chapter 7 | 6.2
uvaddr_to_alenlist() (alenlist_ops(d3x)) | Fill an alenlists with entries that describe a buffer in a user virtual address space. | “Loading Alenlists” in Chapter 8 | 6.4
`uwritec(D3)` | Return a character from space described by uio_t. | “Transferring Data Through a uio_t Object” in Chapter 8 | SV, 5.3
`v_getaddr(D3)` | Get the user virtual address associated with a vhandl_t. | “Managing Mapped Memory” in Chapter 8 | 5.3
`v_gethandle(D3)` | Get a unique identifier associated with a vhandl_t. | “Managing Mapped Memory” in Chapter 8 | 5.3
`v_getlen(D3)` | Get the length of user address space associated with a vhandl_t. | “Managing Mapped Memory” in Chapter 8 | 5.3
`v_mapphys(D3)` | Map kernel address space into user address space. | “Managing Mapped Memory” in Chapter 8 | 5.3
`valusema(D3)` | Return the value associated with a semaphore. | “Semaphores” in Chapter 8 | 5.3
`vme_adapter(D3)` | Determine VME adapter that corresponds to a given memory address. |  | 5.3
`vme_ivec_alloc(D3)` | Allocate a VME bus interrupt vector. |  | 5.3
`vme_ivec_free(D3)` | Free a VME bus interrupt vector. |  | 5.3
`vme_ivec_set(D3)` | Register a VME bus interrupt vector. |  | 5.3
`vsema(D3)` | Perform a “V” or signal semaphore operation. | “Semaphores” in Chapter 8 | 5.3
`wakeup(D3)` | Waken a process waiting for an event. | “Using sleep() and wakeup()” in Chapter 8 | SV, 5.3
`wbadaddr(D3)` | Test physical address for output. | “Testing Device Physical Addresses” in Chapter 8 | SV, 5.3
`wbadaddr_val(D3)` | Test physical address for output of specific value. | “Testing Device Physical Addresses” in Chapter 8 | SV, 5.3
`WR(D3)` | Get a pointer to the write queue. |  | SV, 5.3

The following SVR4 kernel functions are not implemented in IRIX: bioreset, dma_disable, dma_enable, dma_free_buf, dma_free_cb, dma_get_best_mode, dma_get_buf, dma_get_cb, dma_pageio, dma_prog, dma_swstart, dma_swsetup, drv_gethardware, hat_getkpfnum, hat_getppfnum, inb, inl, inw, kvtoppid, mod_drvattach, mod_drvdetach, outb, outl, outw, physmap, physmap_free, phystoppid, psignal, rdma_filter, repinsb, repinsd, repinsw, repoutsb, repoutsd, repoutsw, rminit, rmsetwant, SLEEP_LOCKOWNED, strncat, vtop.

Prev | Table of Contents | Next
Chapter 22. STREAMS Drivers |  | Appendix B. Challenge DMA with Multiple IO4 Boards