Cooperative Linux

Cooperative Linux 1

SEMINAR ON“CO-OPERATIVE LINUX”

Presented by:Pravin G. NimodiyaAmit A. Ohale

Cooperative Linux 2

CERTIFICATE

This is to certify that

Mr. Pravin Ganesh NimodiyaMr. Amit Anilkumar Ohale

from COMPUTER SCIENCE AND ENGINEERING has successfully

delivered a seminar on “COOPERATIVE LINUX” and has submitted

a satisfactory report about it as per syllabus of Shri Guru Gobind

Singhji Institute of Engineering & Technology, NANDED during

the academic year 2006-07.

Date:

Head of Dept Lect. Incharge

Cooperative Linux 3

ACKNOWLEDGEMENT

We feel great pleasure in submitting this seminar

report on “COOPERATIVE LINUX”. We wish to express true sense of

gratitude towards my seminar guide, Miss. Puja Borlepawar madam, who

at very discrete step in study of this seminar contributed her valuable

guidance to solve every problem that arose.

We wish to thank our Dr. J. V. Aghav sir for

opening the doors of the department towards the realization of the seminar

report.

We also express our thanks to all friends for their

undying support shown during the preparation of this seminar. I owe my all

success to them.

Pravin G. NimodiyaAmit A. Ohale

Cooperative Linux 4

Table of Content

1. Abstract ………. 5

2. Introduction ………. 6

3. History ………. 7

4. Uses ………. 8

5. CoLinux first Impression ………. 9

6. Design Overview ………. 11

7. Installation ………. 16

8. Compiling under CoLinux via GCC ………. 27

9. Other Auxiliary tools ………. 29

10. Interaction between Tools ………. 31

11. Current status of CoLinux ………. 33

12. Planned Features ………. 35

13. Disadvantages ………. 37

14. Conclusion ………. 38

15. References ………. 39

Cooperative Linux 5

1 Abstract

Software development for an embedded Linux system in most cases

requires a free license of GCC (GNU C/C++ compiler) and accessories. Many

developers find it disconcerting that the GNU tools are primarily available for

Linux-based PCs. Any attempt to make GCC run under Windows in order to

program an embedded Linux system has been fraught with problems until now.

The popular Cygwin – as a Unix/Linux emulation environment under Windows –

is much too slow and in most cases causes significant library and version

conflicts. Despite the high costs, commercial attempts by some companies to

provide GCC as a Windows application have not lead to any practical solutions.

Even here, there are typically significant library problems. As a result, many

users have no other alternative than to use a Linux distribution as a second

operating system on the Windows PC to be able to use GCC tools. Without some

effort, this technically straightforward solution is not feasible for large companies

in particular, because an IT department is responsible for the PCs. Users are not

able to just install a new operating system to boot instead of Windows.

Another obstacle is often times getting familiar with a new PC operating

system.Many questions can arise, such as: How can I change the network

settings (e.g. IP address, etc.)? Where can I find a Telnet client? Which editor

should I use? How can I later install other software components? The list could

go on ad nauseam. The bottom line is that significant orientation time is required

for a knowledgeable Windows user to get familiar with the new environment.

In this report we’ll describe Cooperative Linux, a port of the Linux kernel

that allows it to run as an unprivileged lightweight virtual machine in kernel mode,

on top of another OS kernel. It allows Linux to run under any operating system

that supports loading drivers, such as Windows or Linux, after minimal porting

efforts. The report includes the present and future implementation details, its

applications, and its comparison with other Linux virtualization methods. Among

the technical details I’ll present the CPU-complete context switch code, hardware

Cooperative Linux 6

interrupt forwarding, the interface between the host OS and Linux, and the

management of the VM’s pseudo physical RAM.

An alternative to using a Linux PC is a free license of Cooperative Linux

(coLinux).This Linux project is a new approach to getting the Linux kernel to run

under Windows XP. CoLinux contains special Windows drivers, which allow it to

run under Windows XP as a guest operating system with all privileges.

2 Introduction

Cooperative Linux utilizes the rather underused concept of a Cooperative

Virtual Machine (CVM), in contrast to traditional VM’s that are unprivileged and

being under the complete control of the host machine.

The term Cooperative is used to describe two entities working in parallel,

e.g. coroutines. In that sense the most plain description of Cooperative Linux is

turning two operating system kernels into two big coroutines. In that Mode, each

kernel has its own complete CPU context and address space, and each kernel

decides when to give control back to its partner.

However, only one of the two kernels has control on the physical

hardware, where the other is provided only with virtual hardware abstraction.

From this point on in the report I’ll refer to these two kernels as the host operating

system, and the guest Linux VM respectively. The host can be every OS kernel

