jailhouse同时运行2个Linux虚拟机（inmate)

最新推荐文章于 2024-04-14 21:21:00 发布
最新推荐文章于 2024-04-14 21:21:00 发布
阅读量2.6k 收藏 6
点赞数
分类专栏： jailhouse 文章标签： jailhouse 树莓派4B 2个cell linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/v6543210/article/details/118031563
版权

jailhouse是用来进行硬件分割的hypervisor，在嵌入式领域中应用。

jailhouse的介绍和基本应用可以参见链接：嵌入式虚拟化平台jailhouse踩坑笔记_v6543210的专栏-CSDN博客_jailhouse

本文讲如何实现在树莓派4B平台同时运行2个linux的虚拟机，即none root cell。

官方提供了树莓派4B平台的镜像，需要自行编译。本文以这个项目生成的镜像为基础进行设置。

GitHub - siemens/jailhouse-images: Jailhouse demonstration and testing images

jailhouse的logo

jailhouse的架构图

官方提供的树莓派的配置文件有2个：

在jailhouse-master\configs\arm64目录下，rpi4.c和rpi4-linux-demo.c

能够非常完美地运行linux虚拟机，但是同一时刻只能运行一个linux虚拟机。

 # jailhouse enable /etc/jailhouse/rpi4.cell
 # jailhouse cell linux /etc/jailhouse/rpi4-linux-demo.cell \
                        /boot/vmlinuz* \
                        -d /etc/jailhouse/dts/inmate-rpi4.dtb \
                        -i /usr/libexec/jailhouse/demos/rootfs.cpio \
                        -c "console=ttyS0,115200 ip=192.168.19.2"
 # ssh 192.168.19.2

如果想在同一时刻运行2个linux虚拟机，需要对配置文件进行修改。

配置文件已经修改并放到这里了：

jailhouse-two-inmates.zip_jailhouse-Linux文档类资源-CSDN下载

root.c



#include <jailhouse/types.h>
#include <jailhouse/cell-config.h>

