Message_queue_delay消息队列延迟监测

已于 2024-03-20 09:07:38 修改
阅读量945 收藏 23
点赞数 19
文章标签： linux
于 2024-03-13 09:00:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abobob/article/details/136669392
版权

Linux进程间通信——消息队列

1、消息队列的学习：

消息队列是进程间通信的一种方法，用于两个进程或多个进程之间通信。

两个或多个处于用户态的进程要进行通信时，会通过相应的系统调用将消息块发送至内核中的相应的消息队列；而接收方也会通过相应的系统调用从内核态的消息队列中按顺序或按某一类型接收消息块；当发送方或接收方进程结束时，内核中对应的消息队列并不会被删除。

Linux提供了两种消息队列的方式，二者的区别可见下图（来自网络）

  • System V消息队列；
  • POSIX 消息队列；

在这里插入图片描述

本文将尽量详细全面的分析两种消息队列的工作流程，并从源码层面给出相应的解读；

1.1、System V 消息队列

待整理中….

1.2、POSIX 消息队列

关于POSIX消息队列,阅读了《深入理解Linux内核》第十九章进程通信模块后，有了一定的了解；

以下为相关参考资料：

  • 《深入理解Linux内核》19章节POSIX消息队列部分；

  • 由浅入深探讨Linux进程间通信

    • https://mp.weixin.qq.com/s/DvhNX7zWWviYCwKW1lHfJQ
    • https://mp.weixin.qq.com/s/DpwWJfFGh1UUkEgQNVLXqA
    • https://mp.weixin.qq.com/s/WlkBfMMkQd1g40P5voJaog

  • Linux mq在内核的发送、唤醒流程简介_mq_timedsend-CSDN博客⁤

  • 进程间通信(IPC) 系列 | Posix 消息队列：https://mp.weixin.qq.com/s/axOGVotn937kBVKey-z4tg

1.2.1、POSIX消息队列实现原理：mqueue文件系统

POSIX消息队列是一种进程间通信的方式，允许同一主机上进程间传递消息；如之前介绍的一样，消息队列是在内核中维护的，不同于System V消息队列，POSIX消息队列是基于特定的文件系统实现的：mqueue文件系统

【mqueue文件系统在哪】

我们可以在/proc/filesystem文件中查看到该文件系统、并且可以查到该文件系统的挂载路径：
在这里插入图片描述

在这里插入图片描述

也即进程间通过POSIX消息队列通信时，会将消息队列中的相关信息存储在dev/mqueue目录下；

【创建消息队列时与mqueue文件系统的联系】

借鉴下面这张图(来自网络)来清晰的梳理创建消息队列时，是如何与文件系统联系起来的：

  • 通过C库的mq_open函数创建或打开POSIX消息队列；
  • POSIX消息队列是一个mqueue文件系统中的mqueue inode节点；
  • mqueue inode节点有一个msg_tree成员（红黑树）用于用户存储消息；
  • 在创建一个消息队列时：
    • 会创建mqueue inode节点；
    • 会创建file结构；
    • 获得当前进程task_struct，并将其中files字段中的fd填入；
1.2.1、mq_open()——创建或打开一个POSIX消息队列：

在C库调用mq_open()去创建或打开一个消息队列时，会通过mq_open系统调用去在内核中实现
在这里插入图片描述

【一句话】：mq_open函数其实就是打开或创建了消息队列所需要的inode节点；

在/ipc/mqueue.c文件中可以``找到对于mq_open()系统调用的源码：

【mq_open系统调用】
SYSCALL_DEFINE4(mq_open, const char __user *, u_name, int, oflag, umode_t, mode,struct mq_attr __user *, u_attr)
{
	// 定义一个消息队列属性结构体
	struct mq_attr attr;
	
	// 如果用户传入的消息队列属性指针不为空，并且从用户空间复制属性到内核空间失败，则返回错误代码 -EFAULT
	if (u_attr && copy_from_user(&attr, u_attr, sizeof(struct mq_attr)))
		return -EFAULT;

	// 调用 do_mq_open 函数打开消息队列，传入参数为消息队列名、标志、权限以及消息队列属性指针（如果用户传入了属性指针，则传入复制后的内核空间地址，否则传入 NULL）
	return do_mq_open(u_name, oflag, mode, u_attr ? &attr : NULL);
}

此处通过系统调用宏 SYSCALL_DEFINE4(mq_open, const char __user *, u_name, int, oflag, umode_t, mode,struct mq_attr __user *, u_attr)进行打开或创建消息列表；

  • copy_from_user：尝试从用户空间复制属性到内核空间中的 attr 结构体中

  • 调用 do_mq_open 函数来实际打开消息队列；