that exports basic primitives that provide the Cooperative Linux portable driver to

run in CPL0 mode (ring 0) and allocate memory.

The special CPL0 approach in Cooperative Linux makes it significantly

different than traditional virtualization solutions such as VMware, plex86, Virtual

PC, and other methods such as Xen. All of these approaches work by running

the guest OS in a less privileged mode than of the host kernel. This approach

allowed for the extensive simplification of Cooperative Linux’s design and its

short early beta development cycle which lasted only one month, starting from

scratch by modifying the vanilla Linux 2.4.23-pre9 release until reaching to the

point where KDE could run. The only downside to the CPL0 approach is stability

Cooperative Linux 7

and security. If it’s unstable, it has the potential to crash the system. However,

measures can be taken, such as cleanly shutting it down on the first internal

Oops or panic. Another disadvantage is security. Acquiring root user access on a

Cooperative Linux machine can potentially lead to root on the host machine if the

attacker loads specially crafted kernel module or uses some very elaborated

exploit in case which the Cooperative Linux kernel was compiled without module

support.

Most of the changes in the Cooperative Linux patch are on the i386 tree—

the only supported architecture for Cooperative at the time of this writing. The

other changes are mostly additions of virtual drivers: cobd (block device), conet

(network), and cocon (console). Most of the changes in the i386 tree involve the

initialization and setup code. It is a goal of the Cooperative Linux kernel design to

remain as close as possible to the standalone i386 kernel, so all changes are

localized and minimized as much as possible.

3 History

Dan Aloni originally started the development of Cooperative Linux based

on similar work with User-mode Linux and LINE. He open sourced the software

under the GNU General Public License. Other developers have since contributed

various patches and additions to the software.

Cooperative Linux 8

4 Uses

Cooperative Linux in its current early state can already provide some of

the uses that User Mode Linux provides, such as virtual hosting, kernel

development environment, research, and testing of new distributions or buggy

software. It also enabled new uses:

• Relatively effortless migration path from Windows.

In the process of switching to another OS, there is the choice between

Installing another computer, dual booting, or using a virtualization software. The

first option costs money, the second is tiresome in terms of operation, But the

third can be the most quick and easy method—especially if it’s free. This is

where Cooperative Linux comes in. It is already used in workplaces to convert

Windows users to Linux.

• Adding Windows machines to Linux clusters.

The Cooperative Linux patch is minimal and can be easily combined with

others such as the MOSIX or Open-MOSIX patches that add clustering

capabilities to the kernel. This work in progress allows to add Windows machines

to super-computer clusters, where one illustration could tell about a secretary

Workstation computer that runs Cooperative Linux as a screen saver—when the

secretary goes home at the end of the day and leaves the computer unattended,

the office’s cluster gets more CPU cycles for free.

• Running an otherwise-dual-booted Linux system from the other OS.

The Windows port of Cooperative Linux allows it to mount real disk

partitions as block devices. Numerous people are using this in order to access,

rescue, or just run their Linux system from their ext3 or reiserfs file systems.

• Using Linux as a Windows firewall on the same machine.

Cooperative Linux 9

As a likely competitor to other out-of-the-box Windows firewalls, iptables

along with a stripped-down Cooperative Linux system can potentially serve as a

network firewall.

• Linux kernel development / debugging / research and study on another

operating systems.

Digging inside a running Cooperative Linux kernel, you can hardly tell the

difference between it and a standalone Linux. All virtual addresses are the Same

—Oops reports look familiar and the architecture dependent code works in the

same manner excepts some transparent conversions, which are described in the

next section in this report.

5 coLinux First Impression

The hardware virtualized by coLinux includes a VGA text console (that is

displayed in a Windows XP window), network, hard disk drives (as normal files

under Windows) and a keyboard. When selecting the virtual hardware, a

configuration was consciously selected that is as minimal as possible in order to

avoid driver problems in Linux.

Fig 5.1: The coLinux VGA text console in Windows XP window

are used by the make file that were previously written under Windows.

Cooperative Linux 10

Figure 5.1 shows the interface of coLinux to be implemented on a Debian

Linux under Windows XP. Just a simple mouse click on the previously described

icon on the Windows XP desktop is needed to start the configuration. And in just

a few seconds, a complete Debian Linux is available in a Windows XP window.

The username root and password root are used to log in.

Fig 5.2: Windows and coLinux use a common directory

Windows and coLinux use a common directory on the hard disk drive (c:\

colinux from the Windows environment – the same directory is accessible under

coLinux under the name /windows). Any files in the directory are accessible

from both Windows and coLinux (Figure 5.2). However, the common hard disk

drive space is managed by Windows exclusively. coLinux does not access the

