QNX-9—QNX官网文档翻译—Resource Managers—Examples

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <sys/iofunc.h>
#include <sys/dispatch.h>
#include <string.h>

static resmgr_connect_funcs_t   connect_func;
static resmgr_io_funcs_t        io_func;
static iofunc_attr_t            attr;

int main (int argc, char **argv)
{
    thread_pool_attr_t    pool_attr;
    thread_pool_t         *tpp;
    dispatch_t            *dpp;
    resmgr_attr_t         resmgr_attr;
    int                   id;

    if ((dpp = dispatch_create ()) == NULL) {
        fprintf (stderr, "%s:  Unable to allocate dispatch context.\n", argv [0]);
        return (EXIT_FAILURE);
    }

    memset (&pool_attr, 0, sizeof (pool_attr));
    pool_attr.handle = dpp;
    pool_attr.context_alloc = (void *) dispatch_context_alloc;
    pool_attr.block_func    = (void *) dispatch_block;
    pool_attr.handler_func  = (void *) dispatch_handler;
    pool_attr.context_free  = (void *) dispatch_context_free;

    // 1) set up the number of threads that you want
    pool_attr.lo_water = 2;
    pool_attr.hi_water = 4;
    pool_attr.increment = 1;
    pool_attr.maximum = 50;

    if ((tpp = thread_pool_create (&pool_attr, POOL_FLAG_EXIT_SELF)) == NULL) {
        fprintf (stderr, "%s:  Unable to initialize thread pool.\n", argv [0]);
        return (EXIT_FAILURE);
    }

    iofunc_func_init (_RESMGR_CONNECT_NFUNCS, &connect_func, _RESMGR_IO_NFUNCS, &io_func);
    iofunc_attr_init (&attr, S_IFNAM | 0777, 0, 0);

    // 2) override functions in "connect_func" and "io_func" as required here

    memset (&resmgr_attr, 0, sizeof (resmgr_attr));
    resmgr_attr.nparts_max = 1;
    resmgr_attr.msg_max_size = 2048;

    // 3) replace "/dev/whatever" with your device name
    if ((id = resmgr_attach (dpp, &resmgr_attr, "/dev/whatever", _FTYPE_ANY, 0, &connect_func, &io_func, &attr)) == -1) {
        fprintf (stderr, "%s:  Unable to attach name.\n", argv [0]);
        return (EXIT_FAILURE);
    }

    // Never returns
    thread_pool_start (tpp);
    
    return (EXIT_SUCCESS);
}

/*
 * io_read1.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/neutrino.h>
#include <sys/iofunc.h>

// our data string
char    *data_string = "Hello, world!\n";

int io_read (resmgr_context_t *ctp, io_read_t *msg, iofunc_ocb_t *ocb)
{
    int     sts;
    int     nbytes;
    int     nleft;
    int     off;
    int     xtype;
    struct _xtype_offset *xoffset;

    // 1) verify that the device is opened for read
    if ((sts = iofunc_read_verify (ctp, msg, ocb, NULL)) != EOK) {
        return (sts);
    }

    // 2) check for and handle an XTYPE override
    xtype = msg->i.xtype & _IO_XTYPE_MASK;
    if (xtype == _IO_XTYPE_OFFSET) {
        xoffset = (struct _xtype_offset *) (&msg->i + 1);
        off = xoffset->offset;
    } else if (xtype == _IO_XTYPE_NONE) {
        off = ocb->offset;
    } else {   // unknown, fail it
        return (ENOSYS);
    }

    // 3) how many bytes are left?
    nleft = ocb->attr->nbytes - off;

    // 4) how many bytes can we return to the client?
    nbytes = min (nleft, msg->i.nbytes);

    // 5) if returning data, write it to client
    if (nbytes) {
        /* the first nbytes value, the status parameter, tells the client how many bytes we're giving them */
        MsgReply (ctp->rcvid, nbytes, data_string + off, nbytes);

        // 6) set up POSIX stat() "atime" data
        ocb->attr->flags |= IOFUNC_ATTR_ATIME | IOFUNC_ATTR_DIRTY_TIME;

        // 7) advance the lseek() index by the number of bytes
        // read if not _IO_XTYPE_OFFSET
        if (xtype == _IO_XTYPE_NONE) {
            ocb->offset += nbytes;
        }
    } else {
        /* 8) no more data to return, tell the client we have 0 bytes left through the status parameter */
        MsgReply (ctp->rcvid, 0, NULL, 0);
    }

    // 9) indicate we already did the MsgReply to the library
    return (_RESMGR_NOREPLY);
}

