|
|
assert_wait_mesg(9r) -- General: Asserts that the current kernel thread is about to block (sleep)
|
|
The assert_wait_mesgroutine asserts that the current kernel thread is about to block (sleep) until the specified event occurs. This routine sets a thread wait bit in the pointer to the thread structur... |
|
backq(9r) -- STREAMS: Gets a pointer to the previous queue
|
|
The backq interface returns a pointer to the queue preceding the current queue (the current_queue argument). If the current queue is a read queue, backq returns a pointer to the queue downstream from ... |
|
BADADDR(9r) -- General: Probes the address during device autoconfiguration
|
|
The BADADDR routine generates a call to a machine-dependent routine that does a read access check of the data at the supplied address and dismisses any machine check exception that may result from the... |
|
bcanput(9r) -- STREAMS: Tests for flow control in a specified priority band
|
|
The bcanput interface, like the canput interface, searches through the stream (starting at the message queue identified by the message_queue argument) until it finds a queue that contains a service in... |
|
bcmp(9r) -- General: Compares two byte strings
|
|
The bcmp routine compares byte string b1 to byte string b2. The routine compares exactly n bytes. No check is made for null bytes. |
|
bcopy(9r) -- General: Copies a series of bytes with a specified limit
|
|
The bcopy routine copies n bytes from string b1 to buffer b2. No check is made for null bytes. The copy is nondestructive, that is, the address ranges of b1 and b2 can overlap. |
|
biodone(9r) -- General: Indicates that block I/O is complete
|
|
The biodone routine is called after an I/O operation to mark the buf structure as completed. It sets the b_flags member to B_SWAP, B_UBC, or B_ASYNC to indicate the type of I/O operation that has comp... |
|
blkclr(9r) -- General: Zero a block of memory
|
|
The blkclr routine zeros n bytes of memory beginning at the address specified by b1. |
|
brelse(9r) -- General: Deallocates a buf structure
|
|
The brelse routine deallocates a buf structure that was previously allocated by the getnewbuf routine. The buf structure contains information describing an I/O request. Device drivers call the brelse ... |
|
btop(9r) -- General: Converts bytes to number of pages
|
|
The btop routine converts the specified byte address to the number of pages. |
|
buf(9s) -- General: Describes arbitrary I/O
|
|
The buf data structure describes arbitrary I/O, but is usually associated with block I/O and physio. A systemwide pool of buf data structures exists for block I/O; however, many kernel modules that ar... |
|
bufcall(9r) -- STREAMS: Gets a buffer when allocb fails
|
|
The bufcall interface serves as a timeout call of indeterminate length. When a buffer allocation request fails, you can use bufcall to schedule the interface passed to the function argument to be call... |
|
BUF_LOCK(9r) -- General: Locks the specified I/O buffer
|
|
The BUF_LOCK routine locks the specified I/O buffer. The routine masks all disk and tape controller interrupts (by calling the splbio routine). It sets the mutual exclusion buffer lock member, b_lock,... |
|
BUF_UNLOCK(9r) -- General: Unlocks the specified I/O buffer
|
|
The BUF_UNLOCK routine unlocks the specified I/O buffer that was locked in a previous call to BUF_LOCK. The routine masks all disk and tape controller interrupts (by calling the splbio routine). It re... |
|
canput(9r) -- STREAMS: Tests for room in a message queue
|
|
The canput interface searches through the stream (starting at the message queue identified by the message_queue argument) until it finds a queue that contains a service interface where the message can... |
|
cfgmgr_get_state(9r) -- General: Determines the configuration state
|
|
The cfgmgr_get_state routine obtains the configuration state of the specified device driver. The specified device driver is in either the static configuration state or the dynamic configuration state.... |
|
cfgmgr_set_status(9r) -- General: Reports failure to the cfgmgr framework
|
|
The cfgmgr_set_status routine reports to the cfgmgr framework that a failure has occurred during static configuration. If the specified device driver is in the static configuration state, it does not ... |
|
cfg_attr_t(9s) -- General: Contains information for managing the loading and unloading of kernel modules
|
|
The cfg_attr_t data structure contains information for managing the configuring and unconfiguring of kernel modules. The cfgmgr framework passes a pointer to this data structure to the kernel module'... |
|
cfg_configure(9r) -- General: Loads and configures a kernel subsystem
|
|
The cfg_configure routine is used to configure a subsystem. If the subsystem is not loaded into the kernel, this routine loads the subsystem. The routine then configures the subsystem using the attrib... |
|
cfg_query(9r) -- General: Determines the values of selected subsystem attributes
|
|
The cfg_query( ) routine obtains information about a list of subsystem attributes. You can obtain information about one or more attributes. When your application calls the cfg_query( ) routine, it pas... |
|
cfg_reconfigure(9r) -- General: Reconfigures the attribute values for a kernel subsystem
|
|
The cfg_reconfigure( ) routine is used to modify attribute values for a subsystem. The modifications made by this routine take effect immediately because they are made to the in-memory copy of the sub... |
|
cfg_subsysop(9r) -- Kernel routine used to perform subsystemdefined operations
|
|
The cfg_subsysop( ) routine performs a subsystem defined operation. The semantics of the operation are defined by the subsystem and implemented in the subsystem's configure routine. |
|
cfg_subsys_attr_t(9s) -- General: Contains attribute information for kernel modules
|
|
The cfg_subsys_attr_t data structure contains information that kernel modules use to describe a variety of attributes. Kernel module writers declare and initialize an array of cfg_subsys_attr_t data s... |
|
cfg_unconfigure(9r) -- General: Unconfigures a kernel subsystem
|
|
The cfg_unconfigure kernel routine is used to unconfigure a subsystem. If the subsystem is not configured into the kernel, this routine returns an error. If subsystem is sucessfully unconfigured, the ... |
|
clear_wait(9r) -- General: Clears the wait condition
|
|
The clear_wait routine clears the wait condition for the specified kernel thread and starts executing the kernel thread, if appropriate. If the kernel thread is interruptible and is still waiting for ... |
|
contig_free(9r) -- General: Frees a block of memory previously allocated by contig_malloc
|
|
The contig_free routine frees the memory allocated in a previous call to contig_malloc. If the memory came from the saved memory pool, contig_free puts it back in the saved memory pool; otherwise, the... |
|
contig_malloc(9r) -- General: Allocates physically contiguous memory
|
|
The contig_malloc routine allocates physically contiguous memory during the boot process (before single-user mode). The routine carves out an area of physically contiguous memory from a contiguous mem... |
|
copyb(9r) -- STREAMS: Copies a message block
|
|
The copyb interface allocates a new message block and copies into it the data from the block pointed to by the message block (the message_block argument). The new message block is at least as large as... |
|
copyin(9r) -- General: Copies data from a user address space to a kernel address space
|
|
The copyin routine copies a specified amount of data from the unprotected user address space to the protected kernel address space. |
|
copyinstr(9r) -- General: Copies a null-terminated string from a user address space to a kernel address space
|
|
The copyinstr routine copies a specified null-terminated string from the unprotected user address space to a specified address in the protected kernel address space. |
|
copymsg(9r) -- STREAMS: Copies a message to a new message
|
|
The copymsg interface: Forms a new message by allocating new message blocks Copies (by calling the copyb interface) the contents of the message referred to by the message_block argument Returns a poin... |
|
copyout(9r) -- General: Copies data from a kernel address space to a user address space
|
|
The copyout routine copies a specified amount of data from the protected kernel address space to the unprotected user address space. |
|
copyoutstr(9r) -- General: Copies a null-terminated string from a kernel address space to a user address space
|
|
The copyoutstr routine copies a specified null-terminated string from the protected kernel address space to the unprotected user address space. |
|
copystr(9r) -- General: Copies a null-terminated character string with a specified limit
|
|
The copystr routine copies string s1 to the buffer pointed to by s2. The routine stops after copying a null character or after copying maxlength characters, whichever comes first. The s2 buffer is not... |
|
copy_to_phys(9r) -- General: Copies data from a virtual address to a physical address
|
|
The copy_to_phys routine copies a specified amount of virtually addressed memory to physically addressed memory. The addresses reside only in system memory space and not in the memory space on I/O bus... |
|
cpu(9v) -- Global Variable: Provides a unique logical processor-type family identifier
|
|
The cpu global variable provides a unique logical family identifier of the processor type of the running system. The logical system name can represent a single processor or a family of processor types... |
|
current_task(9r) -- General: Returns a pointer to the task structure associated with the currently running kernel thread
|
|
The current_task routine returns a pointer to the task structure associated with the currently running kernel thread. A device driver typically calls this routine in preparation for doing a DMA operat... |
|
current_thread(9r) -- General: Is a pointer to the currently running kernel thread
|
|
The current_thread routine is a pointer to the currently running kernel thread. Typically, kernel modules use this routine to reference the wait_result member of the thread structure pointer associate... |
|
datamsg(9r) -- STREAMS: Tests whether a message is a data message
|
|
The datamsg interface tests the type of message to determine if it is a data message type. The following list identifies the data message value types: Ordinary data Requests a real-time delay Internal... |
|
decl_simple_lock_data(9r) -- General: Declares a simple lock structure
|
|
The decl_simple_lock_data routine declares a simple lock structure, slock, of the specified name. You declare a simple lock structure to protect data structures and device register access. You use dec... |
|
DELAY(9r) -- General: Delays the calling routine a specified number of microseconds
|
|
The DELAY routine delays the calling routine a specified number of microseconds. DELAY spins, waiting for the specified number of microseconds to pass before continuing execution. For example, the fol... |
|
do_config(9r) -- EISA/ISA: Initializes the device to its assigned configuration
|
|
The do_config routine initializes the specified controller based on its power-up resource assignments. If the device uses either an interrupt or a DMA channel, then do_config also performs any setup r... |
|
dupb(9r) -- STREAMS: Duplicates a message block descriptor
|
|
The dupb interface creates a new message block structure to reference the message block pointed to by the message_block_ptr argument. Unlike copyb, the dupb interface does not copy the information in ... |
|
dupmsg(9r) -- STREAMS: Duplicates a message
|
|
The dupmsg interface forms a new message by copying the message block descriptors pointed to by the message_block_ptr argument and linking them. The dupmsg interface calls dupb for each message block.... |
|
enableok(9r) -- STREAMS: Enables a queue for service
|
|
The enableok interface allows the queue associated with the queue_pointer argument to be rescheduled for service. The interface cancels the effect of a previous call to the noenable interface on the q... |
|
esballoc(9r) -- STREAMS: Allocates a message block with a shared buffer
|
|
The esballoc interface creates a STREAMS message and attaches a user-supplied data buffer in place of a STREAMS data buffer. The interface calls allocb to obtain a message and data block header. The u... |
|
ffs(9r) -- General: Finds the first set bit in a mask
|
|
The ffs routine returns the bit position of the first bit you set in the mask argument. The scan proceeds from the least significant bit to the most significant bit of the mask. |
|
flushband(9r) -- STREAMS: Flushes messages for a specified priority band
|
|
The flushband interface flushes messages associated with the priority band specified by the pri argument. If pri is zero (0), flushband flushes only normal and high priority messages. Otherwise, flush... |
|
flushq(9r) -- STREAMS: Removes a message from a queue
|
|
The flushq interface frees messages and their associated data structures by calling the freemsg interface. If the queue's count falls below the low-water mark and the QWANTW bit is set, flushq enable... |
|
FREE(9r) -- General: Deallocates (frees) the allocated kernel virtual memory
|
|
The FREE routine deallocates (frees) the allocated kernel virtual memory, which you allocated in a previous call to MALLOC. |
|
freeb(9r) -- STREAMS: Frees a message block
|
|
The freeb interface deallocates a message block. If the reference count of the db_ref member of the datab structure is greater than the value 1, freeb decrements the count. If db_ref equals the value ... |
|
freemsg(9r) -- STREAMS: Frees all message blocks in a message
|
|
The freemsg interface calls the freeb interface to free all message and data blocks associated with the message pointed to by the message_block_ptr argument. |
|
fubyte(9r) -- General: Returns a byte from user address space
|
|
The fubyte routine returns 1 byte from the unprotected user address space to the calling program. |
|
fuibyte(9r) -- General: Returns a byte from user instruction address space
|
|
|
|
fuiword(9r) -- General: Returns a word from user instruction address space
|
|
|
|
fuword(9r) -- General: Returns a word from user instruction address space
|
|
The fuword routine returns one word from the unprotected user address space to the calling program. |
|
getnewbuf(9r) -- General: Allocates a buf structure
|
|
The getnewbuf routine allocates a buf structure for performing I/O operations. This routine guarantees that the members of the structure are properly initialized prior to initiating the I/O request. D... |
|
getq(9r) -- STREAMS: Gets a message from the front of the queue
|
|
The getq interface is used by a service interface to retrieve its enqueued messages. A module or driver may include a service interface to process enqueued messages. Once the STREAMS scheduler calls t... |
|
get_info(9r) -- General: Returns system-specific information
|
|
The get_info routine returns system-specific data assigned to the hardware platform that the driver operates on. For example, a device driver might request system-specific information for the followin... |
|
get_random_bytes(9r) -- General: Returns the requested number of random bytes and stores them in a buffer.
|
|
The get_random_bytes() routine returns the requested number of random bytes and stores them in a buffer. This routine is for kernel modules that cannot be in a wait state. |
|
get_random_bytes_wait(9r) -- General: Returns the requested number of random bytes and places them in a buffer.
|
|
The get_random_bytes_wait() routine returns the requested number of random bytes and places them in a buffer. This routine is for kernel modules that can be in a wait state. |
|
gsignal(9r) -- General: Sends a signal to a process group
|
|
The gsignal routine sends a signal to a process group, invoking psignal for each process that is a member of the specified process group. |
|
htonl(9r) -- General: Convert word and longword values
|
|
The htonl routine converts the specified longword value from host-to-network byte order. The htons routine converts the specified word value from host-to-network byte order. The TCP/IP protocols speci... |
|
htons(9r) -- General: Convert word and longword values
|
|
The htonl routine converts the specified longword value from host-to-network byte order. The htons routine converts the specified word value from host-to-network byte order. The TCP/IP protocols speci... |
|
hz(9v) -- Global Variable: Stores the number of clock ticks per second
|
|
The hz global variable is set to the number of clock ticks per second. The value is useful for timing purposes. For example, if a kernel module wants to schedule a routine to be run in 2 seconds, you ... |
|
insq(9r) -- STREAMS: Inserts a STREAMS message into a queue
|
|
The insq interface inserts a STREAMS message into a queue. The message to be inserted (the message_to_be_inserted argument) is placed in the queue (the message_queue argument) immediately before the m... |
|
insque(9r) -- General: Add or remove an element from the queue
|
|
The insque routine adds the element that the elem argument specifies to the queue. The routine inserts elem in the next position after pred in the queue. The remque routine removes the element that th... |
|
intro(9) -- Introduction to kernel module routines, data structures, and global variables
|
|
Section 9 describes the routines, data structures, and global variables used to develop kernel modules. The descriptions are presented in alphabetical order. Each reference page carries one of the fol... |
|
IS_KSEG_VA(9r) -- General: Determine if
|
|
The IS_KSEG_VA routine determines if the specified address is located in the kernel-unmapped address space. The IS_SEG0_VA routine determines if the specified address is located in the user-mapped add... |
|
IS_SEG0_VA(9r) -- General: Determine if
|
|
The IS_KSEG_VA routine determines if the specified address is located in the kernel-unmapped address space. The IS_SEG0_VA routine determines if the specified address is located in the user-mapped add... |
|
IS_SEG1_VA(9r) -- General: Determine if
|
|
The IS_KSEG_VA routine determines if the specified address is located in the kernel-unmapped address space. The IS_SEG0_VA routine determines if the specified address is located in the user-mapped add... |
|
kernel_isrthread(9r) -- General: Starts a fixed priority kernel thread dedicated to interrupt service
|
|
The kernel_isrthread routine creates and starts a kernel thread at the specified entry point. This kernel thread handles only interrupt service requests in the specified task and at the specified prio... |
|
kernel_thread_w_arg(9r) -- General: Starts a kernel thread with a calling argument passed in
|
|
The kernel_thread_w_arg routine creates and starts a kernel thread in the specified task at the specified entry point with a specified argument. The kernel_thread_w_arg routine passes the specified ar... |
|
KSEG_TO_PHYS(9r) -- General: Converts a kernel-unmapped virtual address to a physical address
|
|
The KSEG_TO_PHYS routine converts a kernel-unmapped virtual address to a kernel physical address. Device drivers can use this physical address in DMA operations. Prior to calling KSEG_TO_PHYS, device ... |
|
lbolt(9v) -- Global Variable: Is a periodic wakeup mechanism
|
|
You use the lbolt global variable as a periodic wakeup mechanism. Wakeups are done on the lbolt variable once per second. For example, if a kernel module was polling for an event once per second, you ... |
|
linkb(9r) -- STREAMS: Concatenates two message blocks
|
|
The linkb interface creates a new message by adding the message specified in the message_to_be_added argument to the tail of the message specified in the message argument. The continuation pointer (th... |
|
lock(9s) -- General: Contains complex lock-specific information
|
|
The lock data structure is the complex lock structure that contains complex lock-specific information. A kernel module writer using the complex lock method declares a pointer to a lock data structure ... |
|
lock_done(9r) -- General: Releases a complex lock
|
|
The lock_done routine releases a lock that was previously asserted by one of the following complex lock routines: lock_read, lock_try_read, lock_try_write, and lock_write. |
|
lock_init(9r) -- General: Initializes a complex lock
|
|
The lock_init routine initializes a complex lock. You identify this lock by declaring a pointer to a complex lock structure and passing it as the first argument. The complex lock structure pointer mus... |
|
lock_read(9r) -- General: Asserts a complex lock with read-only access
|
|
The lock_read routine asserts a lock with read-only access for the resource associated with the specified lock structure pointer. The lock_read routine allows multiple kernel threads to access the res... |
|
lock_terminate(9r) -- General: Terminates, using a complex lock
|
|
The lock_terminate routine determines that the driver is done using the complex lock forever. The complex lock must be free (that is, the driver does not hold the lock) before calling lock_terminate. ... |
|
lock_try_read(9r) -- General: Tries to assert a complex lock
|
|
The lock_try_read routine tries to assert a complex lock (without blocking) with read-only access for the resource associated with the specified lock structure pointer. To release a complex lock with ... |
|
lock_try_write(9r) -- General: Tries to assert a complex lock with write access
|
|
The lock_try_write routine tries to assert a complex lock (without blocking) with write access for the resource associated with the specified lock structure pointer. To release a complex lock with wri... |
|
lock_write(9r) -- Asserts a complex lock with write access
|
|
The lock_write routine asserts a lock with exclusive write access for the resource associated with the specified lock structure pointer. This means that once a write lock is asserted, no other kernel ... |
|
MALLOC(9r) -- General: Allocates a variable-size section of kernel virtual memory
|
|
The MALLOC routine (macro) allocates at least size bytes from the kernel memory and returns the address of the allocated memory. A kernel module can allocate the memory in interrupt and process contex... |
|
mb(9r) -- General: Performs a memory barrier
|
|
The Alpha architecture does not guarantee read/write ordering. That is, the memory subsystem is free to complete read and write operations in any order that is optimal, without regard for the order in... |
|
mpsleep(9r) -- General: Blocks the current kernel thread
|
|
The mpsleep routine blocks (puts to sleep) the current kernel thread until a wakeup is issued on the address you specify in the channel argument. This routine is the symmetric multiprocessor (SMP) sle... |
|
msgdsize(9r) -- STREAMS: Returns the number of bytes in a message
|
|
The msgdsize interface counts the number of bytes in a data message. Only bytes included in the data blocks with a message type of M_DATA (ordinary data) is included in the count. |
|
noenable(9r) -- STREAMS: Prevents a queue from being scheduled
|
|
The noenable interface prevents the queue associated with the queue argument from being scheduled for service by the insq, putbq, or putq interfaces when enqueuing an ordinary priority message. You ca... |
|
ntohl(9r) -- General: Convert longword and word values
|
|
The ntohl routine converts the specified longword value from network-to-host byte order. The ntohs routine converts the specified word value from network-to-host byte order. The TCP/IP protocols speci... |
|
ntohs(9r) -- General: Convert longword and word values
|
|
The ntohl routine converts the specified longword value from network-to-host byte order. The ntohs routine converts the specified word value from network-to-host byte order. The TCP/IP protocols speci... |
|
OTHERQ(9r) -- STREAMS: Gets a pointer to a module's other queue
|
|
The OTHERQ interface returns a pointer to the other of the two queue structures that make up a STREAMS module or driver. If the queue argument points to the read queue, the OTHERQ interface returns th... |
|
ovbcopy(9r) -- General: Copies a byte string with a specified limit
|
|
The ovbcopy routine copies n bytes from string b1 to buffer b2. No check is made for null bytes. The address ranges of b1 and b2 can overlap. |
|
page_size(9v) -- Global Variable: Is the virtual page size
|
|
The page_size global variable is the size of a virtual page on a CPU. A device driver can use this global variable to partition I/O transfers so that they never cross a virtual page boundary. You shou... |
|
panic(9r) -- General: Causes a system crash
|
|
The panic routine causes a system crash, usually because of fatal errors. It sends to the console terminal and error logger the specified message and, possibly, other system-dependent information (for... |
|
PHYS_TO_KSEG(9r) -- General: Converts a physical address to a
|
|
The PHYS_TO_KSEG routine converts a kernel physical address to a kernel-unmapped virtual address. |
|
pmap_extract(9r) -- General: Extracts a physical page address
|
|
The pmap_extract routine extracts the physical page address associated with the specified pmap (physical map) and virt_addr (virtual address) arguments. The virtual address includes the offset within ... |
|
pmap_kernel(9r) -- General: Returns the physical map handle for the kernel
|
|
The pmap_kernel routine returns the physical map handle for the kernel. |
|
pmap_set_modify(9r) -- General: Sets the modify bits of the specified physical page
|
|
The pmap_set_modify routine informs the pmap module that the specified physical page was modified through a backdoor mechanism. |
|
printf(9r) -- General: Write formatted text to some output device
|
|
The printf and uprintf routines are scaled-down versions of the corresponding C library routines. The printf routine prints diagnostic information directly on the console terminal and writes ASCII tex... |
|
privileged(9r) -- General: Checks for proper privileges
|
|
The privileged routine checks for an appropriate privilege when the security feature is enabled. Use privileged with a privilege number and with the error_code argument set to the constant EPERM to em... |
|
psignal(9r) -- General: Sends a signal to a process
|
|
The psignal routine posts a signal to the specified process. The posting of a signal causes that signal to be added to the set of pending signals for the specified process. Depending on the state of t... |
|
pullupmsg(9r) -- STREAMS: Concatenates bytes in a message
|
|
The pullupmsg interface tries to combine multiple data blocks into a single block. The interface concatenates and aligns the first len data bytes of the message pointed to by the message_block_ptr arg... |
|
putbq(9r) -- STREAMS: Places a message at the head of a queue
|
|
The putbq interface places a message at the beginning of the appropriate section of the message queue. There are always sections for high priority and ordinary messages. If other priority bands are us... |
|
putctl(9r) -- STREAMS: Puts a control message on a queue
|
|
The putctl interface tests the type argument to make sure a data type was not specified. It then attempts to allocate a message block. The putctl interface fails if a message block cannot be allocated... |
|
putctl1(9r) -- Puts a control message with a 1-byte parameter on a queue
|
|
Like the putctl interface, the putctl1 interface tests the type argument to make sure a data type was not specified. It then attempts to allocate a message block. In addition, the putctl1 interface ca... |
|
putnext(9r) -- STREAMS: Sends a message to the next module in the stream
|
|
The putnext interface passes a message to the puthere interface of the next queue in the stream. |
|
putq(9r) -- STREAMS: Puts a message on a queue
|
|
The putq interface puts a message on a driver's queue after the module's put interface has finished processing the message. The putq interface places the message after any other messages of the same... |
|
qenable(9r) -- STREAMS: Enables a queue
|
|
The qenable interface puts the queue associated with the queue_pointer argument on the linked list of those whose service interfaces are ready to be called by the STREAMS scheduler. |
|
qreply(9r) -- STREAMS: Sends a message in the reverse direction
|
|
The qreply interface sends a message on a stream in the opposite direction from the queue specified in the queue_pointer argument. It calls the OTHERQ interface to find the queue's module partner. |
|
qsize(9r) -- STREAMS: Finds the number of messages on a queue
|
|
The qsize interface evaluates the queue associated with the queue_pointer argument and returns the number of messages it contains. |
|
queue_init(9r) -- General: Initializes the specified queue
|
|
The queue_init routine initializes the specified queue. Kernel modules call this routine prior to calling select_enqueue to initialize the links member of the sel_queue data structure. This member spe... |
|
RD(9r) -- STREAMS: Gets a pointer to a module's read queue
|
|
The RD interface accepts a write queue pointer as an argument and returns a pointer to the read queue of the same module. |
|
register_callback(9r) -- General: Registers a configuration callback routine
|
|
The register_callback routine registers a kernel module's callback routine. The kernel calls a kernel module's callback routine when execution reaches the point specified in the point and order argu... |
|
remque(9r) -- General: Add or remove an element from the queue
|
|
The insque routine adds the element that the elem argument specifies to the queue. The routine inserts elem in the next position after pred in the queue. The remque routine removes the element that th... |
|
rmalloc(9r) -- General: Allocates size units from the given resource map
|
|
The rmalloc routine allocates size units from the given resource map. In a map, the addresses are increasing, and the list is terminated by a zero size. The actual units managed by the map are arbitra... |
|
rmfree(9r) -- General: Frees space previously allocated into the specified resource map
|
|
The rmfree routine frees the space previously allocated with a call to rmalloc. It frees a space of the size specified by the size argument at the address specified by the addr argument. |
|
rmget(9r) -- General: Allocates size units from the given resource map
|
|
The rmget routine allocates the number of units specified in size, starting at the address specified in addr. |
|
rminit(9r) -- General: Initializes a resource map
|
|
The rminit routine initializes the specified resource map to have mapsize - 2 segments. The routine also identifies this resource map with the string passed to the name argument. It prints this name i... |
|
rmvb(9r) -- STREAMS: Removes a message block from a message block
|
|
The rmvb interface removes a message block (the message_to_be_removed argument) from a message block (the message_block_ptr argument) and returns a pointer to the altered message block. The rmvb inter... |
|
rmvq(9r) -- STREAMS: Removes a message block from a queue
|
|
The rmvq interface removes a message block from a queue. You can remove a message block from anywhere on a queue. To prevent modules and drivers from having to deal with the internals of message linki... |
|
round_page(9r) -- General: Rounds the specified address
|
|
The round_page routine rounds the specified address (or byte count) to a multiple of the page size. For example, round_page would round a 1-byte count to be equal to the size of one page. This routine... |
|
select_dequeue(9r) -- General: Removes the last kernel thread waiting for an event
|
|
The select_dequeue routine removes the last kernel thread waiting for an event to occur on the specified device. This routine is called to terminate a select call. Typically, a kernel module's xxsele... |
|
select_dequeue_all(9r) -- General: Removes all kernel threads waiting for an event
|
|
The select_dequeue_all routine is similar in functionality to the select_dequeue routine. The difference is that select_dequeue_all removes all kernel threads (not just the last one) while waiting for... |
|
select_enqueue(9r) -- General: Adds the current kernel thread
|
|
The select_enqueue routine adds the current kernel thread to the list of kernel threads waiting for a select event on the specified device. This routine is called when a kernel module's select routin... |
|
select_wakeup(9r) -- General: Wakes up a kernel thread
|
|
The select_wakeup routine wakes up a kernel thread that is suspended while waiting for an event on the specified device. A user-level process can use the select system call to cause the process to be ... |
|
sel_queue(9s) -- General: Defines a queue of select events
|
|
The sel_queue data structure provides kernel module writers with a generic queue of select events. You must initialize the links member by calling the queue_init routine prior to using the select_enqu... |
|
simple_lock(9r) -- General: Asserts a simple lock
|
|
The simple_lock routine asserts a lock with exclusive access for the resource associated with the specified slock structure pointer. This means that no other kernel thread can gain access to the locke... |
|
simple_lock_init(9r) -- General: Initializes a simple lock structure
|
|
The simple_lock_init routine initializes the simple lock structure that you previously declared with the decl_simple_lock_data routine. You need to initialize the simple lock structure only once. Afte... |
|
simple_lock_terminate(9r) -- General: Terminates, using a simple lock
|
|
The simple_lock_terminate routine determines that the kernel module is done using the simple lock permanently. The kernel module must free the simple lock (that is, the kernel module does not hold the... |
|
simple_lock_try(9r) -- General: Tries to assert a simple lock
|
|
The simple_lock_try routine tries to assert a lock with read and write access for the resource associated with the specified simple lock. The main difference between this routine and simple_lock is th... |
|
simple_unlock(9r) -- General: Releases a simple lock
|
|
The simple_unlock routine releases a simple lock for the resource associated with the specified simple lock structure pointer. This simple lock was previously asserted by calling the simple_lock or si... |
|
sleep(9r) -- General: Puts a calling process to sleep
|
|
The sleep routine puts a calling process to sleep on the address specified by the channel argument. Some common addresses are the lbolt argument, a buf structure, and a proc structure. This address sh... |
|
slock(9s) -- General: Contains simple lock-specific information
|
|
The slock data structure is the simple spin lock structure that contains simple lock-specific information. The user of the simple lock method declares a slock data structure by calling the decl_simple... |
|
spl(9r) -- General: Sets the processor priority to mask different levels of interrupts
|
|
The operating system supports the naming of spl routines to indicate the associated device types. Named spl routines make it easier to determine which routine you should use to set the priority level ... |
|
strcmp(9r) -- General: Compares two null-terminated character strings
|
|
The strcmp routine lexicographically compares string s1 to string s2. The routine does not continue the comparison beyond the first null character it finds. A fatal error occurs if you call strcmp wit... |
|
strcpy(9r) -- General: Copies a null-terminated character string
|
|
The strcpy routine copies string s2 to buffer s1. The routine stops copying after it copies a null character. Note that the character size is 1 byte. |
|
strlen(9r) -- General: Returns the number of characters in a
|
|
The strlen routine returns the number of characters in s. The count does not include the terminating null character. Note that the character size is 1 byte. |
|
strlog(9r) -- General: Submits messages for logging
|
|
The strlog routine submits formatted messages to the log driver. You can retrieve the messages with the getmsg system call. The flags argument specifies the type of message and where it is to be sent.... |
|
strncmp(9r) -- General: Compares two strings, using a specified number of characters
|
|
The strncmp routine compares string s1 to string s2, using the number of characters specified in n. |
|
strncpy(9r) -- General: Copies a null-terminated character string with a specified limit
|
|
The strncpy routine copies string s2 to buffer s1. The routine stops copying after it copies a null character or n characters, whichever comes first. If the length of s2 as determined by the null char... |
|
strqget(9r) -- General: Obtains information about a queue
|
|
The strqget routine gives modules and drivers a way to obtain information about a queue or a particular band of a queue without directly accessing STREAMS data structures. The values that can be retur... |
|
strqset(9r) -- General: Changes information about a queue
|
|
The strqset routine gives modules and drivers a way to change information about a queue or a particular band of a queue without directly accessing STREAMS data structures. The values that can be retur... |
|
subyte(9r) -- General: Writes a byte into user address space
|
|
The subyte routine copies 1 byte from the protected kernel address space to the unprotected user address space. |
|
suibyte(9r) -- General: Writes a byte into user instruction address space
|
|
|
|
suiword(9r) -- General: Writes a word into user instruction address space
|
|
|
|
suser(9r) -- General: Checks whether the current user is the superuser
|
|
The suser routine checks whether the current user is the superuser. If the test succeeds and ac_flag is not a null pointer, the ASU flag is set in the flag_field structure pointed to by ac_flag. The m... |
|
suword(9r) -- General: Writes a word into user address space
|
|
The suword routine copies one word from the protected kernel address space to the unprotected user address space. |
|
svatophys(9r) -- General: Converts a system virtual address to a physical address
|
|
The svatophys routine converts a system virtual address to the corresponding physical address. All address and data structure manipulation done within the kernel is performed using system virtual addr... |
|
swap_lw_bytes(9r) -- General: Perform
|
|
The swap_lw_bytes interface performs a longword byte swap. The swap_word_bytes interface performs a short word byte swap. The swap_words interface performs a word byte swap. Many computer vendors supp... |
|
swap_words(9r) -- General: Perform
|
|
The swap_lw_bytes interface performs a longword byte swap. The swap_word_bytes interface performs a short word byte swap. The swap_words interface performs a word byte swap. Many computer vendors supp... |
|
swap_word_bytes(9r) -- General: Perform
|
|
The swap_lw_bytes interface performs a longword byte swap. The swap_word_bytes interface performs a short word byte swap. The swap_words interface performs a word byte swap. Many computer vendors supp... |
|
task(9s) -- General: Contains task-specific information
|
|
The task data structure contains task-related information. |
|
thread(9s) -- General: Contains kernel threads-related information
|
|
The thread data structure contains kernel threads-related information. Kernel modules typically use the wait_result member (with the current_thread routine) to check for the result of the wait. The va... |
|
thread_block(9r) -- General: Blocks (puts to sleep) the current kernel thread
|
|
The thread_block routine blocks (puts to sleep) the current kernel thread and selects the next kernel thread to start (run). The routine schedules the next kernel thread onto this CPU. When a kernel t... |
|
thread_halt_self(9r) -- General: Handles asynchronous traps for
|
|
The thread_halt_self routine performs the work associated with a variety of asynchronous traps (ASTs) for a kernel thread that terminates itself. A kernel thread terminates itself (or one kernel threa... |
|
thread_set_timeout(9r) -- General: Sets a timer for the current kernel thread
|
|
The thread_set_timeout routine must be called as follows: Lock the resource. Call assert_wait_mesg to assert that the current kernel thread is about to block. Unlock the resource. Call thread_set_time... |
|
thread_terminate(9r) -- General: Prepares to stop or stops execution of the specified kernel thread
|
|
The thread_terminate routine prepares to stop or permanently stops execution of the specified kernel thread. You created and started this kernel thread in a previous call to the kernel_isrthread or ke... |
|
thread_wakeup(9r) -- General: Wakes up all kernel threads waiting for the specified event
|
|
The thread_wakeup routine wakes up all kernel threads waiting for the event specified in the event argument. This routine is actually a convenience wrapper for the thread_wakeup_prim routine with the ... |
|
thread_wakeup_one(9r) -- General: Wakes up the first kernel thread waiting on a channel
|
|
The thread_wakeup_one routine wakes up only the first kernel thread in the hash chain waiting for the event specified in the event argument. This routine is actually a convenience wrapper for the thre... |
|
timeout(9r) -- General: Initializes a callout queue element
|
|
The timeout routine initializes a callout queue element to make it easy to execute the specified routine at the time specified in the time argument. You often use callout routines for infrequent polli... |
|
trunc_page(9r) -- General: Truncates the specified address
|
|
The trunc_page routine truncates the specified address to be aligned on a page boundary. This routine shields the driver writer from having to know the page size of the system, which could vary in dif... |
|
uio(9s) -- General: Describes I/O, either single vector or multiple vectors
|
|
The uio data structure describes, either singler-vector or multiple-vector I/O. Typically, kernel modules do not manipulate the members of this data structure. However, the data structure is presented... |
|
uiomove(9r) -- General: Moves data between user and system virtual space
|
|
The uiomove routine moves data between user and system virtual space. Data can be moved in either direction. Accessibility to the logical user buffer is verified before the move is made. Accessibility... |
|
unbufcall(9r) -- STREAMS: Cancels a pending bufcall request
|
|
The unbufcall interface cancels a pending bufcall request. The id argument is a nonzero identifier for the request to be canceled. This nonzero identifier is returned to the module from a previous cal... |
|
unix_master(9r) -- General: Forces execution onto the master CPU
|
|
The unix_master routine forces execution of the kernel thread onto the master CPU (also called the boot CPU). In other words, unix_master binds the kernel thread to the master CPU. To release the kern... |
|
unix_release(9r) -- General: Releases binding of the kernel thread
|
|
The unix_release routine releases a kernel thread from being bound to the master CPU. This binding was enforced in a previous call to the unix_master routine. |
|
unlinkb(9r) -- STREAMS: Removes a message block from the head of a message
|
|
The unlinkb interface removes the first message block from the message block pointed to by the message_ptr argument. The interface returns a pointer to the new message block, minus the removed message... |
|
unregister_callback(9r) -- General: Deregisters a configuration callback routine
|
|
The unregister_callback routine deregisters a kernel module's configuration callback routine. The kernel module previously registered its routine or routines by calling the register_callback routine.... |
|
untimeout(9r) -- General: Removes the scheduled routine from the callout queues
|
|
The untimeout routine removes the scheduled routine from the callout queue. The specified routine was placed on the callout queue in a previous call to the timeout routine. The argument formal paramet... |
|
uprintf(9r) -- General: Write formatted text to some output device
|
|
The printf and uprintf routines are scaled-down versions of the corresponding C library routines. The printf routine prints diagnostic information directly on the console terminal and writes ASCII tex... |
|
vm_map_pageable(9r) -- General: Sets pageability of the specified address range
|
|
The vm_map_pageable routine ensures that the address range you specified in the start and end arguments is accessible. If the address range is accessible by the specified process, the memory associate... |
|
vtop(9r) -- General: Converts any virtual address to a physical address
|
|
The vtop routine converts a specified virtual address to a physical address. |
|
wakeup(9r) -- General: Wakes up all processes sleeping on a specified address
|
|
The wakeup routine wakes up all processes sleeping on the address specified by the channel argument. All processes sleeping on this address are awakened and made ready to be scheduled according to the... |
|
WR(9r) -- STREAMS: Gets a pointer to this module's write queue
|
|
The WR interface accepts a read queue pointer as an argument and returns a pointer to the write queue of the same module. |
|
write_const_data(9r) -- Modify kernel text or const data that is replicated across RADs on a NUMA platform
|
|
The write_const_data() function modifies kernel text or const data that has been replicated in memory accessed by different CPUs. This function also ensures that the modifications are visible to all C... |