hard disk drive hardware directly. Consequently, there is no need for a separate

coLinux partition. A special driver (coFS = coLinux File System) is used by

coLinux to access the Windows hard disk drive.

It should be noted, however, that the coFS involves an asynchronous file

system. Write operations within the common directory under coLinux or Windows

are closed from view of the other operating system only after context is next

switched (Surrendering control of the CPU to Windows or coLinux). For this

reason, no GCC make file should directly access /windows under coLinux, if files


6 Design Overview

This section describes the basic methods behind Cooperative Linux,

which include complete context switches, handling of hardware interrupts by

forwarding, physical address translation and the pseudo physical memory RAM.

6.1 Device Driver

The device driver port of Cooperative Linux is used for accessing kernel

mode and using the kernel primitives that are exported by the host OS kernel.

Most of the driver is OS independent code that interfaces with the OS dependent

primitives that include page allocations, debug printing, and interfacing with user

space.

When a Cooperative Linux VM is created, the driver loads a kernel image

from a vmlinux file that was compiled from the patched kernel with

CONFIG_COOPERATIVE. The vmlinux file doesn’t need any cross platform tools

in order to be generated, and the same vmlinux file can be used to run a

Cooperative Linux VM on several OS uses of the same architecture.

The VM is associated with a per-process resource—a file descriptor in

Linux, or a device handle in Windows. The purpose of this association makes

sense: if the process running the VM ends abnormally in any way, all resources

are cleaned up automatically from a call back when the system frees the per-

process resource.

6.2 Pseudo Physical RAM

In Cooperative Linux, we had to work around the Linux MM design

assumption that the entire physical RAM is bestowed upon the kernel on startup,

and instead, only give Cooperative Linux a fixed set of physical pages, and then

only do the translations needed for it to work transparently in that set. All the


memory which Cooperative Linux considers as physical is in that allocated set,

which we call the Pseudo Physical RAM.

The memory is allocated in the host OS using the appropriate kernel

function— alloc_pages() in Linux and MmAllocatePagesForMdl() in Windows—

so it is not mapped in any address space on the host for not wasting PTEs. The

allocated pages are always resident and not freed until the VM is downed.

Page tables are created for mapping the allocated pages in the VM’s

kernel virtual address space. The VM’s address space resembles the address

space of a regular kernel—the normal RAM zone is mapped contiguously at

0xc0000000.

The VM address space also has its own special fix maps—the page tables

themselves are mapped at 0xfef00000 in order to provide an O(1) ability for

translating PPRAM (Pseudo-Physical RAM) addresses to physical addresses

when creating PTEs for user space and vmalloc() space. On the other way

around, a special physical-to-PPRAM map is allocated and mapped at

0xff000000, to speed up handling of events such as pages faults which require

translation of physical addresses to PPRAM address. This bi-directional memory

address mapping allows for a negligible overhead in page faults and user space

mapping operations.

6.3 Context Switching

The Cooperative Linux VM uses only one host OS process in order to

provide a context for itself and its processes. That one process, named colinux-

daemon, can be called a Super Process since it frequently calls the kernel driver

to perform a context switch from the host kernel to the guest Linux kernel and

back. With the frequent (HZ times a second) host kernel entries, it is able able to

completely control the CPU and MMU without affecting anything else in the host

OS kernel.

On the Intel 386 architecture, a complete context switch requires that the

top page directory table pointer register—CR3—is changed. However, it is not


possible to easily change both the instruction pointer (EIP) and CR3 in one

instruction, so it implies that the code that changes CR3 must be mapped in both

contexts for the change to be possible.

It’s problematic to map that code at the same virtual address in both

contexts due to design limitations—the two contexts can divide the kernel and

address space differently, such that one virtual address can contain a kernel

mapped page in oneOS and a user mapped page in another.

In Cooperative Linux the problem was solved by using an intermediate

address space during the switch (referred to as the ‘passage page,’see Figure

6.1). The intermediate address space is defined by a specially created page

tables in both the guest and host contexts and maps the same code that is used

for the switch (passage code) at both of the virtual addresses that are involved.

When a switch occurs, first CR3 is changed to point to the intermediate address

space. Then, EIP is relocated to the other mapping of the passage code using a

jump. Finally, CR3 is changed to point to the top page tabledirectory of the other

OS.

Guest Linux Intermediate Host OS

0xFFFFFFFF

0x80000000

Fig 6.1: Address space transition during an OS cooperative kernel

switch, using an intermapped page


The single MMU page that contains the passage page code, also contains

the saved state of one OS while the other is executing. Upon the beginning of a

switch, interrupts are turned off, and a current state is saved to the passage page

by the passage page code. The state includes all the general purpose registers,

