Difference between revisions of "ARM Port"

From ReactOS Wiki
Jump to: navigation, search
(General update)
(The Plan)
 
(86 intermediate revisions by 2 users not shown)
Line 1: Line 1:
'''ReactOS 32-bit ARM port''' was created by [[ReactOS Portable Systems Group]] back in 2008. Originally it was designed for ARMv5 and ARMv4, but these cores have an MMU that is incompatible with ReactOS/Windows requirements, and lacks instructions needed for synchronization done in user-mode, so currently the port targets '''ARMv7 compatible''' cores.
+
'''ReactOS 32-bit ARM port''' was started by [[ReactOS Portable Systems Group]] back in 2008. Originally it was designed for ARMv5 and ARMv4, but these cores have an MMU that is incompatible with ReactOS/Windows multiprocessor requirements, and lacks instructions needed for synchronization done in user-mode, so currently the port targets '''ARMv7 compatible''' cores.
 +
 
 +
It should be possible to port to ARMv6 and possibly older ARM architecture revisions, but currently it's postponed and the system will be operable only in single-processor mode in these cases.
  
 
Since the GCC compiler has dropped the support for ARM PE executables, and the project had to upgrade GCC version, the port become unmaintained somewhere back in 2015 (see [[#Known facts]] section).
 
Since the GCC compiler has dropped the support for ARM PE executables, and the project had to upgrade GCC version, the port become unmaintained somewhere back in 2015 (see [[#Known facts]] section).
  
However in November 2018 Microsoft has been added official ARM and ARM64 target support into Visual Studio 15.9, so now it is possible to bring the port back to life!
+
However in November 2018 Microsoft has added official ARM and ARM64 target support into Visual Studio 15.9, so now it is possible to bring the port back to life!
  
 
Follow the discussion in this thread: https://reactos.org/forum/viewtopic.php?f=2&t=17977
 
Follow the discussion in this thread: https://reactos.org/forum/viewtopic.php?f=2&t=17977
Line 11: Line 13:
 
* '''15 Oct 2009''': ''Last commit by ReactOS Portable Systems Group.'' [https://github.com/reactos/reactos/commit/e233c46dec1b9ebc720eac567d96d21f3c886281]
 
* '''15 Oct 2009''': ''Last commit by ReactOS Portable Systems Group.'' [https://github.com/reactos/reactos/commit/e233c46dec1b9ebc720eac567d96d21f3c886281]
 
* '''22 Mar 2012''': ''GCC 4.7.0 has dropped support for ARM PE executables.'' [https://gcc.gnu.org/gcc-4.7/changes.html] [https://reactos.org/forum/viewtopic.php?t=16576#p126960]
 
* '''22 Mar 2012''': ''GCC 4.7.0 has dropped support for ARM PE executables.'' [https://gcc.gnu.org/gcc-4.7/changes.html] [https://reactos.org/forum/viewtopic.php?t=16576#p126960]
 +
* '''22 Jul 2012''': ''Timo Kreuzer has added support for MSVC ARM build.'' [https://github.com/reactos/reactos/commit/d62e513aad7ad698564594650ff33ff1ff28be2a]
 
* '''15 May 2015''': ''Beginning with r67740 ReactOS builds for ARM, too. Timo Kreuzer made some effort to get it build and succeeded.'' [https://www.dreimer.de/?p=1212]
 
* '''15 May 2015''': ''Beginning with r67740 ReactOS builds for ARM, too. Timo Kreuzer made some effort to get it build and succeeded.'' [https://www.dreimer.de/?p=1212]
 
* '''15 Nov 2018''': ''Microsoft announced official ARM target support for Visual Studio 2017.'' [https://blogs.windows.com/buildingapps/2018/11/15/official-support-for-windows-10-on-arm-development/]
 
* '''15 Nov 2018''': ''Microsoft announced official ARM target support for Visual Studio 2017.'' [https://blogs.windows.com/buildingapps/2018/11/15/official-support-for-windows-10-on-arm-development/]
* '''19 Nov 2018''': ''Support for VS2017 (15.0) compiler was added.'' [https://github.com/reactos/reactos/commit/f6f1255cf7b9166645092130576a40ee44932227]
+
* '''19 Nov 2018''': ''Support for VS2017 (15.9) compiler was added.'' [https://github.com/reactos/reactos/commit/f6f1255cf7b9166645092130576a40ee44932227]
 +
* '''31 May 2019''': ''A big streak of Pull Requests from woachk related to ARM port, totally not a coincidence.'' [https://chat.reactos.org/reactos/pl/6x1c9kbqwtntzkcce97f1s4b1a] [https://github.com/reactos/reactos/pulls?q=is%3Apr+author%3Awoachk]
 +
* '''17 Aug 2019''': ''Configure option <code>WITH_HOST_TOOLS</code> added to allow cross-compiling to ARM.'' [https://github.com/reactos/reactos/commit/f67345320fdc400e2f354c4eed915fee96eb01b4]
 +
* '''20 Aug 2019''': ''Fixed some ARM compilation problems.'' [https://github.com/reactos/reactos/commits/9853eab1ea16d84591d46aa0cf1ac044b05d49e0][https://github.com/reactos/reactos/pull/1855]
 +
* '''26 Apr 2020''': ''ReactOS Applications Manager was able to start on Windows 10 for ARM32.'' [https://user-images.githubusercontent.com/578406/80280599-b937fc00-870d-11ea-8d6e-588e99088e3c.png]
 +
* '''22 Oct 2020''': ''Building host-tools for the host architecture has been broken, so building ARM binaries on x86 and x64 hosts is not possible.'' [https://jira.reactos.org/browse/CORE-17542]
 +
* '''11 Apr 2021''': ''A new Pull Request with cross-compilation fix has been opened, so building for ARM hopefully will be fixed'' [https://github.com/reactos/reactos/pull/3602]
 +
* '''24 May 2021''': ''ARM cross-compilation has been fixed and simplified. GitHub ARM builders were added (Visual Studio 2017 and 2019), for now only <code>rapps</code> is built. Also it is possible to run ReactOS Calculator on Windows 10 for ARM32.'' [https://github.com/reactos/reactos/commits/c1538a82b88a8043d3541aa09ddfda5197cdea96][https://twitter.com/x86corez/status/1396918979533361157]
 +
* '''28 May 2021''': ''A Jira ticket was created to track problems and progress on ARM port.'' [https://jira.reactos.org/browse/CORE-17604]
 +
* '''9 Sep 2021''': ''Most CRT bugs have been fixed, ReactOS applications are mostly working with Windows on ARM.'' [https://github.com/reactos/reactos/commits/3f4c98a425fb42f346ec01007860133e849330ca]
 +
* '''21 Sep 2021''': ''ReactOS Explorer and System Properties control panel applet are working in Windows 10 ARM with classic theme enabled.'' [https://twitter.com/reactos/status/1440277259038773252]
 +
* '''17 Nov 2021''': ''All applications (base and rosapps) and control panel applets are now built without errors. Now it's possible to download ARM build artifacts (both debug and release + symbols) from GitHub Actions CI.'' [https://github.com/reactos/reactos/commit/f8010947fefc802c99f315f60d18d746b8a7f13e][https://twitter.com/reactos/status/1461399438627422210]
 +
* '''18 Mar 2022''': ''Entire base module is now built without errors. You can now download full ReactOS Shell compiled for ARM (<code>explorer.exe</code>, <code>rshell.dll</code>) from GitHub Actions.'' [https://github.com/reactos/reactos/commit/40fe3e5dd99ace99e7a36fa9b1dcc8aa4e0cb8b7]
 +
* '''8 May 2022''': ''[[User:binarymaster|Stas'M]] in cooperation with [[User:driver1998|driver1998]] were able to patch QEMU to make Windows RT emulation possible. This work will be reused in ReactOS ARM port development.'' [https://twitter.com/x86corez/status/1523303255438028800]
  
 
== Building ==
 
== Building ==
  
=== Visual Studio 2017 ===
+
=== Visual Studio ===
  
 
This is recommended build method. Please refer to these articles:
 
This is recommended build method. Please refer to these articles:
Line 25: Line 41:
 
* https://blogs.windows.com/buildingapps/2018/11/15/official-support-for-windows-10-on-arm-development/ - and now officially with Visual Studio 15.9
 
* https://blogs.windows.com/buildingapps/2018/11/15/official-support-for-windows-10-on-arm-development/ - and now officially with Visual Studio 15.9
  
==== General TODO list ====
+
==== Building steps ====
 +
[[File:vsarm.png|220px|thumb|frame|Visual Studio ARM cross-compilation tools]]
 +
 
 +
You will need latest [[RosBE]] and Visual Studio 2017 or 2019 installed. It would work with VS community edition as well.
 +
 
 +
* Make sure you have selected ''"Add BIN folder to PATH variable"'' when installing RosBE (see [[Visual Studio]] for details)
 +
** If you have RosBE installed but did not selected this option earlier, you need to add <code>C:\RosBE\Bin</code> (or your installation directory) to the PATH environment variable
 +
* Start VS command prompt '''for ARM cross-compilation'''
 +
** Normally you should have ''"x64_arm Cross Tools Command Prompt for VS"'' shortcut in your Start Menu within Visual Studio section
 +
** If you don't have it, make sure you have selected ARM cross-compilation tools in VS installer
 +
** If the tools are installed but there is still no shortcut, you can create it manually:<br><code>%comspec% /k "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsamd64_arm.bat"</code> (replace with your VS installation path)
 +
* Make sure to set <code>BISON_PKGDATADIR</code> and <code>M4</code> variables as described in [[Visual Studio]]
 +
* Run <code>configure.cmd</code>
 +
* Type <code>cd output-VS-arm</code> and run <code>ninja rapps</code> or <code>ninja calc</code>, or just <code>ninja -k 1</code> to build everything (in latter case there will be lots of build errors to fix)
 +
 
 +
==== Debugging steps ====
 +
The steps below are describing how to debug ReactOS applications built for ARM architecture on Windows platform. It's important to ensure our applications are running there without problems.
 +
 
 +
* You will need Windows on ARM environment (or just WoA) and WinDbg debugger
 +
** Most devices/computers with Windows 10 ARM64 would work
 +
** Windows RT devices are okay in case you are able to run non-signed code there
 +
* Get WinDbg debugger for ARM architecture (available in [https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk/ Windows 10 SDK])
 +
** Once installed, it's usually located in <code>C:\Program Files (x86)\Windows Kits\10\Debuggers\arm</code>
 +
* Set debug symbols path to <code>C:\path\to\reactos\output-VS-arm\msvc_pdb</code> (see [[WinDBG#Symbols]] for details)
 +
* Build wanted application for ARM and start it with WinDbg in WoA environment
 +
* Debugging experience should be the same as usual at this point, if you are not familiar with it, see [[WinDBG]]
 +
 
 +
=== RosBE (outdated) ===
 +
<div class="toccolours mw-collapsible mw-collapsed">
 +
: ''This build method has not been maintained for some years and may not work.''
 +
<div class="mw-collapsible-content">
 +
 
 +
<hr>
 +
 
 +
 
 +
Obtain the React OS Build Environment for ARM (RosBE-ARM). The latest version is
 +
1.0 and available from: https://download.reactos.org/reactos/RosBE-Windows/arm/1.0/RosBE-ARM-1.0.exe
 +
 
 +
Launch the RosBE-ARM command prompt, and type <code>makex</code> on the command line. After
 +
some minutes, you should have the whole tree built.
 +
</div>
 +
</div>
 +
 
 +
== The Plan ==
 +
This is the general todo list with rough estimates in order to revive the ARM port.
  
* Make <code>configure.cmd</code> detect the Visual Studio 15.9 environment
+
{| class="wikitable"
* Make sure it detects and builds both x86 and x64 ports successfully
+
! Task
* Add ARM target support to the <code>configure.cmd</code> build script
+
! Completion
* Fix the ARM port build so it can generate <code>bootcd-arm.iso</code> and <code>livecd-arm.iso</code>
+
! Comments
* Once the whole tree is built without issues, one can step into the development
+
|-
 +
| Add ARM target support to the <code>configure.cmd</code> build script || 100% || Works perfectly with MSVC
 +
|-
 +
| Create MSVC ARM builder in our GitHub CI so we notice when stuff is broken || 75% || We only build applications (base and rosapps) and control panel applets for now
 +
|-
 +
| Make ReactOS applications work with Windows on ARM without crashes || 90% || Missing functions: atan, ldexp, log10, _logb, tan
 +
* See existing tickets in this Jira epic: {{JIRA|17604}}
 +
* Fix remaining problems in our CRT and SDK: possibly sync with newer versions of upstream components
 +
|-
 +
| Fix build errors for all modules || 40% || There are a lot of errors in ntoskrnl and dll's
 +
|-
 +
| Build ISO images <code>bootcd-arm.iso</code> and <code>livecd-arm.iso</code> || 20% || Build proper EFI-bootable ISO images with El-Torito specification
 +
* Issue with <code>bootcd</code> - see [https://chat.reactos.org/reactos/pl/a73xdzn3x3bw9f1cp7ooteuahc message in chat]
 +
* [https://github.com/reactos/reactos/pull/4407 PR #4407 (merged)]
 +
* [https://github.com/reactos/reactos/pull/4407 PR #4425]
 +
|-
 +
| Work on bootloader || 25% || [[UEFI]] version of FreeLoader is being worked on: [[UEFI Freeldr]]. ARM boot support is in progress
 +
|-
 +
|}
  
  
 
These pages may be helpful to accomplish the tasks above:
 
These pages may be helpful to accomplish the tasks above:
* [[Building with MSVC]]
+
* [[Building ReactOS#Windows.2FMSVC|Building with MSVC]]
 
* [[AMD64#Building amd64 port|AMD64 building instructions]].
 
* [[AMD64#Building amd64 port|AMD64 building instructions]].
  
Line 41: Line 119:
 
<u>Don't be in hurry and '''propose a [[Commiting Changes|Pull Request]]''' for the each fix you have done into the ReactOS repository.</u>
 
<u>Don't be in hurry and '''propose a [[Commiting Changes|Pull Request]]''' for the each fix you have done into the ReactOS repository.</u>
  
=== RosBE (outdated) ===
+
== Testing ==
 +
=== QEMU 6.2.0 (VirtIO on PCI) ===
 +
[[File:arm-virt-acpi-tree.png|300px|thumb|frame|ACPI device tree on virt platform]]
 +
 
 +
Use "virt" machine platform with UEFI firmware and ACPI tables. It consists mostly of synthetic VirtIO devices and can boot only from them.
 +
* UEFI supports FAT32 filesystem for hard disks (both MBR and GPT partitions) and CDFS/UDF for CD/DVD disks
 +
* In order to boot from a recognized filesystem, it tries to find and execute <code>\EFI\Boot\bootarm.efi</code>
 +
* First it attempts to boot from VirtIO SCSI CD-ROM (vioscsi.sys, device <code>PCI\VEN_1AF4&DEV_1004</code>)
 +
* Then it attempts to boot from VirtIO Hard Disk (viostor.sys, device <code>PCI\VEN_1AF4&DEV_1001</code>)
 +
 
 +
Additionally there is VirtIO Ethernet Adapter (netkvm.sys, device <code>PCI\VEN_1AF4&DEV_1000</code>). The only non-synthetic devices are PCI Express Root Complex (pci.sys, device <code>ACPI\PNP0A08</code>), ICH9 USB EHCI controller (usbehci.sys, device <code>PCI\VEN_8086&DEV_293A</code>), PL011 Serial UART (device <code>ACPI\ARMH0011</code>), and PL061 GPIO Controller (pl061gpio.sys, device <code>ACPI\ARMH0061</code>). QEMU VGA video is emulated and exposed on the PCI bus, also it's being passed as a linear framebuffer to the OS.
 +
 
 +
You can see the ACPI device tree on the right, interpreted by device manager of Windows 10 ARM. Note that some minor unknown devices were removed from the screenshot.
 +
 
 +
* Make sure to use exactly this QEMU release, as newer one 7.0.0 has problems with emulating Windows 10 for ARM.
 +
* Also make sure to use Linaro UEFI 15.12 firmware for QEMU. Download links are listed in the end of this section.
 +
 
 +
Batch file to start emulation:
 +
<syntaxhighlight lang="batch">
 +
@echo off
 +
set ISO=livecd-arm.iso
 +
set HDD=disk.vhd
 +
 
 +
qemu-system-arm ^
 +
-M virt,highmem=false ^
 +
-cpu cortex-a15 ^
 +
--accel tcg,thread=multi ^
 +
-m 2G ^
 +
-bios QEMU_EFI.fd ^
 +
-device VGA ^
 +
-device ich9-usb-ehci1 ^
 +
-device usb-kbd ^
 +
-device usb-tablet ^
 +
-device virtio-scsi-pci,id=scsi0 ^
 +
-drive if=none,format=raw,id=cdrom,file=%ISO%,readonly=on -device scsi-cd,drive=cdrom,bus=scsi0.0
 +
-drive if=virtio,file=%HDD% ^
 +
-nic user
 +
</syntaxhighlight>
 +
 
 +
Downloads:
 +
* [https://qemu.weilnetz.de/w32/2021/qemu-w32-setup-20211215.exe Download for Windows x86 host]
 +
* [https://qemu.weilnetz.de/w64/2021/qemu-w64-setup-20211215.exe Download for Windows x64 host]
 +
* [https://releases.linaro.org/components/kernel/uefi-linaro/15.12/release/qemu/QEMU_EFI.fd Linaro UEFI firmware 15.12 for QEMU]
 +
 
 +
=== QEMU 6.2.0 (bare minimum hardware, no PCI) ===
 +
[[File:winrt-acpi-tree.png|280px|thumb|frame|ACPI device tree on QEMU WinRT platform]]
 +
 
 +
This one is an attempt to create a less synthetic platform, which would be able to boot Windows RT (both 8 and 8.1) without 3rd party drivers. It has only USB EHCI-compliant controller (for USB input and CD/DVD drive), SDA-compliant SD host controller (for the hard disk), and PL011 Serial UART (for debugging).
 +
* UEFI supports FAT32 filesystem for hard disks (both MBR and GPT partitions) and CDFS/UDF for CD/DVD disks
 +
* In order to boot from a recognized filesystem, it tries to find and execute <code>\EFI\Boot\bootarm.efi</code>
 +
* First it attempts to boot from USB CD/DVD-ROM (usbehci.sys, device <code>ACPI\PNP0D20</code> => usbstor.sys)
 +
* Then it attempts to boot from SD Card (sdbus.sys, device <code>ACPI\PNP0D40</code> => sdstor.sys, device <code>SD\CLASS_STORAGE</code>)
 +
 
 +
The platform does not expose PCI bus, because Windows RT does not support bus mapping properly. All devices are connected to the system bus and exposed via ACPI tables. QEMU VGA video is emulated, but it's only being passed as a linear framebuffer to the OS.
 +
 
 +
You can see the ACPI device tree on the right, interpreted by device manager of Windows RT 8.1. Note that some minor unknown devices were removed from the screenshot.
 +
 
 +
* Make sure to use this with custom UEFI firmware that is attached to the release in GitHub.
 +
 
 +
Batch file to start emulation:
 +
<syntaxhighlight lang="batch">
 +
@echo off
 +
set ISO=livecd-arm.iso
 +
set HDD=sdcard.vhd
 +
 
 +
qemu-system-arm ^
 +
-M virt,highmem=false ^
 +
-cpu cortex-a15 ^
 +
--accel tcg,thread=multi ^
 +
-m 2G ^
 +
-bios QEMU_EFI_1512_driver1998.fd ^
 +
-device VGA ^
 +
-device usb-kbd,id=kbd ^
 +
-device usb-tablet,id=mice ^
 +
-drive id=usbcdrom,if=none,media=cdrom,format=raw,file=%ISO%,readonly=on -device usb-storage,drive=usbcdrom ^
 +
-drive id=mydrive,if=none,file=%HDD% -device sd-card,drive=mydrive
 +
</syntaxhighlight>
 +
 
 +
Downloads:
 +
* https://github.com/binarymaster/qemu/releases
 +
 
 +
== Testing (deprecated way) ==
 +
<div class="toccolours mw-collapsible mw-collapsed">
 +
This section is about legacy testing method that was used in early times of ARM port. Click "Expand" to read further.
 +
<div class="mw-collapsible-content">
 +
 
 +
<hr>
  
: ''This build method is not maintained for some years and may not work.''
 
  
Obtain the React OS Build Environment for ARM (RosBE-ARM). The latest version is
+
Development of ReactOS ARM port was started some years before the first public release of Windows on ARM (namely, Windows RT). At the time there were no standard ways of booting operating systems on ARM-based devices. One of possible ways was to follow Linux kernel boot process.
1.0 and available from: https://download.reactos.org/reactos/RosBE-Windows/arm/1.0/RosBE-ARM-1.0.exe
 
  
Launch the RosBE-ARM command prompt, and type "makex" on the command line. After
+
If you want to try reproducing the method documented in this section, you may encounter the following difficulties:
some minutes, you should have the whole tree built.
+
* ReactOS system image (either LiveCD or installed on disk) would not fit into 32 MB space.
 +
* <code>makex install</code> command in RosBE is not used anymore and may not work.
 +
* <code>armllb</code> is not being maintained and may not work.
 +
* <code>freeldr</code> may not support RAMDisk as a boot device anymore, this functionality is not being used.
 +
* <code>nandflash</code> is not being maintained and may not work.
  
== Making a RAM disk ==
+
=== Making a RAM disk ===
  
 
Currently, the ARM port will only boot from a RAM disk, either in NOR/NAND flash
 
Currently, the ARM port will only boot from a RAM disk, either in NOR/NAND flash
Line 84: Line 250:
 
or by using a hex editor and locating the boot sector (look for "FAT").
 
or by using a hex editor and locating the boot sector (look for "FAT").
  
== Installing ==
+
=== Installing ===
  
 
Now that you have a mountable, formatted, FAT image file, go ahead and mount it,
 
Now that you have a mountable, formatted, FAT image file, go ahead and mount it,
 
and set your ROS_INSTALL environment variable to the \reactos folder on the virtual
 
and set your ROS_INSTALL environment variable to the \reactos folder on the virtual
drive. For example, if you mapped it to X:\, this would be ROS_INSTALL=X:\reactos.
+
drive. For example, if you mapped it to X:\, this would be <code>ROS_INSTALL=X:\reactos</code>.
  
Now issue a "makex install" from the RosBE command line. This will copy all the
+
Now issue a <code>makex install</code> from the RosBE command line. This will copy all the
 
files to your new RAM disk.
 
files to your new RAM disk.
  
The last thing you'll need is a freeldr.ini. You can write one from scratch, or
+
The last thing you'll need is a <code>freeldr.ini</code>. You can write one from scratch, or
 
simply take the usual one that the x86 ReactOS setup program installs on your
 
simply take the usual one that the x86 ReactOS setup program installs on your
 
x86 ReactOS partition/image file. You'll want to keep the ReactOS entry that's
 
x86 ReactOS partition/image file. You'll want to keep the ReactOS entry that's
 
marked as "(RAMDisk)".
 
marked as "(RAMDisk)".
  
== Preparing to boot ==
+
=== Preparing to boot ===
  
 
Now that you have a RAM disk, you are ready to build the final components. The
 
Now that you have a RAM disk, you are ready to build the final components. The
 
ARM port basically uses an LLB (Low-Level Bootloader) to initialize the hardware,
 
ARM port basically uses an LLB (Low-Level Bootloader) to initialize the hardware,
 
and then pass control to FreeLDR, the ReactOS Boot Loader. FreeLDR will then use
 
and then pass control to FreeLDR, the ReactOS Boot Loader. FreeLDR will then use
the RAM disk to search for freeldr.ini, present the OS options, etc, and finally
+
the RAM disk to search for <code>freeldr.ini</code>, present the OS options, etc, and finally
 
load the kernel.
 
load the kernel.
  
Line 112: Line 278:
 
for technical reasons beyond the scope of this document.
 
for technical reasons beyond the scope of this document.
  
Thankfully, a tool exists to perform these operations: nandflash. You simply need
+
Thankfully, a tool exists to perform these operations: <code>nandflash</code>. You simply need
to run nandflash (from your output-arm/tools/nandflash directory) with the "1"
+
to run nandflash (from your <code>output-arm/tools/nandflash</code> directory) with the "1"
 
option to instruct it to generate the necessary files. The other use of nandflash
 
option to instruct it to generate the necessary files. The other use of nandflash
 
(without the parameter) is to generate OMAP3 ROM NAND flash files, but that usage
 
(without the parameter) is to generate OMAP3 ROM NAND flash files, but that usage
 
is beyond the scope of this document.
 
is beyond the scope of this document.
  
Note that nandflash expects your image file to have been called ramdisk.img, so
+
Note that nandflash expects your image file to have been called <code>ramdisk.img</code>, so
 
make sure you rename it to match this. After running nandflash, you will have
 
make sure you rename it to match this. After running nandflash, you will have
two new files: ramdisk.bin, which is a modified version of your ramdisk image,
+
two new files: <code>ramdisk.bin</code>, which is a modified version of your ramdisk image,
and reactos.bin, which is the fused LLB and loader together.
+
and <code>reactos.bin</code>, which is the fused LLB and loader together.
  
== Booting ==
+
=== Booting ===
  
 
You can now instruct QEMU to boot ReactOS for ARM. You will need to obtain the
 
You can now instruct QEMU to boot ReactOS for ARM. You will need to obtain the
Line 130: Line 296:
 
the Cortex A8, an ARMv7-a core, which is being used internally for BeagleBoard
 
the Cortex A8, an ARMv7-a core, which is being used internally for BeagleBoard
 
and ZoomII-MDK work.
 
and ZoomII-MDK work.
To specify these two options, use "-M versatilepb -cpu cortex-a8" on your command
+
To specify these two options, use <code>-M versatilepb -cpu cortex-a8</code> on your command
 
line.
 
line.
  
 
You now need to specify the two files that nandflash created for you. You may do
 
You now need to specify the two files that nandflash created for you. You may do
this with the following two options: "-kernel reactos.bin -initrd ramdisk.bin".
+
this with the following two options: <code>-kernel reactos.bin -initrd ramdisk.bin</code>.
  
 
Finally, you need to tell the LLB that we are booting from a RAM disk, and you
 
Finally, you need to tell the LLB that we are booting from a RAM disk, and you
 
need to input the boot sector offset we talked about earlier. You can do this with
 
need to input the boot sector offset we talked about earlier. You can do this with
the following options: "-append boot-device=RAMDISK,rdoffset=0x200". In general,
+
the following options: <code>-append boot-device=RAMDISK,rdoffset=0x200</code>. In general,
"-append" is used to send command-line parameters to the LLB, and you can specify
+
<code>-append</code> is used to send command-line parameters to the LLB, and you can specify
 
additional options by comma-separating them.
 
additional options by comma-separating them.
  
 
Here is an example final command line for QEMU:
 
Here is an example final command line for QEMU:
"qemu-system-arm -M versatilepb -cpu cortex-a8 -kernel reactos.bin -initrd ramdisk.bin -append boot-device=RAMDISK,rdoffset=0x200"
+
qemu-system-arm -M versatilepb -cpu cortex-a8 -kernel reactos.bin -initrd ramdisk.bin -append boot-device=RAMDISK,rdoffset=0x200
  
 
Past this point, the experience should be familiar. Note that the only thing you
 
Past this point, the experience should be familiar. Note that the only thing you
 
can do for now is select the OS from the boot selection menu, and see it load a
 
can do for now is select the OS from the boot selection menu, and see it load a
 
couple of drivers and hang somewhere in the kernel.
 
couple of drivers and hang somewhere in the kernel.
 +
 +
</div>
 +
</div>
  
 
== Compatible devices list ==
 
== Compatible devices list ==
 
See this forum post: https://reactos.org/forum/viewtopic.php?f=2&t=17977#p134530
 
See this forum post: https://reactos.org/forum/viewtopic.php?f=2&t=17977#p134530
 +
 +
== Potential testers ==
 +
* [[User:Ben_Nottelling|Ben Nottelling]] - '''Raspberry Pi 3'''
 +
* [[Daniel Reimer]] aka EmuandCo - '''Lumia 950 XL''', '''Microsoft Surface Duo'''
 +
* [[User:Illen|Illen]] - '''Lumia 950 XL''', '''Xiaomi Poco F1'''
 +
* [[User:TheR4K|TheR4K]] - '''Lumia 930''', '''Lumia 950 XL'''
 +
* Alula - '''Nubia Mini 5G (TP1803)'''
 +
* [[User:The_DarkFire|The_DarkFire]] - '''Microsoft Surface RT 2''', '''ECS LIVA Mini Box QC710 Desktop'''
 +
* [[User:chaosleo07|ChaosLeo07]] - '''Microsoft Surface RT''', '''Samsung Ativ Tab GT-P8510'''
 +
* [[User:Julenuri|Julen Urizar]] - '''Raspberry Pi 3B+''', '''Raspberry Pi 400'''
 +
 +
== Gallery ==
 +
<gallery widths="192px" heights="192px">
 +
File:ReactOS ARM Low-Level Boot Loader (TI OMAP34x-II).jpg|ARM Low-Level Boot Loader on TI OMAP34x-II (courtesy of [[ros-arm-bringup|ros&#8209;arm&#8209;bringup]], Nov&nbsp;2010)
 +
File:ReactOS ARM FreeLoader (TI OMAP34x-II).jpg|FreeLoader on TI OMAP34x-II (courtesy of [[ros-arm-bringup|ros&#8209;arm&#8209;bringup]], Nov&nbsp;2010)
 +
File:ReactOS ARM FreeLoader (Apple iPhone 4).jpg|FreeLoader on Apple iPhone 4 (courtesy of winocm, Jun&nbsp;2012) [https://reactos.org/pipermail/ros-dev/2012-June/015669.html][https://www.betaarchive.com/forum/viewtopic.php?t=25326]
 +
File:ReactOS apps compiled to ARM running on WoA (QEMU).png|ReactOS applications compiled to ARM are running in WoA (tested in QEMU, courtesy of [[User:binarymaster|Stas'M]], Sep&nbsp;2021) [https://twitter.com/reactos/status/1440277259038773252]
 +
File:First tests of ReactOS apps on ARM (Lumia 950 XL) - 1.jpg|First tests of ReactOS apps on ARM hardware (tested on Lumia 950 XL, courtesy of [[User:Illen|Illen]], Jul&nbsp;2021) - Part 1 [https://discord.com/channels/374957651676626945/374957651676626947/867529509996593163]
 +
File:First tests of ReactOS apps on ARM (Lumia 950 XL) - 2.jpg|First tests of ReactOS apps on ARM hardware (tested on Lumia 950 XL, courtesy of [[User:Illen|Illen]], Jul&nbsp;2021) - Part 2
 +
File:First tests of ReactOS apps on ARM (Lumia 950 XL) - 3.jpg|First tests of ReactOS apps on ARM hardware (tested on Lumia 950 XL, courtesy of [[User:Illen|Illen]], Jul&nbsp;2021) - Part 3
 +
File:More ReactOS apps on ARM (Lumia 950 XL).png|More ReactOS applications were confirmed on ARM (tested on Lumia 950 XL, courtesy of [[User:Illen|Illen]], Sep&nbsp;2021) [https://twitter.com/reactos/status/1440662175039823872]
 +
File:ReactOS apps on Windows RT (Samsung GT-P8510).jpg|Also confirmed on a real Windows RT device (Samsung Ativ Tab GT-P8510, courtesy of [[User:chaosleo07|ChaosLeo07]], Sep&nbsp;2021) [https://discord.com/channels/374957651676626945/374957651676626947/890106985876447232]
 +
</gallery>
  
 
== Links ==
 
== Links ==
Line 157: Line 349:
 
* http://reactosnews.blogspot.com/2010/11/news-reactos-en-microprocesadores-arm.html - News article in Spanish
 
* http://reactosnews.blogspot.com/2010/11/news-reactos-en-microprocesadores-arm.html - News article in Spanish
 
* https://www.dreimer.de/?p=1212 - ReactOS builds for x64 and ARM!
 
* https://www.dreimer.de/?p=1212 - ReactOS builds for x64 and ARM!
 +
 +
== See Also ==
 +
* [https://www.youtube.com/watch?v=rvzJmRBS84w First Windows on ARM live demonstration at CES 2011 - GameSpot channel] (and [https://www.youtube.com/watch?v=xKc_XGuvNIk VentureBeat channel])
 +
* [https://web.archive.org/web/20160304015254/http://blogs.msdn.com/b/ntdebugging/archive/2013/11/22/understanding-arm-assembly-part-1.aspx Understanding ARM Assembly Part 1 - Ntdebugging Blog]
 +
* [https://web.archive.org/web/20160312014230/http://blogs.msdn.com/b/ntdebugging/archive/2014/05/15/understanding-arm-assembly-part-2.aspx Understanding ARM Assembly Part 2 - Ntdebugging Blog]
 +
* [https://web.archive.org/web/20160312023037/http://blogs.msdn.com/b/ntdebugging/archive/2014/05/29/understanding-arm-assembly-part-3.aspx Understanding ARM Assembly Part 3 - Ntdebugging Blog]
 +
* [https://codemachine.com/article_armasm.html CodeMachine - Article - Windows on ARM - An assembly language primer]
 +
* [https://web.archive.org/web/20200106191700/https://blogs.msdn.microsoft.com/b8/2012/02/09/building-windows-for-the-arm-processor-architecture/ Building Windows for the ARM processor architecture]
 +
* [https://lwn.net/Articles/574439/ ACPI on ARM? - LWN.net]
 +
* [https://web.archive.org/web/20160502042141/http://winocm.moe/projects/bringup/osports/2015/01/12/giving-windows-on-arm-a-hand/ Giving Windows on ARM a hand]
 +
* [https://www.imbushuo.net/blog/archives/590 Give TianoCore/EDK2 on AArch64 a hand in 2018]
 +
* [https://www.imbushuo.net/blog/archives/637 Bootstrapping the blue Windows when you have random AArch64 devices in the backyard]
 +
* [https://www.imbushuo.net/blog/archives/725 So you told me you want to run Windows on a Calculator]
  
 
{{Navigation Ports}}
 
{{Navigation Ports}}

Latest revision as of 15:01, 9 May 2023

ReactOS 32-bit ARM port was started by ReactOS Portable Systems Group back in 2008. Originally it was designed for ARMv5 and ARMv4, but these cores have an MMU that is incompatible with ReactOS/Windows multiprocessor requirements, and lacks instructions needed for synchronization done in user-mode, so currently the port targets ARMv7 compatible cores.

It should be possible to port to ARMv6 and possibly older ARM architecture revisions, but currently it's postponed and the system will be operable only in single-processor mode in these cases.

Since the GCC compiler has dropped the support for ARM PE executables, and the project had to upgrade GCC version, the port become unmaintained somewhere back in 2015 (see #Known facts section).

However in November 2018 Microsoft has added official ARM and ARM64 target support into Visual Studio 15.9, so now it is possible to bring the port back to life!

Follow the discussion in this thread: https://reactos.org/forum/viewtopic.php?f=2&t=17977

Known facts

  • 15 Oct 2009: Last commit by ReactOS Portable Systems Group. [7]
  • 22 Mar 2012: GCC 4.7.0 has dropped support for ARM PE executables. [8] [9]
  • 22 Jul 2012: Timo Kreuzer has added support for MSVC ARM build. [10]
  • 15 May 2015: Beginning with r67740 ReactOS builds for ARM, too. Timo Kreuzer made some effort to get it build and succeeded. [11]
  • 15 Nov 2018: Microsoft announced official ARM target support for Visual Studio 2017. [12]
  • 19 Nov 2018: Support for VS2017 (15.9) compiler was added. [13]
  • 31 May 2019: A big streak of Pull Requests from woachk related to ARM port, totally not a coincidence. [14] [15]
  • 17 Aug 2019: Configure option WITH_HOST_TOOLS added to allow cross-compiling to ARM. [16]
  • 20 Aug 2019: Fixed some ARM compilation problems. [17][18]
  • 26 Apr 2020: ReactOS Applications Manager was able to start on Windows 10 for ARM32. [19]
  • 22 Oct 2020: Building host-tools for the host architecture has been broken, so building ARM binaries on x86 and x64 hosts is not possible. [20]
  • 11 Apr 2021: A new Pull Request with cross-compilation fix has been opened, so building for ARM hopefully will be fixed [21]
  • 24 May 2021: ARM cross-compilation has been fixed and simplified. GitHub ARM builders were added (Visual Studio 2017 and 2019), for now only rapps is built. Also it is possible to run ReactOS Calculator on Windows 10 for ARM32. [22][23]
  • 28 May 2021: A Jira ticket was created to track problems and progress on ARM port. [24]
  • 9 Sep 2021: Most CRT bugs have been fixed, ReactOS applications are mostly working with Windows on ARM. [25]
  • 21 Sep 2021: ReactOS Explorer and System Properties control panel applet are working in Windows 10 ARM with classic theme enabled. [26]
  • 17 Nov 2021: All applications (base and rosapps) and control panel applets are now built without errors. Now it's possible to download ARM build artifacts (both debug and release + symbols) from GitHub Actions CI. [27][28]
  • 18 Mar 2022: Entire base module is now built without errors. You can now download full ReactOS Shell compiled for ARM (explorer.exe, rshell.dll) from GitHub Actions. [29]
  • 8 May 2022: Stas'M in cooperation with driver1998 were able to patch QEMU to make Windows RT emulation possible. This work will be reused in ReactOS ARM port development. [30]

Building

Visual Studio

This is recommended build method. Please refer to these articles:

Building steps

Visual Studio ARM cross-compilation tools

You will need latest RosBE and Visual Studio 2017 or 2019 installed. It would work with VS community edition as well.

  • Make sure you have selected "Add BIN folder to PATH variable" when installing RosBE (see Visual Studio for details)
    • If you have RosBE installed but did not selected this option earlier, you need to add C:\RosBE\Bin (or your installation directory) to the PATH environment variable
  • Start VS command prompt for ARM cross-compilation
    • Normally you should have "x64_arm Cross Tools Command Prompt for VS" shortcut in your Start Menu within Visual Studio section
    • If you don't have it, make sure you have selected ARM cross-compilation tools in VS installer
    • If the tools are installed but there is still no shortcut, you can create it manually:
      %comspec% /k "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvarsamd64_arm.bat" (replace with your VS installation path)
  • Make sure to set BISON_PKGDATADIR and M4 variables as described in Visual Studio
  • Run configure.cmd
  • Type cd output-VS-arm and run ninja rapps or ninja calc, or just ninja -k 1 to build everything (in latter case there will be lots of build errors to fix)

Debugging steps

The steps below are describing how to debug ReactOS applications built for ARM architecture on Windows platform. It's important to ensure our applications are running there without problems.

  • You will need Windows on ARM environment (or just WoA) and WinDbg debugger
    • Most devices/computers with Windows 10 ARM64 would work
    • Windows RT devices are okay in case you are able to run non-signed code there
  • Get WinDbg debugger for ARM architecture (available in Windows 10 SDK)
    • Once installed, it's usually located in C:\Program Files (x86)\Windows Kits\10\Debuggers\arm
  • Set debug symbols path to C:\path\to\reactos\output-VS-arm\msvc_pdb (see WinDBG#Symbols for details)
  • Build wanted application for ARM and start it with WinDbg in WoA environment
  • Debugging experience should be the same as usual at this point, if you are not familiar with it, see WinDBG

RosBE (outdated)

This build method has not been maintained for some years and may not work.


Obtain the React OS Build Environment for ARM (RosBE-ARM). The latest version is 1.0 and available from: https://download.reactos.org/reactos/RosBE-Windows/arm/1.0/RosBE-ARM-1.0.exe

Launch the RosBE-ARM command prompt, and type makex on the command line. After some minutes, you should have the whole tree built.

The Plan

This is the general todo list with rough estimates in order to revive the ARM port.

Task Completion Comments
Add ARM target support to the configure.cmd build script 100% Works perfectly with MSVC
Create MSVC ARM builder in our GitHub CI so we notice when stuff is broken 75% We only build applications (base and rosapps) and control panel applets for now
Make ReactOS applications work with Windows on ARM without crashes 90% Missing functions: atan, ldexp, log10, _logb, tan
  • See existing tickets in this Jira epic: CORE-17604
  • Fix remaining problems in our CRT and SDK: possibly sync with newer versions of upstream components
Fix build errors for all modules 40% There are a lot of errors in ntoskrnl and dll's
Build ISO images bootcd-arm.iso and livecd-arm.iso 20% Build proper EFI-bootable ISO images with El-Torito specification
Work on bootloader 25% UEFI version of FreeLoader is being worked on: UEFI Freeldr. ARM boot support is in progress


These pages may be helpful to accomplish the tasks above:


Don't be in hurry and propose a Pull Request for the each fix you have done into the ReactOS repository.

Testing

QEMU 6.2.0 (VirtIO on PCI)

ACPI device tree on virt platform

Use "virt" machine platform with UEFI firmware and ACPI tables. It consists mostly of synthetic VirtIO devices and can boot only from them.

  • UEFI supports FAT32 filesystem for hard disks (both MBR and GPT partitions) and CDFS/UDF for CD/DVD disks
  • In order to boot from a recognized filesystem, it tries to find and execute \EFI\Boot\bootarm.efi
  • First it attempts to boot from VirtIO SCSI CD-ROM (vioscsi.sys, device PCI\VEN_1AF4&DEV_1004)
  • Then it attempts to boot from VirtIO Hard Disk (viostor.sys, device PCI\VEN_1AF4&DEV_1001)

Additionally there is VirtIO Ethernet Adapter (netkvm.sys, device PCI\VEN_1AF4&DEV_1000). The only non-synthetic devices are PCI Express Root Complex (pci.sys, device ACPI\PNP0A08), ICH9 USB EHCI controller (usbehci.sys, device PCI\VEN_8086&DEV_293A), PL011 Serial UART (device ACPI\ARMH0011), and PL061 GPIO Controller (pl061gpio.sys, device ACPI\ARMH0061). QEMU VGA video is emulated and exposed on the PCI bus, also it's being passed as a linear framebuffer to the OS.

You can see the ACPI device tree on the right, interpreted by device manager of Windows 10 ARM. Note that some minor unknown devices were removed from the screenshot.

  • Make sure to use exactly this QEMU release, as newer one 7.0.0 has problems with emulating Windows 10 for ARM.
  • Also make sure to use Linaro UEFI 15.12 firmware for QEMU. Download links are listed in the end of this section.

Batch file to start emulation:

@echo off
set ISO=livecd-arm.iso
set HDD=disk.vhd

qemu-system-arm ^
-M virt,highmem=false ^
-cpu cortex-a15 ^
--accel tcg,thread=multi ^
-m 2G ^
-bios QEMU_EFI.fd ^
-device VGA ^
-device ich9-usb-ehci1 ^
-device usb-kbd ^
-device usb-tablet ^
-device virtio-scsi-pci,id=scsi0 ^
-drive if=none,format=raw,id=cdrom,file=%ISO%,readonly=on -device scsi-cd,drive=cdrom,bus=scsi0.0
-drive if=virtio,file=%HDD% ^
-nic user

Downloads:

QEMU 6.2.0 (bare minimum hardware, no PCI)

ACPI device tree on QEMU WinRT platform

This one is an attempt to create a less synthetic platform, which would be able to boot Windows RT (both 8 and 8.1) without 3rd party drivers. It has only USB EHCI-compliant controller (for USB input and CD/DVD drive), SDA-compliant SD host controller (for the hard disk), and PL011 Serial UART (for debugging).

  • UEFI supports FAT32 filesystem for hard disks (both MBR and GPT partitions) and CDFS/UDF for CD/DVD disks
  • In order to boot from a recognized filesystem, it tries to find and execute \EFI\Boot\bootarm.efi
  • First it attempts to boot from USB CD/DVD-ROM (usbehci.sys, device ACPI\PNP0D20 => usbstor.sys)
  • Then it attempts to boot from SD Card (sdbus.sys, device ACPI\PNP0D40 => sdstor.sys, device SD\CLASS_STORAGE)

The platform does not expose PCI bus, because Windows RT does not support bus mapping properly. All devices are connected to the system bus and exposed via ACPI tables. QEMU VGA video is emulated, but it's only being passed as a linear framebuffer to the OS.

You can see the ACPI device tree on the right, interpreted by device manager of Windows RT 8.1. Note that some minor unknown devices were removed from the screenshot.

  • Make sure to use this with custom UEFI firmware that is attached to the release in GitHub.

Batch file to start emulation:

@echo off
set ISO=livecd-arm.iso
set HDD=sdcard.vhd

qemu-system-arm ^
-M virt,highmem=false ^
-cpu cortex-a15 ^
--accel tcg,thread=multi ^
-m 2G ^
-bios QEMU_EFI_1512_driver1998.fd ^
-device VGA ^
-device usb-kbd,id=kbd ^
-device usb-tablet,id=mice ^
-drive id=usbcdrom,if=none,media=cdrom,format=raw,file=%ISO%,readonly=on -device usb-storage,drive=usbcdrom ^
-drive id=mydrive,if=none,file=%HDD% -device sd-card,drive=mydrive

Downloads:

Testing (deprecated way)

This section is about legacy testing method that was used in early times of ARM port. Click "Expand" to read further.



Development of ReactOS ARM port was started some years before the first public release of Windows on ARM (namely, Windows RT). At the time there were no standard ways of booting operating systems on ARM-based devices. One of possible ways was to follow Linux kernel boot process.

If you want to try reproducing the method documented in this section, you may encounter the following difficulties:

  • ReactOS system image (either LiveCD or installed on disk) would not fit into 32 MB space.
  • makex install command in RosBE is not used anymore and may not work.
  • armllb is not being maintained and may not work.
  • freeldr may not support RAMDisk as a boot device anymore, this functionality is not being used.
  • nandflash is not being maintained and may not work.

Making a RAM disk

Currently, the ARM port will only boot from a RAM disk, either in NOR/NAND flash on a real device, or an emulated one like QEMU. A RAM disk is a simple flat image file that is loaded into memory.

To generate one of these images, you may use a tool such as qemu-img, the Mac OS Disk Image utility, or any other tool capable of generating a raw image file that corresponds to a hard disk image. You should generate a RAM disk of 32MB or less.

You then need a tool (on Windows), or the proper set of commands, to mount this virtual file/image as an actual hard drive on your machine. This step is required as the ARM port does not have an "installer" of any sorts, and cannot partition your disk, so you must do so yourself.

On a system such as Linux, you can use a local loopback mount, and then launch mkfs_fat on the mounted device. You can use either FAT16 or FAT32, as both have been tested with success. On OS X, the Disk Utility will automatically ask you to partition/format the image. Make sure you select "MS-DOS" partitioning when asked. On Windows, you may need to obtain a tool that can mount such images, such as vdkmount. Alternatively, you may use this image as an x86 ReactOS hard disk in QEMU, and then launch the x86 ReactOS setup program. Continue through the installer pages until you reach the formatting step, and allow ReactOS setup to format the disk. After that, you should be able to quit QEMU and have a formatted image file.

IMPORTANT: Usually, your raw image file will look like a real "disk". It will have an MBR sector at 0x00000000, followed by a boot sector for your first partition somewhere else on the disk. Sometimes this is at sector 63, 2, 1, 60, etc. You will need to know the offset of where the partition starts. Often this will be 0x7E00 (32256), although on Mac OS X .dmg images it will be 0x200. This offset is easy to find, either with a tool that understands your image file when mounting it, or by using a hex editor and locating the boot sector (look for "FAT").

Installing

Now that you have a mountable, formatted, FAT image file, go ahead and mount it, and set your ROS_INSTALL environment variable to the \reactos folder on the virtual drive. For example, if you mapped it to X:\, this would be ROS_INSTALL=X:\reactos.

Now issue a makex install from the RosBE command line. This will copy all the files to your new RAM disk.

The last thing you'll need is a freeldr.ini. You can write one from scratch, or simply take the usual one that the x86 ReactOS setup program installs on your x86 ReactOS partition/image file. You'll want to keep the ReactOS entry that's marked as "(RAMDisk)".

Preparing to boot

Now that you have a RAM disk, you are ready to build the final components. The ARM port basically uses an LLB (Low-Level Bootloader) to initialize the hardware, and then pass control to FreeLDR, the ReactOS Boot Loader. FreeLDR will then use the RAM disk to search for freeldr.ini, present the OS options, etc, and finally load the kernel.

Therefore, there are three components that the system needs: the LLB, the loader, and the RAM disk. QEMU has command-line options and support for only loading two image files, and so the LLB and the loader must be fused together into one binary file. Additionally, the RAM disk image file you created must be slightly modified for technical reasons beyond the scope of this document.

Thankfully, a tool exists to perform these operations: nandflash. You simply need to run nandflash (from your output-arm/tools/nandflash directory) with the "1" option to instruct it to generate the necessary files. The other use of nandflash (without the parameter) is to generate OMAP3 ROM NAND flash files, but that usage is beyond the scope of this document.

Note that nandflash expects your image file to have been called ramdisk.img, so make sure you rename it to match this. After running nandflash, you will have two new files: ramdisk.bin, which is a modified version of your ramdisk image, and reactos.bin, which is the fused LLB and loader together.

Booting

You can now instruct QEMU to boot ReactOS for ARM. You will need to obtain the ARM version of QEMU (qemu-system-arm) or build it yourself. Currently, testing is done with the "Versatile/PB" platform, but with a modified CPU target being the Cortex A8, an ARMv7-a core, which is being used internally for BeagleBoard and ZoomII-MDK work. To specify these two options, use -M versatilepb -cpu cortex-a8 on your command line.

You now need to specify the two files that nandflash created for you. You may do this with the following two options: -kernel reactos.bin -initrd ramdisk.bin.

Finally, you need to tell the LLB that we are booting from a RAM disk, and you need to input the boot sector offset we talked about earlier. You can do this with the following options: -append boot-device=RAMDISK,rdoffset=0x200. In general, -append is used to send command-line parameters to the LLB, and you can specify additional options by comma-separating them.

Here is an example final command line for QEMU:

qemu-system-arm -M versatilepb -cpu cortex-a8 -kernel reactos.bin -initrd ramdisk.bin -append boot-device=RAMDISK,rdoffset=0x200

Past this point, the experience should be familiar. Note that the only thing you can do for now is select the OS from the boot selection menu, and see it load a couple of drivers and hang somewhere in the kernel.

Compatible devices list

See this forum post: https://reactos.org/forum/viewtopic.php?f=2&t=17977#p134530

Potential testers

  • Ben Nottelling - Raspberry Pi 3
  • Daniel Reimer aka EmuandCo - Lumia 950 XL, Microsoft Surface Duo
  • Illen - Lumia 950 XL, Xiaomi Poco F1
  • TheR4K - Lumia 930, Lumia 950 XL
  • Alula - Nubia Mini 5G (TP1803)
  • The_DarkFire - Microsoft Surface RT 2, ECS LIVA Mini Box QC710 Desktop
  • ChaosLeo07 - Microsoft Surface RT, Samsung Ativ Tab GT-P8510
  • Julen Urizar - Raspberry Pi 3B+, Raspberry Pi 400

Gallery

Links

See Also

ReactOS ports‎
In active development Intel IA-32 (x86) | AMD64 (x64)
In slow development ARM64 (aarch64) | ARM32 (armv7) | NEC PC-98 (x86) | OG Xbox (x86)
Unmaintained OLPC (x86)
Missing ports that Windows has Intel IA-64 (Itanium) | IBM PS/2 MCA (x86) | SGI 320/540 (x86) | DEC Alpha (axp) | MIPS | PowerPC (ppc)
Ideas for new ports Apple TV 1st Gen (x86) | FM Towns (x86) | PlayStation 4 (x64) | Intel SFI (x86)