KVM中virtio之vring（八）

最新推荐文章于 2024-10-10 08:47:37 发布
最新推荐文章于 2024-10-10 08:47:37 发布
阅读量3.3k 收藏 12
点赞数 2
原文链接：https://blog.csdn.net/qq_15437629/article/details/82084470
版权

1 virtio原理

拿网络驱动部分做案例，网络驱动virtio-net有两个队列：接收队列和发送队列；每个队列都对应一个virtqueue,两个队列之间是互不影响的。

前后端利用virtqueue的方式如下图所示：
在这里插入图片描述
当收包时，ReceiveQueue需要客户机 driver提前填充分配好的空buffer，然后记录到availRing，并在恰当的时机通知后端,当外部网络有数据包到达时，qemu后端就从availRing 中获取一个buffer，然后填充数据，完事后记录buffer head index到usedRing.最后在恰当的时机通知客户机（向客户机注入中断），客户机接收到信号便知道有数据包到达，这里只需要从usedRing 中获取到index，然后取data数组的第i个元素即可。因为在客户机填充buffer的时候把逻辑buffer的指针保存在data数组中。

而SendQueue同样需要客户机去填充，只不过这里是当客户机需要发送数据包时，把数据包构造成逻辑buffer，然后填充到send Queue,并在恰当的时机通知后端，qemu后端收到通知就知道那个队列有请求到达，如果当前没有处理其他数据包就着手处理这个数据包。
在这里插入图片描述
具体就同样是从AvailRing中取出buffer head index，然后从描述符表中get到buffer，这时就需要从buffer中copy数据了，因为要把数据包从host发送出去，然后更新usedRing。最后同样要在恰当的时机通知客户机。注意这里客户机同样需要从usedRing 中get index，但是这里主要是用于delay notify,因为数据包由客户机构造，其占用的buffer并不能重复使用，只是每次有数据包就把其构造成buffer而已。
在这里插入图片描述

2 Virtqueue

struct VirtQueue
{
    VRing vring;  /* vring的元数据 */
    hwaddr pa;  /* vring实际的内存地址 */
    uint16_t last_avail_idx;
    /* Last used index value we have signalled on */
    uint16_t signalled_used;

    /* Last used index value we have signalled on */
    bool signalled_used_valid;

    /* Notification enabled? */
    bool notification;

    uint16_t queue_index;

    int inuse;

    uint16_t vector;
    void (*handle_output)(VirtIODevice *vdev, VirtQueue *vq);
    VirtIODevice *vdev;
    EventNotifier guest_notifier;
    EventNotifier host_notifier;
};

每个设备拥有多个 virtqueue 用于大块数据的传输。virtqueue 是一个简单的队列，guest 把 buffers 插入其中，每个 buffer 都是一个分散-聚集数组。驱动调用 find_vqs()来创建一个与 queue 关联的结构体。virtqueue 的数目根据设备的不同而不同，比如 block 设备有一个 virtqueue，network 设备有 2 个 virtqueue,一个用于发送数据包，一个用于接收数据包，Balloon 设备有 3 个 virtqueue.

针对 virtqueue 的操作包括：

  1. int virtqueue_add_buf(struct virtqueue *_vq, struct scatterlist sg[], unsigned int out, unsigned int in, void *data, gfp_t gfp)
    用于向 queue 中添加一个新的 buffer，参数 data 是一个非空的令牌，用于识别 buffer，当 buffer 内容被消耗后，data 会返回。

  2. virtqueue_kick()
    Guest 通知 host 单个或者多个 buffer 已经添加到 queue 中,调用 virtqueue_notify()，notify 函数会向 queue notify(VIRTIO_PCI_QUEUE_NOTIFY)寄存器写入 queue index 来通知 host。

  3. void *virtqueue_get_buf(struct virtqueue *_vq, unsigned int *len)
    返回使用过的 buffer，len 为写入到 buffer 中数据的长度。获取数据，释放 buffer,更新 vring 描述符表格中的 index。

  4. virtqueue_disable_cb()
    示意 guest 不再需要再知道一个 buffer 已经使用了，也就是关闭 device 的中断。驱动会在初始化时注册一个回调函数，disable_cb()通常在这个 virtqueue 回调函数中使用，用于关闭再次的回调发生。

  5. virtqueue_enable_cb()
    与 disable_cb()刚好相反，用于重新开启设备中断的上报。

3 VRing