the segment registers, the interrupt descriptor table register (IDTR), the global

descriptor table (GDTR), the local descriptor register (LTR), the task register

(TR), and the state of the FPU / MMX / SSE registers. In the middle of the

passage page code, it restores the state of the other OS and interrupts are

turned back on. This process is akin to a “normal” process to process context

switch. Since control is returned to the host OS on every hardware interrupt

(described in the following section), it is the responsibility of the host OS

scheduler to give time slices to the Cooperative Linux VM just as if it was a

regular process.

6.4 Interrupt Handling and Forwarding

Since a complete MMU context switch also involves the IDTR,

Cooperative Linux must set an interrupt vector table in order to handle the

hardware interrupts that occur in the system during its running state. However,

Cooperative Linux only forwards the invocations of interrupts to the host OS,

because the latter needs to know about these interrupts in order to keep

functioning and support the coLinux-daemon process itself, regardless to the fact

that external hardware interrupts are meaningless to the Cooperative Linux

virtual machine.

The interrupt vectors for the internal processor exceptions (0x0–0x1f) and

the system call vector (0x80) are kept like they are so that Cooperative Linux

handles its own page faults and other exceptions, but the other interrupt vectors

point to special proxy ISRs (interrupt service routines). When such an ISR is

invoked during the Cooperative Linux context by an external hardware interrupt,

a context switch is made to the host OS using the passage code. On the other


side, the address of the relevant ISR of the host OS is determined by looking at

its IDT.An interrupt call stack is forged and a jump occurs to that address.

Between the invocation of the ISR in the Linux side and the handling of the

interrupt in the host side, the interrupt flag is disabled.

The operation adds a tiny latency to interrupt handling in the host OS, but

it is quite neglectable. Considering that this interrupt forwarding technique also

involves the hardware timer interrupt, the host OS cannot detect that its CR3 was

hijacked for a moment and therefore no exceptions in the host side would occur

as a result of the context switch.

To provide interrupts for the virtual device drivers of the guest Linux, the

changes in the arch code include a virtual interrupt controller which receives

messages from the host OS on the occasion of a switch and invokes do_IRQ ()

with a forged struct pt_args. The interrupt numbers are virtual and allocated on a

per-device basis.


7 Installation

If you have something different, than an Intel compatible CPU with either a

Windows XP or a Windows 2000 based operating system, coLinux will not

work. You should also have the latest service pack installed.

The CoLinux system comes as a tar file that contains a basic subset of

components.

• The Windows CoLinux driver

• A linux kernel vmlinux

• One or more file system images.

o Root file system

o Swap file

o Other file systems

• A configuration file.

• A program that creates empty files of arbitrary size: mkFile.exe

If you have a virus scanner with on-access scanning, you should make

sure that it is disabled or doesn’t touch the directory, where you want to install

coLinux.

If you have downloaded the installer package v.95 from

http://bla c kfin.uclin u x. o rg/projects/bfin- c olin u x , you must not unzip it in a

directory, which has white spaces in its path.

On the Windows machine in which CoLinux is being installed create a root

folder(e.g. colinux) where the proper files and subdirectories will be located. Now

make sure that you have the following files located in these specific directories:

/colinux/coLinux_setup_rc6.exe/colinux/readme.doc/colinux/extra/PuTTY-setup.exe/colinux/extra/Xming-setup.exe/colinux/sources/colinux-0.7.1-hn4.src/colinux/sources/file-utils/colinux/images/tardump.tgz

http://blackfin.uclinux.org/projects/bfin-colinux


If installing from a CD then you do not have to copy the files to your hard

drive as described above. You may simply run the installation from the CD by

running the coLinux_setup_rc6.exe.

Now to start the installation procedure, double click the

coLinux_setup_rc6.exe icon in the colinux directory. You should receive a

welcome screen that looks like this:

Now Click on the Next button.

You will then be brought to the coLinux Licenses agreement screen.


Here you should read the documentation and accept the agreement and

then click Next if you wish to continue.

You will then be brought to an information screen which provides the

following warning:

You should know, that this software installs a Windows kernel driver, that loads a

Linux kernel to run aside the Windows kernel.

This software can destabilize or crash your system!!

You should therefore not use software or edit data, that is vital for you or your

business, while running coLinux.

After you have read this click the Next button to continue the installation.

You will then be prompted for the directory that you want bfin-colinux installed in

(the default is C:\bfin-coLinux).

You should select a drive that has at least 3.2 GB of space left, because coLinux

doesn’t use a partition, but stores everything inside two files (rootfs.img and


homefs.img) on the windows file system. Due to a coLinux problem the path of

the coLinux installation must not contain any spaces.

After entering this information click the Next button.