struct {
	struct jailhouse_system header;
	__u64 cpus[1];
	struct jailhouse_memory mem_regions[26];
	struct jailhouse_irqchip irqchips[2];
	struct jailhouse_pci_device pci_devices[3];
} __attribute__((packed)) config = {
	.header = {
		.signature = JAILHOUSE_SYSTEM_SIGNATURE,
		.revision = JAILHOUSE_CONFIG_REVISION,
		.flags = JAILHOUSE_SYS_VIRTUAL_DEBUG_CONSOLE,
		.hypervisor_memory = {
			.phys_start = 0x2fc00000,
			//0x51000000,
			.size       = 0x00400000,
		},
		.debug_console = {
			.address = 0xfe215040,
			.size = 0x40,
			.type = JAILHOUSE_CON_TYPE_8250,
			.flags = JAILHOUSE_CON_ACCESS_MMIO |
				 JAILHOUSE_CON_REGDIST_4,
		},
		.platform_info = {
			.pci_mmconfig_base = 0xff900000,
			// 0xe0000000,
			.pci_mmconfig_end_bus = 0,
			.pci_is_virtual = 1,
			.pci_domain = 1,
			.arm = {
				.gic_version = 2,
				.gicd_base = 0xff841000,
				.gicc_base = 0xff842000,
				.gich_base = 0xff844000,
				.gicv_base = 0xff846000,
				.maintenance_irq = 25,
			},
		},
		.root_cell = {
			.name = "rpi4-two",

			.cpu_set_size = sizeof(config.cpus),
			.num_memory_regions = ARRAY_SIZE(config.mem_regions),
			.num_irqchips = ARRAY_SIZE(config.irqchips),
			.num_pci_devices = ARRAY_SIZE(config.pci_devices),

			.vpci_irq_base = 182 - 32,
		},
	},

	.cpus = {
		0b1111,
	},

	.mem_regions = {
		/* IVSHMEM shared memory regions for 00:00.0 (demo) */
		{
			.phys_start = 0x2faf0000,
			.virt_start = 0x2faf0000,
			.size = 0x1000,
			.flags = JAILHOUSE_MEM_READ,
		},
		{
			.phys_start = 0x2faf1000,
			.virt_start = 0x2faf1000,
			.size = 0x9000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
		},
		{
			.phys_start = 0x2fafa000,
			.virt_start = 0x2fafa000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE,
		},
		{
			.phys_start = 0x2fafc000,
			.virt_start = 0x2fafc000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ,
		},
		{
			.phys_start = 0x2fafe000,
			.virt_start = 0x2fafe000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ,
		},
		/* IVSHMEM shared memory regions for 00:01.0 (networking) */
		JAILHOUSE_SHMEM_NET_REGIONS(0x2fb00000, 0),
		/* IVSHMEM shared memory regions for 00:02.0 (networking) */
		JAILHOUSE_SHMEM_NET_REGIONS(0x4fb00000, 0),
		/* MMIO 1 (permissive) */ {
			.phys_start = 0xfd500000,
			.virt_start = 0xfd500000,
			.size =        0x1b00000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_IO,
		},
		/* MMIO 2 (permissive) */ {
			.phys_start = 0x600000000,
			.virt_start = 0x600000000,
			.size =         0x4000000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_IO,
		},
		/* RAM (0M-~762M) */ {
			.phys_start = 0x0,
			.virt_start = 0x0,
			.size = 0x2fa10000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_EXECUTE,
		},

		/* ~2M reserved for shared memory regions */

		/* 4M reserved for the hypervisor */

		/* RAM (768M-4032M) */ {
			.phys_start = 0x30000000,
			.virt_start = 0x30000000,
			.size = 0xcc000000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_EXECUTE,
		},

		/* RAM (4096M-8192M) */ {
			.phys_start = 0x100000000,
			.virt_start = 0x100000000,
			.size = 0x100000000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_EXECUTE,
		},
		/*gpio 0xfe200000-0xfe201000*/
		// {
			// .phys_start = 0xfe200000,
			// .virt_start = 0xfe200000,
			// .size = 0x1000,
			// .flags = JAILHOUSE_MEM_READ|JAILHOUSE_MEM_WRITE|JAILHOUSE_MEM_IO|JAILHOUSE_MEM_IO_8|JAILHOUSE_MEM_IO_16|JAILHOUSE_MEM_IO_32|JAILHOUSE_MEM_IO_64,
		// },
	},

	.irqchips = {
		/* GIC */ {
			.address = 0xff841000,
			.pin_base = 32,
			.pin_bitmap = {
				0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
			},
		},
		/* GIC */ {
			.address = 0xff841000,
			.pin_base = 160,
			.pin_bitmap = {
				0xffffffff, 0xffffffff
			},
		},
	},

	.pci_devices = {
		{ /* IVSHMEM 0001:00:00.0 (demo) */
			.type = JAILHOUSE_PCI_TYPE_IVSHMEM,
			.domain = 1,
			.bdf = 0 << 3,
			.bar_mask = JAILHOUSE_IVSHMEM_BAR_MASK_INTX,
			.shmem_regions_start = 0,
			.shmem_dev_id = 0,
			.shmem_peers = 3,
			.shmem_protocol = JAILHOUSE_SHMEM_PROTO_UNDEFINED,
		},
		{ /* IVSHMEM 0001:00:01.0 (networking) */
			.type = JAILHOUSE_PCI_TYPE_IVSHMEM,
			.domain = 1,
			.bdf = 1 << 3,
			.bar_mask = JAILHOUSE_IVSHMEM_BAR_MASK_INTX,
			.shmem_regions_start = 5,
			.shmem_dev_id = 0,
			.shmem_peers = 2,
			.shmem_protocol = JAILHOUSE_SHMEM_PROTO_VETH,
		},
		{ /* IVSHMEM 0001:00:02.0 (networking) */
			.type = JAILHOUSE_PCI_TYPE_IVSHMEM,
			.domain = 1,
			.bdf = 2 << 3,
			.bar_mask = JAILHOUSE_IVSHMEM_BAR_MASK_INTX,
			.shmem_regions_start = 9,
			.shmem_dev_id = 0,
			.shmem_peers = 2,
			.shmem_protocol = JAILHOUSE_SHMEM_PROTO_VETH,
		},
	},
};

linux-demo1.c



