【Zephyr】K_MSGQ

最新推荐文章于 2024-02-28 17:17:38 发布
最新推荐文章于 2024-02-28 17:17:38 发布
阅读量221 收藏 1
点赞数
分类专栏： Zephyr 文章标签： p2p 网络协议 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37458552/article/details/122425706
版权

/*
 * Copyright (c) 2016 Wind River Systems, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */

/**
 * @file
 * @brief Message queues.
 */



#endif /* CONFIG_POLL */

//消息队列的初始化

void k_msgq_init(struct k_msgq *msgq, char *buffer, size_t msg_size,
         uint32_t max_msgs)
{
    msgq->msg_size = msg_size;
    msgq->max_msgs = max_msgs;
    msgq->buffer_start = buffer;
    msgq->buffer_end = buffer + (max_msgs * msg_size);
    msgq->read_ptr = buffer;
    msgq->write_ptr = buffer;
    msgq->used_msgs = 0;
    msgq->flags = 0;
    z_waitq_init(&msgq->wait_q);
    msgq->lock = (struct k_spinlock) {};
#ifdef CONFIG_POLL
    sys_dlist_init(&msgq->poll_events);
#endif    /* CONFIG_POLL */

    SYS_PORT_TRACING_OBJ_INIT(k_msgq, msgq);

    z_object_init(msgq);
}

int z_impl_k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
                uint32_t max_msgs)
{
    void *buffer;
    int ret;
    size_t total_size;

    SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_msgq, alloc_init, msgq);

    if (size_mul_overflow(msg_size, max_msgs, &total_size)) {
        ret = -EINVAL;
    } else {
        buffer = z_thread_malloc(total_size);
        if (buffer != NULL) {
            k_msgq_init(msgq, buffer, msg_size, max_msgs);
            msgq->flags = K_MSGQ_FLAG_ALLOC;
            ret = 0;
        } else {
            ret = -ENOMEM;
        }
    }

    SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, alloc_init, msgq, ret);

    return ret;
}

#ifdef CONFIG_USERSPACE
int z_vrfy_k_msgq_alloc_init(struct k_msgq *msgq, size_t msg_size,
                uint32_t max_msgs)
{
    Z_OOPS(Z_SYSCALL_OBJ_NEVER_INIT(msgq, K_OBJ_MSGQ));

    return z_impl_k_msgq_alloc_init(msgq, msg_size, max_msgs);
}
#include <syscalls/k_msgq_alloc_init_mrsh.c>
#endif

int k_msgq_cleanup(struct k_msgq *msgq)
{
    SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_msgq, cleanup, msgq);

    CHECKIF(z_waitq_head(&msgq->wait_q) != NULL) {
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, cleanup, msgq, -EBUSY);

        return -EBUSY;
    }

    if ((msgq->flags & K_MSGQ_FLAG_ALLOC) != 0U) {
        k_free(msgq->buffer_start);
        msgq->flags &= ~K_MSGQ_FLAG_ALLOC;
    }

    SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, cleanup, msgq, 0);

    return 0;
}