Next you will be brought to the Ram and block size selection screen.

Here you have to select the size of the actual installation and the amount

of RAM, coLinux should use. The coLinux RAM is exclusively used by coLinux

and will no longer be available for Windows (only as long as coLinux runs). You

should reserve as much as possible, where a minimum should be 128MB. You

have to remember, that Windows also needs RAM and it should have at least

128MB left. For example if you have 256MB, you could try to use 128MB (It is

possible, that Windows would not allow coLinux to use that much RAM. If that is

the case, try 96MB). If you have 512MB then 256MB or 320MB would be a good

idea. Also you should remember that if Windows does not have enough RAM for

smooth operation then it will slow coLinux down and could destabilize your

system. Also you should not run unnecessary Windows software, while

working with coLinux. You should also select a bigger swap size than you have

selected the RAM size.


The coLinux standard installation uses about 750MB space on the rootfs.

So you should at least select 1GB for the root file system. If you want to install

additional software, you should select it bigger. For the home filesystem, you

should select at least select 1.8GB, since you will be installing the uClinux

distribution here.

driver

The next step is to select an IP address for coLinux and install the tuntap

If this is your first coLinux installation, you should check the Install a TAP

driver box and select an IP address for the Windows side of the TAP. It should

be an address in a not yet routed class C subnet in the address space of

10.xxx.xxx.xxx or 172.16.xxx.xxx or 192.168.xxx.xxx. (An example of a class C

network is 10.12.12.xxx).

There is also an option for serial support. If you activate it, you should also

select the right COM port. You should also know, that the console will block,

while using the serial port. So you have to use a xterm or PuTTY, while working

with the serial port. Now you may hit the Next button to move on with the

installation.

In the next step you can select a different start menu folder name. After

you have done this hit Next.

The final step allows you to select additional tasks to install. If this is your

first installation, you should select the PuTTY ssh client and the Xming X-Server

to be installed. You can also select the profile for PuTTY and the service if you

want.

If you confirm the installation by hitting Next and then Install, the setup

starts. You can see how the installer installs some files. After a few seconds a

new window opens. This is the coLinux console. This is part of the installation

process. You are now seeing a small Linux system that installs the main system.

This will take some time. After a few minutes the window closes and the setup

continues with the PuTTY and Xming installation. Maybe Windows asks you if

you want to install a driver which is not certified by Microsoft. You should answer

this with Yes. When the additional software components have been installed, the

coLinux setup shows some information and then goes to the login in screen. Now

you have successfully installed coLinux.

CoLinux Basics

The system consists of a set of Windows drivers linux.sys.

The colinux-daemon.exe --install-driver command will set up the Windows

system.

Use colinux-daemon.exe -–remove-driver to remove the drivers

Then a CoLinux executable can be run to start the linux virtual machine. This

system requires the folowing:

• A config file

• A Linux Kernel

• An initial Ram Disk.

A full system will also need some disk images:

• A root file system image

• A swap partition

• One or more additional images.

In this example system the images are compressed and will have to be

uncompressed using a “stand alone” CoLinux boot.

CoLinux Root Pasword

The CoLinux root password is bf533.

CoLinux Configuration

kernel=vmlinux# this specifies the kernel to be used

mem=120# this is the system virtual memory

initrd=.\initrd.gz# this is the initial ram disk

cobd0=.\root.img# specify partition /dev/cobd0 to point to this file

cobd1=.\home.img# specify partition /dev/cobd1 to point to this file

cobd2=.\swap.img# specify partition /dev/cobd2 to point to this file

cofs0=c:\# specify device /dev/cofs0 to point to the c: drive

root=/dev/cobd0# specify the mounted root file system.# this can be overridden in the example shown.

eth0=slirp,"",tcp:333:22/tcp:1000:1000/udp:69:69# set up an ethernet connection using the windows host.# devices on ports# tcp 333:22 (ssh)# tcp 1000:1000 (webmin)# udp 69:69 (tftp)# are assigned to services running under the CoLinux virtual machine.

eth1=tuntap# set up ether1 to work with the tap controller

cofs1=.# set up cofs01 to be the current working directory

cofs2=d:\# set up cofs02 to be the CD

# You can just add additional cofs entries for other drives or directories.# But you should know, that if you add a directory like cofsxx=j:\somepath you must# not add a trailing backslash. Only if you reference a drive like cofsxx=j:\ then you# have to add a trailing backslash


This config file has to work with the /etc/fstab on the root file system

image.

Here is a typical example:

# <file system> <mount point> <type> <foptions>/dev/cobd0 / ext3 defaults 0 0 proc /proc proc defaults 0 0 tmpfs /dev/shm tmpfs defaults 0 0/dev/cobd2 swap swap defaults 0 0/dev/cobd1 /home ext3 defaults 0 0 cofs00 /windows cofs defaults,noatime 0 0