typedef struct VRing
{
    unsigned int num;
    unsigned int align;
    hwaddr desc;
    hwaddr avail;
    hwaddr used;
} VRing;

virtio_ring 是 virtio 传输机制的实现，vring 引入 ring buffers 来作为我们数据传输的载体。virtio_ring 包含 3 部分：

  1. 描述符数组（descriptor table）用于存储一些关联的描述符，每个描述符都是一个对 buffer 的描述，包含一个 address/length 的配对。
  2. 可用的 ring(available ring)用于 guest 端表示那些描述符链当前是可用的。
  3. 使用过的 ring(used ring)用于表示 Host 端表示那些描述符已经使用。

Ring 的数目必须是 2 的次幂。

avail ring有两个用途，一是发送侧(send queue)前端驱动发送报文的时，将待发送报文加入avail ring等待后端的处理，后端处理完后，会将其放入used ring，并由前端将其释放desc中(free_old_xmit_skbs, detach_buf)，最后通过try_fill_recv重新装入avail ring中; 二是接收侧(receive qeueu)，前端将空白物理块加入avail ring中，提供给后端用来接收报文，后端接收完报文会放入used ring。

可以看出，都是后端用完前端的avail ring的东西放入used ring，即avail ring是前端维护，后端访问；used ring 是后端修改，前端访问。

4 VRingDesc

描述符和描述符表格

vring descriptor 用于指向 guest 使用的 buffer。

typedef struct VRingDesc
{
    uint64_t addr;
    uint32_t len;
    uint16_t flags;
    uint16_t next;
} VRingDesc;

addr：guest 物理地址
len：buffer 的长度
flags：flags 的值含义包括：

  • VRING_DESC_F_NEXT：用于表明当前 buffer 的下一个域是否有效，也间接表明当前 buffer 是否是 buffers list 的最后一个。
  • VRING_DESC_F_WRITE：当前 buffer 是 read-only 还是 write-only。
  • VRING_DESC_F_INDIRECT：表明这个 buffer 中包含一个 buffer 描述符的 list

next：所有的 buffers 通过 next 串联起来组成 descriptor table

多个 buffer 组成一个 list 由 descriptor table 指向这些 list。

约定俗成，每个 list 中，read-only buffers 放置在 write-only buffers 前面。
在这里插入图片描述
图 2.descriptor table

有些设备可能需要同时完成大量数据传输的大量请求，设备 VIRTIO_RING_F_INDIRECT_DESC 特性能够满足这种需求。为了增加 ring 的容量，vring 可以指向一个可以处于内存中任何位置 indirect descriptors table，而这个 table 指向一组 vring descriptors，而这些 vring descriptor 分别指向一组 buffer list（如图所示）。当然 indirect descriptors table 中的 descriptor 不能再次指向 indirect descriptors table。单个 indirect descriptor table 可以包含 read-only 和 write-only 的 descriptors，带有 write-only flag 的 descriptor 会被忽略。
在这里插入图片描述
图 3.indirect decriptors

5 VRingAvail

typedef struct VRingAvail
{
    uint16_t flags;
    uint16_t idx;
    uint16_t ring[0];
} VRingAvail;

Available ring 指向 guest 提供给设备的描述符,它指向一个 descriptor 链表的头。Available ring 结构如下图所示。其中标识 flags 值为 0 或者 1，1 表明 Guest 不需要 device 使用完这些 descriptor 时上报中断。idx 指向我们下一个 descriptor 入口处，idx 从 0 开始，一直增加，使用时需要取模：idx=idx&(vring.num-1)
在这里插入图片描述
图 4.available ring

6 VRingUsed

typedef struct VRingUsedElem
{
    uint32_t id;
    uint32_t len;
} VRingUsedElem;

typedef struct VRingUsed
{
    uint16_t flags;
    uint16_t idx;
    VRingUsedElem ring[0];
} VRingUsed;

Used ring 指向 device(host)使用过的 buffers。Used ring 和 Available ring 之间在内存中的分布会有一定间隙，从而避免了 host 和 guest 两端由于 cache 的影响而会写入到 virtqueue 结构体的同一部分的情况。

flags 用于 device 告诉 guest 再次添加 buffer 到 available ring 时不再提醒，也就是说 guest 添加 buffers 到 available ring 时不必进行 kick 操作。

Used vring element 包含 id 和 len，id 指向 descriptor chain 的入口,与之前 guest 写入到 available ring 的入口项一致。

