Message Structure
A STREAMS message in its simplest form contains three elements—a message block, a data block, and a data buffer. The data buffer is the location in memory where the actual data of the message is stored. The data block (datab(9S) describes the data buffer—where it starts, where it ends, the message types, and how many message blocks reference it. The message block (msgb(9S)) describes the data block and how the data is used.
The data block has a typedef of dblk_t and has the following public elements:
struct datab {
unsigned char *db_base; /* first byte of buffer */
unsigned char *db_lim; /* last byte+1 of buffer */
unsigned char db_ref; /* msg count ptg to this blk */
unsigned char db_type; /* msg type */
};
typedef struct datab dblk_t;The datab structure specifies the data buffers' fixed limits (db_base and db_lim), a reference count field (db_ref), and the message type field (db_type). db_base points to the address where the data buffer starts, db_lim points one byte beyond where the data buffer ends, and db_ref maintains a count of the number of message blocks sharing the data buffer.
 | Caution - db_base, db_lim, and db_ref should not be modified directly. db_type is modified under carefully monitored conditions, such as changing the message type to reuse the message block. |
In a simple message, the message block references the data block, identifying for each message the address where the message data begins and ends. Each simple message block refers to the data block to identify these addresses, which must be within the confines of the buffer such that db_base ≥ b_rptr ≥≥ b_wptr ≥ db_lim. For ordinary messages, a priority band can be indicated, and this band is used if the message is queued.
Figure 7–1 shows the linkages between msgb, datab, and the data buffer in a simple message.
Figure 7-1 Simple Message Referencing the Data Block
The message block (see msgb(9S)) has a typedef of mblk_t and has the following public elements:
struct msgb {
struct msgb *b_next; /*next msg in queue*/
struct msgb *b_prev; /*previous msg in queue*/
struct msgb *b_cont; /*next msg block of message*/
unsigned char *b_rptr; /*1st unread byte in bufr*/
unsigned char *b_wptr; /*1st unwritten byte in bufr*/
struct datab *b_datap; /*data block*/
unsigned char b_band; /*message priority*/
unsigned short b_flag; /*message flags*/
};The STREAMS framework uses the b_next and b_prev fields to link messages into queues. b_rptr and b_wptr specify the current read and write pointers respectively, in the data buffer pointed to by b_datap. The fields b_rptr and b_wptr are maintained by drivers and modules.
The field b_band specifies a priority band where the message is placed when it is queued using the STREAMS utility routines. This field has no meaning for high-priority messages and is set to zero for these messages. When a message is allocated using allocb(9F), the b_band field is initially set to zero. Modules and drivers can set this field to a value from 0 to 255 depending on the number of priority bands needed. Lower numbers represent lower priority. The kernel incurs overhead in maintaining bands if nonzero numbers are used.
| Caution - Message block data elements must not modify b_next, b_prev, or b_datap. The first two fields are modified by utility routines such as putq(9F) and getq(9F). Message block data elements can modify b_cont, b_rptr, b_wptr, b_band (for ordinary messages types), and b_flag. |
The SunOS environment places b_band in the msgb structure. Some other STREAMS implementations place b_band in the datab structure. The SunOS implementation is more flexible because each message is independent. For shared data blocks, the b_band can differ in the SunOS implementation, but not in other implementations.