icylisper's blog

Faraday's book - random notes in emacs

2010-10-06T00:00:00-07:00

Faradays book is an interesting way to store your random notes and have them be organized by tags implicitly and automagically. I found this implicit-tagging system brilliant and very easy to use.

Most often you would want to post content from within your favourite editor. I love emacs and am comfortable using it to post content than typing in the rich or poor text area. Sounds like you? Then here is an emacs client for the Faraday’s book.

Download frb.el and add it to path

(require 'frb)
(setq frb-username <your-email-address>)
(setq frb-password <your-password>) ;(optionally)

Below is a demo of the emacs client for faraday’s book.

emacs client for faraday’s book from icylisper on Vimeo.

How to create a custom firmware for the ASUS O!play

2010-10-02T00:00:00-07:00

ASUS provides firmware updates quite frequently for the O!play media player. I wanted to create a custom firmware with some useful optware packages like openssh, rtorrent etc. Also wanted to enable NAS so I can copy media files to its local storage. I did not find much documentation relating to creating custom firmware. So here is what I tried and worked.

Obtaining factory firmware image

The firmware image (install.img) used by the O!Play is a simple tar file. The latest factory image can be got from: ASUS FTP server

$ mkdir install_img 
$ tar -C install_img -xvf /path/to/image.img

Now let us peek into the image and see the contents.

Peeking into the image

$ ls install_img/
arial.ttf                   configuration.xml  install_a   mkyaffs2image  video_firmware..
audio_firmware.install.bin  flash_erase        mkfs.jffs2  nandwrite      package2

The files are as follows:
bluecore.audio – Audio Firmware
video_firmware.bin – Video Firmware
yaffs2_1.img – Linux filesystem image in YAFFS2 format.

The yaffs2_1 image contains the root filesystem.

Modifying the root filesystem contents

We need the yaffs unpacker tool unyaffs. unyaffs is also available in the AUR repository for arch Linux.

$ mkdir -p yaffs2_1
$ cd yaffs2_1
$ unyaffs ../install_img/package2/yaffs2_1.img

Once in the yaffs2_1 directory which is the content of the root partition, lets make some changes. You could setup optware or modify any of the configurations to suit your needs.

Changing the root partition size

To get some free space on the root partition you have to modify the configuration.xml file.

<fileName>package2/yaffs2_1.img</fileName>
   <mountPoint>/</mountPoint>
<sizeBytesMin>0x6300000</sizeBytesMin>

The example value of 0×6300000 is a Hexvalue, in decimal it is 103809024 = 99MB.

Generating the image

Get mkyaffs2image from yaffs source

$ cd yaffs/utils
$ make

$ sudo chown -R root:root yaffs2_1
$ mkyaffs2image yaffs2_1 install_img/package2/yaffs2_1.img
$ cd install_img
$ tar cvf ../install.img *

Happy hacking!

Attaching to a running common-lisp application

2010-09-29T00:00:00-07:00

I have heard people mention about the feature of LISP systems wherein one can “attach” to a running process and change code dynamically, almost magically. There ain’t any pragmatic documentation on the subject. Ofcourse there are tools like SLIME, but they are tied to emacs or a particular client. I played a bit with Daniel Barlow’s detachtty and came up with a utility called boots.

Boots is a tool that helps install, build and launch CL applications. It also provides a facility to attach and detach from these running applications. It is a convenient wrapper on top of clbuild. Currently, it works only with SBCL. Here is a brief tutorial on boots.

Getting started

Boots is a self-extracting script and very easy to install. SBCL needs to be installed and so should versioning systems like git, darcs, cvs and svn.

$ wget http://github.com/icylisper/boots/blob/master/boots
$ ./boots self-install

To list the available application definitions:

$ boots list
Available app definitions:
  - beirc
  - cells
  - climacs
  - closure
  - common-music
  - default-swank
  - gtfl
  - listener
  - shuffletron
  - stumpwm
  - typeset
  - weblocks

The simplest image definition is the default one.

$ boots build default-swank
$ boots start default-swank

We can connect to the default-swank image from emacs that has SLIME configured.

M-x slime-connect 4005

Say, we want to try out Andy Hefner’s mcclim-based listener. Just do

$ boots install listener
$ boots build listener
$ boots start listener

And you should see the wonderful listener launch!

One can attach to the listener tty to debug if something goes wrong

$ boots attach listener
C-\ to detach

Now, let us see how to define an application image.

Defining an application image

An application image definition is a directory containing atleast these 3 files named below:

install - script to install the application
build   - script to compile and generate CL cores/images
start   - script to launch the application

Now isn’t that easy?

Happy Hacking!

How to boot a virtual machine over HTTP

2010-09-28T00:00:00-07:00

I was trying to boot a virtual machine over HTTP and I could not find much documentation on the web apart from knoppix and OS Circular. The knoppix developers have done some very interesting work in this area but very specific to knoppix. OS circular is a complete solution. I wanted something that was basic, easy-to-setup both on the server and client side. Also needed something that worked well with vmware player. I made chunks of the virtual image on the HTTP server box and aggregated them on the client using fswrapper, cloop and unionfs.

Chunking the virtual machine on the server

mkmd5files makes ‘split-and-compressed block files’ from a block device. mkmd5files is part of fs-wrapper

$ mkmd5files <block device> <index file name> <split-block size>

As an example, let us try to boot React OS over HTTP. Download the preloaded vmware image and unzip the image.

$ dd if=/dev/zero of=reactos.dd bs=1M count=40
$ mke2fs -j reactos.dd
$ mount reactos.dd /mnt/ 
$ cp -r /path/to/reactos/* /mnt/
$ umount /mnt && losetup /dev/loop1 reactos.dd
$ mkmd5files /dev/loop1 reactos.idx 262144

256KB spit-and-block files are created under “blockfile” directory. The split-and-block files are served by HTTP server and can be mounted by fs_wrapper. Let us say that the reactos index is accessible via http://host/reactos.idx

Assembling the virtual machine on the client

fs-wrapper needs to be installed on the client. Also load the cloop kernel module (it is not compiled using the default config).

$ mkdir /mnt/{image-read, image-tmp, image}
$ fs_wrapper /mnt/image-tmp -f http://host/reactos.idx
$ cd /mnt/image-tmp
$ losetup /dev/cloop3 KNOPPIX
$ mount /dev/cloop3 /mnt/image-read

Redirect the writes to a temp filesystem.

$ mkdir /mnt/image-writes
$ mount -t tmpfs tmpfs /mnt/image-writes
$ mount -t unionfs -o dirs=/mnt/image-read:/mnt/image-writes none /mnt/image

And finally launch the virtual machine.

Launching the virtual machine

vmplayer /mnt/image/reactos.vmx