After settings up a virtual machine using debootstrap, let’s do some more advanced work.

Kmemleak

kmemleak can be used to search for memory leaks. Enable it in the kernel and rebuild. Note that we update the “Maximum kmemleak early log entries”. If the value is too low, kmemleak would disable itself at boot time.

	-> Memory Debugging
		[*]Enable kernel memory leak detector.
		(2000) Maximum kmemleak early log entries

After booting this kernel, the memory leaks will be detected periodically. When a leak would be detected, traces will be displayed in dmesg. Leak detection can be triggered manually too.

$ echo scan >> /sys/kernel/debug/kmemleak
$ cat /sys/kernel/debug/kmemleak

A scan has a certain duration, and the detected leaks won’t appear immediately. Even after a manual scan, if no leak is detected, nothing is displayed. To ensure that no leaks where detected, it is better to wait a few tenths of seconds, and also to trigger several manual scans.

Full documentation can be found here: https://www.kernel.org/doc/Documentation/kmemleak.txt

Networking

Using serial link has some limitations as terminal emulation problems sometime occur. A screen or vi session in the guest sometimes get screwed up and need to be restarted. Hence ssh is a better candidate. To enable networking, the option is : -net nic -net user. You can immediatly notice that the interface is not setup.

auto eth0
iface eth0 inet dhcp

$ apt-get install openssh-server
$ adduser fredo

To add a redirection from ssh guest port to a host port -net nic -net user,hostfwd=tcp::5555-:22.

$ qemu-system-x86_64 -kernel bzImage
                     -append "root=/dev/sda console=ttyS0 single"
                     -drive file=toto.img,index=0,media=disk,format=raw
                     --enable-kvm --nographic
                     -net nic -net user,hostfwd=tcp::5555-:22

On the host, connect with:

$ ssh -p 5555 fredo@localhost

Bridging a usb device with qemu

A realworld USB device can be bridged into Qemu. It takes the following option. -usb -usbdevice host:050d:016a. The cryptic last two values are product and vendor ids. They can be retrieved using lsusb on the host.

Booting in gdb

We can go even further in debugging the kernel using gdb. Just add the necessary options. Those can be found in “Kernel hacking”.

	[*] KGDB: kernel debugger  --->
		<*>   KGDB: use kgdb over the serial console
	-> Compile-time checks and compiler options
		[*] Compile the kernel with debug info

We must add the -s option to qemu. It will instruct qemu to create a serial port to control kernel debugging in the guest. This serial port will be backed to a tcp socket that a gdb running on the host can connect to.

Our command line becomes:

$ qemu-system-x86_64 -kernel arch/x86/boot/bzImage
                     -hda toto.img
                     -append "root=/dev/sda" -s

qemu will start as usual and run as if nothing happened.

vmlinux is the uncompressed bzImage and the symbols are included in the binary. This is what we use in gdb:

$ gdb vmlinux

In gdb, attach to the running machine:

(gdb) target remote localhost:1234

Note that the virtual machine has been stopped. From here it is now possible to inspect the backtrace and use typical gdb commands: breakpoint, continue… Try that (and delete quickly):

(gdb) breakpoint spin_lock
(gdb) continue

More kernel debugging options

In kernel hacking, an good amount of debugging tools are available: dynamic_debug: You want to enable dynamic debug.

	-> printk and dmesg options
		[*] Enable dynamic printk() support

ftrace: ftrace can be useful too

	-> Tracers (FTRACE [=y])

I wont tell more here, since excellent lectures already exists: see lwn.

Using several qemu at same time

Only one qemu at a time can handle -s. Should you really need to debug two machines at a time, it is possible to create a dedicated serial port per process.

Using the same disk image from two machines at same time will generate undefined results and is highly likely to break the disk image. Just copy the image with a new name to use it. Qemu also provide copy-on-write, which helps to solve that problem by writing changes to the original filesystem in a separate file.