zafena development

September 18, 2009

Dear Jalimo users!

I have pushed a quite massive patch into the Jalimo sourcetree to make all OpenJDK 6b16 recipe's in sync with and able to cross-compile the latest Icedtea6-1.6.1 release!

So... What’s New?
- Security fixes for:
CVE-2009-2670 – OpenJDK Untrusted applet System properties access
CVE-2009-2671 CVE-2009-2672 – OpenJDK Proxy mechanism information leaks
CVE-2009-2673 – OpenJDK proxy mechanism allows non-authorized socket connections
CVE-2009-2674 – Java Web Start Buffer JPEG processing integer overflow
CVE-2009-2675 – Java Web Start Buffer unpack200 processing integer overflow
CVE-2009-2625 – OpenJDK XML parsing Denial-Of-Service
CVE-2009-2475 – OpenJDK information leaks in mutable variables
CVE-2009-2476 – OpenJDK OpenType checks can be bypassed
CVE-2009-2689 – OpenJDK JDK13Services grants unnecessary privileges
CVE-2009-2690 – OpenJDK private variable information disclosure
- FAST interpreter for ARM, now with gcc 4.1.2 support!
- Timezone fix:
- Stackoverflow error fix:

- Backport regression (NPE) fix for AccessControlContext fix
- Bump to hs14b16

The following people helped with this release:
Gary Benson, Deepak Bhole, Andrew Haley, Andrew John Hughes, Mark
Wielaard, Lillian Angel, Matthias Klose, Ed Nevill, and many others.

We would also like to thank the bug reporters and testers!

Cheers and have a great day!

September 15, 2009

The Haiku team finally made it, they have released their first spin of the free software implementation of "BeOS"!
The R1/alpha 1 release and source can be fetched from:
Dig around and you will even find a long anticipated status update on their ARM port where they now can display a booting kernel and framebuffer!

September 13, 2009

During the past month i have been running a public llvm-arm-linux buildbot in order to iron out the remaining bugs in the LLVM Execution Engine JIT for ARM.
My goal was to stabilise the LLVM JIT so that it can be used to speed up cool projects like OpenJDK on ARM by fixing all pre-requirements to run Gary Benson's Shark JIT compiler on top of Zero!

I have been following the LLVM project for about a year and for me to see the following reports from the buildbot makes me jump of joy! It marks a new era, when all cool and silent energy efficient computing on ARM can get JIT accelerated!

  • (Sep 12 21:57) rev=[81669] success #153: build successful
  • (Sep 12 19:17) rev=[81660] success #152: build successful
  • (Sep 12 16:31) rev=[81655] failure #151: failed test-llvm
  • (Sep 12 13:03) rev=[81626] failure #148: failed test-llvm

The next LLVM release 2.6 gets out in about a week (21 of september 2009) and feel I have done my part in the LLVM stabilisation process for ARM, It are now up for the LLVM 2.6 release managers to merge in the patches from the 2.7 svn trunk to the release branch in order to make the LLVM 2.6 release stable on ARM as well.

Life is cool!

June 10, 2009

IcedTea is served: openjdk/build/linux-i586
mkdir -p stamps
touch stamps/icedtea.stamp
printf -- '-cacao ERROR\n' >> openjdk/build/linux-i586/j2sdk-image/jre/lib/i386/jvm.cfg
touch stamps/add-cacao.stamp
printf -- '-zero ERROR\n' >> openjdk/build/linux-i586/j2sdk-image/jre/lib/i386/jvm.cfg
touch stamps/add-zero.stamp
xerxes@labbserver:~/icedtea6$ openjdk/build/linux-i586/j2sdk-image/bin/java -version
java version "1.6.0_0"
OpenJDK Runtime Environment (IcedTea6 1.5-rce70ed27635c) (build 1.6.0_0-b16)
OpenJDK Shark VM (build 14.0-b15, mixed mode)

May 10, 2009

I have just pushed an update to the Jalimo project that enables the new OpenJDK 6 b16 sourcebundle to be cross-compile-able for embedded devices using Jalimo as a cross-compile layer for Icedtea6.

Using Jalimo you can now cross-compile OpenJDK b16 and have hotspot + zero, hotspot + shark or cacao as the vm built out of the box, simply awesome!

Since shark are using the pre2.6 LLVM sources for its JIT I have also prepared ".bb" build recipes for Openembedded that enables quick cross compilation of LLVM based on the LLVM svn trunk so that Jalimo can make use of them when building shark.

The shark vm are built with assertions enabled in order to produce better debug output for all Jalimo users.

Robert Schuster have been an excellent tutor for me to understand all the quirks of OE-recipes, quirks that in turn helped me to creating all these new nice cross compile recipes for OE and Jalimo. Thank you Robert and thank you for pushing the LLVM recipes into the main OE dev git tree!

Andrew Haley and Gary Benson have helped me enormously to understand the lock-free code using memory-barriers that are part of the zero and shark hotspot implementations. I will keep working on these parts in order to make zero and shark rock solid on ARM before ARM Cortex A9 multi-core CPU's will be part of every cool and silent computing loving persons pocket.

April 15, 2009

Why going to hell in the first place?
During the past year I have involved myself in the porting effort of OpenJDK to various embedded systems using the Icedtea build system. Unfortunally the embedded development boards that I had access during last year where equiped with inadequate amounts of RAM making it practically impossible to build Icedtea directly on native hardware. I learnt how to workaround this by using emulated hardware with more RAM using QEMU, now the compilation process of Icedtea was doable, yet it still took a week to compile Icedtea6 using QEMU. urgh...