# You can simply add your cofs drives with a simple entry like:# cofsxx /mountpint cofs defaults,noatime 0 0# You can also use additinal options like "noauto", if you want to mount# the fs manually or "user", if you want the filesystem be user mountable.

mode.

With just a few of these components CoLinux can be run in a stand alone

colinux-daemon.exe @config.txt root=/dev/ram0

In the above example config file the CoLinux working directory can be

mounted as follows:

mkdir -p /colinuxmount -t cofs cofs01 /colinux

Doing this will allow the use of Linux commands to manipulate the

installation kit. For example to uncompress images after booting in stand alone

mode and mounting the CoLinux image:

gunzip /colinux/swap.img.gz gunzip /colinux/home.img.gz gunzip /colinux/root.img.gz

mailto:@config.txt

CoLinux Disk Images

There are two ways to create disk images with CoLinux, one uses a

Windows based tool, the other is the “standard” Linux method. The Linux method

only runs under a Linux System.

There is a mkFile.exe utility that can be used under Windows to build an

image.

# At a Windows command prompt# example to create a 2G file mkFile -m mysys.img 2000

This file will then have to be populated within CoLinux but the image

mysys.img can be mounted within CoLinux if it is defined in the CoLinux config

file.

# this is the entry in the config.txt file cobd4=.\mysys.img

specify partition /dev/cobd4 to point to this file

In the CoLinux virtual machine:

# first create an ext2 file system on the disk image mke2fs -F /dev/cobd4

#turn this into an ext3 filesystem tune2fs -i 0 -j /dev/cobd4

# then under CoLinux mkdir -p /mymntmount /dev/cobd4 /mymount

The normal Linux way to make a blank disk image is as follows:

dd if=/dev/zero of=mysys.img bs=1k count=2048k

Starting a Colinux Session

To avoid errors during initialization, the following CoLinux startup order is

recommended:

1. Start Xming2. Start Blackfin-coLinux (Colinux main console)3. Login = uclinux

passwd = bf533

4. Start bfin-uclinux (Putty console)5. passwd = bf533

start konsole or xterm (in background) from Putty console

6. Launch minicom from the konsole or xterm terminal

To tftp the kernel to the stamp board you must disable the coorporate

firewall:

Goto Control Panel -> Administrative Tools -> Component Services -> Services Local ->Sygate Security Agent ->Under Properties, DISABLE firewall & Restart your PC

A crossover cable, hub or switch does work.

Stopping a Colinux Session

When you are ready to end your colinux session, in super user mode, type

‘shutdown -h now’ within the main console. Wait until the main console prints

‘Power down’ before closing all linux windows. This shut down procedure will

allow Colinux to start up normally the next time without a reboot.

The following commands can be used to terminate a CoLinux session (in

super user mode):

• halt

• shutdown -h now

Both of these will Power Down the virtual machine. The CoLinux Console

can then be closed using the Quit command.

8 Compiling under coLinux via GCC

A coLinux for embedded Linux development typically contains the original

GNU tools for compiling C/C++ programs and corresponding libraries. In addition

to the native GCC for x86 code, SSV coLinux contains Cross versions M68KELF-

GCC (M68K code, output format ELF) and ARM-ELF-GCC (code for various

ARM architectures in the ELF output format). The native GCC, for example, can

be used to program an ADNP/1520 with an embedded gateway Linux. The

M68KELF-GCC lends itself to software development for ColdFire DIL/NetPCs

under uClinux (DNP/5280, DNP/5282 and PNP/520). The Linux control

DIL/NetPC DNP/7520 is supported by the ARM-ELF-GCC. Other Cross GCC

versions can be subsequently added to SSV coLinux, as needed.

Fig 8.1: Initial steps with the compilers in SSV coLinux

A good first test of the various GNU tools of an SSV coLinux installation is

to create and compile a C program in the coLinux window.

These steps, for example, can be executed with the following entries:

cat > hello.c

#include <stdio.h>

#include <stdlib.h>

void main (void)

{

printf (“Hello...\n”);

}

CTRL-D (ends the input of the C source text)

gcc –o hello hello.c

This input sequence results in a C source code file called hello.c. The file

is then compiled with the native GCC. The resulting program can be directly

executed in the coLinux window. Figure8.1 illustrates this example. In this figure,

M68K-ELFGCC is then called up to create an executable for a ColdFire

DIL/NetPC from hello.c. The uClinux executable hello is then moved to the

/windows/root directory. The file can then, for example, be transferred with TFTP

to the DNP/5280.

