xwmq.c

浏览该文件的文档.

 
#include <xwos/standard.h>
#include <xwos/lib/object.h>
#include <xwos/mm/memslice.h>
#include <xwmd/isc/xwmq/mif.h>
 
static __xwmd_code
void xwmq_msg_construct(struct xwmq_msg * msg);
 
static __xwmd_code
void xwmq_construct(struct xwmq * mq)
{
        xwos_object_construct(&mq->xwobj);
}
 
static __xwmd_code
void xwmq_destruct(struct xwmq * mq)
{
        xwos_object_destruct(&mq->xwobj);
}
 
static __xwmd_code
xwer_t xwmq_gc(struct xwos_object * obj)
{
        struct xwmq * mq;
 
        mq = xwcc_derof(obj, struct xwmq, xwobj);
        xwos_sem_fini(&mq->txqsem);
        xwos_sem_fini(&mq->rxqsem);
        xwmq_destruct(mq);
        return XWOK;
}
 
__xwmd_api
xwsq_t xwmq_get_tik(struct xwmq * mq)
{
        xwsq_t tik;
 
        if (NULL != mq) {
                tik = mq->xwobj.tik;
        } else {
                tik = 0;
        }
        return tik;
}
 
__xwmd_api
xwer_t xwmq_acquire(xwmq_d mqd)
{
        return xwos_object_acquire(&mqd.mq->xwobj, mqd.tik);
}
 
__xwmd_api
xwer_t xwmq_release(xwmq_d mqd)
{
        return xwos_object_release(&mqd.mq->xwobj, mqd.tik);
}
 
__xwmd_api
xwer_t xwmq_grab(struct xwmq * mq)
{
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
 
        return xwos_object_grab(&mq->xwobj);
}
 
__xwmd_api
xwer_t xwmq_put(struct xwmq * mq)
{
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
 
        return xwos_object_put(&mq->xwobj);
}
 
static __xwmd_rodata
const char xwmq_txq_name[] = "xwmq.txq";
 