int z_impl_k_msgq_put(struct k_msgq *msgq, const void *data, k_timeout_t timeout)
{
    __ASSERT(!arch_is_in_isr() || K_TIMEOUT_EQ(timeout, K_NO_WAIT), "");

    struct k_thread *pending_thread;
    k_spinlock_key_t key;
    int result;

    key = k_spin_lock(&msgq->lock);

    SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_msgq, put, msgq, timeout);

    if (msgq->used_msgs < msgq->max_msgs) {
        /* message queue isn't full */
        pending_thread = z_unpend_first_thread(&msgq->wait_q);
                //there is thread waiting for get message 
        if (pending_thread != NULL) {
            SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, put, msgq, timeout, 0);

            /* give message to waiting thread */
            (void)memcpy(pending_thread->base.swap_data, data,
                   msgq->msg_size);
            /* wake up waiting thread */
            arch_thread_return_value_set(pending_thread, 0);
            z_ready_thread(pending_thread);
            z_reschedule(&msgq->lock, key);
            return 0;
        } else {
            /* put message in queue */
            (void)memcpy(msgq->write_ptr, data, msgq->msg_size);
            msgq->write_ptr += msgq->msg_size;
            if (msgq->write_ptr == msgq->buffer_end) {
                msgq->write_ptr = msgq->buffer_start;
            }
            msgq->used_msgs++;
#ifdef CONFIG_POLL
            handle_poll_events(msgq, K_POLL_STATE_MSGQ_DATA_AVAILABLE);
#endif /* CONFIG_POLL */
        }
        result = 0;
    } else if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
        /* don't wait for message space to become available */
        result = -ENOMSG;
    } else {
        SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_msgq, put, msgq, timeout);

        /* wait for put message success, failure, or timeout */
        _current->base.swap_data = (void *) data;

        result = z_pend_curr(&msgq->lock, key, &msgq->wait_q, timeout);
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, put, msgq, timeout, result);
        return result;
    }

    SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, put, msgq, timeout, result);

    k_spin_unlock(&msgq->lock, key);

    return result;
}

#ifdef CONFIG_USERSPACE
static inline int z_vrfy_k_msgq_put(struct k_msgq *msgq, const void *data,
                    k_timeout_t timeout)
{
    Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
    Z_OOPS(Z_SYSCALL_MEMORY_READ(data, msgq->msg_size));

    return z_impl_k_msgq_put(msgq, data, timeout);
}
#include <syscalls/k_msgq_put_mrsh.c>
#endif

void z_impl_k_msgq_get_attrs(struct k_msgq *msgq, struct k_msgq_attrs *attrs)
{
    attrs->msg_size = msgq->msg_size;
    attrs->max_msgs = msgq->max_msgs;
    attrs->used_msgs = msgq->used_msgs;
}

#ifdef CONFIG_USERSPACE
static inline void z_vrfy_k_msgq_get_attrs(struct k_msgq *msgq,
                       struct k_msgq_attrs *attrs)
{
    Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
    Z_OOPS(Z_SYSCALL_MEMORY_WRITE(attrs, sizeof(struct k_msgq_attrs)));
    z_impl_k_msgq_get_attrs(msgq, attrs);
}
#include <syscalls/k_msgq_get_attrs_mrsh.c>
#endif

int z_impl_k_msgq_get(struct k_msgq *msgq, void *data, k_timeout_t timeout)
{
    __ASSERT(!arch_is_in_isr() || K_TIMEOUT_EQ(timeout, K_NO_WAIT), "");

    k_spinlock_key_t key;
    struct k_thread *pending_thread;
    int result;

    key = k_spin_lock(&msgq->lock);

    SYS_PORT_TRACING_OBJ_FUNC_ENTER(k_msgq, get, msgq, timeout);

    if (msgq->used_msgs > 0U) {
        /* take first available message from queue */
        (void)memcpy(data, msgq->read_ptr, msgq->msg_size);
        msgq->read_ptr += msgq->msg_size;
        if (msgq->read_ptr == msgq->buffer_end) {
            msgq->read_ptr = msgq->buffer_start;
        }
        msgq->used_msgs--;

        /* handle first thread waiting to write (if any) */
        pending_thread = z_unpend_first_thread(&msgq->wait_q);
        if (pending_thread != NULL) {
            SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_msgq, get, msgq, timeout);

            /* add thread's message to queue */
            (void)memcpy(msgq->write_ptr, pending_thread->base.swap_data,
                   msgq->msg_size);
            msgq->write_ptr += msgq->msg_size;
            if (msgq->write_ptr == msgq->buffer_end) {
                msgq->write_ptr = msgq->buffer_start;
            }
            msgq->used_msgs++;

            /* wake up waiting thread */
            arch_thread_return_value_set(pending_thread, 0);
            z_ready_thread(pending_thread);
            z_reschedule(&msgq->lock, key);

            SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, get, msgq, timeout, 0);

            return 0;
        }
        result = 0;
    } else if (K_TIMEOUT_EQ(timeout, K_NO_WAIT)) {
        /* don't wait for a message to become available */
        result = -ENOMSG;
    } else {
        SYS_PORT_TRACING_OBJ_FUNC_BLOCKING(k_msgq, get, msgq, timeout);

        /* wait for get message success or timeout */
        _current->base.swap_data = data;

        result = z_pend_curr(&msgq->lock, key, &msgq->wait_q, timeout);
        SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, get, msgq, timeout, result);
        return result;
    }

    SYS_PORT_TRACING_OBJ_FUNC_EXIT(k_msgq, get, msgq, timeout, result);

    k_spin_unlock(&msgq->lock, key);

    return result;
}

