ตั้งแต่วันที่ 27 มีนาคม 2025 เป็นต้นไป เราขอแนะนำให้ใช้ android-latest-release
แทน aosp-main
เพื่อสร้างและมีส่วนร่วมใน AOSP โปรดดูข้อมูลเพิ่มเติมที่หัวข้อการเปลี่ยนแปลงใน AOSP
Microdroid
จัดทุกอย่างให้เป็นระเบียบอยู่เสมอด้วยคอลเล็กชัน
บันทึกและจัดหมวดหมู่เนื้อหาตามค่ากำหนดของคุณ
Microdroid เป็นระบบปฏิบัติการ Android ขนาดเล็กที่ทำงานใน pVM คุณไม่จำเป็นต้องใช้ Microdroid คุณสามารถเริ่ม VM โดยใช้ระบบปฏิบัติการใดก็ได้ อย่างไรก็ตาม Use Case หลักสำหรับ pVM ไม่ได้เป็นการเรียกใช้ระบบปฏิบัติการแบบสแตนด์อโลน แต่เป็นการนำเสนอสภาพแวดล้อมการเรียกใช้แบบแยกส่วนเพื่อเรียกใช้แอปบางส่วนที่มีการรับประกันความลับและความสมบูรณ์ที่ดีกว่าที่ Android มอบให้ได้
ในระบบปฏิบัติการแบบดั้งเดิม การรักษาความลับและความสมบูรณ์ที่เข้มงวดต้องใช้ความพยายามอย่างมาก (มักทำซ้ำกัน) เนื่องจากระบบปฏิบัติการแบบดั้งเดิมไม่เหมาะกับสถาปัตยกรรม Android ครอบจักรวาล ตัวอย่างเช่น เมื่อใช้สถาปัตยกรรม Android มาตรฐาน นักพัฒนาแอปต้องใช้วิธีโหลดและเรียกใช้แอปบางส่วนใน pVM อย่างปลอดภัย และสร้างเพย์โหลดกับ glibc แอป Android ใช้ Bionic, การสื่อสารต้องใช้โปรโตคอลที่กำหนดเองผ่าน vsock และการแก้ไขข้อบกพร่องโดยใช้ adb นั้นทำได้ยาก
Microdroid เติมเต็มช่องว่างเหล่านี้ด้วยการจัดหาภาพระบบปฏิบัติการสำเร็จรูปที่ออกแบบมาเพื่อให้นักพัฒนาแอปทำงานน้อยที่สุดในการย้ายข้อมูลบางส่วนของแอปไปยัง pVM โค้ดเนทีฟสร้างขึ้นโดยใช้ Bionic, การสื่อสารเกิดขึ้นผ่าน Binder และอนุญาตให้นําเข้า APEX จาก Android โฮสต์ รวมถึงแสดงชุดย่อยของ Android API เช่น คีย์สโตร์สําหรับการดำเนินการเข้ารหัสด้วยคีย์ที่รองรับฮาร์ดแวร์ โดยรวมแล้ว นักพัฒนาแอปควรพบว่า Microdroid เป็นสภาพแวดล้อมที่คุ้นเคยด้วยเครื่องมือที่พวกเขาคุ้นเคยในระบบปฏิบัติการ Android แบบสมบูรณ์
ฟีเจอร์
Microdroid เป็น Android เวอร์ชันที่ตัดองค์ประกอบบางอย่างออกและมีคอมโพเนนต์เพิ่มเติมอีก 2-3 อย่างสำหรับ pVM โดยเฉพาะ Microdroid รองรับการดำเนินการต่อไปนี้
- ชุดย่อยของ NDK API (มี API ทั้งหมดสําหรับการใช้งาน libc และ Bionic ของ Android)
- ฟีเจอร์การแก้ไขข้อบกพร่อง เช่น adb, logcat, tombstone และ gdb
- การเปิดเครื่องที่ได้รับการยืนยันและ SELinux
- การโหลดและเรียกใช้ไบนารีพร้อมกับไลบรารีที่ใช้ร่วมกันซึ่งฝังอยู่ใน APK
- Binder RPC ผ่าน vsock และการแลกเปลี่ยนไฟล์ที่มีการตรวจสอบความสมบูรณ์โดยนัย
- การโหลด APEX
Microdroid ไม่รองรับรายการต่อไปนี้
สถาปัตยกรรม Microdroid
Microdroid คล้ายกับ Cuttlefish ตรงที่ทั้ง 2 แพลตฟอร์มมีสถาปัตยกรรมที่คล้ายกับ Android มาตรฐาน Microdroid ประกอบด้วยพาร์ติชันต่อไปนี้ซึ่งจัดกลุ่มรูปภาพไว้ด้วยกันในภาพดิสก์แบบคอมโพสิต
bootloader
- ยืนยันและเริ่มเคอร์เนล
boot.img
- มีเคอร์เนลและ init ramdisk
vendor_boot.img
- มีโมดูลเคอร์เนลสำหรับ VM โดยเฉพาะ เช่น virtio
super.img
- ประกอบด้วยพาร์ติชันตรรกะของระบบและผู้ให้บริการ
vbmeta.img
- มีข้อมูลเมตาของการเปิดเครื่องที่ได้รับการยืนยัน
อิมเมจพาร์ติชันจะมาพร้อมกับ APEX การจำลองเสมือนและจะบรรจุอยู่ในอิมเมจดิสก์คอมโพสิตโดย VirtualizationService
นอกเหนือจากภาพดิสก์คอมโพสิตหลักของ OS แล้ว VirtualizationService
ยังมีหน้าที่สร้างพาร์ติชันอื่นๆ ต่อไปนี้ด้วย
payload
- ชุดพาร์ติชันที่สำรองข้อมูลโดย APEX และ APK ของ Android
instance
- พาร์ติชันที่เข้ารหัสสำหรับการจัดเก็บข้อมูลการบูตที่ยืนยันแล้วของอินสแตนซ์แต่ละรายการ เช่น Salt ของอินสแตนซ์แต่ละรายการ คีย์สาธารณะ APEX ที่เชื่อถือได้ และตัวนับการย้อนกลับ
ลำดับการบูต
ลำดับการบูต Microdroid จะเกิดขึ้นหลังจากการบูตอุปกรณ์ การบูตอุปกรณ์จะกล่าวถึงในส่วนเฟิร์มแวร์ pVM ของเอกสารสถาปัตยกรรม รูปที่ 1 แสดงขั้นตอนที่เกิดขึ้นระหว่างลําดับการบูตของ Microdroid
รูปที่ 1 ขั้นตอนการเปิดเครื่องที่ปลอดภัยของอินสแตนซ์ microdroid
ต่อไปนี้เป็นคำอธิบายขั้นตอนต่างๆ
crosvm จะโหลดบูตโหลดเดอร์ลงในหน่วยความจำและ pvmfw เริ่มทำงาน pvmfw จะทํางาน 2 อย่างก่อนข้ามไปยังบูตโหลดเดอร์
- ตรวจสอบ Bootloader เพื่อดูว่ามาจากแหล่งที่มาที่เชื่อถือได้หรือไม่ (Google หรือ OEM)
- ตรวจสอบว่ามีการใช้บูตโหลดเดอร์เดียวกันอย่างสม่ำเสมอในการบูต pVM เดียวกันหลายครั้งผ่านการใช้รูปภาพอินสแตนซ์ กล่าวโดยละเอียดคือ pVM จะบูตด้วยอิมเมจอินสแตนซ์ที่ว่างเปล่าในตอนแรก pvmfw จะจัดเก็บข้อมูลประจำตัวของบูตโหลดเดอร์ไว้ในอิมเมจอินสแตนซ์และเข้ารหัส ดังนั้น เมื่อบูต pVM ด้วยอิมเมจอินสแตนซ์เดียวกันในครั้งถัดไป pvmfw จะถอดรหัสข้อมูลประจำตัวที่บันทึกไว้จากอิมเมจอินสแตนซ์ และยืนยันว่าข้อมูลดังกล่าวเหมือนกับที่บันทึกไว้ก่อนหน้านี้ หากข้อมูลระบุตัวตนแตกต่างกัน pvmfw จะไม่ยอมบูต
จากนั้น Bootloader จะบูต Microdroid
โปรแกรมโหลดบูตจะเข้าถึงดิสก์อินสแตนซ์ บูตโหลดเดอร์มีไดรฟ์ดิสก์อินสแตนซ์ที่มีข้อมูลเกี่ยวกับอิมเมจพาร์ติชันที่ใช้ในอินสแตนซ์นี้ระหว่างการบูตก่อนหน้านี้ รวมถึงคีย์สาธารณะ ซึ่งคล้ายกับ pvmfw
Bootloader จะยืนยัน vbmeta และพาร์ติชันที่ลิงก์กัน เช่น boot
และ super
และหากยืนยันสำเร็จ ก็จะดึงข้อมูลลับ pVM ระยะถัดไป
จากนั้น Microdroid จะส่งการควบคุมไปยังเคอร์เนล
เนื่องจากบูตโหลดเดอร์ได้ยืนยันพาร์ติชันซุปเปอร์แล้ว (ขั้นตอนที่ 3) เคอร์เนลจึงมาสก์พาร์ติชันซุปเปอร์โดยไม่มีเงื่อนไข เช่นเดียวกับ Android แบบสมบูรณ์ พาร์ติชันซุปเปอร์ประกอบด้วยพาร์ติชันตรรกะหลายรายการที่ติดตั้งบน dm-verity จากนั้นระบบจะส่งการควบคุมไปยังกระบวนการ init
ซึ่งจะเริ่มต้นบริการเนทีฟต่างๆ สคริปต์ init.rc
คล้ายกับสคริปต์ของ Android แบบเต็ม แต่ปรับให้เหมาะกับความต้องการของ Microdroid
กระบวนการ init
จะเริ่มต้นตัวจัดการ Microdroid ซึ่งจะเข้าถึงอินสแตนซ์
image บริการจัดการ Microdroid จะถอดรหัสรูปภาพโดยใช้คีย์ที่ส่งมาจากระยะก่อนหน้า และอ่านคีย์สาธารณะและตัวนับการย้อนกลับของ APK และ APEX ของไคลเอ็นต์ที่ pVM นี้เชื่อถือ zipfuse
และ apexd
จะใช้ข้อมูลนี้ในภายหลังเมื่อมาเทมเพลต APK ของลูกค้าและ APEX ที่ขอตามลำดับ
บริการตัวจัดการ Microdroid จะเริ่มในวันที่ apexd
apexd
จะต่อเชื่อม APEX ในไดเรกทอรี /apex/<name>
ความแตกต่างเพียงอย่างเดียวระหว่างวิธีที่ Android และ Microdroid ใส่ APEX คือใน Microdroid ไฟล์ APEX มาจากอุปกรณ์บล็อกเสมือน (/dev/vdc1
, …), ไม่ใช่จากไฟล์ปกติ (/system/apex/*.apex
)
zipfuse
คือระบบไฟล์ FUSE ของ Microdroid zipfuse
จะต่อเชื่อม APK ของลูกค้า ซึ่งโดยพื้นฐานแล้วคือไฟล์ Zip ที่เป็นระบบไฟล์ ด้านล่างนี้ pVM จะส่งไฟล์ APK เป็นอุปกรณ์บล็อกเสมือนด้วย dm-verity เช่นเดียวกับ APEX APK มีไฟล์การกําหนดค่าที่มีรายการ APEX ที่ผู้พัฒนาแอปขอสําหรับอินสแตนซ์ pVM นี้ apexd
จะใช้รายการนี้เมื่อเปิดใช้งาน APEX
ขั้นตอนการบูตจะกลับไปที่บริการจัดการ Microdroid จากนั้นบริการผู้จัดการจะสื่อสารกับ VirtualizationService
ของ Android โดยใช้ Binder RPC เพื่อให้รายงานเหตุการณ์สำคัญ เช่น ข้อขัดข้องหรือการปิดระบบ และยอมรับคำขอต่างๆ เช่น การสิ้นสุด pVM บริการจัดการจะอ่านตำแหน่งของไบนารีหลักจากไฟล์กำหนดค่าของ APK แล้วดำเนินการ
การแลกเปลี่ยนไฟล์ (AuthFS)
คอมโพเนนต์ Android มักใช้ไฟล์สำหรับอินพุต เอาต์พุต และสถานะ และส่งไฟล์เหล่านี้เป็นไฟล์ข้อมูล (ParcelFileDescriptor
พิมพ์ใน IDE) ของไฟล์ที่มีการควบคุมการเข้าถึงโดยเคอร์เนล Android AuthFS ช่วยให้การดำเนินการที่คล้ายกันสำหรับการแลกเปลี่ยนไฟล์ระหว่างอุปกรณ์ปลายทางที่ไม่ไว้ใจกันข้ามขอบเขต pVM เป็นไปได้
โดยพื้นฐานแล้ว AuthFS คือระบบไฟล์ระยะไกลที่มีการตรวจสอบความสมบูรณ์แบบโปร่งใสในการดำเนินการเข้าถึงแต่ละรายการ ซึ่งคล้ายกับ fs-verity
การตรวจสอบช่วยให้ส่วนหน้า เช่น โปรแกรมอ่านไฟล์ที่ทำงานใน pVM ตรวจจับได้ว่าแบ็กเอนด์ที่ไม่น่าเชื่อถือ ซึ่งโดยปกติจะเป็น Android มีการดัดแปลงเนื้อหาไฟล์หรือไม่
หากต้องการแลกเปลี่ยนไฟล์ ระบบจะเริ่มต้นแบ็กเอนด์ (fd\_server
) ด้วยการกำหนดค่าไฟล์ต่อไฟล์ที่ระบุว่าไฟล์มีไว้สำหรับอินพุต (อ่านอย่างเดียว) หรือเอาต์พุต (อ่านและเขียน) สำหรับอินพุต ฟรอนต์เอนด์จะบังคับให้เนื้อหาตรงกับแฮชที่รู้จัก บนยอดของต้นไม้ Merkle เพื่อการยืนยันเมื่อเข้าถึง สำหรับเอาต์พุต AuthFS จะดูแลรักษาต้นไม้แฮชของเนื้อหาที่สังเกตได้จากการดำเนินการเขียนภายใน และสามารถบังคับใช้ความสมบูรณ์ได้เมื่ออ่านข้อมูลกลับ
ปัจจุบันการขนส่งพื้นฐานอิงตาม Binder RPC แต่อาจเปลี่ยนแปลงในอนาคตเพื่อเพิ่มประสิทธิภาพ
การจัดการคีย์
pVM มีคีย์การปิดผนึกที่เสถียรซึ่งเหมาะสำหรับปกป้องข้อมูลถาวร และคีย์การรับรองที่เหมาะสำหรับการสร้างลายเซ็นที่ pVM สร้างขึ้นและตรวจสอบได้
Binder RPC
อินเทอร์เฟซส่วนใหญ่ของ Android จะแสดงเป็น AIDL ซึ่งสร้างขึ้นจากไดรเวอร์เคอร์เนล Binder Linux โปรโตคอล Binder ได้รับการเขียนใหม่ให้ทำงานผ่านซ็อกเก็ต vsock ในกรณีของ pVM เพื่อรองรับอินเทอร์เฟซระหว่าง pVM การทำงานผ่านซ็อกเก็ตช่วยให้ใช้อินเทอร์เฟซ AIDL ที่มีอยู่ของ Android ในสภาพแวดล้อมใหม่นี้ได้
หากต้องการตั้งค่าการเชื่อมต่อ อุปกรณ์ปลายทาง 1 เครื่อง เช่น เพย์โหลด pVM จะสร้างออบเจ็กต์ RpcServer
ลงทะเบียนออบเจ็กต์รูท และเริ่มรอการเชื่อมต่อใหม่ ไคลเอ็นต์สามารถเชื่อมต่อกับเซิร์ฟเวอร์นี้โดยใช้ออบเจ็กต์ RpcSession
รับออบเจ็กต์ Binder
และใช้ออบเจ็กต์ดังกล่าวได้เหมือนกับการใช้ออบเจ็กต์ Binder
กับไดรเวอร์ Binder ของเคอร์เนล
ตัวอย่างเนื้อหาและโค้ดในหน้าเว็บนี้ขึ้นอยู่กับใบอนุญาตที่อธิบายไว้ในใบอนุญาตการใช้เนื้อหา Java และ OpenJDK เป็นเครื่องหมายการค้าหรือเครื่องหมายการค้าจดทะเบียนของ Oracle และ/หรือบริษัทในเครือ
อัปเดตล่าสุด 2025-07-27 UTC
[[["เข้าใจง่าย","easyToUnderstand","thumb-up"],["แก้ปัญหาของฉันได้","solvedMyProblem","thumb-up"],["อื่นๆ","otherUp","thumb-up"]],[["ไม่มีข้อมูลที่ฉันต้องการ","missingTheInformationINeed","thumb-down"],["ซับซ้อนเกินไป/มีหลายขั้นตอนมากเกินไป","tooComplicatedTooManySteps","thumb-down"],["ล้าสมัย","outOfDate","thumb-down"],["ปัญหาเกี่ยวกับการแปล","translationIssue","thumb-down"],["ตัวอย่าง/ปัญหาเกี่ยวกับโค้ด","samplesCodeIssue","thumb-down"],["อื่นๆ","otherDown","thumb-down"]],["อัปเดตล่าสุด 2025-07-27 UTC"],[],[],null,["# Microdroid is a mini-Android OS that runs in a pVM. You don't have to use\nMicrodroid, you can start a VM with any OS. However, the primary use cases\nfor pVMs aren't running a standalone OS but rather offering an isolated\nexecution environment for running a portion of an app with stronger\nconfidentiality and integrity guarantees than Android can provide.\n\nWith traditional operating systems, providing strong confidentiality and\nintegrity requires a fair amount of work (often duplicated)\nbecause traditional operating systems don't fit with the overarching Android\narchitecture. For example, with the standard Android architecture, developers\nneed to implement a means of securely loading and executing part of their app\nin the pVM, and the payload is built against glibc. The Android app uses\nBionic, communication requires a custom protocol over vsock, and debugging using\nadb is challenging.\n\nMicrodroid fills these gaps by providing an off-the-shelf OS image designed to\nrequire the least amount of effort from developers to offload a portion of\ntheir app into a pVM. Native code is built against Bionic, communication happens\nover Binder, and it allows importing APEXes from the host Android and exposes\na subset of the Android API, such as keystore for cryptographic operations with\nhardware-backed keys. Overall, developers should find Microdroid a familiar\nenvironment with the tools they've grown accustomed in the full Android OS.\n\nFeatures\n--------\n\nMicrodroid is a stripped down version of Android with a few additional\ncomponents specific to pVMs. Microdroid supports:\n\n- A subset of NDK APIs (all APIs for Android's implementation of libc and Bionic are provided)\n- Debugging features, such as adb, logcat, tombstone, and gdb\n- Verified Boot and SELinux\n- Loading and executing a binary, together with shared libraries, embedded in an APK\n- Binder RPC over vsock and exchange of files with implicit integrity checks\n- Loading of APEXes\n\nMicrodroid doesn't support:\n\n- Android Java APIs in the `android.\\*` packages\n\n | **Note:** Core Java APIs in the `java.\\*` packages can be supported by activating the ART APEX in the VM.\n- SystemServer and Zygote\n\n- Graphics/UI\n\n- HALs\n\nMicrodroid architecture\n-----------------------\n\nMicrodroid is similar to\n[Cuttlefish](/docs/devices/cuttlefish) in that both have an architecture that's\nsimilar to standard Android. Microdroid consists of the following partition\nimages grouped together in a composite disk image:\n\n- `bootloader` - Verifies and starts the kernel.\n- `boot.img` - Contains the kernel and init ramdisk.\n- `vendor_boot.img` - Contains VM-specific kernel modules, such as virtio.\n- `super.img` - Consists of system and vendor logical partitions.\n- `vbmeta.img` - Contains verified boot metadata.\n\nThe partition images ship in the Virtualization APEX and are packaged in\na composite disk image by `VirtualizationService`. In addition to the main\nOS composite disk image, `VirtualizationService` is responsible for creating\nthese other partitions:\n\n- `payload` - A set of partitions backed by Android's APEXes and APKs\n- `instance` - An encrypted partition for persisting per-instance verified boot data, such as per-instance salt, trusted APEX public keys, and rollback counters\n\nBoot sequence\n-------------\n\nThe Microdroid boot sequence occurs after\n[Device boot](/docs/core/virtualization/architecture#device-boot). Device boot is\ndiscussed in the pVM Firmware section of the [Architecture](/docs/core/virtualization/architecture)\ndocument. Figure 1 shows the steps that take place during the Microdroid boot\nsequence:\n\n\n**Figure 1.** Secure bootflow of microdroid instance\n\n\u003cbr /\u003e\n\nHere's an explanation of the steps:\n\n1. The bootloader is loaded into memory by crosvm and pvmfw starts\n executing. Before jumping to the bootloader, pvmfw performs two tasks:\n\n - Verifies the bootloader to check if it is from a trusted source (Google or an OEM).\n - Ensures that the same bootloader is used consistently across multiple boots of the same pVM through the use of the instance image. Specifically, the pVM is initially booted with an empty instance image. pvmfw stores the identity of the bootloader in the instance image and encrypts it. So, the next time the pVM is booted with the same instance image, pvmfw decrypts the saved identity from the instance image and verifies that it's the same that was previously saved. If the identities differ, pvmfw refuses to boot.\n\n The bootloader then boots Microdroid.\n2. The bootloader accesses the instance disk. Similar to pvmfw, the\n bootloader has an instance disk drive with information about partition images\n used in this instance during previous boots, including the public key.\n\n3. The bootloader verifies vbmeta and the chained partitions, such as `boot`\n and `super`, and, if successful, derives the next-stage pVM secrets.\n Then, Microdroid hands control over to the kernel.\n\n4. Because the super partition has already been verified by the bootloader\n (step 3), the kernel unconditionally mounts the super partition. As with the\n full Android, the super partition consists of multiple logical partitions\n mounted over dm-verity. Control is then passed to the `init` process, which\n starts various native services. The `init.rc` script is similar to that of full\n Android but tailored to the needs of Microdroid.\n\n5. The `init` process starts the Microdroid manager, which accesses the instance\n image. The Microdroid manager service decrypts the image using the key passed\n from the previous stage and reads the public keys and rollback counters of the\n client APK and APEXes that this pVM trusts. This information is used later by\n `zipfuse` and `apexd` when they mount the client APK and requested APEXes,\n respectively.\n\n6. The Microdroid manager service starts `apexd`.\n\n7. `apexd` mounts the APEXes at `/apex/\u003cname\u003e` directories. The only difference\n between how Android and Microdroid mount APEXes is that in\n Microdroid, the APEX files are coming from virtual block devices\n (`/dev/vdc1`, ...), not from regular files (`/system/apex/*.apex`).\n\n8. `zipfuse` is Microdroid's FUSE file system. `zipfuse` mounts the client APK,\n which is essentially a Zip file as a file system. Underneath, the APK file is\n passed as a virtual block device by the pVM with dm-verity, same as APEX. The\n APK contains a config file with a list of APEXes that the app developer has\n requested for this pVM instance. The list is used by `apexd` when activating\n APEXes.\n\n9. The boot flow returns to the Microdroid manager service. The manager\n service then communicates with Android's `VirtualizationService` using\n Binder RPC so that it can report important events like crash or shutdown,\n and accept requests such as terminating the pVM. The manager service reads the\n location of the main binary from the APK's config file and executes it.\n\nFile exchange (AuthFS)\n----------------------\n\nIt's common for Android components to use files for input, output, and state\nand to pass these around as file descriptors (`ParcelFileDescriptor` type in\nAIDL) with access controlled by the Android kernel. AuthFS facilitates similar\nfunctionality for exchanging files between mutually distrusting endpoints\nacross pVM boundaries.\n\nFundamentally, AuthFS is a remote file system with transparent integrity checks\non individual access operations, similar to `fs-verity`. The checks allow the\nfrontend, such as a file-reading program running in a pVM, to detect if the\nuntrusted backend, typically Android, tampered with file content.\n\nTo exchange files, the backend (`fd\\_server`) is started with per-file\nconfiguration specifying whether it's meant for input (read-only) or output\n(read-write). For input, the frontend enforces that the contents match a known\nhash, on top of a Merkle tree for on-access verification. For output, AuthFS\ninternally maintains a hash tree of the contents as observed from write\noperations and can enforce integrity when the data are read back.\n\nThe underlying transport is currently based on Binder RPC, however that might\nchange in the future to optimize performance.\n\nKey management\n--------------\n\npVMs are provided with a stable *sealing key* that's suitable for protecting\npersistent data, and an *attestation key* that's suitable for producing\nsignatures that are verifiably produced by the pVM.\n\nBinder RPC\n----------\n\nA majority of Android's interfaces are expressed in\n[AIDL](https://developer.android.com/guide/components/aidl), which\nis built on top of the Binder Linux kernel driver. To support interfaces\nbetween pVMs, the Binder protocol has been rewritten to work over sockets,\n[vsock](/docs/core/virtualization/virtualization-service#vm-sockets)\nin the case of pVMs. Operating over sockets allows Android's existing AIDL\ninterfaces to be used in this new environment.\n\nTo set up the connection, one endpoint, such as pVM payload, creates\nan `RpcServer` object, registers a root object, and begins listening for new\nconnections. Clients can connect to this server using an `RpcSession` object,\nget the `Binder` object, and use it exactly like a `Binder` object is used\nwith the kernel Binder driver."]]