#include <jailhouse/types.h>
#include <jailhouse/cell-config.h>

struct {
	struct jailhouse_cell_desc cell;
	__u64 cpus[1];
	struct jailhouse_memory mem_regions[16];
	struct jailhouse_irqchip irqchips[2];
	struct jailhouse_pci_device pci_devices[2];
} __attribute__((packed)) config = {
	.cell = {
		.signature = JAILHOUSE_CELL_DESC_SIGNATURE,
		.revision = JAILHOUSE_CONFIG_REVISION,
		.name = "linux-demo1",
		.flags = JAILHOUSE_CELL_PASSIVE_COMMREG |
			JAILHOUSE_CELL_VIRTUAL_CONSOLE_PERMITTED,

		.cpu_set_size = sizeof(config.cpus),
		.num_memory_regions = ARRAY_SIZE(config.mem_regions),
		.num_irqchips = ARRAY_SIZE(config.irqchips),
		.num_pci_devices = ARRAY_SIZE(config.pci_devices),

		.vpci_irq_base = 185-32,

		.console = {
			.address = 0xfe215040,
			.type = JAILHOUSE_CON_TYPE_8250,
			.flags = JAILHOUSE_CON_ACCESS_MMIO |
				 JAILHOUSE_CON_REGDIST_4,
		},
	},

	.cpus = {
		0b0100,
	},

	.mem_regions = {
		/* IVSHMEM shared memory regions (demo) */
		{
			.phys_start = 0x2faf0000,
			.virt_start = 0x2faf0000,
			.size = 0x1000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x2faf1000,
			.virt_start = 0x2faf1000,
			.size = 0x9000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x2fafa000,
			.virt_start = 0x2fafa000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
                JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x2fafc000,
			.virt_start = 0x2fafc000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
                JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x2fafe000,
			.virt_start = 0x2fafe000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_ROOTSHARED,
		},
		/* IVSHMEM shared memory region */
		JAILHOUSE_SHMEM_NET_REGIONS(0x2fb00000, 1),
		/* UART */ {
			.phys_start = 0xfe215040,
			.virt_start = 0xfe215040,
			.size = 0x40,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_IO | JAILHOUSE_MEM_IO_8 |
				JAILHOUSE_MEM_IO_32 | JAILHOUSE_MEM_ROOTSHARED,
		},
		/* RAM */ {
			.phys_start = 0x2f900000,
			.virt_start = 0,
			.size = 0x10000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_LOADABLE,
		},
		/* RAM */ {
			.phys_start = 0x20000000,
			.virt_start = 0x20000000,
			.size = 0x08000000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA |
				JAILHOUSE_MEM_LOADABLE,
		},
		/* communication region */ {
			.virt_start = 0x80000000,
			.size = 0x00001000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_COMM_REGION,
		},

	},

	.irqchips = {
		/* GIC */ {
			.address = 0xff841000,
			.pin_base = 32,
			.pin_bitmap = {
				0,
				0,
				1 << (125 - 96),
				0,
			},
		},
		/* GIC */ {
			.address = 0xff841000,
			.pin_base = 160,
			.pin_bitmap = {
				(1 << (185 - 160)) | (1 << (186 - 160)),
				0,
				0,
				0
			},
		},
	},

	.pci_devices = {
		{ /* IVSHMEM 00:00.0 (demo) */
			.type = JAILHOUSE_PCI_TYPE_IVSHMEM,
			.domain = 1,
			.bdf = 0 << 3,
			.bar_mask = JAILHOUSE_IVSHMEM_BAR_MASK_INTX,
			.shmem_regions_start = 0,
			.shmem_dev_id = 1,
			.shmem_peers = 3,
			.shmem_protocol = JAILHOUSE_SHMEM_PROTO_UNDEFINED,
		},
		{ /* IVSHMEM 00:01.0 (networking) */
			.type = JAILHOUSE_PCI_TYPE_IVSHMEM,
			.bdf = 1 << 3,
			.bar_mask = JAILHOUSE_IVSHMEM_BAR_MASK_INTX,
			.shmem_regions_start = 5,
			.shmem_dev_id = 1,
			.shmem_peers = 2,
			.shmem_protocol = JAILHOUSE_SHMEM_PROTO_VETH,
		},
	},
};

