*

Kernel debugging with QEMU: An overview of tools available

Posted on 13/03/2017 by Frédéric Dalleau

After setting 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 here and here.

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.

 

Original post

Comments (0)


Add a Comment





Allowed tags: <b><i><br>Add a new comment:


Latest Blog Posts

XDC 2017 - Links to recorded presentations (videos)

23/09/2017

Many thanks to Google for recording all the XDC2017 talks. To make them easier to watch, here are direct links to each talk recorded at…

DebConf 17: Flatpak and Debian

17/08/2017

Last week, I attended DebConf 17 in Montréal, returning to DebConf for the first time in 10 years (last time was DebConf 7 in Edinburgh).…

Android: NXP i.MX6 on Etnaviv Update

24/07/2017

More progress is being made in the area of i.MX6, etnaviv and Android. Since the last post a lot work has gone into upstreaming and stabilizing…

vkmark: more than a Vulkan benchmark

18/07/2017

Ever since Vulkan was announced a few years ago, the idea of creating a Vulkan benchmarking tool in the spirit of glmark2 had been floating…

Quick hack: Performance debugging Linux graphics on Mesa

29/06/2017

Debugging graphics performance in a simple and high-level manner is possible for all Gallium based Mesa drivers using GALLIUM_HUD, a feature…

Debian armhf VM on arm64 server

20/06/2017

At Collabora one of the many things we do is build Debian derivatives/overlays for customers on a variety of architectures including 32…

Open Since 2005

We use cookies on this website to ensure that you get the best experience. By continuing to use this website you are consenting to the use of these cookies. To find out more please follow this link.

Collabora Ltd © 2005-2017. All rights reserved. Website sitemap.