【do_mq_open】
static int do_mq_open(const char __user *u_name, int oflag, umode_t mode, struct mq_attr *attr)
{
    // 获取当前进程的 IPC 命名空间中的消息队列挂载点
    struct vfsmount *mnt = current->nsproxy->ipc_ns->mq_mnt;
    // 获取挂载点的根目录
    struct dentry *root = mnt->mnt_root;
    // 定义一个文件名结构体指针，用于存储消息队列的名字
    struct filename *name;
    // 定义一个路径结构体，用于表示消息队列的路径
    struct path path;
    // 定义文件描述符和错误码变量
    int fd, error;
    // 用于标记挂载点是否为只读
    int ro;

    // 对消息队列的打开进行审计
    audit_mq_open(oflag, mode, attr);

    // 从用户空间获取消息队列的名字，并存储到 filename 结构体中
    if (IS_ERR(name = getname(u_name)))
        return PTR_ERR(name);

    // 获取一个未使用的文件描述符，并设置 CLOEXEC 标志
    fd = get_unused_fd_flags(O_CLOEXEC);
    if (fd < 0)
        goto out_putname;

    // 获取挂载点的写锁，将其标记为只读
    ro = mnt_want_write(mnt); /* we'll drop it in any case */
    // 锁定挂载点的 inode
    inode_lock(d_inode(root));
    // 在挂载点的根目录中查找消息队列的路径
    path.dentry = lookup_one_len(name->name, root, strlen(name->name));
    if (IS_ERR(path.dentry)) {
        // 如果查找失败，则返回错误码
        error = PTR_ERR(path.dentry);
        goto out_putfd;
    }
    // 获取挂载点的引用计数
    path.mnt = mntget(mnt);
    // 准备打开消息队列，包括权限检查和其他验证操作
    error = prepare_open(path.dentry, oflag, ro, mode, name, attr);
    if (!error) {
        // 打开消息队列，获取文件指针
        struct file *file = dentry_open(&path, oflag, current_cred());
        if (!IS_ERR(file))
            // 将文件指针安装到指定的文件描述符上
            fd_install(fd, file);
        else
            // 如果打开文件失败，则返回错误码
            error = PTR_ERR(file);
    }
    // 释放路径资源
    path_put(&path);
out_putfd:
    // 处理错误情况下的文件描述符和错误码
    if (error) {
        put_unused_fd(fd);
        fd = error;
    }
    // 解锁 inode
    inode_unlock(d_inode(root));
    // 如果挂载点不是只读，则释放挂载点的写锁
    if (!ro)
        mnt_drop_write(mnt);
out_putname:
    // 释放消息队列名字的内存空间
    putname(name);
    // 返回文件描述符
    return fd;
}

该函数由底而上的创建了/打开了消息队列对应的inode数据结构，并将struct file对应的f_inode字段指向该inode；

  • 通过do_mq_open函数获取消息队列的路径以及inode地址；
  • 通过prepare_open函数准备打开或创建消息队列；
  • 打开消息队列，获取文件的指针；
  • 释放相应的资源；
【prepare_open】
static int prepare_open(struct dentry *dentry, int oflag, int ro,
                        umode_t mode, struct filename *name,
                        struct mq_attr *attr)
{
    // 定义一个数组，用于将打开标志转换为权限位掩码
    static const int oflag2acc[O_ACCMODE] = { MAY_READ, MAY_WRITE, MAY_READ | MAY_WRITE };
    int acc;

    // 如果 dentry 指向的是一个空文件，则根据打开标志和只读标志进行相应处理
    if (d_really_is_negative(dentry)) {
        // 如果打开标志没有包含 O_CREAT，则返回 ENOENT 错误
        if (!(oflag & O_CREAT))
            return -ENOENT;
        // 如果只读标志为真，则返回 ro（挂载点是否为只读）作为错误码
        if (ro)
            return ro;
        // 对创建消息队列进行审计，并调用 vfs_mkobj 创建消息队列
        audit_inode_parent_hidden(name, dentry->d_parent);
        return vfs_mkobj(dentry, mode & ~current_umask(), mqueue_create_attr, attr);
    }
    /* it already existed */
    // 对已存在的消息队列进行审计
    audit_inode(name, dentry, 0);
    // 如果同时设置了 O_CREAT 和 O_EXCL 标志，则返回 EEXIST 错误
    if ((oflag & (O_CREAT|O_EXCL)) == (O_CREAT|O_EXCL))
        return -EEXIST;
    // 如果同时打开了 O_RDWR 和 O_WRONLY，则返回 EINVAL 错误
    if ((oflag & O_ACCMODE) == (O_RDWR | O_WRONLY))
        return -EINVAL;
    // 根据打开标志获取权限位掩码
    acc = oflag2acc[oflag & O_ACCMODE];
    // 检查当前用户对消息队列的权限
    return inode_permission(&init_user_ns, d_inode(dentry), acc);
}
  • dentry路径指向空文件，则查看是否需要创建消息队列
  • 通过文件系统中的创建inode对应的函数：vfs_mkobj()创建消息队列对应的inode；
1.2.2、mq_send()/mq_timedsend()——发送消息块到消息队列：

Linux mq在内核的发送、唤醒流程简介_mq_timedsend-CSDN博客⁤

C库提供的mq_send()、mq_timedsend()函数都是调用的mq_timedsend()系统调用进入内核；

在这里插入图片描述

在对发消息块和收消息块进行源码分析之前，先对于两个结构体进行学习：

【struct ext_wait_queue】：
struct ext_wait_queue {//休眠队列
    struct task_struct *task;   // 指向等待的任务的指针
    struct list_head list;      // 用于将等待项链接到等待队列中的链表节点
    struct msg_msg *msg;        // 指向加载的消息的指针
    int state;                  // 等待项的状态，可以是 STATE_* 中定义的一个值
};

该结构体表示扩展的等待队列中的一个等待项，其中包含一个指向消息块（要传送的）的指针；

【struct mqueue_inode_info】:
struct mqueue_inode_info {
    spinlock_t lock;                     // 自旋锁，用于保护结构体的访问
    struct inode vfs_inode;              // VFS inode 结构体，用于表示文件系统中的一个文件
    wait_queue_head_t wait_q;            // 等待队列头，用于等待消息队列的操作

    struct rb_root msg_tree;             // 红黑树根节点，用于按消息标识符存储消息
    struct rb_node *msg_tree_rightmost;  // 指向红黑树中最右边的节点，用于快速查找最大的消息标识符
    struct posix_msg_tree_node *node_cache; // 指向用于缓存节点的指针，用于提高性能