linux-demo2.c



#include <jailhouse/types.h>
#include <jailhouse/cell-config.h>

struct {
	struct jailhouse_cell_desc cell;
	__u64 cpus[1];
	struct jailhouse_memory mem_regions[16];
	struct jailhouse_irqchip irqchips[2];
	struct jailhouse_pci_device pci_devices[2];
} __attribute__((packed)) config = {
	.cell = {
		.signature = JAILHOUSE_CELL_DESC_SIGNATURE,
		.revision = JAILHOUSE_CONFIG_REVISION,
		.name = "linux-demo2",
		.flags = JAILHOUSE_CELL_PASSIVE_COMMREG |
			JAILHOUSE_CELL_VIRTUAL_CONSOLE_PERMITTED,

		.cpu_set_size = sizeof(config.cpus),
		.num_memory_regions = ARRAY_SIZE(config.mem_regions),
		.num_irqchips = ARRAY_SIZE(config.irqchips),
		.num_pci_devices = ARRAY_SIZE(config.pci_devices),

		.vpci_irq_base = 185-32,

		.console = {
			.address = 0xfe215040,
			.type = JAILHOUSE_CON_TYPE_8250,
			.flags = JAILHOUSE_CON_ACCESS_MMIO |
				 JAILHOUSE_CON_REGDIST_4,
		},
	},

	.cpus = {
		0b1000,
	},

	.mem_regions = {
		/* IVSHMEM shared memory regions (demo) */
		{
			.phys_start = 0x4faf0000,
			.virt_start = 0x4faf0000,
			.size = 0x1000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x4faf1000,
			.virt_start = 0x4faf1000,
			.size = 0x9000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x4fafa000,
			.virt_start = 0x4fafa000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
                JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x4fafc000,
			.virt_start = 0x4fafc000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
                JAILHOUSE_MEM_ROOTSHARED,
		},
		{
			.phys_start = 0x4fafe000,
			.virt_start = 0x4fafe000,
			.size = 0x2000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_ROOTSHARED,
		},
		/* IVSHMEM shared memory region */
		JAILHOUSE_SHMEM_NET_REGIONS(0x4fb00000, 1),
		/* UART */ {
			.phys_start = 0xfe215040,
			.virt_start = 0xfe215040,
			.size = 0x40,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_IO | JAILHOUSE_MEM_IO_8 |
				JAILHOUSE_MEM_IO_32 | JAILHOUSE_MEM_ROOTSHARED,
		},
		/* RAM */ {
			.phys_start = 0x4f900000,
			.virt_start = 0,
			.size = 0x10000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_LOADABLE,
		},
		/* RAM */ {
			.phys_start = 0x40000000,
			.virt_start = 0x40000000,
			.size = 0x08000000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_EXECUTE | JAILHOUSE_MEM_DMA |
				JAILHOUSE_MEM_LOADABLE,
		},
		/* communication region */ {
			.virt_start = 0x80000000,
			.size = 0x00001000,
			.flags = JAILHOUSE_MEM_READ | JAILHOUSE_MEM_WRITE |
				JAILHOUSE_MEM_COMM_REGION,
		},

	},

	.irqchips = {
		/* GIC */ {
			.address = 0xff841000,
			.pin_base = 32,
			.pin_bitmap = {
				0,
				0,
				1 << (125 - 96),
				0,
			},
		},
		/* GIC */ {
			.address = 0xff841000,
			.pin_base = 160,
			.pin_bitmap = {
				(1 << (185 - 160)) | (1 << (187 - 160)),
				0,
				0,
				0
			},
		},
	},

	.pci_devices = {
		{ /* IVSHMEM 00:00.0 (demo) */
			.type = JAILHOUSE_PCI_TYPE_IVSHMEM,
			.domain = 1,
			.bdf = 0 << 3,
			.bar_mask = JAILHOUSE_IVSHMEM_BAR_MASK_INTX,
			.shmem_regions_start = 0,
			.shmem_dev_id = 2,
			.shmem_peers = 3,
			.shmem_protocol = JAILHOUSE_SHMEM_PROTO_UNDEFINED,
		},
		{ /* IVSHMEM 00:01.0 (networking) */
			.type = JAILHOUSE_PCI_TYPE_IVSHMEM,
			.bdf = 2 << 3,
			.bar_mask = JAILHOUSE_IVSHMEM_BAR_MASK_INTX,
			.shmem_regions_start = 5,
			.shmem_dev_id = 1,
			.shmem_peers = 2,
			.shmem_protocol = JAILHOUSE_SHMEM_PROTO_VETH,
		},
	},
};

