Toro Kernel

From Lazarus wiki
Jump to navigationJump to search

A dedicated kernel for multi-threading applications

On Windows

It's possible to develop Toro Kernel microservices on Windows.


  • you'll need to have cross-compile linux binary utils
those could be acquired from fpcup or fpcupdeluxe (
  • the project contain "build" utility complication as well. The utiltiy produces an image from the resulting .elf file

Running QEMU

  • install QEmu for Windows
  • run the system specifying the built image
qemu-system-x86_64 -hda HelloWorldMicroservice.img
  • on start qemu can complain about unknown or raw format of ".img" file.
One might find the script files to build the Qemu recognizable image file formats: BuildVHDX.cmd and/or BuildVMDK.cmd

From Lazarus as Hosting Application

Lazarus can be configured to run QEmu as a hosting or launching application. Typically such approach is used for developing libraries, rather than virtual machines. Yet, the approach could be used for the virtual machine as well. While it works, it does introduce some difficulties when debugging is needed.

Open Run->Run Parameters... and specify QEmu as the host application.

On the command-line parameters specify -hda parameter, that should point to the produced image file.

Normally this would be an output file with .img extension.


From Lazarus as External Tool

Another approach is to launch from IDE QEmu manually as an External Tool.

The approach is semi-automatic, yet it's friendly with the remote debugging capabilities (which are covered below)

To create an external tool, click Tools->Configure External Tools.... (if there are some other tools configured you need to click "Add")

On the new dialog, the similar information regarding QEmu needs to be provided:

  • the qemu executable
  • a parameter -hda specifying the target image file
  • additional parameters (i.e. network configuration)

torokernel external-tool.png

Once the external tool configuration has been saved. The new section is added under "Tools" menu.

The execution can be invoked by either selecting the menu or assigning hot key combinations.


QEmu provides a built-in support for GDB remote debuggin


  • run QEmu with enabling gdb (-s) and also requesting the QEmu to halt until getting the "continue" signal from gdb (-S)
qemu-system-x86_64 -s -S -hda HelloWorldMicroservice.img
The expected result is that Qemu window will halt with the message that "vga" system has not been initialized yet (and doing nothing)
-s - configures the default remote GDB mode for the use of TCP socket for port 1234
  • run the debugger, and provide the previously complied binary file as its gdb target. (The file is needed to load debugging information)
gdb HelloWorldMicroservice
  • after that run the remote target command
(gdb)> target remote localhost:1234
The command makes gdb connect to the specified address. In which case this would be Qemu running locally at port 1234.
  • setup the debugging information (i.e. breakpoints, etc)
The debugging information in the compiled binary contains the information necessary to work with binary during debugging.
(gdb)> b HelloWorldMicroservice.pas:250
sets a breakpoint HelloWorldMicroservice at the line that outputs "ToroService: listening on port xxxx ..."
  • "continue" the process.
(gdb)> continue

From Lazarus IDE

It's possible to use Gdb with Lazarus IDE to debug remote applications.

However, due to limitations on Lazarus IDE debugger handling, the remote application is expected to be launched outside of Lazarus IDE project run flow. (Lazarus attempts to launch the debugger first, and let debugger launch the debugged application. Which doesn't make much sense for remote debugging)

The easiest way to make Lazarus debug ToroKernel application under QEmu is to configure Running QEmu as am External Tool. Which is covered in the section above.

Important thing to remember is to have


parameters added. (as described above "-s" configures the network port for GDB, while "-S" makes sure QEmu would wait for the debugger to connect)

The "debugger" needs to be configured as following.

  • type should be set to (gdbserver)
  • executable should be the same as the Lazarus supplied gdb.exe.
  • Debugger_Remote_HostName should be set to "localhost" (you are running Qemu locally)
  • Debugger_Remote_Post should be set to 1234. (This is dictated by "-s" parameter passed to QEmu)

torokernel debugger.png

IMPORTANT - make sure that "Run Parameters" don't have Host Application or Launch Application configured. If they're configured it will prevent the debugger from loading proper symbol files and will prevent the debugging.

Run the QEmu via configured "External Tool" (or manually). When ran you should see "Guest has not initialized the display (yet)". That means that Qemu is waiting for the debugger to connect. torokernel qemu.png

Hit "Run" project (F9) in Lazarus IDE.

See Also