An updated version of my presentation on Linux user namespaces, a mechanism that is at the heart of many interesting technologies that allow isolation and sandboxing of applications, for example running containers without root privileges and sandboxes for web browser plug-ins.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make.
Even a seemingly simple API can turn out to have complex and surprising behaviors, as I illustrate by telling the story of an API feature that was added to Linux in 1997 and looking at how it interacts (and has evolved) with other parts of the Linux API. These kinds of complexities and surprises of course create pain for user-space programmers, and so I also muse about some of the reasons that these API design problems occur and a few things we can do to reduce the likelihood of such problems reoccurring in the future.
One goal of containers is to provide an illusion: that a group of processes is in a world of their own, and that there are no other processes on the system. In this presentation, I briefly describe how namespaces, capabilities, cgroups (control groups), and seccomp are used to support the creation of that illusion.
Cgroups v2 is (finally) supplanting cgroups v1. This presentation describes how cgroups work from the perspective of the future. That is to say, we ignore cgroups v1, and explore how cgroups work starting fresh from a version 2 perspective.
Continuing on from "An introduction to control groups (cgroups) version 2", this presentation takes a look at some of the more advanced features of cgroups, namely, release notification, delegation, and thread mode.
An introduction to the Linux capabilities model.
A lightly revised (and somewhat shorter) version of a presentation that I first gave at Linux Piter 2019 at the start of the same month. See below.
An introduction to Linux user namespaces, a mechanism that is at the heart of many interesting technologies that allow isolation and sandboxing of applications.
Once upon an API
(video)
—
Linux Piter 2019;
5 October 2019, St Petersburg, Russia
Even a seemingly simple API can turn out to have complex and surprising behaviors, as I illustrate by looking at an API feature that was added to Linux in 1997 and considering how it interacts (and has evolved) with other parts of the Linux API. These kinds of complexities and surprises of course create pain for user-space programmers, and so I consider some of the reasons that these API design problems occur and what we can do to reduce the likelihood of such problems reoccurring in the future.
An overview of Linux namespaces—including UTS, mount, network, and PID namespaces—in order to understand what resources they govern and what use cases they serve.
An introduction to Linux user namespaces, a mechanism that is at the heart of many interesting technologies that allow isolation and sandboxing of applications.
A presentation covering the motivations for the cgroups v2 redesign and how cgroups v2 differs from cgroups v1.
An introduction to cgroups, primarily focussing on cgroups v1.
An introduction to Linux user namespaces, a mechanism that is at the heart of many interesting technologies that allow isolation and sandboxing of applications, for example running containers without root privileges and sandboxes for web browser plug-ins.
An overview of Linux namespaces—including UTS, mount, network, and PID namespaces—in order to understand what resources they govern and what use cases they serve.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make.
A high-speed introduction to the workings of user namespaces.
An introduction to the Linux capabilities model.
An introduction to set-user-ID and set-group-ID programs.
A presentation covering the motivations for the cgroups v2 redesign and how cgroups v2 differs from cgroups v1.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make.
A high-speed introduction to the workings of user namespaces.
A tutorial introduction to cgroups, primarily focussing on cgroups v1.
A tutorial covering the motivations for the cgroups v2 redesign and how cgroups v2 differs from cgroups v1.
A high-speed introduction to the workings of user namespaces.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make.
An introduction to strace(1), a tool for tracing the system calls made by an application.
A high-speed introduction to the workings of user namespaces.
A high-speed introduction to the workings of user namespaces.
A discussion of Linux kernel-user-space API design, and some of the steps we could take to make it better.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make.
An introduction to the Linux control groups (cgroups) mechanism, covering both v1 and v2 cgroups.
A discussion of Linux kernel-user-space API design, and some of the steps we could take to make it better. Jonathan Corbet kindly wrote up this presentation as an article on LWN.net.
A discussion of some "soft" techniques for improving the design of Linux kernel-user-space APIs, coupled with a number of more technical tips.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make.
An introduction to strace(1), a tool for tracing the system calls made by an application
An introduction to strace(1), a tool for tracing the system calls made by an application.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make.
An overview of the seccomp (Secure Computing) facility, which can be used to restrict the set of system calls that an application may make. A summary of this talk was written up by Jake Edge for LWN.net.
A discussion of some "soft" techniques for improving the design of Linux kernel-user-space APIs, coupled with a number of more technical tips.
(An older version of a talk described above.)
A few slides that I used when Andy Lutomirski and I kicked off a discussion about review (or lack of review) of new kernel-user-space APIs at the 2014 Kernel Summit.
A few years ago, kernel hacker Dave Jones gave a highly entertaining talk entitled Why Userspace Sucks, about the ways in which various userspace systems and applications kill performance by wasting system resources on pointless tasks. I'm not contradicting anything that Dave says, but it seems at least fair to point out that there are places where kernel space sucks too. This presentation is about one of those places with special interest to me—the programming interface between the kernel and user space—a place where kernel developers have inflicted a steady stream of small train wrecks (to borrow Dave's term) on userspace.
An overview of Linux IPC techniques.
(An older version of a presentation described above.)
A talk for a non-engineer audience on what Linux and Free Software are, how they're created, where they're used, and the importance and advantages of Free Software. Presented in English to a Spanish-speaking audience, so there's a few Spanish terms sprinkled among the slides.
(An older version of a presentation described above.)
Best practices, and mistakes to avoid, in order to write secure (C) programs.
A discussion of bugs and design errors in the kernel-userland API, some theories about their causes, and some suggestions about how to improve matters.
A presentation that considered which groups determine the features that are and are not included in the Linux (kernel and glibc) programming interface, coupled with a discussion of the problems that result from the fact that ownership of the Linux interface is distributed across several groups.
A discussion of problems in newly released APIs on Linux. LWN.net had a nice summary write-up.
An exploration of how improving kernel-userland interface documentation reduces bugs in, and improves the design of, kernel-userland interfaces.
A 3-hour tutorial describing new features in the Linux 2.6 kernel-userspace interface.
A tutorial presentation on building and using shared libraries on Linux.