VxWorks 7 SDK for QEMU (IA)

Introduction

The VxWorks 7 SDK is a development environment dedicated to VxWorks application developers which include the following features:

• standard cross-compilation tools based on clang/LLVM which can be used to build both downloadable kernel modules (DKM) and RTP (Real Time Process) applications
• simplified build management: makefile, cmake, roll-your own
• target / architecture specific: includes a generic VxWorks kernel which is bootable on the target platform
• header files and libraries for application development
• Wind River Debugger (wrdbg)
• documentation

This guide helps you get up and running with developing applications for platforms running VxWorks. You can use it for creating new applications, or just exploration of VxWorks capabilities.

Setting up the development environment

You should start by downloading a VxWorks SDK for your platform of choice from https://labs.windriver.com and unpacking it. Refer to the documentation in docs in the unpacked SDK for additional information on creating and debugging applications.

OS requirements

The SDKs are meant to run on Linux hosts. Some of the examples in this document are specific to Debian derivatives.

Prerequisite(s)

Host dependencies

On Debian derivatives, the following packages need to be installed:

sudo apt install build-essential libc6:i386

Having an FTP server installed on your development host will make application deployment easier and allow you to access the host file system from a VxWorks target.

To accommodate for the varying runtime configurations of the VxWorks kernel images included in the SDKs, you may be interested in using an FTP server option based on pyftpdlib.

Install pyftpdlib.

sudo apt install python-pip
sudo pip install pyftpdlib

Starting a local FTP server on port 21 with user "target" and password "vxtarget" and FTP root in the current user's home can be done as follows

sudo python -m pyftpdlib -p 21 -u target -P vxTarget -i 127.0.0.1 -d $HOME

Running the VxWorks kernel and the applications created with the SDK requires installing QEMU

sudo apt install qemu-system-x86

Booting VxWorks on QEMU (IA)

QEMU can be used to run the VxWorks kernel included in the SDK and to deploy VxWorks applications.

Start by opening a Linux terminal window and going to the location of your unpacked VxWorks SDK. The following command can be used to start a VxWorks guest in QEMU.

qemu-system-x86_64 -m 512M -kernel bsps/itl_generic_2_0_0_2/boot/vxWorks \
-net nic -net user,hostfwd=tcp::1534-:1534 \
-display none -serial stdio -monitor none \
-append "bootline:fs(0,0)host:vxWorks h=10.0.2.2 e=10.0.2.15 u=target pw=vxTarget o=gei0" 

Customizing the values for the user (u) and password (pw) parameters to the ones matching a valid FTP user on your development host will allow you to access the host file system from the VxWorks instance running in QEMU. The VxWorks instance will have access to the root folder of your FTP server.

Application development

Start by opening a Linux terminal window and going to the location of your unpacked VxWorks SDK.

Source the SDK environment file to update your PATH and environmental variables, gaining direct access to the tools included within the SDK.

$ source <SDK_DIR>/toolkit/wind_sdk_env.linux 

Building applications

A "hello world" C application can be built as:

$ $CC hello.c -static -o hello

Make a note of the location of your application.

Running applications

After booting VxWorks on your target, switching to the "cmd" shell will allow you to navigate to the location of your application with greater ease.

E.g.

-> cmd
[vxWorks *]# 

Placing the application in a location accessible over FTP will make it visible with minimal configuration to the VxWorks instance.

Assuming the application is located in $HOME/opt and the FTP server uses a minimal configuration which provides FTP access to $HOME:

[vxWorks *]# cd opt
[vxWorks *]# ls
opt/./hello
opt/./hello.c
[vxWorks *]# more hello.c
#include <stdio.h>

int main(int argc, char **argv) {
    printf("Hello World\n");
    return 0;
}
[vxWorks *]# hello
Launching process 'hello' ...
Process 'hello' (process Id = 0xffff8000004bb6e0) launched.
Hello World

Refer to the documentation in docs for additional information on creating and debugging applications.

Creating Rust applications

The Rust development environment is set up in a similar manner to the standard application development environment, i.e. by sourcing the SDK environment file.

E.g.

$ source <SDK_DIR>/toolkit/wind_sdk_env.linux 

Building a simple hello world Rust program

$ cargo new hello
$ cd hello
$ cargo build

This will create an RTP called hello.vxe in the directory target/vxworks-target/build-mode where vxworks-target is one of the targets listed below and build-mode is either debug or release.

For example you might see an RTP in the directory: target/armv7-wrs-vxworks-eabihf/debug/hello.vxe

VxWorks Rust targets:

• ARM 32-bit: armv7-wrs-vxworks-eabihf
  
• ARM 64-bit: aarch64-wrs-vxworks
  
• Intel 32-bit: i686-wrs-vxworks
  
• Intel 64-bit: x86_64-wrs-vxworks

Run the hello.vxe in the VxWorks shell. You will see the following output:

Hello, world!

Note: For more information on using cargo, including how to customize the build output location or change the build mode from debug to release, see the cargo documentation here https://doc.rust-lang.org/cargo/guide/.