    struct mq_attr attr;                 // 消息队列的属性，包括最大消息数、最大消息大小等信息

    struct sigevent notify;              // 用于通知的事件
    struct pid *notify_owner;            // 通知的所有者的进程 ID
    u32 notify_self_exec_id;             // 通知自身的执行 ID
    struct user_namespace *notify_user_ns; // 通知的用户命名空间
    struct ucounts *ucounts;             // 创建该消息队列的用户的计数器信息
    struct sock *notify_sock;            // 用于通知的套接字
    struct sk_buff *notify_cookie;       // 通知的数据包

    /* 用于等待空闲空间和消息的任务 */
    struct ext_wait_queue e_wait_q[2];   // 两个扩展等待队列，用于等待空闲空间和消息

    unsigned long qsize;                 // 队列在内存中的大小，即所有消息的总大小
};

用于表示消息队列的 inode 相关信息，其中消息队列中维护着一套等待队列（struct ext_wait_queue）；

在/ipc/mqueue.c文件中可以找到对于mq_timedsend()系统调用的源码：

【mq_timedsend 系统调用】
SYSCALL_DEFINE5(mq_timedsend, mqd_t, mqdes, const char __user *, u_msg_ptr,
                size_t, msg_len, unsigned int, msg_prio,
                const struct __kernel_timespec __user *, u_abs_timeout)
{
    // 定义一个 timespec64 结构体，用于存储超时时间
    struct timespec64 ts, *p = NULL;

    // 如果用户传入的绝对超时时间指针不为空，则准备超时时间
    if (u_abs_timeout) {
        // 调用 prepare_timeout 函数准备超时时间，并将结果存储到 ts 结构体中
        int res = prepare_timeout(u_abs_timeout, &ts);
        if (res)
            return res; // 如果准备超时时间失败，则直接返回错误码
        p = &ts; // 否则，将超时时间结构体的地址赋值给 p 指针
    }

    // 调用 do_mq_timedsend 函数执行消息队列的定时发送操作
    return do_mq_timedsend(mqdes, u_msg_ptr, msg_len, msg_prio, p);
}
  • mq_send 传入的参数u_abs_timeout为NULL；mq_timedsend传入的参数u_abs_timeout为时间限制；
  • 执行mq_timedsend()函数，则需要prepare_timeout函数准备超时时间，其中prepare_timeout函数通过调用get_timespec64()函数来从用户空间获取超时时间；
  • 调用真正的处理函数：do_mq_timedsend；
【do_mq_timedsend】：
static int do_mq_timedsend(mqd_t mqdes, const char __user *u_msg_ptr,
                            size_t msg_len, unsigned int msg_prio,
                            struct timespec64 *ts)
{
    struct fd f;
    struct inode *inode;
    struct ext_wait_queue wait;
    struct ext_wait_queue *receiver;
    struct msg_msg *msg_ptr;
    struct mqueue_inode_info *info;
    ktime_t expires, *timeout = NULL;
    struct posix_msg_tree_node *new_leaf = NULL;
    int ret = 0;
    DEFINE_WAKE_Q(wake_q);
    // 检查消息优先级是否有效
    if (unlikely(msg_prio >= (unsigned long) MQ_PRIO_MAX))
        return -EINVAL;
    // 如果指定了超时时间，则将其转换为 ktime_t 结构体
    if (ts) {
        expires = timespec64_to_ktime(*ts);
        timeout = &expires;
    }
    // 对消息发送进行审计记录
    audit_mq_sendrecv(mqdes, msg_len, msg_prio, ts);

    // 通过文件描述符获取文件对象
    f = fdget(mqdes);
    if (unlikely(!f.file)) {
        ret = -EBADF;
        goto out;
    }
    // 获取文件对象的 inode
    inode = file_inode(f.file);
    // 检查文件是否是消息队列文件
    if (unlikely(f.file->f_op != &mqueue_file_operations)) {
        ret = -EBADF;
        goto out_fput;
    }
    // 获取消息队列的信息结构体
    info = MQUEUE_I(inode);
    // 对文件进行审计记录
    audit_file(f.file);

    // 检查文件是否具有写权限
    if (unlikely(!(f.file->f_mode & FMODE_WRITE))) {
        ret = -EBADF;
        goto out_fput;
    }

    // 检查消息长度是否超过消息队列的最大长度
    if (unlikely(msg_len > info->attr.mq_msgsize)) {
        ret = -EMSGSIZE;
        goto out_fput;
    }

    // 从用户空间加载消息
    msg_ptr = load_msg(u_msg_ptr, msg_len);
    if (IS_ERR(msg_ptr)) {
        ret = PTR_ERR(msg_ptr);
        goto out_fput;
    }
    msg_ptr->m_ts = msg_len;
    msg_ptr->m_type = msg_prio;

    // 锁定消息队列信息结构体，开始消息发送操作
    spin_lock(&info->lock);

    // 尝试预先分配内存，以避免在操作现有队列之前进行分配
    if (!info->node_cache)
        new_leaf = kmalloc(sizeof(*new_leaf), GFP_KERNEL);