len 为写入到 buffer 中的字节数。

Guest 向设备提供 buffer

  1. 把 buffer 添加到 description table 中,填充 addr,len,flags
  2. 更新 available ring head
  3. 更新 available ring 中的 index
  4. 通知 device，通过写入 virtqueue index 到 Queue Notify 寄存器

Device 使用 buffer 并填充 used ring

device 端使用 buffer 后填充 used ring 的过程如下：

  1. virtqueue_pop()——从描述符表格（descriptor table）中找到 available ring 中添加的 buffers，映射内存
  2. 从分散-聚集的 buffer 读取数据
  3. virtqueue_fill()——取消内存映射,更新 ring[idx]中的 id 和 len 字段
  4. virtqueue_flush()——更新 vring_used 中的 idx
  5. virtio_notify()——如果需要的话，在 ISR 状态位写入 1，通知 guest 描述符已经使用

VIRTIO的vring收发队列创建流程：

在初始化阶段，前端分配好内存区，并初始化好前端的vring后，就把内存区的信息传递到后端，后端也利用这个内存区的信息初始化队列相关的vring。这样vring就在前后端保持了一致。原理就是如此，下面看具体初始化代码：

// GUEST前端驱动，以网络设备为例： Virtio-net: PCI 发现后，通过PCI总线分配收发队列，函数调用依次如下：前端：virtnet_probe->init_vqs->virtnet_find_vqs->vi->vdev->config->find_vqs(vp_find_vqs)->vp_try_to_find_vqs->setup_vq,在setup_vp中通过IO端口和后端交互

static int virtnet_probe(structvirtio_device *vdev)
{
        /*
         * 初始化virtqueue
        * 创建和初始化发送/接收队列
        */
        err = init_vqs(vi);
}

/*创建和初始化发送/接收队列*/
static int init_vqs(struct virtnet_info*vi)
{
        /*分配*/
        ret = virtnet_alloc_queues(vi);
        if (ret)
                  goto err;

        /*通过find vqs来创建vring*/
        ret = virtnet_find_vqs(vi);
        if (ret)
                  goto err_free;
}

/*通过find vqs来创建vring*/
static int virtnet_find_vqs(structvirtnet_info *vi)
{
        /*最后调用的是vp_find_vqs，真正的创建virtqueue内部结构和分配地址，并将地址告诉后端QEMU驱动*/
        ret = vi->vdev->config->find_vqs(vi->vdev,total_vqs, vqs, callbacks, names);
}

//VIRTIO PCI总线
static int vp_find_vqs(struct virtio_device*vdev, unsigned nvqs,struct virtqueue *vqs[],vq_callback_t *callbacks[],const char *names[])
{
        int err;
        err = vp_try_to_find_vqs(vdev,nvqs, vqs, callbacks, names, true, true);
        err = vp_try_to_find_vqs(vdev,nvqs, vqs, callbacks, names, true, false);
        return vp_try_to_find_vqs(vdev,nvqs, vqs, callbacks, names, false, false);

}

static int vp_try_to_find_vqs()
{
                  /*最核心的是setup_vq()*/
                  vqs[i] = setup_vq(vdev,i, callbacks[i], names[i], msix_vec);

}

static struct virtqueue *setup_vq(structvirtio_device *vdev, unsigned index,void (*callback)(struct virtqueue *vq),const char *name,u16 msix_vec)
{

        /*这里实际上把info->queue的GPA(页框号写入到了设备的VIRTIO_PCI_QUEUE_PFN)，这样后端就会得到这块内存区的信息。然后我们先看下前端利用这块内存区做了什么？看下面的vring_new_virtqueue函数，该函数中调用vring_init来初始化vring*/

        iowrite32(virt_to_phys(info->queue)>> VIRTIO_PCI_QUEUE_ADDR_SHIFT, vp_dev->ioaddr +VIRTIO_PCI_QUEUE_PFN);

/* create the vring */
    vq = vring_new_virtqueue(index, info->num, VIRTIO_PCI_VRING_ALIGN, vdev,
                 true, info->queue, vp_notify, callback, name);
}

static inline void vring_init(struct vring *vr, unsigned int num, void *p,
                  unsigned long align)
{
    vr->num = num;
    vr->desc = p;
    vr->avail = p + num*sizeof(struct vring_desc);
    vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(__u16)
        + align-1) & ~(align - 1));
}