/*
 * io_write1.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/neutrino.h>
#include <sys/iofunc.h>

void process_data (int offet, void *buffer, int nbytes)
{
    // do something with the data
}

int io_write (resmgr_context_t *ctp, io_write_t *msg, iofunc_ocb_t *ocb)
{
    int     sts;
    size_t  nbytes;
    size_t  off;
    size_t  start_data_offset;
    int     xtype;
    char    *buffer;
    struct _xtype_offset *xoffset;

    // verify that the device is opened for write
    if ((sts = iofunc_write_verify (ctp, msg, ocb, NULL)) != EOK)
    {
        return (sts);
    }

    // 1) check for and handle an XTYPE override
    xtype = msg->i.xtype & _IO_XTYPE_MASK;
    if (xtype == _IO_XTYPE_OFFSET) {
        xoffset = (struct _xtype_offset *) (&msg->i + 1);
        start_data_offset = sizeof (msg->i) + sizeof (*xoffset);
        off = xoffset->offset;
    } else if (xtype == _IO_XTYPE_NONE) {
        off = ocb->offset;
        start_data_offset = sizeof (msg->i);
    } else {   // unknown, fail it
        return (ENOSYS);
    }

    // 2) allocate a buffer big enough for the data
    nbytes = _IO_WRITE_GET_NBYTES(msg);
    if ((buffer = malloc (nbytes)) == NULL) {
        return (ENOMEM);
    }

    // 3) read the message data
    if (resmgr_msgget (ctp, buffer, nbytes, start_data_offset) == -1)
    {
        free (buffer);
        return (errno);
    }

    // 4) do something with the data
    process_data (off, buffer, nbytes);

    // 5) free the buffer
    free (buffer);

    // 6) set up the number of bytes for the client's "write" function to return
    _IO_SET_WRITE_NBYTES (ctp, nbytes);

    // 7) if any data written, update POSIX structures and OCB offset
    if (nbytes) {
        ocb->attr->flags |= IOFUNC_ATTR_MTIME | IOFUNC_ATTR_DIRTY_TIME;
        if (xtype == _IO_XTYPE_NONE) {
            ocb->offset += nbytes;
        }
    }

    // 8) tell the resource manager library to do the reply, and that it was okay
    return (EOK);
}

#include <sys/types.h>
#include <unistd.h>
#include <devctl.h>

int devctl (int fd, int dcmd, void *dev_data_ptr, size_t nbytes, int *dev_info_ptr);

/*
 * io_devctl1.c
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <sys/neutrino.h>
#include <sys/iofunc.h>
#include <devctl.h>

#define AUDIO_DAC 1
#define AUDIO_ADC 2

extern void audio_set_nchannels(unsigned num);
extern uint32_t audio_get_samplerate(unsigned port);
extern void audio_set_samplerate(unsigned port, unsigned rate);

#define DCMD_AUDIO_SET_CHANNEL_MONO         __DION(_DCMD_MIXER, 1)
#define DCMD_AUDIO_SET_CHANNEL_STEREO       __DION(_DCMD_MIXER, 2)
#define DCMD_AUDIO_GET_SAMPLE_RATE_DAC      __DIOF(_DCMD_MIXER, 4, uint32_t)
#define DCMD_AUDIO_SET_SAMPLE_RATE_DAC      __DIOT(_DCMD_MIXER, 5, uint32_t)
#define DCMD_AUDIO_GET_SAMPLE_RATE_ADC      __DIOF(_DCMD_MIXER, 6, uint32_t)
#define DCMD_AUDIO_SET_SAMPLE_RATE_ADC      __DIOT(_DCMD_MIXER, 7, uint32_t)

int io_devctl (resmgr_context_t *ctp, io_devctl_t *msg, iofunc_ocb_t *ocb)
{
    int     sts;

    /* 1) Create the reply buffer at the start of ctp->msg so we make sure we have enough space */
    struct _io_devctl_reply *reply = (struct _io_devctl_reply *)ctp->msg;

    /* Create a pointer to the rate variable for the _GET_ devctls. */
    unsigned nbytes = 0;
    uint32_t *rate = _DEVCTL_DATA(*reply);

    /* 2) Verify we have the entire devctl header in the buffer */
    if( ctp->size < sizeof(msg->i) ) {
        return EBADMSG;
    }

    /* 3) See if it's a standard devctl() */
    if ((sts = iofunc_devctl_default (ctp, msg, ocb)) != _RESMGR_DEFAULT)
    {
        return (sts);
    }

    /* How many bytes did the client send in addition to the devctl header? */
    size_t payload_size = ctp->size - sizeof(msg->i);

    /* 4) See which command it was, and act on it */
    switch (msg->i.dcmd) {
    case DCMD_AUDIO_SET_CHANNEL_MONO:
        /* Read or write access are sufficient */
        if( !(ocb->ioflag & (_IO_FLAG_WR | _IO_FLAG_RD)) ) {
            return EPERM;
        }
        audio_set_nchannels (1);
        break;

    case DCMD_AUDIO_SET_CHANNEL_STEREO:
        /* Read or write access are sufficient */
        if( !(ocb->ioflag & (_IO_FLAG_WR | _IO_FLAG_RD)) ) {
            return EPERM;
        }
        audio_set_nchannels (2);
        break;

    case DCMD_AUDIO_GET_SAMPLE_RATE_DAC:
        /* Write access is required for accessing the DAC */
        if( !(ocb->ioflag & _IO_FLAG_WR) ) {
            return EPERM;
        }

        /* Verify that the client wants enough bytes */
        if( ctp->info.dstmsglen < (sizeof(*reply) + sizeof(uint32_t)) ) {
            return EINVAL;
        }

        /* Set up the reply to the client */
        nbytes = sizeof(uint32_t);
        *rate = audio_get_samplerate (AUDIO_DAC);
        break;

    case DCMD_AUDIO_SET_SAMPLE_RATE_DAC:
        /* Write access is required for accessing the DAC */
        if( !(ocb->ioflag & _IO_FLAG_WR) ) {
            return EPERM;
        }

        /* Verify that we got all the bytes. */
        if( payload_size < sizeof(uint32_t) ) {
            return EBADMSG;
        }

        rate = _DEVCTL_DATA(msg->i);
        audio_set_samplerate (AUDIO_DAC, *rate);
        break;

    case DCMD_AUDIO_GET_SAMPLE_RATE_ADC:
        /* Read access is required for accessing the ADC */
        if( !(ocb->ioflag & _IO_FLAG_RD) ) {
            return EPERM;
        }

        /* Verify that the client wants enough bytes */
        if( ctp->info.dstmsglen < (sizeof(*reply) + sizeof(uint32_t)) ) {
            return EINVAL;
        }
        
        /* Set up the reply to the client */
        nbytes = sizeof(uint32_t);
        *rate = audio_get_samplerate (AUDIO_ADC);
        break;

    case DCMD_AUDIO_SET_SAMPLE_RATE_ADC:
        /* Read access is required for accessing the ADC */
        if( !(ocb->ioflag & _IO_FLAG_RD) ) {
            return EPERM;
        }

        /* Verify that we got all the bytes. */
        if( payload_size < sizeof(uint32_t) ) {
            return EBADMSG;
        }

        rate = _DEVCTL_DATA(msg->i);
        audio_set_samplerate (AUDIO_ADC, *rate);
        break;

    /* 5) In case it's a command that we don't recognize, fail it */
    default:
        return (ENOSYS);
    }

    /* 6) Tell the client that it worked */
    memset(reply, 0, sizeof(*reply));
    SETIOV (ctp->iov, reply, sizeof(*reply) + nbytes);
    return (_RESMGR_NPARTS (1));
}

/* 6) tell the client it worked */
memset(reply, 0, sizeof(*reply));
return (_RESMGR_PTR (ctp, reply, sizeof(*reply) + nbytes));