    // 如果消息队列已满，等待直到有可用空间或者超时
    if (info->attr.mq_curmsgs == info->attr.mq_maxmsg) {
        if (f.file->f_flags & O_NONBLOCK) {
            ret = -EAGAIN;
        } else {
            // 进入等待队列
            wait.task = current;
            wait.msg = (void *)msg_ptr;
            WRITE_ONCE(wait.state, STATE_NONE);
            ret = wq_sleep(info, SEND, timeout, &wait);
            goto out_free;
        }
    } else {
        // 如果有接收者在等待消息，则直接将消息发送给接收者
        receiver = wq_get_first_waiter(info, RECV);
        if (receiver) {
            pipelined_send(&wake_q, info, msg_ptr, receiver);
        } else {
            // 否则，将消息插入队列，并通知等待的接收者
            ret = msg_insert(msg_ptr, info);
            if (ret)
                goto out_unlock;
            __do_notify(info);
        }
        // 更新文件的访问时间、修改时间和更改时间
        inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
    }

out_unlock:
    // 解锁消息队列信息结构体
    spin_unlock(&info->lock);
    // 唤醒等待队列中的等待者
    wake_up_q(&wake_q);
out_free:
    // 如果出现错误，则释放消息
    if (ret)
        free_msg(msg_ptr);
out_fput:
    // 释放文件对象
    fdput(f);
out:
    return ret;
}

  • 通过mqdes标识的消息队列，获取到文件对象file的文件描述符；再通过文件描述符fd获得具体的消息队列：

        // 通过文件描述符获取文件对象
    f = fdget(mqdes);
    if (unlikely(!f.file)) {
        ret = -EBADF;
        goto out;
    }
    // 获取文件对象的 inode
    inode = file_inode(f.file);
    // 检查文件是否是消息队列文件
    if (unlikely(f.file->f_op != &mqueue_file_operations)) {
        ret = -EBADF;
        goto out_fput;
    }
    // 获取消息队列的信息结构体
    info = MQUEUE_I(inode);

  • 通过load_msg()函数从用户空间加载消息；

        // 从用户空间加载消息
    msg_ptr = load_msg(u_msg_ptr, msg_len);
    if (IS_ERR(msg_ptr)) {
        ret = PTR_ERR(msg_ptr);
        goto out_fput;
    }
    msg_ptr->m_ts = msg_len;
    msg_ptr->m_type = msg_prio;

  • 若消息队列满，则等待直到有可用空间/超时；其中通过wq_sleep()函数将等待项放入等待队列，并持续等待被唤醒；

    if (info->attr.mq_curmsgs == info->attr.mq_maxmsg) {//消息队列已满
        if (f.file->f_flags & O_NONBLOCK) {
            ret = -EAGAIN;
        } else {
            // 进入等待队列
            wait.task = current;
            wait.msg = (void *)msg_ptr;
            WRITE_ONCE(wait.state, STATE_NONE);
            ret = wq_sleep(info, SEND, timeout, &wait);//将处于等待状态的进程放人
            goto out_free;
        }

  • 如果消息队列未满，并且有接受者在等待消息，则直接调用pipelined_send()函数将消息发送给接受者；

    //wq_get_first_waiter函数获得等待队列第一个等待项
receiver = wq_get_first_waiter(info, RECV);
        if (receiver) {//有等待者
            pipelined_send(&wake_q, info, msg_ptr, receiver);//调用pipelined_send
        }

  • 如果消息队列未满，且没有等待消息的进程，则调用msg_insert向消息队列插入发送的消息块；

    else {
        // 否则，将消息插入队列，并通知等待的接收者
        ret = msg_insert(msg_ptr, info);
        if (ret)//插入成功，则通过wake_up_q(&wake_q)唤醒等待队列的等待者
        goto out_unlock;
        __do_notify(info);
      }
【pipelined_send】：

该函数用来向接收进程直接发送消息块；

static inline void pipelined_send(struct wake_q_head *wake_q,
				  struct mqueue_inode_info *info,
				  struct msg_msg *message,
				  struct ext_wait_queue *receiver)
{
    // 将要发送的消息设置到接收者的消息指针中
    receiver->msg = message;
    // 调用管道式操作函数进行发送操作
    __pipelined_op(wake_q, info, receiver);
}
  • 参数：struct wake_q_head *wake_q：等待队列的首部；
  • 参数：struct mqueue_inode_info *info：消息队列；
  • 参数：struct msg_msg *message：要传送的消息块；
  • 参数：struct ext_wait_queue *receiver：接收进程的等待结构体；
  • receiver->msg = message;将要发送的消息设置到接收者的消息指针中
  • 通过调用__pipelined_op()函数，发送
【__pipelined_op】：
static inline void __pipelined_op(struct wake_q_head *wake_q,
				  struct mqueue_inode_info *info,
				  struct ext_wait_queue *this)
{
    struct task_struct *task;
    // 从等待队列中移除当前等待项
    list_del(&this->list);
    // 获取当前等待任务的任务结构体指针
    task = get_task_struct(this->task);
    /* 使用 smp_store_release 释放内存屏障保证状态修改的可见性 */
    smp_store_release(&this->state, STATE_READY);
    // 将任务添加到唤醒队列中
    wake_q_add_safe(wake_q, task);
}
  • 删除位于消息队列的对应等待型；
  • 准备唤醒处于等待中的接收者进程；
【msg_insert】：

该函数实现了向消息队列中插入消息块的操作；

static int msg_insert(struct msg_msg *msg, struct mqueue_inode_info *info)
{
    struct rb_node **p, *parent = NULL;
    struct posix_msg_tree_node *leaf;
    bool rightmost = true;

    // 从根节点开始搜索插入位置
    p = &info->msg_tree.rb_node;
    while (*p) {
        parent = *p;
        leaf = rb_entry(parent, struct posix_msg_tree_node, rb_node);

        // 如果消息的优先级与当前节点的优先级相同，则直接插入到当前节点的消息列表中
        if (likely(leaf->priority == msg->m_type))
            goto insert_msg;
        // 如果消息的优先级小于当前节点的优先级，则向左子树搜索
        else if (msg->m_type < leaf->priority) {
            p = &(*p)->rb_left;
            rightmost = false;
        } else
            // 否则向右子树搜索
            p = &(*p)->rb_right;
    }

    // 如果存在缓存的节点，则使用缓存的节点
    if (info->node_cache) {
        leaf = info->node_cache;
        info->node_cache = NULL;
    } else {
        // 否则分配一个新的节点
        leaf = kmalloc(sizeof(*leaf), GFP_ATOMIC);
        if (!leaf)
            return -ENOMEM;
        INIT_LIST_HEAD(&leaf->msg_list);
    }
    // 设置节点的优先级为消息的优先级
    leaf->priority = msg->m_type;

    // 如果是最右边的节点，则更新消息队列中最右边的节点指针
    if (rightmost)
        info->msg_tree_rightmost = &leaf->rb_node;

    // 将节点链接到树中
    rb_link_node(&leaf->rb_node, parent, p);
    // 将节点插入到红黑树中
    rb_insert_color(&leaf->rb_node, &info->msg_tree);
insert_msg:
    // 更新消息队列的当前消息数量和总大小
    info->attr.mq_curmsgs++;
    info->qsize += msg->m_ts;
    // 将消息添加到节点的消息列表中
    list_add_tail(&msg->m_list, &leaf->msg_list);
    return 0;
}
1.2.4、mq_receive()/mq_timedreceive()——接收消息块从消息队列：

Linux mq在内核的发送、唤醒流程简介_mq_timedsend-CSDN博客⁤

C库提供的mq_receive()、mq_timedreceive()函数都是调用的mq_timedreceive()系统调用进入内核；

在这里插入图片描述

以上是接收进程通过调用mq_tiemedreceive()系统调用来从消息队列接收消息的大体流程，下面将从源码层面进行分析：

【mq_timedreceive】：

用户程序通过C库中的mq_receive()、mq_timedreceive()函数进行进程间接收消息，主要是通过mq_timedreceive系统调用实现的。

在该系统调用中，如果设置了超时时间，先获取超时时间，再通过调用内核函数do_mq_timedreceive()进行具体的获取消息的实现。

SYSCALL_DEFINE5(mq_timedreceive, mqd_t, mqdes, char __user *, u_msg_ptr,
		size_t, msg_len, unsigned int __user *, u_msg_prio,
		const struct __kernel_timespec __user *, u_abs_timeout)
{
	struct timespec64 ts, *p = NULL;  // 定义 timespec64 结构体和指针变量 p

	// 如果指定了超时时间
	if (u_abs_timeout) {
		int res = prepare_timeout(u_abs_timeout, &ts);  // 准备超时时间
		if (res)  // 如果准备失败
			return res;  // 返回准备失败的错误码
		p = &ts;  // 否则将超时时间赋值给 p
	}

	// 调用底层函数 do_mq_timedreceive 进行消息接收操作
	return do_mq_timedreceive(mqdes, u_msg_ptr, msg_len, u_msg_prio, p);
}
【do_mq_timedreceive】：

该内核函数是mq_timedreceive系统调用的主要函数，该函数主要实现了如下功能：

  • 获取消息队列所在的文件信息和inode结构；
  • 给消息缓冲区分配空间；给消息队列上锁；为接收消息做准备；
  • 开始准备接收消息：
    • if(消息队列没有消息) 即需要等待消息的到来。
      • a. 并且处于非阻塞模式 ==即消息队列没有消息，也不等消息的到来；==1). 解锁消息队列 2). 跳出系统调用；
      • b. ==消息队列无消息，且愿意等消息的到来；==调用wq_sleep()等待消息得到来。关于该函数是如何实现的，会在下文给出详细的源码介绍。
    • else（消息队列中有消息等待接收）即不需要等待消息的到来。
      • a. 唤醒消息队列DEFINE_WAKE_Q(wake_q);
      • b. 通过msg_get(info);从消息队列中获取具体的消息；
      • c. 通过pipelined_receive()从管道中接收消息；该函数具体怎么实现，会在下文详细介绍；
      • d. 解锁消息队列，唤醒等待队列；
  • 处理接收到的消息；