至于如何编译：

参考这个Makefile。

这个makefile用于放到 jailhouse/configs/abc目录下，编译abc这个目录下的所有.c 为.cell文件。

主要动作就2步：

1.gcc  demo1.c -o  demo1.o   -I../../hypervisor/arch/aarch64/include 

2.objcopy -O binary  demo1.o    demo1.cell

如果生成的.cell文件不太正确(x86上），就加上 --remove-section=.note.gnu.property，像这样

objcopy -O binary  --remove-section=.note.gnu.property demo1.o    demo1.cell  

XX = gcc
OBJCOPY=objcopy

ARCH=arm64


INCLUDE_DIRS =  -I$$PWD/../../hypervisor/arch/$(ARCH)/include \
		-I$$PWD/../../hypervisor/include \
		-I$$PWD/../../include


OBJDIR := objs
SRC=$(wildcard *.c)
OBJECTS:=$(patsubst %.c,%.o,$(SRC))
CELL:=$(patsubst %.c,%.cell,$(SRC))



all: MD  $(CELL)



OBJFLAGS = -O binary 
#--remove-section=.note.gnu.property

$(CELL) : %.cell : %.o
	$(OBJCOPY)  $(OBJFLAGS)  $(OBJDIR)/$<  $@  


$(OBJECTS)  : %.o : %.c
	$(XX) -c  $<  -o $(OBJDIR)/$@  $(INCLUDE_DIRS) 


MD:
	mkdir -p  $(OBJDIR)

.PHONY : clean

clean:
	rm -rf $(CELL) $(OBJDIR)/$(OBJECTS)

路边闲人2
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【Jailhouse】Jailhouse 介绍（一）
Jia ming 的日常学习笔记
05-07 2244
jailhouse 介绍（一）
【Jailhouse 文章】Jailhouse Hypervisor
Jia ming 的日常学习笔记
07-04 787
jailhouse 文章翻译，Jailhouse Hypervisor
嵌入式虚拟化平台jailhouse踩坑笔记
闲人的专栏
02-20 8379
简介 jailhouse是一个嵌入式系统的虚拟化工具，它的英文介绍如下，非常强调partition。实时性比较好，隔离的也比较好。 Jailhouse, a Linux-based partitioning hypervisor 由德国西门子开发。始于2013年11月。 版权：GPLv2 代码地址： https://github.com/siemens/jailhouse https://github.com/siemens/jailhouse-images 论文 Look Mum, n.
在x86机器上运行jailhouse
闲人的专栏
06-17 1700
jailhouse jaihouse提供了一个demo ,https://github.com/siemens/jailhouse-images可以用于编译一整套可用的demo。 适用于多个平台。编译过程主要参考https://blog.csdn.net/weixin_39541632/article/details/110422345 此demo可以生成多个平台所用的操作系统image。 ...
jaihouse介绍
ScilogyHunter的博客
04-02 887
本文来自jaihouse在github上的仓库readme第一段。
【Jailhouse 文章】Specific Electronic Platform to Test the Influence of Hypervisors on the Performance..
Jia ming 的日常学习笔记
07-17 284
jailhouse 文章，Specific Electronic Platform to Test the Influence of Hypervisors on the Performance of Embedded Systems(2022)
【Jailhouse】Erika RTOS
Jia ming 的日常学习笔记
10-24 1072
Erika RTOS v3
监狱：基于Linux的分区管理程序
02-03
监狱 介绍 Jailhouse是基于Linux的分区管理程序。 除了Linux，它还可以运行裸机应用程序或（适应的）操作系统。 为此，它以某种方式配置硬件平台的CPU和设备虚拟化功能，以使这些域（在此处称为“单元”）都不会以不可接受的方式相互干扰。 监狱监狱是为了简化而不是功能丰富而优化的。 与KVM或Xen等基于Linux的功能齐全的虚拟机管理程序不同，Jailhouse不支持CPU，RAM或设备等资源的过度使用。 它不执行调度，仅虚拟化软件中对平台必不可少且无法在硬件中进行分区的那些资源。 一旦启用了Jailhouse，它就会在裸机上运行，​​即可以完全控制硬件，不需要外部支持。 但是，与其他裸机管理程序相比，它是由​​普通Linux系统加载和配置的。 其管理界面基于Linux基础结构。 因此，您首先启动Linux，然后启用Jailhouse，最后拆分系统资源的一部分，并将它们分配给其他单元。 社区资源 项目首页： 源代码： ：siemens / jailhouse.git 演示和测试图像： 常见问题解答（FAQ）： 查看 IRC频道： Freenode，irc.
bao-hypervisor_betaversion
04-20
Bao-轻量级静态分区管理程序 介绍 Bao （汉语中的“bǎohù”，意思是“保护”）是一种轻量级的开源嵌入式管理程序，旨在提供强大的隔离和实时保证。 Bao提供了分区管理程序架构的最小的，从零开始的实现。 Bao主要针对混合关键性系统而设计，非常注重故障隔离和实时行为的隔离。 它的实现仅包括一个最小的特权软件薄层，这些软件利用ISA虚拟化支持来实现静态分区虚拟机管理程序体系结构：资源是在VM实例化时进行静态分区和分配的； 内存是使用两阶段转换静态分配的； IO仅是直通的； 虚拟中断直接映射到物理中断； 它实现了虚拟CPU与物理CPU的1-1映射，无需调度程序。 Bao没有外部依赖关系，例如，在运行不可信任的大型整体通用操作系统（例如Linux）的特权VM上，因此，它包含的TCB要小得多。 Bao最初以Armv8-A架构为目标，但是已经支持RISC-V架构。 受支持的（和正在进行的
虚拟化软件XEN安装与配置
07-16
Xen是一个基于虚拟硬件监控器技术的虚拟化软件。Xen运行在一个宿主linux系统上，提供同时引导启动多个linux实例的能力。每个由Xen生成的虚拟机，被称为domain 。新创建的domain需要为其安装一个操作系统，方可引导并使用。
hypervisor简介.pdf
10-30
hypervisor简介.pdf
jailhouse-two-inmates.zip
04-21
jailhouse在树莓派4B平台上 运行2个linux cell的配置文件。 操作系统使用 https://github.com/siemens/jailhouse-images提供的树莓派4B镜像。
jailhouse-master_hypervisor_
10-02
very clean hypervisor code by siemens!
基于树莓派4B的Jailhouse源码资源
06-03
在树莓派4B上构建Jailhouse环境。包含了：Linux 源码、bl31.bin、rootfs.cpio、jailhouse-0.12 源码、jailhouse-images-0.12 源码。
Linux系统分区详细解答
07-06
Linux系统分区 详细解答 !!!!!!!!!!!!!!!!!!!
Linux 网络排查命令
最新发布
学习记录
04-14 473
学习记录
【Linux】Linux信号
ZHENGZJM的博客
04-14 784
介绍Linux中信号的概率
jailhouse虚拟化linux
10-18
jailhouse是一种基于hypervisor的虚拟化技术，它可以将一个物理处理器分割成多个独立的虚拟处理器，每个虚拟处理器都可以运行一个独立的操作系统。jailhouse主要用于嵌入式系统中，可以提高系统的可靠性和安全性。 在jailhouse中，每个虚拟处理器都有自己的内存空间和I/O设备，它们之间通过IPC（Inter-Process Communication）进行通信。jailhouse还提供了一些安全机制，如防止虚拟处理器越界访问内存、防止虚拟处理器之间的干扰等。 jailhouse虚拟化linux时，需要将linux内核编译成一个可加载模块，并将其加载到jailhouse hypervisor中。在jailhouse中，linux内核运行在一个称为root cell的虚拟处理器中，其他虚拟处理器可以通过IPC与root cell进行通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

路边闲人2

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值