static __xwmd_code
xwer_t xwmq_activate(struct xwmq * mq,
                     struct xwmq_msg * txq, xwsz_t num,
                     xwobj_gc_f gcfunc)
{
        xwer_t rc;
 
        rc = xwos_object_activate(&mq->xwobj, gcfunc);
        if (rc < 0) {
                goto err_xwobj_activate;
        }
        rc = xwmm_memslice_init(&mq->txq,
                                (xwptr_t)txq,
                                sizeof(struct xwmq_msg) * num,
                                sizeof(struct xwmq_msg), xwmq_txq_name,
                                (ctor_f)xwmq_msg_construct, NULL);
        if (rc < 0) {
                goto err_memslice_init;
        }
        xwos_sem_init(&mq->txqsem, (xwssq_t)num, (xwssq_t)num);
        xwlib_bclst_init_head(&mq->rxq);
        xwos_splk_init(&mq->rxqlock);
        xwos_sem_init(&mq->rxqsem, 0, (xwssq_t)num);
        return XWOK;
 
err_memslice_init:
        xwmq_put(mq); // cppcheck-suppress [misra-c2012-17.7]
err_xwobj_activate:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_init(struct xwmq * mq, struct xwmq_msg * txq, xwsz_t num)
{
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((txq), "nullptr", -EFAULT);
 
        xwmq_construct(mq);
        return xwmq_activate(mq, txq, num, xwmq_gc);
}
 
__xwmd_api
xwer_t xwmq_fini(struct xwmq * mq)
{
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        return xwmq_put(mq);
}
 
static __xwmd_code
void xwmq_msg_construct(struct xwmq_msg * msg)
{
        xwlib_bclst_init_node(&msg->node);
        msg->topic = 0;
        msg->data = NULL;
}
 
static __xwmd_code
struct xwmq_msg * xwmq_msg_get(struct xwmq * mq)
{
        union {
                struct xwmq_msg * msg;
                void * anon;
        } mem;
 
        // cppcheck-suppress [misra-c2012-17.7]
        xwmm_memslice_alloc(&mq->txq, &mem.anon);
        return mem.msg;
}
 
static __xwmd_code
void xwmq_msg_put(struct xwmq * mq, struct xwmq_msg * msg)
{
        // cppcheck-suppress [misra-c2012-17.7]
        xwmm_memslice_free(&mq->txq, msg);
}
 
__xwmd_api
xwer_t xwmq_eq(struct xwmq * mq, xwsq_t topic, void * data)
{
        return xwmq_eq_to(mq, topic, data, XWTM_MAX);
}
 
__xwmd_api
xwer_t xwmq_eq_to(struct xwmq * mq, xwsq_t topic, void * data, xwtm_t to)
{
        xwer_t rc;
        xwreg_t cpuirq;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((data), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_to(&mq->txqsem, to);
        if (rc < 0) {
                goto err_sem_wait_to;
        }
        msg = xwmq_msg_get(mq);
        msg->topic = topic;
        msg->data = data;
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        xwlib_bclst_add_tail(&mq->rxq, &msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        xwos_sem_post(&mq->rxqsem);
        return XWOK;
 
err_sem_wait_to:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_eq_unintr(struct xwmq * mq, xwsq_t topic, void * data)
{
        xwer_t rc;
        xwreg_t cpuirq;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((data), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_unintr(&mq->txqsem);
        if (rc < 0) {
                goto err_sem_wait_unintr;
        }
        msg = xwmq_msg_get(mq);
        msg->topic = topic;
        msg->data = data;
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        xwlib_bclst_add_tail(&mq->rxq, &msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        xwos_sem_post(&mq->rxqsem);
        return XWOK;
 
err_sem_wait_unintr:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_tryeq(struct xwmq * mq, xwsq_t topic, void * data)
{
        xwer_t rc;
        xwreg_t cpuirq;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((data), "nullptr", -EFAULT);
 
        rc = xwos_sem_trywait(&mq->txqsem);
        if (rc < 0) {
                goto err_sem_trywait;
        }
        msg = xwmq_msg_get(mq);
        msg->topic = topic;
        msg->data = data;
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        xwlib_bclst_add_tail(&mq->rxq, &msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        xwos_sem_post(&mq->rxqsem);
        return XWOK;
 
err_sem_trywait:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_jq(struct xwmq * mq, xwsq_t topic, void * data)
{
        return xwmq_jq_to(mq, topic, data, XWTM_MAX);
}
 
__xwmd_api
xwer_t xwmq_jq_to(struct xwmq * mq, xwsq_t topic, void * data, xwtm_t to)
{
        xwer_t rc;
        xwreg_t cpuirq;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((data), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_to(&mq->txqsem, to);
        if (rc < 0) {
                goto err_sem_wait_to;
        }
        msg = xwmq_msg_get(mq);
        msg->topic = topic;
        msg->data = data;
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        xwlib_bclst_add_head(&mq->rxq, &msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        xwos_sem_post(&mq->rxqsem);
        return XWOK;
 
err_sem_wait_to:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_jq_unintr(struct xwmq * mq, xwsq_t topic, void * data)
{
        xwer_t rc;
        xwreg_t cpuirq;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((data), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_unintr(&mq->txqsem);
        if (rc < 0) {
                goto err_sem_wait_unintr;
        }
        msg = xwmq_msg_get(mq);
        msg->topic = topic;
        msg->data = data;
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        xwlib_bclst_add_head(&mq->rxq, &msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        xwos_sem_post(&mq->rxqsem);
        return XWOK;
 
err_sem_wait_unintr:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_tryjq(struct xwmq * mq, xwsq_t topic, void * data)
{
        xwer_t rc;
        xwreg_t cpuirq;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((data), "nullptr", -EFAULT);
 
        rc = xwos_sem_trywait(&mq->txqsem);
        if (rc < 0) {
                goto err_sem_trywait;
        }
        msg = xwmq_msg_get(mq);
        msg->topic = topic;
        msg->data = data;
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        xwlib_bclst_add_head(&mq->rxq, &msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        xwos_sem_post(&mq->rxqsem);
        return XWOK;
 
err_sem_trywait:
        return rc;
}
 
static __xwmd_code
struct xwmq_msg * xwmq_choose_head(struct xwmq * mq)
{
        struct xwmq_msg * msg;
        xwreg_t cpuirq;
 
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        msg = xwlib_bclst_first_entry(&mq->rxq,
                                      struct xwmq_msg,
                                      node);
        xwlib_bclst_del_init(&msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        return msg;
}
 
static __xwmd_code
struct xwmq_msg * xwmq_choose_tail(struct xwmq * mq)
{
        struct xwmq_msg * msg;
        xwreg_t cpuirq;
 
        xwos_splk_lock_cpuirqsv(&mq->rxqlock, &cpuirq);
        msg = xwlib_bclst_last_entry(&mq->rxq,
                                     struct xwmq_msg,
                                     node);
        xwlib_bclst_del_init(&msg->node);
        xwos_splk_unlock_cpuirqrs(&mq->rxqlock, cpuirq);
        return msg;
}
 
__xwmd_api
xwer_t xwmq_dq(struct xwmq * mq, xwsq_t * topic, void ** databuf)
{
        return xwmq_dq_to(mq, topic, databuf, XWTM_MAX);
}
 
__xwmd_api
xwer_t xwmq_dq_to(struct xwmq * mq, xwsq_t * topic, void ** databuf, xwtm_t to)
{
        xwer_t rc;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((topic), "nullptr", -EFAULT);
        XWOS_VALIDATE((databuf), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_to(&mq->rxqsem, to);
        if (rc < 0) {
                goto err_sem_wait_to;
        }
        msg = xwmq_choose_head(mq);
        *databuf = msg->data;
        if (NULL != topic) {
                *topic = msg->topic;
        }
        xwmq_msg_put(mq, msg);
        xwos_sem_post(&mq->txqsem);
        return XWOK;
 
err_sem_wait_to:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_dq_unintr(struct xwmq * mq, xwsq_t * topic, void ** databuf)
{
        xwer_t rc;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((topic), "nullptr", -EFAULT);
        XWOS_VALIDATE((databuf), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_unintr(&mq->rxqsem);
        if (rc < 0) {
                goto err_sem_wait_unintr;
        }
        msg = xwmq_choose_head(mq);
        *databuf = msg->data;
        if (NULL != topic) {
                *topic = msg->topic;
        }
        xwmq_msg_put(mq, msg);
        xwos_sem_post(&mq->txqsem);
        return XWOK;
 
err_sem_wait_unintr:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_trydq(struct xwmq * mq, xwsq_t * topic, void ** databuf)
{
        xwer_t rc;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((topic), "nullptr", -EFAULT);
        XWOS_VALIDATE((databuf), "nullptr", -EFAULT);
 
        rc = xwos_sem_trywait(&mq->rxqsem);
        if (rc < 0) {
                goto err_sem_trywait;
        }
        msg = xwmq_choose_head(mq);
        *databuf = msg->data;
        if (NULL != topic) {
                *topic = msg->topic;
        }
        xwmq_msg_put(mq, msg);
        xwos_sem_post(&mq->txqsem);
        return XWOK;
 
err_sem_trywait:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_rq(struct xwmq * mq, xwsq_t * topic, void ** databuf)
{
        return xwmq_rq_to(mq, topic, databuf, XWTM_MAX);
}
 
__xwmd_api
xwer_t xwmq_rq_to(struct xwmq * mq, xwsq_t * topic, void ** databuf, xwtm_t to)
{
        xwer_t rc;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((topic), "nullptr", -EFAULT);
        XWOS_VALIDATE((databuf), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_to(&mq->rxqsem, to);
        if (rc < 0) {
                goto err_sem_wait_to;
        }
        msg = xwmq_choose_tail(mq);
        *databuf = msg->data;
        if (NULL != topic) {
                *topic = msg->topic;
        }
        xwmq_msg_put(mq, msg);
        xwos_sem_post(&mq->txqsem);
        return XWOK;
 
err_sem_wait_to:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_rq_unintr(struct xwmq * mq, xwsq_t * topic, void ** databuf)
{
        xwer_t rc;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((topic), "nullptr", -EFAULT);
        XWOS_VALIDATE((databuf), "nullptr", -EFAULT);
 
        rc = xwos_sem_wait_unintr(&mq->rxqsem);
        if (rc < 0) {
                goto err_sem_wait_unintr;
        }
        msg = xwmq_choose_tail(mq);
        *databuf = msg->data;
        if (NULL != topic) {
                *topic = msg->topic;
        }
        xwmq_msg_put(mq, msg);
        xwos_sem_post(&mq->txqsem);
        return XWOK;
 
err_sem_wait_unintr:
        return rc;
}
 
__xwmd_api
xwer_t xwmq_tryrq(struct xwmq * mq, xwsq_t * topic, void ** databuf)
{
        xwer_t rc;
        struct xwmq_msg * msg;
 
        XWOS_VALIDATE((mq), "nullptr", -EFAULT);
        XWOS_VALIDATE((topic), "nullptr", -EFAULT);
        XWOS_VALIDATE((databuf), "nullptr", -EFAULT);
 
        rc = xwos_sem_trywait(&mq->rxqsem);
        if (rc < 0) {
                goto err_sem_trywait;
        }
        msg = xwmq_choose_tail(mq);
        *databuf = msg->data;
        if (NULL != topic) {
                *topic = msg->topic;
        }
        xwmq_msg_put(mq, msg);
        xwos_sem_post(&mq->txqsem);
        return XWOK;
 
err_sem_trywait:
        return rc;
}