static int do_mq_timedreceive(mqd_t mqdes, char __user *u_msg_ptr,
		size_t msg_len, unsigned int __user *u_msg_prio,
		struct timespec64 *ts)
{
	ssize_t ret;  // 定义返回值
	struct msg_msg *msg_ptr;  // 消息指针
	struct fd f;  // 文件描述符
	struct inode *inode;  // inode 结构
	struct mqueue_inode_info *info;  // 消息队列 inode 信息
	struct ext_wait_queue wait;  // 等待队列
	ktime_t expires, *timeout = NULL;  // 超时时间
	struct posix_msg_tree_node *new_leaf = NULL;  // 新节点

	// 如果设置了超时时间，则将其转换为内核时间格式
	if (ts) {
		expires = timespec64_to_ktime(*ts);
		timeout = &expires;
	}

	// 记录系统调用的审计信息
	audit_mq_sendrecv(mqdes, msg_len, 0, ts);

	// 获取文件描述符对应的文件
	f = fdget(mqdes);
	if (unlikely(!f.file)) {
		ret = -EBADF;  // 如果文件描述符无效，返回 EBADF 错误码
		goto out;  // 跳转到 out 标签
	}

	// 获取文件的 inode 结构
	inode = file_inode(f.file);
	if (unlikely(f.file->f_op != &mqueue_file_operations)) {
		ret = -EBADF;  // 如果文件操作不是消息队列操作，返回 EBADF 错误码
		goto out_fput;  // 跳转到 out_fput 标签
	}
	info = MQUEUE_I(inode);  // 获取消息队列 inode 信息
	audit_file(f.file);  // 记录文件的审计信息