#ifdef CONFIG_USERSPACE
static inline int z_vrfy_k_msgq_get(struct k_msgq *msgq, void *data,
                    k_timeout_t timeout)
{
    Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
    Z_OOPS(Z_SYSCALL_MEMORY_WRITE(data, msgq->msg_size));

    return z_impl_k_msgq_get(msgq, data, timeout);
}
#include <syscalls/k_msgq_get_mrsh.c>
#endif

int z_impl_k_msgq_peek(struct k_msgq *msgq, void *data)
{
    k_spinlock_key_t key;
    int result;

    key = k_spin_lock(&msgq->lock);

    if (msgq->used_msgs > 0U) {
        /* take first available message from queue */
        (void)memcpy(data, msgq->read_ptr, msgq->msg_size);
        result = 0;
    } else {
        /* don't wait for a message to become available */
        result = -ENOMSG;
    }

    SYS_PORT_TRACING_OBJ_FUNC(k_msgq, peek, msgq, result);

    k_spin_unlock(&msgq->lock, key);

    return result;
}

#ifdef CONFIG_USERSPACE
static inline int z_vrfy_k_msgq_peek(struct k_msgq *msgq, void *data)
{
    Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
    Z_OOPS(Z_SYSCALL_MEMORY_WRITE(data, msgq->msg_size));

    return z_impl_k_msgq_peek(msgq, data);
}
#include <syscalls/k_msgq_peek_mrsh.c>
#endif

void z_impl_k_msgq_purge(struct k_msgq *msgq)
{
    k_spinlock_key_t key;
    struct k_thread *pending_thread;

    key = k_spin_lock(&msgq->lock);

    SYS_PORT_TRACING_OBJ_FUNC(k_msgq, purge, msgq);

    /* wake up any threads that are waiting to write */
    while ((pending_thread = z_unpend_first_thread(&msgq->wait_q)) != NULL) {
        arch_thread_return_value_set(pending_thread, -ENOMSG);
        z_ready_thread(pending_thread);
    }

    msgq->used_msgs = 0;
    msgq->read_ptr = msgq->write_ptr;

    z_reschedule(&msgq->lock, key);
}

#ifdef CONFIG_USERSPACE
static inline void z_vrfy_k_msgq_purge(struct k_msgq *msgq)
{
    Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
    z_impl_k_msgq_purge(msgq);
}
#include <syscalls/k_msgq_purge_mrsh.c>

static inline uint32_t z_vrfy_k_msgq_num_free_get(struct k_msgq *msgq)
{
    Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
    return z_impl_k_msgq_num_free_get(msgq);
}
#include <syscalls/k_msgq_num_free_get_mrsh.c>

static inline uint32_t z_vrfy_k_msgq_num_used_get(struct k_msgq *msgq)
{
    Z_OOPS(Z_SYSCALL_OBJ(msgq, K_OBJ_MSGQ));
    return z_impl_k_msgq_num_used_get(msgq);
}
#include <syscalls/k_msgq_num_used_get_mrsh.c>

#endif
 