9 Other Auxiliary Tools

There are other tools on the coLinux Cross Tools CD-ROM. The opens

source editor PN (Programmers Notepad) is of particular importance. The

installation program for this auxiliary tool can be found on the CD-ROM in the

Programmers Notepad directory.

Fig 9.1: Editing with the open source editor PN (Programmers Notepad)

PN is capable of editing the C/C++ source code for an embedded Linux

module in the familiar Windows XP environment. Resulting source code files can

be saved in the common Windows directory c:\colinux. Additional subdirectories

(e.g. c:\colinux\root or even c:\colinux\transfer) should be created within

c:\colinux for the individual projects, as needed.

Another important resource on the SSV coLinux Cross Tools CD-ROM is

a TFTP server called TFTPD in the TFTP-Server-Win32 directory. The same

server application is also included on the starter kit CD-ROMs for the respective

DIL/NetPCs. TFTPD is used for TFTP-based file transfer over an Ethernet LAN

connection between PC and embedded Linux module. Figure 8.2 shows TFTPD

in use. It should be noted that this programs requires file transfer from a base

directory. The Browse button on the TFTP user interface is used to select the

directory.

Fig 9.2: The TFTP server is used for file transfer

All TFTP file transfers to and from DIL/NetPCs are based on the TFTPD

base directory. Therefore, c:\colinux or a subdirectory within c:\colinux must be

selected as the base directory to use TFTPD in conjunction with coLinux.

10 The Interaction between Tools

The coLinux window itself, the open source editor PN and a TFTP server

TFTP can be used together in such a way that the developer will practically never

have to leave the familiar Windows XP environment of the development PC.

Figure 8 provides an overview of the interaction between the development tools

that are used in the coLinux-based development environment for DIL/NetPCs.

C/C++ source code is edited in Windows using the PN editor. This

Windows application organizes the source code files into projects. All source

code is saved in the directory c:\colinux, or a subdirectory within c:\colinux. A

script file (build script) is run in the coLinux window to compile the entire project.

The script pulls the appropriate source code files from the common directory,

activates the GCC sing a make file and after successfully running the GCC writes

the executable for the embedded Linux system back to the common directory.

The following is an example of such a build script:

#!/bin/sh

cp /windows/root/ngsmtp1.c ngsmtp1.c

make all

mv /tftpboot/ngsmtp1 /windows/root/ngsmtp1

mv ngsmtp1.c ngsmtp1.bak

rm ngsmtp1.gdb

The second line of the build script copies C source code with the name

ngsmtp1.c from c:\colinux\root (/windows/root in coLinux) to the coLinux

directory, in which the build script was launched. The third line activates the GCC

make. The GCC make run creates an executable in the coLinux directory

/tftpboot. The fourth line moves the executable to the common directory

c:\colinux\root (/windows/root in coLinux), from where it can then be transferred


per TFTP to the DIL/NetPC. Such a build script is executed from the coLinux

window.

Fig 10.1: The interaction between development tools

The user only has to launch the script file in the coLinux window. This

essentially eliminates any orientation in Linux as a PC operating system. The

Windows TFTP server TFTPD and the standard XP Telnet client in Figure 9.1

are used for file transfer to the embedded Linux system and the shell access.


11 Current Status of coLinux

• Version: 0.6.4

• Released on date: July 02, 2006

• Supported architectures:

o Intel-compatible 386 and above

Supported operating s ystem s :

Windows 2000

Windows XP

Linux 2.6.x

• Supported guest Linux kernel versions:

o 2.6.11


Here is the list of changes that led to the current version:

* Version 0.6.4* colinux-daemon: Fix incorrect explaination in --help, for --remove-driver.

SF Bug#1483449* Improved building

* improvements to cut down on disk size needed to build coLinux* improvements to make process smoother and better handle some

errors* Fix do_wp_page: bogus page at address <address> (mainly seen with

syslog)when linux is hostThanks to Robert for >=2.6.13 part (2006-02-26) and Bernd Brandstetter for 2.6.12 (2005-10-01).Tested host kernels: 2.6.10, 2.6.11, 2.6.12, 2.6.13, 2.6.14.4, 2.6.15,

2.6.16-rc5* Fix daemons to read more than one message* Fix for dropped UDP/TCP packets between linux and host daemons.* cofs and cobd:

* Allow relative paths in XML (except for \Device & \DosDevices)* Remove trailing backslashes from cofs paths* Improve console output of mapped devices & paths* Case insensitive scans for duplicate paths

* cobd:* Fix for reference to NULL-Pointer

* cofs:* Fix BSOD for long non-ansi names in directory(Thanks to Kensuke Matsuzaki)

* Fix for handling longer basenames (from 127 to 255)* slirp:

