Another year, another Google Summer of Code. This time I got the chance to work on something that I had on my TODO list for quite a long time: DRM Render- and Modeset-Nodes

As part of the X.org Foundation mentoring organization, I will try to pick up the work from Ilija Hadzic, Dave Airlie, Kristian Hoegsberg, Martin Peres and others. The idea is to extend the DRM user-space API of the linux kernel to split modeset and rendering interfaces apart. The main usage is to allow different access-modes for graphics-compositors (which require the modeset API) and client-side rendering or GPGPU-users (which both require the rendering API). We currently use the DRM-Master interface to restrict the modeset API to privileged applications. However, this requires SYS_CAP_ADMIN privileges, which is roughly equivalent to root-privileges. With two different interfaces for modeset and rendering APIs, we can apply a different set of filesystem-access-modes to each of them and thus get fine-grained access-control.

Apart from fine-grained access control, we also get some other nice features almost for free:

We will be able to run GPGPU clients without any running compositor or event without any display controller

We can split modeset objects across multiple nodes to allow multi-seat setups with a single display controller

Efficient compositor-stacking by granting page-flip access or full modeset access temporarily to sub-compositors

There are actually a lot of other ideas how to extend this. So I decided to concentrate on the modeset-node / render-node split first. Once that is done (and fully working), I will pick different ideas that depend on this and try to implement them. Considering the lot of work others have put in this already, I think if I get the split merged into mainline, the project will already be a great success. Everything on top of it will be some bonus that will probably take more time to get merged. But lets see, maybe it turns out to be easier than I think and we end up with some of the use-cases merged upstream, too.

Thanks to the X.org Foundation, Google and my GSoC-mentor Dave Airlie for giving me the chance to work on the DRM API! I hope it will be a productive summer.

GSoC-Proposal

If someone is interested in more details, some excerpts from my original GSoC proposal:

Project Description: Since several years xserver is no longer the only user-space project that makes use of the kernel DRM API. The introduction of KMS allowed many new projects to emerge, including plymouth, weston and kmscon. On the other side, OpenCL support allows applications to make use of DRM without requiring any KMS APIs. Even though both use-cases work with the current APIs, there are a lot of restrictions that need to be worked around. The most problematic concept is DRM-Master. KMS applications are required to be DRM-Master to perform modesetting, but DRM-Master is tightly coupled to CAP_SYS_ADMIN/root. On the other side, render clients are required to be assigned to a DRM-Master so they can get authenticated. This prevents off-screen/offline rendering without a running compositor. One possible solution is to split render- and modeset-nodes apart. The DRM control node can be used as the management node (which is, as far as I understand, what it was designed for, anyway). A separate static render-node is created for each DRM device which is restricted to ioctls specific to rendering operations. Instead of requiring drmAuth() for authorization, we can now use filesystem access-modes. This allows slightly more dynamic access-control, but the biggest advantage is that we can do off-screen/offline rendering without a running compositor/DRM-Master. On the other side, a modeset-node is a concept to have KMS separated from DRM. The use-case is to split modeset objects (eg., crtcs, encoders, connectors) across different modesetting applications. This allows one compositor to use one CRTC+connector combination, while another compositor (maybe on another seat) can use another CRTC+external-connector. This doesn't have to be a static setup. On the contrary, one use-case I am very interested in is a dynamic modeset-object assignment to temporary clients. This way, a fullscreen application can be granted page-flip rights from the compositor to avoid context-switches to the compositor for doing trivial page-flips only. Deliverables * Working render-node clients: Preferably an offline OpenCL example and a wayland EGL client * Merged kernel render-node implementation with at least i915 support * Dynamic kernel modeset-nodes * "Zero-context-switches" wayland/weston fullscreen client (optional) Known Problems: There were several attempts to push render-nodes into the kernel, but all failed due to missing motivation to finish the user-space clients. Writing up new fancy APIs is one part, but pushing API changes to such big projects requires the whole environment to work well with the changes. That's why I want to concentrate on the user-space side of render-nodes. And I want to finish the render-nodes project before continuing with modeset-nodes. The idea has been around long enough that it's time that we get it done. However, one problem is that I never worked with the low-level X11 stack. The wayland environment is great for experiments and quite active. I am very familiar with it and know how to get examples easily running. The xserver, however, is a huge black box to me. I know the concepts and understand the input and graphics drivers design. But I never read xserver core code. That's something I'd like to change during this project. I will probably be limited to DRI and graphics drivers, but that's a good start. Another idea that came up quite often is something like gem-fs. It's far beyond the scope of this project, but it's something I'd like to keep in mind when designing the API. It's hard to account for something that's only an idea, but the concepts seem related so I will try to understand the reasons behind gem-fs and avoid orthogonal implementations. A few smaller implementation-specific problems are already known, including the mmap-security problem, static "possible_encoders"/"possible_crtcs" bitsets and missing MMUs on GPUs. However, there already have been ideas how to solve them so I don't consider them blockers for render-nodes.