	// 检查文件是否可读
	if (unlikely(!(f.file->f_mode & FMODE_READ))) {
		ret = -EBADF;  // 如果文件不可读，返回 EBADF 错误码
		goto out_fput;  // 跳转到 out_fput 标签
	}

	// 检查消息缓冲区是否足够大
	if (unlikely(msg_len < info->attr.mq_msgsize)) {
		ret = -EMSGSIZE;  // 如果消息缓冲区大小不够，返回 EMSGSIZE 错误码
		goto out_fput;  // 跳转到 out_fput 标签
	}

	// 如果没有缓存节点，则分配一个新的节点
	if (!info->node_cache)
		new_leaf = kmalloc(sizeof(*new_leaf), GFP_KERNEL);

	spin_lock(&info->lock);

	if (!info->node_cache && new_leaf) {
		/* Save our speculative allocation into the cache */
		INIT_LIST_HEAD(&new_leaf->msg_list);  // 初始化消息链表
		info->node_cache = new_leaf;  // 将新节点存储到缓存中
	} else {
		kfree(new_leaf);  // 释放新节点的内存
	}

	// 如果消息队列中没有消息
	if (info->attr.mq_curmsgs == 0) {
		if (f.file->f_flags & O_NONBLOCK) {  // 如果设置了非阻塞标志
			spin_unlock(&info->lock);  // 解锁消息队列
			ret = -EAGAIN;  // 返回 EAGAIN 错误码（表示资源暂时不可用）
		} else {  // 否则
			wait.task = current;  // 设置等待队列的任务为当前任务

			/* memory barrier not required, we hold info->lock */
			WRITE_ONCE(wait.state, STATE_NONE);  // 设置等待状态为 STATE_NONE
			ret = wq_sleep(info, RECV, timeout, &wait);  // 等待消息的到来
			msg_ptr = wait.msg;  // 获取等待队列中的消息指针
		}
	} else {  // 如果消息队列中有消息
		DEFINE_WAKE_Q(wake_q);  // 定义唤醒队列

		// 从消息队列中获取消息
		msg_ptr = msg_get(info);

		// 更新 inode 的访问时间
		inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);

		/* There is now free space in queue. */
		pipelined_receive(&wake_q, info);  // 从管道中接收消息
		spin_unlock(&info->lock);  // 解锁消息队列
		wake_up_q(&wake_q);  // 唤醒等待队列
		ret = 0;  // 设置返回值为 0（表示成功）
	}

	// 处理接收到的消息
	if (ret == 0) {
		ret = msg_ptr->m_ts;  // 获取消息的时间戳

		// 将消息的优先级存储到用户空间
		if ((u_msg_prio && put_user(msg_ptr->m_type, u_msg_prio)) ||
			store_msg(u_msg_ptr, msg_ptr, msg_ptr->m_ts)) {
			ret = -EFAULT;  // 如果存储消息失败，返回 EFAULT 错误码
		}
		free_msg(msg_ptr);  // 释放消息占用的内存
	}

out_fput:
	fdput(f);  // 释放文件描述符
out:
	return ret;  // 返回结果
}
【wq_sleep】：

该函数主要通过wq_add()将等待项添加到消息队列中，并进入一个无限循环中进行睡眠等待。

在该循环中，会将当前进程状态设为可中断睡眠状态，并解锁消息消息队列，一直等待被唤醒(即ewp->state == STATE_READY时被唤醒)，或呗信号/超时被唤醒。

在被唤醒时，会将该等待项从等待队列中移除，并解锁消息队列。

static int wq_sleep(struct mqueue_inode_info *info, int sr,
		    ktime_t *timeout, struct ext_wait_queue *ewp)
	__releases(&info->lock)  // 函数释放 info->lock 锁
{
	int retval;  // 返回值
	signed long time;  // 超时时间

	wq_add(info, sr, ewp);  // 将等待队列添加到消息队列中

	for (;;) {  // 无限循环，直到条件满足或者超时或者被信号中断
		/* memory barrier not required, we hold info->lock */
		__set_current_state(TASK_INTERRUPTIBLE);  // 设置当前进程状态为可中断睡眠状态

		spin_unlock(&info->lock);  // 解锁消息队列
		time = schedule_hrtimeout_range_clock(timeout, 0,
			HRTIMER_MODE_ABS, CLOCK_REALTIME);  // 设置超时时间

		if (READ_ONCE(ewp->state) == STATE_READY) {  // 如果等待状态为 STATE_READY
			/* see MQ_BARRIER for purpose/pairing */
			smp_acquire__after_ctrl_dep();  // 内存屏障
			retval = 0;  // 返回成功
			goto out;  // 跳转到 out 标签
		}
		spin_lock(&info->lock);  // 加锁消息队列

		/* we hold info->lock, so no memory barrier required */
		if (READ_ONCE(ewp->state) == STATE_READY) {  // 如果等待状态为 STATE_READY
			retval = 0;  // 返回成功
			goto out_unlock;  // 跳转到 out_unlock 标签
		}
		if (signal_pending(current)) {  // 如果当前进程有信号待处理
			retval = -ERESTARTSYS;  // 返回重新启动系统调用的错误码
			break;  // 跳出循环
		}
		if (time == 0) {  // 如果超时时间为 0
			retval = -ETIMEDOUT;  // 返回超时错误码
			break;  // 跳出循环
		}
	}
	list_del(&ewp->list);  // 从列表中删除等待队列
out_unlock:
	spin_unlock(&info->lock);  // 解锁消息队列
out:
	return retval;  // 返回结果
}

