Talk: Kernel and Userspace frontier, V4L subsystem

The first thing to do is to enable the VIDEO_VIVID feature on the kernel.

How to enable VIDEO_VIVID on your kernel through menuconfig

To do that, inside the kernel directory, type make menuconfig. Then with the menu open, type / to begin searching and search for VIDEO_VIVID. A screen should appear with the results, with the first one being for the VIDEO_VIVID symbol. There, you should take note of the line starting with Depends on:. The symbols shown in that line need to be enabled before you can enable VIDEO_VIVID. From that line, you should see that you need to enable MEDIA_SUPPORT, V4L_TEST_DRIVERS, VIDEO_DEV and VIDEO_V4L2.

Now that you know the dependencies that you need to enable first, you can exit the results screen by typing Enter and searching for the first dependency: MEDIA_SUPPORT. Note that its only dependency (HAS_IOMEM) is already satisfied (indicated by the [=y] next to it), so you can directly enable it. To do so, first type 1, which is number in parenthesis in front of it. This will take you to the menu entry corresponding to it, which is Multimedia support, then just type y to enable it (you should see a star in front of it meaning it's now enabled). Now you should repeat this process for the remaining dependencies of VIDEO_VIVID and then enable VIDEO_VIVID itself.

With vivid enabled, recompile your kernel with make -j$(nproc).

Now copy the following code into some file and compile it:

/* V4L2 video picture grabber
   Copyright (C) 2009 Mauro Carvalho Chehab <>

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   GNU General Public License for more details.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/mman.h>
#include <linux/videodev2.h>

#define CLEAR(x) memset(&(x), 0, sizeof(x))

struct buffer {
        void   *start;
        size_t length;

static void xioctl(int fh, int request, void *arg)
        int r;

        do {
                r = ioctl(fh, request, arg);
        } while (r == -1 && ((errno == EINTR) || (errno == EAGAIN)));

        if (r == -1) {
                fprintf(stderr, "error %d, %s\n", errno, strerror(errno));

int main(int argc, char **argv)
        struct v4l2_format              fmt;
        struct v4l2_buffer              buf;
        struct v4l2_requestbuffers      req;
        enum v4l2_buf_type              type;
        fd_set                          fds;
        struct timeval                  tv;
        int                             r, fd = -1;
        unsigned int                    i, n_buffers;
        char                            *dev_name = "/dev/video0";
        char                            out_name[256];
        FILE                            *fout;
        struct buffer                   *buffers;

        fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);
        if (fd < 0) {
                perror("Cannot open device");

        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        fmt.fmt.pix.width       = 640;
        fmt.fmt.pix.height      = 480;
        fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
        fmt.fmt.pix.field       = V4L2_FIELD_INTERLACED;
        xioctl(fd, VIDIOC_S_FMT, &fmt);
        if (fmt.fmt.pix.pixelformat != V4L2_PIX_FMT_RGB24) {
                printf("Device didn't accept RGB24 format (got %x). Can't proceed.\n", fmt.fmt.pix.pixelformat);
        if ((fmt.fmt.pix.width != 640) || (fmt.fmt.pix.height != 480))
                printf("Warning: driver is sending image at %dx%d\n",
                        fmt.fmt.pix.width, fmt.fmt.pix.height);

        req.count = 2;
        req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        req.memory = V4L2_MEMORY_MMAP;
        xioctl(fd, VIDIOC_REQBUFS, &req);

        buffers = calloc(req.count, sizeof(*buffers));
        for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {

                buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory      = V4L2_MEMORY_MMAP;
                buf.index       = n_buffers;

                xioctl(fd, VIDIOC_QUERYBUF, &buf);

                buffers[n_buffers].length = buf.length;
                buffers[n_buffers].start = mmap(NULL, buf.length,
                              PROT_READ | PROT_WRITE, MAP_SHARED,
                              fd, buf.m.offset);

                if (MAP_FAILED == buffers[n_buffers].start) {

        for (i = 0; i < n_buffers; ++i) {
                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_MMAP;
                buf.index = i;
                xioctl(fd, VIDIOC_QBUF, &buf);
        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;

        xioctl(fd, VIDIOC_STREAMON, &type);
        for (i = 0; i < 20; i++) {
                do {
                        FD_SET(fd, &fds);

                        /* Timeout. */
                        tv.tv_sec = 2;
                        tv.tv_usec = 0;

                        r = select(fd + 1, &fds, NULL, NULL, &tv);
                } while ((r == -1 && (errno = EINTR)));
                if (r == -1) {
                        return errno;

                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
                buf.memory = V4L2_MEMORY_MMAP;
                xioctl(fd, VIDIOC_DQBUF, &buf);

                sprintf(out_name, "out%03d.ppm", i);
                fout = fopen(out_name, "w");
                if (!fout) {
                        perror("Cannot open image");
                fprintf(fout, "P6\n%d %d 255\n",
                        fmt.fmt.pix.width, fmt.fmt.pix.height);
                fwrite(buffers[buf.index].start, buf.bytesused, 1, fout);

                xioctl(fd, VIDIOC_QBUF, &buf);

        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
        xioctl(fd, VIDIOC_STREAMOFF, &type);
        for (i = 0; i < n_buffers; ++i)
                munmap(buffers[i].start, buffers[i].length);

        return 0;

Run virtme with read-write permissions on the folder containing the compiled code:

virtme-run --kdir=/path/to/kernel --rwdir=/path/to/folder/contaning/code

Inside virtme, execute the code you compiled.

Let it run for some seconds and cancel it with Ctrl-c.

Finally, you should open the folder containing the code you compiled on your host machine and check the files generated by the code!

Read lwn series of articles

Review the things from previous meetings, make questions, check if other students need some help.

Recommended reading: Linux Device Drivers, Chapter 3: Char Drivers and Chapter 6: Advanced Char Driver Operations.

Don’t forget to update the spreadsheet for tracking our progress.