I spent some time in my personal created emulator hell watching time pass by and always feeling behind not working on the current code base like all other freejava hackers. I finally decided something had to be done about this and wanted to break free.

My liberation was made possible by first scouting for a build environment suitable for rapid cross compilation and porting development of OpenJDK for any hardware architecture imaginable, including your toaster. Lucky for me I got to know about the Jalimo project and even got the chance to meet one of its core developers Robert Schuster during FOSDEM09. Robert demonstrated how easy embedded Java development could be using the Jalimo infrastructure and it provided me with all the tools I needed to speedup my compile run and test cycle, I was no longer in need of a emulator instead I could build binarys swiftly using the full power of an affordable IA32 quadcore cpu (with 12Mb of cache) and deploy my work for testing on real hardware for debugging within ohurs not days, simply bliss.

It took some time for me to understand how the four required pieces openembedded, bitbake, jalimo and my own goal could be merged, it turned out they where designed to fit!
First openembedded bitbake and jalimo where all three downloaded from their respecive svn or git trees
The only tricky part was that I (the user) needs to provide configuration files containing the basic information of what kind of target i want to crosscompile against and specify what bundles of recipe I want to use to accomplish this, basically I had to express my mind in a way that bitbake understood.

Once this was setup I could stand in any directory and start the build by simply typing:
bitbake openjdk-6
... or any other software package as long I knew the name of the recipe to use.
Even bitbake openjdk-6-shark builds out of the box!

Within a day playing with bitbake my build computer had downloaded 2gig of sourcecode, eaten several gigs of harddrive space. Rather cool... It had built all cross compilers tools I needed, compiled all dependent librarys, from scratch and all optimised for the target hardware that I wanted to run and debug the binarys on.
The final result was then obtained in the temp directory of my choice.

I have documented my work crosscompilation experiences on the Icedtea wiki:

Cheers and have a great day!

February 28, 2009


Cheers to you from Xerxes and JeNI on this flashy picture!

I have prepared for your amusement some photogallerys from the pictures I took at FOSDEM 09.
# Free Java - FOSDEM 09 photography - Arrival and first day
# Free Java - FOSDEM 09 photography - First night and dinner
# Free Java - FOSDEM 09 photography - Second day
# Free Java - FOSDEM 09 photography - The day after - a great experience

It was thrilling meeting you all during the event, many thanks to SUN for sponsoring the Free Java devroom dinner!
I will fill in more photos for the second day so stay tuned. If you are portraited in any of these photos and would prefer not to please let me know ASAP: xerxes at zafena dot se .

February 9, 2009

Mecanics performing some handson debugging.

On my flight home from FOSDEM 09 i got some experience of howto debug an airplane. The airplane I was traveling in was accelerating up to flightspeed on the runway when it suddenly started to wiggle. The pilot responded by making a emergency halt just seconds before airborne. It turnedout that the pedals the pilot used to stear the plane in flight was faulty wired and made the airplane turn in the opposite direction to how the pilot manuvered the planes pedals (ouch, not good).

Im gratefull my airliner did not simply try the three R's of windows to solve the problem like what Joseph D. Darcy had experienced done by his airliner. Instead of retrying to make a new takeoff my airliner drove the airplane back to the airport and sent in a lot of mecanics to do some handson debugging. They quickly decided to make a new new airplane "build" based on the same crew, passengers and baggage in a new yet identical plane, they also did extended and rigerous regression testing to see that the pedals was wired correctly this time.

It seems airlines have adopted the use of pre flight regression tests to minimize the time spent of inflight debugging. Perhaps developers have more to learn from aviation best practise?

The word debugging have been used years before admiral Grace Hopper found the first famous computer bug stuck inside one of the Mark II Computer at Harvard University. Debugging actually orgins from the context of aviation, more specific from finding faults in airplane engines. So i guess to bugger is when one installs faults in airplane engine and to debug is when someone removes them, on second thought perhaps to debug are simply the task of swiping off all bugs that got trapped inside and gradually clogging up the engine after a normal flight.

November 12, 2008

A lable sticker made GPLable
GPLable is a lable-print Java class library API with built in driver.
It is designed to convert and rasterise any Java swing frame/panel/component and print it on a label using the builtin pTouch GPLable QL550Driver. The API is designed to make it possible to controll the exact output of a connected QL-570, QL-550 or QL-500 printer and to make it easy to add lable-print functionality to any Java program.

Fetch the GPLable sources from:
and run java -jar GPLable.jar to get your own GPLable sticker!

Have a great day!

GPLable running on asus EeePC connected to QL-500

August 29, 2008

Processing; a lightweight Java IDE targeted for creation of interactive computer art can now be run on embedded ARM hardware thanks to the Icedtea, Cacao, Classpath and OpenJDK projects!

Check out the full Processing IDE is running below on a embedded Fedora 8 ARM Linux system ! It is running using OpenJDK6 with CACAO vm, compiled using the classpath bootstrapped Icedtea buildsystem. The ARM hardware is a ATMEL AT91SAM9263-EK devkit with a 200mhz ARMv5tejl cpu and 64Mb ram.

Good news for embedded ARM users; The Debian armel port for ARM are now shipping prebuilt openjdk packages that can be installed by simply running:

apt-get install openjdk-6-jdk

OpenJDK using the CACAO JIT can also be obtained from the experimental (sid) repositorys and be installed by running:

apt-get install cacao-oj6-jdk

I look forward to see all the possibilities with interactive art created by using embedded ARM hardware, Linux, OpenJDK and Processing!

Ps. the ARM cpu is the same kind of cpu found in most cellphones including the iPhone!


Xerxes Rånby

« Newer PostsOlder Posts »

Powered by WordPress