* Handle larger UDP/TCP packet (more than 3000...4000 bytes of userdata

* Fix realloc problem that caused slirp to crash(Thanks to Bernd Brandstetter for finding it)

* Always set destination address and port, destination port is not always the same(Thanks to Bern Brandstetter for finding & submitting patch)

* bind 10.0.2.2 to Window's localhost, instead of window's LAN adapter* Packets from Windows host are translated to 10.0.2.2,

other packets are routed but not translated* Slirp redirection now works without any real net w ork adapter * Fix Slirp redirection to work on LAN if colinux started before LAN is

connected* pcap/Bridged:

* Add promisc="false" in config.xml, or 'nopromisc' as last command-line

argument(ie, eth1=pcap,"Local Area Connection","<FAKE MAC>",nopromisc ). Default is Promiscuous on.

http://colinux.org/?section=status



12 Planned Features

Since Cooperative Linux is a new project, most of its features are still

waiting to be implemented.

12.1 Suspension

Software-suspending Linux is a challenge on standalone Linux systems,

considering the entire state of the hardware needs to be saved and restored,

along with the space that needs to be found for storing the suspended image. On

User Mode Linux suspending [3] is easier only the state of a few processes

needs saving, and no hardware is involved.

However, in Cooperative Linux, it will be even easier to implement

suspension, because it will involve its internal state almost entirely. The

procedure will involve serializing the pseudo physical RAM by enumerating all

the page table entries that are used in Cooperative Linux, either by itself (for user

space and vmalloc page tables) or for itself (the page tables of the pseudo

physical RAM), and change them to contain the pseudo value instead of the real

value.

The purpose of this suspension procedure is to allow no notion of the real

physical memory to be contained in any of the pages allocated for the

Cooperative Linux VM, since Cooperative Linux will be given a different set of

pages when it will resume at a later time. At the suspended state, the pages can

be saved to a file and the VM could be resumed later. Resuming will involve

loading that file, allocating the memory, and fix-enumerate all the page tables

again so that the values in the page table entries point to the newly allocated

memory.

Another implementation strategy will be to just dump everything on

suspension as it is, but on resume—enumerate all the page table entries and

adjust between the values of the old RPPFNs2 and new RPPFNs. Note that a

suspended image could be created under one host OS and be resumed in

another host OS of the same architecture. One could carry a suspended Linux on

a USB memory device and resume/suspend it on almost any computer.

12.2 User Mode Linux inside Cooperative Linux

The possibility of running UML inside Cooperative Linux is not far from

being immediately possible. It will allow to bring UML with all its glory to operating

systems that cannot support it otherwise because of their user space APIs.

Combining UML and Cooperative Linux cancels the security downside that

running Cooperative Linux could incur.

12.3 Live Cooperative Distributions

Live-CD distributions like KNOPPIX can be used to boot on top of another

operating system and not only as standalone, reaching a larger sector of

computer users considering the host operating system to be Windows

NT/2000/XP.

12.4 Integration with ReactOS

ReactOS, the free Windows NT clone, will be incorporating Cooperative

Linux as a POSIX subsystem.

12.5 Miscellaneous

• Virtual frame buffer support.

• Incorporating features from User Mode Linux, e.g. humfs 3.

• Support for more host operating systems such as FreeBSD.

13 Disadvantage

The biggest disadvantage is that coLinux runs aside the Windows kernel.

It runs on the same hardware abstraction layer that is also called ring0. Inside

this CPU abstraction layer, there is no hardware memory protection. This is the

same situation as between the Linux or Windows kernel and their device drivers.

So a problem in the Linux kernel can bring the Windows kernel down, if Linux

violates the Windows address space. Also there are security implications. If a

malice user gains root access inside coLinux he can compromise the security of

the Windows system as well. Also to load and use coLinux the user has to have

administrator rights. (There is the possibility to start coLinux as a service, so it is

possible to start coLinux as a normal user, if the user has been granted the right

to start the service)

14 Conclusion

We have discussed how Cooperative Linux works and its benefits. The

coLinux is an economical and efficient possibility to program embedded Linux

systems directly from a Windows PC. Cooperative Linux has the potential to

become an alternative to User Mode Linux that enhances on portability and

performance, rather than on security.

Moreover, the implications that Cooperative Linux has on what is the

media defines as ‘Linux on the Desktop’—are massive, as the world’s most

dominant albeit proprietary desktop OS supports running Linux distributions for

free, as another software, with the aimed for possibility that the Linux newbie

would switch to the standalone Linux. As user friendliness of the Windows port

will improve, the exposure that Linux gets by the average computer user can

increase tremendously.

15 References

Documents

Cooperative Linux