// 这个函数正好体现了我们前面那个结构图。这样前端vring就初始化好了。对队列填充数据时就是根据这个vring填充信息。

// QEMU后端驱动：
// 下面在通过VIRTIO_PCI_QUEUE_PFN传递地址的时候，调用virtio_queue_set_addr设置后端相关队列的vring，该函数实现较简单

static void virtio_ioport_write(void*opaque, uint32_t addr, uint32_t val)
{
    switch (addr) {
    case VIRTIO_PCI_QUEUE_PFN:
        /*pa就是desc的GPA*/
        pa = (target_phys_addr_t)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT;
        if (pa == 0) {
            virtio_pci_stop_ioeventfd(proxy);
            virtio_reset(proxy->vdev);
            msix_unuse_all_vectors(&proxy->pci_dev);
        }
        else
            //下面在通过VIRTIO_PCI_QUEUE_PFN传递地址的时候，调用virtio_queue_set_addr设置后端相关队列的vring
            virtio_queue_set_addr(vdev, vdev->queue_sel, pa);
        break;
    //仅仅是标记了下设备中的queue_sel表示当前操作的队列索引
    case VIRTIO_PCI_QUEUE_SEL:
        if (val < VIRTIO_PCI_QUEUE_MAX)
            vdev->queue_sel = val;
        break;
    case VIRTIO_PCI_QUEUE_NOTIFY:
        if (val < VIRTIO_PCI_QUEUE_MAX) {
            virtio_queue_notify(vdev, val);
        }
        break;
}

void virtio_queue_set_addr(VirtIODevice *vdev, int n, target_phys_addr_t addr)
{
    vdev->vq[n].pa = addr;
    virtqueue_init(&vdev->vq[n]);
}

static void virtqueue_init(VirtQueue *vq)
{
    target_phys_addr_t pa = vq->pa;

    vq->vring.desc = pa;
    vq->vring.avail = pa + vq->vring.num * sizeof(VRingDesc);
    vq->vring.used = vring_align(vq->vring.avail +
                                 offsetof(VRingAvail, ring[vq->vring.num]),
                                 VIRTIO_PCI_VRING_ALIGN);
}

看到这里有么有很面熟，没错，这个函数和前端初始化vring的函数很是类似，这样前后端的vring就同步起来了……

而在guest通知后端的时候，通过VIRTIO_PCI_QUEUE_NOTIFY接口，该函数调用了virtio_queue_notify_vq继而调用 vq->handle_output……就这样，后端就得到通知着手处理了！

还有个细节问题，前端驱动写入的应该是QEUEU的GPA

iowrite32(virt_to_phys(info->queue)>> VIRTIO_PCI_QUEUE_ADDR_SHIFT,vp_dev->ioaddr+ VIRTIO_PCI_QUEUE_PFN);

这个被后端QEMU截获后，QEMU怎么直接使用了GPA呢？哪里完成的GPA->HVA的转换呢？

这个是在QEMU从virtqueue中取消息的时候，进行转换的

QEMU代码，在收到VIRTIO通知后，会通过virtqueue_pop从共享队列中取出消息

intvirtqueue_pop(VirtQueue *vq, VirtQueueElement *elem)
{
    /*Now map what we have collected */
    virtqueue_map_sg(elem->in_sg,elem->in_addr, elem->in_num, 1);
    virtqueue_map_sg(elem->out_sg,elem->out_addr, elem->out_num, 0);
}

voidvirtqueue_map_sg()
{
   for (i = 0; i < num_sg; i++) {
       len = sg[i].iov_len;
       sg[i].iov_base =cpu_physical_memory_map(addr[i], &len, is_write);
       if (sg[i].iov_base == NULL || len != sg[i].iov_len) {
           error_report("virtio: trying to map MMIO memory");
           exit(1);
       }
    }
}

/*完成一个GUEST的物理地址GPA到HVA的转换*/
void*cpu_physical_memory_map(hwaddr addr,hwaddr *plen,int is_write)
{
   return address_space_map(&address_space_memory,addr, plen, is_write);
}

收包过程如下所示：
在这里插入图片描述

  1. 前端填充好desc（addr/len），并更新vring->avail（ring[0]）
  2. 后端读取avail ring索引，找到desc(if ring[0]=2,then desctable[2] 记录的就是一个逻辑buffer的首个物理块的信息)，填充buffer数据；将buffer索引存在desc，将desc索引存放在used ring中
  3. 前端读取used ring索引，找到desc，获取buffer数据

原文链接：https://blog.csdn.net/qq_15437629/article/details/82084470

关于 virtio 的重要知识点总结
yiyeguzhou100的专栏
02-10 2776
1，virtio ring（vring）队列由 guest 准备（申请内存），vring包含三部分：desc, avail, used， 且 vring.avail 所指向的 desc 也由 guest 准备，guest 给队列准备 desc 分两种： 1)，发送时准备，如 virtio-blk 所用队列以及 virtio-net 中 guest 主动发送数据用到的队列； 2)，事先准备好，如 virtio-net 中 host 主动发送数据的队列； 2，virtio-blk ...
Linux Kernel 之七 虚拟化、VirtIO 架构及规范、VirtQueue & VRing
技术干货
09-29 1156
VirtIO 是一种 IO 半虚拟化解决方案，它提供 Guest OS 与 Hypervisor 虚拟化设备之间的通信框架和编程接口。其主要的优势是能提高性能且减少跨平台带来的兼容性问题。本文重点结合 VirtIO 规范 1.1 版以及 Linux 中的源码来分析 VirtIO 框架。
KVM中virtio之vring（十）
bob的博客
06-10 1144
一、Vring数据结构 1、数据结构图的左半部分描述了virtio-blk设备与virtio设备的关系，virtqueue与vring_virtqueue的关系，如下： virtio-blk是一个virtio设备，它看到的队列是virtqueue，里面没有vring的实现，只记录了vring中还有多少空闲的buffer可以使用 vring_virtqueue是一个virtqueue，它将VRing的实现隐藏在virtqueue下面，当一个virtio-blk设备真正要发送数据时，只要传入virtqueu
OpenAMP：开启异构多处理系统开发的新纪元
最新发布
gitblog_00915的博客
10-10 685
OpenAMP：开启异构多处理系统开发的新纪元 项目地址:https://gitcode.com/gh_mirrors/op/open-amp 项目介绍 OpenAMP（Open Asymmetric Multi Processing）是一个开源的异构多处理（AMP）框架，旨在为开发者提供一套完整的软件组件，用于构建和部署异构多处理系统。OpenAMP 框架的核心功能包括生命周期管理、处理器间通信...
(KVM连载)5.1.1 Virtio概述和基本原理（KVM半虚拟化驱动）
ponymwt的专栏
05-07 1709
5.1 半虚拟化驱动 5.1.1 virtio概述 KVM是必须使用硬件虚拟化辅助技术（如Intel VT-x、AMD-V）的hypervisor，在CPU运行效率方面有硬件支持，其效率是比较高的；在有Intel EPT特性支持的平台上，内存虚拟化的效率也较高。QEMU/KVM提供了全虚拟化环境，可以让客户机不经过任何修改就能运行在KVM环境中。不过，KVM在I/O虚拟化方面，传统的方式是使用
virtio的vring队列
热门推荐
majieyue的专栏
04-17 1万+
上一篇已经提到，在virtio设备初始化的过程中，会通过setup_vp创建virtqueue，目前的virtqueue队列都是通过vring来实际工作的，我们可以把virtqueue当做一个接口类，而把vring_virtqueue当做这个接口的一个实现 /** * virtqueue - a queue to register buffers for sending or receivin
VirtIO vring实现原理详解
大隐隐于野
04-08 960
VRing包含数据传输的所有要素，包括Descriptor Table，Avail Ring和Used Ring，其中Descriptor Table是一个数组，每个Entry描述一个数据的buffer，Descriptor Table存放的是指针，Avail Ring和Used Ring中的ring数组则不同，它们存放的是索引，用来间接记录Descriptor chain。对于发送数据，buffer对于后端来说是只读的，对于接受数据，后端需要往buffer中写数据，所以是可写的。
virtio vring原理
Eddy的博客
12-25 3127
在 virtio 设备上进行批量数据传输的机制被称为 virtqueue 。每个设备可以拥有零个或多个 virtqueue ，当 Driver 想要向设备发送数据时，它会填充 Descriptor Table 中的一项（或将几项链接在一起），并将描述符索引写入 Available Ring 中，然后它通知 Device ，当 Device 完成后，它将描述符索引写入 Used Ring 中并发送中断。 Virtio 在 Guest 中实现了前端驱动，在 Host （qemu）中实现了后端驱动，前后端之间通
计算机io工作方式,QEMU/KVM和VirtIO工作模式
weixin_29213827的博客
07-26 879
https://blog.csdn.net/shengxia1999/article/details/52244119KVM：Kernel-Based Virtual Machine 基于内核的虚拟机，是Linux内核的一个可加载模块，通过调用Linux本身内核功能，实现对CPU的底层虚拟化和内存的虚拟化，使Linux内核成为虚拟化层，需要x86架构的，支持虚拟化功能的硬件支持(比如Intel V...
QEMU源码全解析 —— virtio（1）
phmatthaus的专栏
12-11 1840
QEMU源码全解析 —— virtio（1）
一文分析Linux虚拟化KVM-Qemu之virtqueue
youzhangjing_的博客
02-28 439
前边系列将Virtio Device和Virtio Driver都已经讲完，本文将分析virtqueue；virtqueue用于前后端之间的数据交换，一看到这种数据队列，首先想到的就是ring-buffer，实际的实现会是怎么样的呢？
KVM中virtio实现（九）
bob的博客
06-10 519
一、什么是 vhost vhost 是 virtio 的一种后端实现方案，在 virtio 简介中，我们已经提到 virtio 是一种半虚拟化的实现方案，需要虚拟机端和主机端都提供驱动才能完成通信，通常，virtio 主机端的驱动是实现在用户空间的 qemu 中，而 vhost 是实现在内核中，是内核的一个模块 vhost-net.ko。为什么要实现在内核中，有什么好处呢，请接着往下看。 二、为什么要用 vhost 在 virtio 的机制中，guest 与 用户空间的 Hypervisor 通信，会造成
介绍virtio ring数据结构非常详细的博文
qq_32044045的博客
09-16 826
https://www.cnblogs.com/yi-mu-xi/p/12544695.html 为博主点赞
virtio简介
qq_23929673的博客
01-27 806
文章目录什么是virtiovirtio 的架构总结： 什么是virtio virtio 是一种 I/O 半虚拟化解决方案，是一套通用 I/O 设备虚拟化的程序，是对半虚拟化 Hypervisor 中的一组通用 I/O 设备的抽象。提供了一套上层应用与各 Hypervisor 虚拟化设备（KVM，Xen，VMware等）之间的通信框架和编程接口，减少跨平台所带来的兼容性问题，大大提高驱动程序开发效率...
virtio 简介
kunkliu的博客
03-26 370
virtio 是一种 I/O 半虚拟化解决方案，是一套通用 I/O 设备虚拟化的程序，是对半虚拟化 Hypervisor 中的一组通用 I/O 设备的抽象。提供了一套上层应用与各 Hypervisor 虚拟化设备（KVM，Xen，VMware等）之间的通信框架和编程接口，减少跨平台所带来的兼容性问题，大大提高驱动程序开发效率。在完全虚拟化的解决方案中，guest VM 要使用底层 host 资源，需要 Hypervisor 来截获所有的请求指令，然后模拟出这些指令的行为，这样势必会带来很多性能上的开销。
虚拟化之---virtio通信
a2591748032的博客
05-06 1474
虚拟化之---virtio通信
浅析virtio技术（3）virtqueue机制
Aspiresky的专栏
12-30 3903
virtio的关键技术是virtqueue机制，其提供了一套统一的用于virito前端和后端的通信机制。virtqueue的核心数据结构是vring，这是virtio前端驱动和后端Hypervisor虚拟设备之间传输数据的载体。
QEMU源码全解析 —— virtio（2）
phmatthaus的专栏
12-12 1556
QEMU源码全解析 —— virtio（2）
VirtIO实现原理——vring数据结构
Take Easy，Work Hard！
12-27 9572
主要介绍vring数据结构的介绍，我们参照的virtio spec的定义，围绕示意图进行，介绍的层次从下到上，从最接近数据buffer到最接近内核块设备进行。
OpenAMP简介
weixin_30262255的博客
07-14 1万+
通常在AMP（非对称多处理）配置中，会采用在不同的处理核上运行不同的软件环境并执行各自的代码程序，各核心之间通力合作实现处理器性能的提升。在AMP系统中，所谓的主处理器通常是指最先启动且主要负责管理其他CPU以及这些CPU上软件环境的CPU处理器。而远程处理器简单的讲就是指被主核所支配的CPU。主软件环境通常需要进行远程核心的管理以及任务调度，在需要进行计算任务分配时，将选择性地驱动远程内核上的远...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值