疑问：为何在该函数中，会进行两次相同的状态判断if (READ_ONCE(ewp->state) == STATE_READY) :

答：这两个判断的作用是在多线程或者多进程环境中确保对等待状态的准确性。在解锁和重新锁定之间可能会有其他线程或者进程修改了 ewp->state 的值，为了确保获取到最新的状态，需要使用 READ_ONCE 来获取 ewp->state 的值，并且确保在相应的位置使用内存屏障来保证内存一致性。

使用两次判断的目的是为了确保获取到最新的状态，并且避免在解锁和重新锁定之间产生竞态条件。

【msg_get】：

该函数主要通过按优先级一次遍历消息队列红黑树，获取到消息后更新消息数和消息总大小；其作用是从消息队列中获取一个消息，并返回该消息的指针。

  • 函数首先尝试从优先级最高的节点开始查找消息，然后从该节点的消息列表中获取第一个消息。
  • 如果该节点的消息列表为空，则移除该节点，并重新尝试获取消息。
  • 最后，函数更新消息队列中的消息数和总消息大小，并返回获取到的消息指针。
【pipelined_receive】：

在通过msg_get函数从消息队列中获取到消息指针后，通过pipelined_receive()函数从等待发送队列中拿出首个等待项，将其插入消息队列中；即msg_get函数从消息队列中拿走一个消息块，通过pipelined_receive()函数再向消息队列放一个消息块；

  • 获取“等待发送队列”中的第一个等待发送项；
  • 等待发送队列中没有要发送的等待项，则唤醒等待队列，通知其他进程；
  • 通过调用msg_insert()将发送者等待项中要发送的信息插入消息队列中；
  • 通过调用__pipelined_op(wake_q, info, sender);来从等待发送队列中移除 当前发送的等待项，并唤醒发送进程。
/* pipelined_receive() - if there is task waiting in sys_mq_timedsend()
 * gets its message and put to the queue (we have one free place for sure). */
static inline void pipelined_receive(struct wake_q_head *wake_q,
				     struct mqueue_inode_info *info)
{
	struct ext_wait_queue *sender = wq_get_first_waiter(info, SEND);  // 获取第一个等待发送的任务

	if (!sender) {  // 如果没有等待发送的任务
		/* for poll */
		wake_up_interruptible(&info->wait_q);  // 唤醒等待队列
		return;  // 返回
	}
	if (msg_insert(sender->msg, info))  // 将发送任务的消息插入到队列中
		return;  // 如果插入失败，直接返回

	__pipelined_op(wake_q, info, sender);  // 执行管道操作
}

在这里插入图片描述

持续更新中…