jacky_jin1
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
zephyr笔记 2.5.4 消息队列
IoT小能手
05-03 1311
1 前言 消息队列是实现简单消息队列的内核对象，允许线程和ISR异步发送和接收固定大小的数据项。 我正在学习 Zephyr，一个很可能会用到很多物联网设备上的操作系统，如果你也感兴趣，可点此查看帖子zephyr学习笔记汇总。 2 概念 可以定义任何数量的消息队列。 每个消息队列都由其内存地址引用。 消息队列具有以下关键属性： 已发送但尚未收到的数据项的环形缓冲区。 数据项大小，以...
Zephyr poll
qq_36115224的博客
04-04 640
在Zephyr中，polling是一种等待事件的机制，它可以等待多个事件同时发生。在Zephyr中，可以使用k_poll()函数来等待事件。k_poll()函数接受一个k_poll_event数组，数组中的每个元素都描述了一个等待的事件。在等待期间，线程会被阻塞，直到所有事件都发生或等待超时。在等待结束后，k_poll()函数会返回一个整数，表示发生的事件数。
Zephyr 消息队列
qq_36115224的博客
04-18 807
message queue 用于中断和线程之间进行数据传输的一项服务，其本质是一个环形缓冲区，例如串口驱动中通常会使用环形缓冲区来接收数据，缓冲区中每一项的大小是固定的。Zephyr 中的 msgq 是消息队列的具体实现，它需要提供一个缓冲区用于存储数据，缓冲区的大小是缓存项大小的整数倍，与 Zephyr 中的 queue 不同，消息队列写入和读取会拷贝数据。消息队列包含3个重要属性，单条消息的大小，缓冲区最大消息容量，缓冲区对齐大小。定义一个静态缓冲区可使用 K_MSGQ_DEFINE 宏。
4、zephyr内核中的消息队列
qq_45093614的博客
01-23 380
zephyr内核中的消息队列
Zephyr内核对象分析之：k_fifo/k_lifo、k_queue、sys_sflist_t
liuxinagyun的博客
06-13 645
zephyr提供的数据数据传递对象之一便是，k_fifo、k_lifo。以下以FIFO为例，简单分析其源码。 zephyr版本：2.5.99
zephyr_install.sh
08-05
zephyr的一键自动下载配置脚本
zephyr OS 文档(中文版)_os_zephyr_操作系统_嵌入式_
10-03
**Zephyr OS**，全称为Zephyr实时操作系统（RTOS），是一款开源、轻量级且高度可定制的操作系统，专为物联网（IoT）设备和嵌入式系统设计。这款操作系统提供了微内核架构，支持多种硬件平台，包括ARM、RISC-V、X86等...
zephyr_zperf
04-10
自由板（FRDM K64F） Quark SE C1000开发板 QEMU x86 要求 主机上安装了iPerf 2.0.5 支持板 根据所选的网络技术，可能需要额外的步骤来设置网络环境。 用法 如果Zephyr充当客户端，则iPerf必须在服务器模式下执行...
Zephyr_NUS_Sample:Zephyr NUS示例实施
05-10
Zephyr NUS示例实施 这是在Zephyr v1.12.0上实现Nordic NUS服务的实验。 将代码应用于<Zephyr> / samples。 2018/06/26 双方都添加了LESC配对，支持数字比较（默认）或密码输入。 注意中央需要在下面的提交： : ...
ESM_ArcSight控制台用户指南（中文翻译版—Zephyr）_6.11.0 .pdf
08-20
**HPE Security ArcSight ESM 控制台用户指南概览** HPE Security ArcSight Event Security Manager (ESM) 是一款强大的安全信息和事件管理(SIEM)平台，用于监控、分析和响应组织的网络安全事件。...
Zephyr queue
qq_36115224的博客
04-02 387
Zephyr 内核中支持队列操作，该队列是由带头指针和尾指针的单链表组成。并且提供了队列的常见操作方式，和内核中的其他对象一样，向队列中插入数据是不会进行深拷贝的，用户向其中插入数据时需要自己申请动态空间，否则就会造成内存错误。Zephyr 中的队列是链式队列，队列的插入和并不会进行数据的深拷贝，使用时应避免使用栈上的内存，如果传入的对象来自于栈需要仔细考虑同步问题，否则会造成严重错误。
Zephyr的message queue机制以及API
最新发布
qq_35555785的博客
02-28 323
Zephyr实现消息队列的功能，允许线程和ISR异步地接收和发送固定大小的消息数据项。如果有等待消息的线程存在，那么就会把消息数据项直接拷贝给这个线程，特别声明的是这里只做数据项的内容的拷贝复制，并没有把消息数据项的地址传递。另外有一种情况是如果ring buffer有空间，那么这个消息数据项会被拷贝到消息队列的ring buffer。还有一点就是，发送数据的大小都必须和一开始定义的消息队列的数据项大小一致。
NCS-OS系列11 :轮询API
weixin_36224284的博客
01-05 384
NCS-OS系列11 :轮询API 文章目录NCS-OS系列11 :轮询API前言概念实现使用`k_poll`使用`k_poll_signal_raise()`推荐用法配置选项 前言 ncs 相关文章，部分为原始文档翻译，水平有限，如果有错误，欢迎指出。 本文参考链接： https://docs.zephyrproject.org/latest/reference/kernel/other/polling.html 概念 轮询API用于同时等待多个条件中的任何一个得到满足，轮询API的主要函数是k_poll
zephyr操作系统_检查Zephyr操作系统代码
cullen2012的博客
09-07 1354
zephyr操作系统 Some time ago we announced PVS-Studio's new feature that enabled it to integrate into PlatformIO. Naturally, our team kept in touch with the PlatformIO team while working on that feature, ...
第13篇 zephyr 数据传递之Message Queues
霍宏鹏的专栏
04-22 942
本学笔记基于zephyr 工程版本 2.2.99，主机环境为ubuntu18.04，开发平台 nrf52840dk_nrf52840 摘要 消息队列是一个内核对象，简单的实现了消息队列的功能。允许线程和ISR异步的发送和接收固定大小的数据项。
nrf5340运行的时候出现ASSERTION FAIL错误 解决方案
wanjietiam的博客
07-13 468
现象;log输出以下内容 ASSERTION FAIL [((arch_is_in_isr() == 0) || ((timeout).ticks == (((k_timeout_t) {})).ticks))] @ WEST_TOPDIR/zephyr/kernel/sem.c:140 解决方案： 不要在定时器回调或者中断里面运行需要消耗很长时间的代码 ...
ktime实现忙闲等待
jason的笔记
02-21 2241
可以使用ktime来实现等待。例如下面这段code 首先用ktime_get()得到当前时间，然后使用ktime_add_us来得到需要到期的时间。      ktime_t timeout = ktime_add_us(ktime_get(), ARM_SMMU_POLL_TIMEOUT_US); while (ktime_compare(ktime_get(), timeout) >
【Zephyr】nRF52840线程切换，动态内存分配所占用的时间
m0_37458552的博客
12-18 927
在NRF52840上，一直有一个疑问是，别人总是说，优化代码，有的互斥锁，信号量等，等都是有代价的 ，下面可以看出，在64M主频下，进行操作系统的各项操作所占用的时间。
HCI Command packet
m0_37458552的博客
06-07 727
HCI Command是有方向性的，从Host发给Controller。是2个字节的长度，OPCODE 其中，分为两部分，OCF和OGF，OGF，是上面的6bits，剩余的10个bit位是OCF。
zephyr系统fs_open函数
04-01
zephyr系统中的fs_open函数是用于打开文件的函数。其定义如下： ```c int fs_open(struct fs_file_t *zfp, const char *file_name) ``` 其中，参数zfp是一个指向fs_file_t类型的指针，用于存储打开的文件的信息。参数file_name是一个字符串，表示要打开的文件的路径和名称。 函数返回值为0表示成功打开文件，否则返回错误代码。在函数执行完毕后，文件指针zfp中存储着打开文件的信息，可以通过该指针访问文件内容或进行其他操作。 例如，以下代码示例演示了如何使用fs_open函数打开一个名为"test.txt"的文件： ```c #include <stdio.h> #include <fs/fs.h> void main(void) { struct fs_file_t fp; int ret; ret = fs_open(&fp, "/test.txt"); if (ret != 0) { printf("Failed to open file: %d", ret); return; } // read or write file content // ... fs_close(&fp); } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值