abobob
关注
进程间通信——消息队列（Message queue）
ypt
04-16 2369
在Linux中，IPC消息队列是一个双向通信的全内存设计，即内核保证了读写顺序和数据同步，并且是性能比较好的先进先出的数据结构。消息队列的应用场景：比如异步任务处理，抢占式的数据分发，顺序缓存区等。消息队列的产生原因消息队列其实就是消息传输过程中保存消息的容器，既然有了管道，为什么要出现消息队列呢？理由如下：（1）生命周期：匿名管道和命名管道都是随进程的，意味着管道的生命周期是随进程的退出而退出的...
Spring Boot + RabbitMQ + rabbitmq_delayed_message_exchange插件实现延迟队列
qq_33749799的博客
04-01 2088
最近在实现一个业务，就是需要做到消息延迟推送，在Java 多线程并发开发过程中，了解到DelayQueue类的：是一个无界的BlockingQueue，用于放置实现了Delayed接口的对象，其中的对象只能在其到期时才能从队列中取走。这种队列是有序的，即队头对象的延迟到期时间最长。注意：不能将null元素放置到这种队列中。然后再开一个扫描线程去轮询，就可以实现延迟消息的处理了，但是这样子做有一个弊...
nsqdelay:nsqdelay - NSQ 的延迟消息队列
07-03
nsqdelay - NSQ 的延迟消息队列 nsqdelay可用于在 NSQ 之上发送延迟消息，它默认侦听延迟主题（可配置）并接收具有以下结构的 JSON 编码消息： { "topic": "my_topic", "body": "message_body", "send_at": <unix> } 它将消息持久化到一个 sqlite 文件数据库，并在时机成熟时发布它们。 用法 对于所有命令行参数，使用docker run --rm gbenhaim/nsqdelay -h 否则使用docker run -d --name nsqdelay gbenhaim/nsqdelay .... 建议将 sqlite db 文件的路径挂载为一个卷，这样延迟的消息将被持久化。
消息队列之关于如何实现延时队列
技术能量站
12-23 345
首先它要具有队列的特性，再给它附加一个延迟消费队列消息的功能，也就是说可以指定队列中的消息在哪个时间点被消费。下订单成功后，在30分钟内没有支付，自动取消订单外卖平台发送订餐通知，下单成功后60s给用户推送短信。如果订单一直处于某一个未完结状态时，及时处理关单，并退还库存淘宝新建商户一个月内还没上传商品信息，将冻结商铺等用户登录之后5分钟给用户做分类推送；用户多少天未登录给用户做召回推送；关闭空闲连接。服务器中，有很多客户端的连接，空闲一段时间之后需要关闭之。
mq_open函数打开失败原因
爱柚柚的老板的博客
11-28 5117
最近在看IPC，自己在编写Posix消息队列时，遇到mq_open无法打开，总是返回错误。因为在posix标准中，并不是所有的名字都可以使用，必须是以 / 开始，并且名字里只能包含一个 / 。 代码如下，如果使用NAME ，输出success。如果使用NAME1，输出erro #include &lt;stdlib.h&gt; #include &lt;sys/stat.h&gt; #inc...
php-rabbitmq结合rabbitmq_delayed_message_exchange实现延时队列
夏已微凉、
06-11 654
1、安装 rabbitmq_delayed_message_exchange #查看插件列表 rabbitmq-plugins list #如果未安装，则下载 wget https://dl.bintray.com/rabbitmq/community-plugins/3.7.x/rabbitmq_delayed_message_exchange/rabbitmq_delayed_message_exchange-20171201-3.7.x.zip #解压 unzip rabbitmq_delayed
RabbitMQ学习笔记：RabbitMQ延迟队列(DLX、TTL及rabbitmq_delayed_message_exchange插件)
热门推荐
OceanSky的专栏
01-03 1万+
延迟队列存储的对象是对应的延迟消息，所谓的延迟消息是指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费。 延迟消息使用的场景有很多，比如： 在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行异常处理，这时候就可以使用延迟队列来处理这些订单了。 用户希望通过手机远程遥控家里的智能设备在指定...
Rabbitm 延迟队列插件rabbitmq_delayed_message_exchange
05-23 2680
延迟队列: 根据上面的方案我门知道我们生产中不可缺少的使用延迟队列，我们如何实现今天介绍下 需要安装插件 https://www.rabbitmq.com/community-plugins.html 这个里面有rabbitmq的插件集合 我们从中找到rabbitmq_delayed_message_exchange 点击下载，下载后的代码放到你的安装目录 下面的plugins目录下 比如我放的就是： /usr/local/Cellar/rabbitmq/3.8.16/plugins 这个目录下面，找自己的
rt_thread的消息队列
RONG_YAO的博客
06-21 1670
在 RT-Thread 中，数字优先 级越小，逻辑优先级越高 主函数 int main(void) { // 硬件初始化,写在此处 // 关中断 rt_hw_interrupt_disable(); // 定期性的中断或者异常来作为系统的时基 --时钟节拍 // SysTick中断频率设置 CM3内核 (系统时钟)SystemCoreClock = 25M RT_TICK_PER_SECOND(重装载寄存器的值 ticks)
RabbitMQ消息插件rabbitmq_delayed_message_exchange3.7
09-30
2. 延迟消息可能导致消息积压，因此在设计系统时要考虑队列容量和消息清理策略。 3. 插件可能不兼容所有RabbitMQ版本，升级前需确认兼容性。 综上，`rabbitmq_delayed_message_exchange`插件是RabbitMQ中实现消息...
rabbitmq_delayed_3.6.x延迟插件.rar
12-23
压缩包内的文件“rabbitmq_delayed_message_exchange-20171215-3.6.x.ez”是一个经过打包的插件文件，其中"rabbitmq_delayed_message_exchange"是延迟消息交换机的名称，这通常是延迟队列功能的核心组件。...
DLX + TTL/TTL+rabbitmq_delayed_message_exchange插件实现延迟队列
weixin_44362368的博客
04-21 272
DLX(死信队列)+TTL（消息生存时间） 1.mq配置（rabbitConfig） @Configuration public class RabbitConfig { @Bean(RabbitMqConstant.INM_MARKET_EXCHANGE) public DirectExchange directExchange(){ return new DirectExchange(RabbitMqConstant.INM_MARKET_EXCHANGE,true,fa
rabbitmq plugins rabbitmq_delayed_message_exchange消息队列延迟消息插件
偶爱喝可乐
09-08 8356
RabbitMQ实现延迟消息传递的方法
《Linux从小白到高手》综合应用篇：详解Linux系统调优之内存优化
最新发布
qq_45732829的博客
10-11 942
内存是影响Linux性能的主要因素之一，内存资源的充足与否直接影响应用系统的使用性能。内存调优的主要目标是合理分配和利用内存资源，减少内存浪费，提高内存利用率，从而提升系统整体性能。
（Linux和数据库）1.Linux操作系统和常用命令
2301_79144798的博客
10-09 777
除了办公和玩游戏之外不用Linux，其他地方都要使用Linux（it相关）iOS的本质是unix（unix是付费版本的操作系统）unix和Linux之间很相似命令 选项 参数由这三部分组成 可以只有命令目录就是文件夹。
Linux 内核清理缓存命令
luoye_369的博客
10-11 294
一、问题描述log：
LeetCode题练习与总结：二叉树的序列化与反序列化--297
一直学习永不止步
10-11 1106
本文详细介绍了二叉树序列化与反序列化的实现方法，包括前序遍历序列化、队列辅助反序列化等，分析了时间复杂度和空间复杂度，并总结了涉及的重要知识点，为二叉树处理提供了实用的解决方案。
Linux软硬链接
2301_76197086的博客
10-09 745
详解Linux系统软硬链接
springboot redis延迟消息队列实现代码怎么写
05-18
实现延迟消息队列可以使用 Redis 的 sorted set 数据结构，其中 score 表示消息的执行时间戳，member 表示消息内容。每隔一段时间轮询一次 sorted set，将 score 小于当前时间的消息取出来执行即可。 下面是一个...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值