Kernel Recipes 2016 - The Free Software Bastard Guide

•

1 like•737 views

Developer, Enterprise, there are many ways to be a Free Software bastard. This talk will give you some useful hints to become the best asshole in communities. Clément Oudot – Clément Oudot works for Savoir-faire Linux, a worldwide FOSS company. He is the leader of LemonLDAP::NG, a free WebSSO and Access Management software. He also works for other LDAP-related projects (OpenLDAP, LDAP Tool Box, LDAP Synchronization Connector).

Software

~ 2 ~@CreativeConnard
HOW TO
be an asshole
~ User ~
~ Developer ~
~ Company ~

~ 4 ~@CreativeConnard
Chapter #1
[ Mailing lists ]

~ 5 ~@CreativeConnard
Don’t use lists
Send mail directly to project leaders※
Paste stack traces on IRC channels※
Use Twitter and Facebook to ask question or report
problems※
※ Open issues in bug tracker to ask questions

~ 6 ~@CreativeConnard
Use the lists
Never register! Let administrators take time to moderate
your message.
Be rude if you don’t get any answer.
※
Use a Vacation Away message to inform all people that
your are not available※
Do not answer to the list but directly to sender. You want
to get help, not to give it.※

~ 7 ~@CreativeConnard
Invite the list to all professional networks

~ 8 ~@CreativeConnard
Write on lists
※
Use your mother thong. Anybody can use a translation tool
to read you.
Answer on top, don’t include original text, use HTML,
include pictures in your signature, TRY TO
UPPERCASE ALL WORDS, put !!! and ??? everywhere
※
※ FEED THE TROLL

~ 9 ~@CreativeConnard
Chapter #2
[ Bugs ]

~ 10 ~@CreativeConnard
Find bugs
※ Use prehistoric version (>2 years old)
※ Use non official patch
※ Use weird operating systems
※ Let your children use the software

~ 11 ~@CreativeConnard
Report bugs
※
Don’t search if the bug was already reported, try to create
duplicates
※ Description “Does not work” is often enough
※
Demand a quick solution for free. Use the word “ASAP”.
Never test the patch because it’s too hard

~ 13 ~@CreativeConnard
Chapter #3
[ Documentation ]

~ 14 ~@CreativeConnard
Acronyms
※ RTFM (Read The Fucking Manual)
※ WITFM (Where Is The Fucking Manual)
※ TODO (Too Old DOcument)
※ RTS (Read The Source)

~ 15 ~@CreativeConnard
Documentation everywhere
※
Create files in project (README, INSTALL) but never
update them
※ Install an open wiki (without authentication)
※
Explain a lot of things on mailing list but never put them in
a documentation

~ 16 ~@CreativeConnard
Chapter #4
[ Quality ]

~ 17 ~@CreativeConnard
TESTING
IS
DOUBTING

~ 19 ~@CreativeConnard
Using Free Software
※ License? Let this to Bob from accounting department
※ OMG they give it for free! Idiots ;)
※ Give something back? We will that next year
※ Community? Are we doing politics here?

~ 20 ~@CreativeConnard
Making Free Software
※ Fork instead of contributing (Fork as a Service)
※
Keep interesting features for “enterprise” edition, because
only big companies use them
※
Create a new license and pay a team of lawyer for this,
because no existing license fits your needs
※
Don’t let external people contribute, they will mess up all
with their dirty hands

~ 21 ~@CreativeConnard
@CreativeConnard
Links for bastards
@DonJon_Legacy
http://donjonlegacy.com/

What's hot

But there is no web component for that - Web Components Remote Conference - 2...

Horacio Gonzalez

Desktop e go!

jefferson Otoni Lima

WTF Is the Semantic Web? - Greg Elin

CrisisCommons

WTF Is the Semantic Web? Ignite

Greg Elin

Khem Puthea

Teach your Browser new tricks

Dirk Ginader

AWS Lambda, WTF : I secretly hate you

Brentoids

Kotlin no Hacktown 2018

Lucas de Almeida Marciano

AWS Lambda, WTF

Brentoids

Frozen Perl 2009 Keynote

Andy Lester

Scott Chamberlain: Thinking Programmatically #crossref15

Crossref

R language installation

payalnirmal

What's hot (12)

But there is no web component for that - Web Components Remote Conference - 2...

Desktop e go!

WTF Is the Semantic Web? - Greg Elin

WTF Is the Semantic Web? Ignite

Teach your Browser new tricks

AWS Lambda, WTF : I secretly hate you

Kotlin no Hacktown 2018

AWS Lambda, WTF

Frozen Perl 2009 Keynote

Scott Chamberlain: Thinking Programmatically #crossref15

R language installation

Viewers also liked

Linux has multiple access-control features, which help to contain the damage from a malicious process. However, it is difficult and complex, especially for unprivileged users, to create a sandboxed application because of the currently administrator-oriented security. seccomp-bpf was a big step forward in empowering any user with the ability to filter syscalls and therefore limit access to some resources. Nevertheless, it lacks the ability to create a full standalone sandbox (e.g. restrict access to a set of files), unlike Seatbelt/XNU Sandbox or OpenBSD Pledge. In this talk, we present Landlock, a new Linux Security Module for unprivileged users. This brings some interesting challenges, from architecture design to userland API definition. Mickaël Salaün

Kernel Recipes 2016 - Landlock LSM: Unprivileged sandboxing

Anne Nicolas

Paper

Mokey Mokie

Concurso Cultural 20 anos com estilo

QualityBrasilLCC

B-TECH CONSOLIDATE MARK LIST

nirmal francis

ey-getting-from-big-data-to-analytics

Gautam Jaggi

skill competion certificcate

nirmal francis

2011_Beyond borders_FINAL_High_Res

Gautam Jaggi

Patches carved into stone tablets, why the Linux kernel developers rely on plain text email instead of using “modern” development tools. With the wide variety of more “modern” development tools such as github, gerrit, and other methods of software development, why is the Linux kernel team still stuck in the 1990’s with ancient requirements of plain text email in order to get patches accepted? This talk will discuss just how the kernel development process works, why we rely on these “ancient” tools, and how they still work so much better than anything else. Patches carved into stone tablets, why the Linux kernel developers rely on plain text email instead of using “modern” development tools. With the wide variety of more “modern” development tools such as github, gerrit, and other methods of software development, why is the Linux kernel team still stuck in the 1990’s with ancient requirements of plain text email in order to get patches accepted? This talk will discuss just how the kernel development process works, why we rely on these “ancient” tools, and how they still work so much better than anything else. Greg KH, The Linux Foundation

Kernel Recipes 2016 - Patches carved into stone tablets...

Anne Nicolas

Kernel Recipes 2016 - Speeding up development by setting up a kernel build farm

Anne Nicolas

Measuring the impact and return of social and community programs

Next Generation Consultants: Reana Rossouw

I have always wondered what happens when we enter the kernel from userspace: what preparations does the hardware meet when the userspace to kernel space switch instructions are executed and back, and what does the kernel do when it executes a system call. There are also a bunch of things it does before it executes the actual syscall so I try to look at those too. This talk is an attempt to demystify some of the aspects of the cryptic x86 entry code in arch/x86/entry/ written in assembly and how does that all fit with software-visible architecture of x86, what hardware features are being used and how. With the hope to get more people excited about this funky piece of the kernel and maybe have the same fun we’re having. Borislav Petkov, SUSE

Kernel Recipes 2016 - entry_*.S: A carefree stroll through kernel entry code

Anne Nicolas

The Linux kernel features an extensive array of, to put it kindly, somewhat disorganized documentation. A significant effort is underway to make things better, though. This talk will review the state of kernel documentation, cover the changes that are being made (including the adoption of a new system for formatted documentation), and discuss how interested developers can help. Jonathan Corbet, LWN.net

Kernel Recipes 2016 - Kernel documentation: what we have and where it’s going

Anne Nicolas

Libabigail is a new infrastructure for semantic analysis of ELF binaries containing C or C++ programs that has emerged lately. It powers command line tools like ‘abidiff’, which let users compare ABI changes between two different versions of a given ELF binary by analyzing just the binary and its ancillary debug information. The result of the binary comparison is a kind of hierarchical ‘diff’ which shows changes up to the types of the interfaces that constitute the ABI of an ELF program. This interactive talk intents to spark discussions around the idea of having a libabigail-based tool specifically targeted to comparing the ABI of two Linux Kernel binary trees and how it could be useful to maintainers of the stable kernel tree. The main goal of such a tool would be to show the ABI differences between two kernels, in terms of which function or variable — part of the ABI exposed by the kernel to its modules — changed and what the details of the changes are. This interactive talk will present what libabigail and its associated tools can do today, and how the library can be used to build an hypothetical “kabidiff” new tool. Discussions are going to be very welcome so please make sure to attend. Dodji Seketeli, Red Hat

Kernel Recipes 2016 - Would an ABI changes visualization tool be useful to Li...

Anne Nicolas

Kernel Recipes 2016 -

Anne Nicolas

The PREEMPT_RT patch turns Linux into a hard Real-Time designed operating system. But it takes more than just a kernel to make sure you can meet all your requirements. This talk explains all aspects of the system that is being used for a mission critical project that must be considered. Creating a Real-Time environment is difficult and there is no simple solution to make sure that your system is capable to fulfill its needs. One must be vigilant with all aspects of the system to make sure there are no surprises. This talk will discuss most of the “gotchas” that come with putting together a Real-Time system. You don’t need to be a developer to enjoy this talk. If you are curious to know how your computer is an unpredictable mess you should definitely come to this talk. Steven Rostedt - Red Hat

Kernel Recipes 2016 - Understanding a Real-Time System (more than just a kernel)

Anne Nicolas

JLR E Learning Completed Courses

Kiran Bobade

A tale from one of the busier places (by patch churn at least) in the kernel, and how to make it all work well. Since about 1 year the drm/i915 kernel driver is maintained by 2 maintainers and a team of 15 people who can apply patches directly to the main branch – in a way it’s group maintainership, but with a fairly large group, by kernel standards. It all started as an experiment, with the expectation that worst case I’ll burry it quietly again. Which hasn’t happened, at least yet. I’ll talk about why I considered trying this out, what I feared could happen, what’s actually happened and what I think, with a bit of hindsight, are the key ingredients to make this work, and where it could be useful model in other places. Daniel Vetter

Kernel Recipes 2016 - Maintainer’s Don’t Scale

Anne Nicolas

Kernel Recipes 2016 - Control Group Status Update

Anne Nicolas

About 5 years ago I was at a big conference on the topic of what’s needed for upstream graphics. I spent a lot of time apologizing for and ranting about the various horror shows in the DRM graphics subsystems. And eventually some engineer from a hardware vendor asked: “If this all such crap, why should we bother with upstream graphics?“ Now I can finally and honestly answer this, because upstream supports everything, has helpers for all possible and impossible display standards, is supported by ever Linux-based OS out there and every vendor has a driver. In this talk I will present about how we got there, and especially what’s been going on recently. Daniel Vetter

Kernel Recipes 2016 - Upstream Kernel Graphics is (Finally) Winning

Anne Nicolas

Design Portfolio

Colorcode Global

Viewers also liked (20)

Kernel Recipes 2016 - Landlock LSM: Unprivileged sandboxing

Paper

Concurso Cultural 20 anos com estilo

B-TECH CONSOLIDATE MARK LIST

ey-getting-from-big-data-to-analytics

skill competion certificcate

2011_Beyond borders_FINAL_High_Res

Kernel Recipes 2016 - Patches carved into stone tablets...

Kernel Recipes 2016 - Speeding up development by setting up a kernel build farm

Measuring the impact and return of social and community programs

Kernel Recipes 2016 - entry_*.S: A carefree stroll through kernel entry code

Kernel Recipes 2016 - Kernel documentation: what we have and where it’s going

Kernel Recipes 2016 - Would an ABI changes visualization tool be useful to Li...

Kernel Recipes 2016 -

Kernel Recipes 2016 - Understanding a Real-Time System (more than just a kernel)

JLR E Learning Completed Courses

Kernel Recipes 2016 - Maintainer’s Don’t Scale

Kernel Recipes 2016 - Control Group Status Update

Kernel Recipes 2016 - Upstream Kernel Graphics is (Finally) Winning

Design Portfolio

Similar to Kernel Recipes 2016 - The Free Software Bastard Guide

Everything you wanted to know about making an R package but were afraid to ask

Emily Robinson

How to Create the API Document from Real API and Localization

Pronovix

Rails Development That Doesn't Hurt

Akira Matsuda

It's time to be honest with ourselves and admit that we do not treat our frontend code the same way we treat our backend code. And it shows. But what's wrong with our frontend code, you ask? Well, not surprisingly, the same things that we usually recognize as Bad Things™ for backend: duplication, coupling, clutter, lack of unit tests, bad naming, etc. Let's take a closer look at some of these anti-patterns showing up in our frontend code and how we can avoid them.

[Codecamp] The sorry state of frontend code

Alin Pandichi

Networking with Twitter, Part 2

Dennis Lembree

How to discover contribution item ?

Gyuyoung Kim

Similar to Kernel Recipes 2016 - The Free Software Bastard Guide (6)

Everything you wanted to know about making an R package but were afraid to ask

How to Create the API Document from Real API and Localization

Rails Development That Doesn't Hurt

[Codecamp] The sorry state of frontend code

Networking with Twitter, Part 2

How to discover contribution item ?

More from Anne Nicolas

Wanting to avoid the Android experience, Google developers always aimed to make their Chrome OS Linux kernels as close to mainline as possible. However, when Chromebooks were first created, Google was left with no choice, the mainline kernel, in some subsystems, still did not have all the functionalities needed by Chromebooks. Hence, similarly to Android, Chrome OS had to develop their own out-of-tree code for the kernel and maintain that for a few different kernel versions. Luckily, over the last few years a strong and consistent effort has been happening to bring Chromebook devices closer to mainline. It has led to significant improvements that now make it possible to run mainline on Chrome OS devices. And not only Chromebooks, as these significant strides are also improving Arm-based SOCs and other key components of the rich Chromebook hardware ecosystem. In this talk, we will look at how and why upstream support for Chromebooks improved, the current status of various models, and what we expect in the future. Enric Balletbò i Serra

Kernel Recipes 2019 - Driving the industry toward upstream first

Anne Nicolas

As the name would suggest, a Non-Maskable Interrupt (NMI) is an interrupt-like feature that is unaffected by the disabling of classic interrupts. In Linux, NMIs are involved in some features such as performance event monitoring, hard-lockup detector, on demand state dumping, etc… Their potential to fire when least expected can fill the most seasoned kernel hackers with dread. AArch64 (aka arm64 in the Linux tree) does not provide architected NMIs, a consequence being that features benefiting from NMIs see their use limited on AArch64. However, the Arm Generic Interrupt Controller (GIC) supports interrupt prioritization and masking, which, among other things, provides a way to control whether or not a set of interrupts can be signaled to a CPU. This talk will cover how, using the GIC interrupt priorities, we provide a way to configure some interrupts to behave in an NMI-like manner on AArch64. We’ll discuss the implementation, some of the complications that ensued and also some of the benefits obtained from it. Julien Thierry

Kernel Recipes 2019 - No NMI? No Problem! – Implementing Arm64 Pseudo-NMI

Anne Nicolas

At a rate of almost 9 changes per hour (24/7), the Linux kernel is definitely a scary beast. Bugs are introduced on a daily basis and, through the use of multiple code analyzers, *some* of them are detected and fixed before they hit mainline. Over the course of the last few years, Gustavo has been fixing such bugs and many different issues in every corner of the Linux kernel. Recently, he was in charge of leading the efforts to globally enable -Wimplicit-fallthrough; which appears by default in Linux v5.3. This presentation is a report on all the stuff Gustavo has found and fixed in the kernel with the support of the Core Infrastructure Initiative. Gustavo A.R. Silva

Kernel Recipes 2019 - Hunting and fixing bugs all over the Linux kernel

Anne Nicolas

Kernel Recipes 2019 - Metrics are money

Anne Nicolas

The Linux kernel project includes a huge amount of documentation, but that information has seen little in the way of care over the years. The amount of care has increased significantly recently, though, and things are improving quickly. Listen as the kernel’s documentation maintainer discusses the current state of the kernel’s docs, how we got here, where we’re trying to go, and how you can help. Jonathan Corbet

Kernel Recipes 2019 - Kernel documentation: past, present, and future

Anne Nicolas

Modern SoC designs incorporate technologies from numerous vendors, each with their own inconsistent, confusing, undocumented and even contradictory terminology. The result is a mess of acronyms and product names which have a surprising impact on the ability to develop reusable, modular code thanks to the nature of the underlying IP being obscured. This presentation will dive into some of the misnomers plaguing the Arm ecosystem, with the aim of explaining why things are like they are, how they fit together under the architectural umbrella and how you, as a developer, can decipher the baffling ingredients list of your next SoC design! Will Deacon

Embedded Recipes 2019 - Knowing your ARM from your ARSE: wading through the t...

Anne Nicolas

GNU poke is a new interactive editor for binary data. Not limited to editing basic ntities such as bits and bytes, it provides a full-fledged procedural, interactive programming language designed to describe data structures and to operate on them. Once a user has defined a structure for binary data (usually matching some file format) she can search, inspect, create, shuffle and modify abstract entities such as ELF relocations, MP3 tags, DWARF expressions, partition table entries, and so on, with primitives resembling simple editing of bits and bytes. The program comes with a library of already written descriptions (or “pickles” in poke parlance) for many binary formats. GNU poke is useful in many domains. It is very well suited to aid in the development of programs that operate on binary files, such as assemblers and linkers. This was in fact the primary inspiration that brought me to write it: easily injecting flaws into ELF files in order to reproduce toolchain bugs. Also, due to its flexibility, poke is also very useful for reverse engineering, where the real structure of the data being edited is discovered by experiment, interactively. It is also good for the fast development of prototypes for programs like linkers, compressors or filters, and it provides a convenient foundation to write other utilities such as diff and patch tools for binary files. This talk (unlike Gaul) is divided into four parts. First I will introduce the program and show what it does: from simple bits/bytes editing to user-defined structures. Then I will show some of the internals, and how poke is implemented. The third block will cover the way of using Poke to describe user data, which is to say the art of writing “pickles”. The presentation ends with a status of the project, a call for hackers, and a hint at future works. Jose E. Marchesi

Kernel Recipes 2019 - GNU poke, an extensible editor for structured binary data

Anne Nicolas

Operating system distributors often face challenges that are somewhat different from that of upstream kernel developers. For instance, some kernel updates often need to stay at least binary compatible with modules that might be “out of tree” for some time. In that context, being able to automatically detect and analyze changes to the binary interface exposed by the kernel to its module does have some noticeable value. The Libabigail framework is capable of analyzing ELF binaries along with their accompanying debug info in the DWARF format, detect and report changes in types, functions, variables and ELF symbols. It has historically supported that for user space shared libraries and application so we worked to make it understand the Linux kernel binaries. In this presentation, we are going to present the current support of ABI analysis for Linux Kernel binaries, the challenges we face, how we address them and the plans we have for the future. Dodji Seketeli, Jessica Yu, Matthias Männich

Kernel Recipes 2019 - Analyzing changes to the binary interface exposed by th...

Anne Nicolas

Different upgrade and update strategies exist when it comes to embedded Linux system. If at development time none of these strategies have been chosen, adding them afterwards can be tedious task. Even harder it gets when the system is already deployed in the field and only accessible via a 3G connection. This talk is a developer experience of putting in place exactly that. Giving a return of experience on one way of doing it on a system running Barebox and a Yocto-based distribution. Patrick Boettcher

Embedded Recipes 2019 - Remote update adventures with RAUC, Yocto and Barebox

Anne Nicolas

Traditionally graphics drivers were one of the last hold-outs of proprietary software in an embedded Linux system. This situation is changing with open-source graphics drivers showing up for almost all of the graphics acceleration peripherals on the market right now. This talk will show how open-source graphics drivers are making embedded systems less special, as well as trying to provide an overview of the Linux graphics stack, de-mystifying what is often seen as black magic GPU stuff from outside observers. Lucas Stach

Embedded Recipes 2019 - Making embedded graphics less special

Anne Nicolas

This talk will explore Open Source Hardware projects relevant to Linux, including boards like BeagleBone, Olimex OLinuXino, Giant board and more. Looking at the benefits and challenges of designing Open Source Hardware for a Linux system, along with BeagleBoard.org’s experience of working with community, manufacturers, and distributors to create an Open Source Hardware platform. In closing also looking at the future, Libre Silicon like RISC-V designs, and where this might take Linux. Drew Fustini

Embedded Recipes 2019 - Linux on Open Source Hardware and Libre Silicon

Anne Nicolas

The I2C subsystem is not the shiniest part of the Linux Kernel. For embedded devices, though, it is one of the many puzzle pieces which just have to work. Wolfram Sang has the experience of maintaining this subsystem for nearly 7 years now. This talk gives a short overview of how maintaining works in general and specifically in this subsystem. But mainly, it will highlight noteworthy points in the timeline and lessons learnt from that. It will present trends, not so much regarding I2C but more the Linux Kernel and the embedded ecosystem in general. And of course, there will be plenty of anecdotes and bits from behind the scenes for your entertainment. Wolfram Sang

Embedded Recipes 2019 - From maintaining I2C to the big (embedded) picture

Anne Nicolas

ITRenew is selling recertified OCP servers under the Sesame brand, those servers come either with their original UEFI BIOS or with LinuxBoot. The LinuxBoot project is pushing the Linux kernel inside bios flash and using userland programs as bootloader. To achieve quality on our software stack, as any project, we need to test it. Traditional BIOS are tested by hand, this is 2019 we need to do it automatically! We already presented the hardware setup behind the LinuxBoot CI, this talk will focus on the software. We use u-root for our userland bootloader; this software is written in Go so we naturally choose to use Go for our testing too. We will present how we are using and extending the Go native test framework `go test` for testing embedded systems (serial console) and improving the report format for integration to a CI. Julien Viard de Galbert

Embedded Recipes 2019 - Testing firmware the devops way

Anne Nicolas

About 60% of the Linux kernel source tree is devoted to drivers for a large variety of supported hardware components. Especially in the embedded world, the number of different SoC families, versions, and revisions, integrating a myriad of “IP cores”, keeps on growing. In this presentation, Geert will explain how to match drivers against hardware, and how to support a wide variety of (dis)similar devices, without turning platform and driver code into an entangled bowl of spaghetti.tra Starting with a brief history of driver matching in Linux, he will fast-forward to device-tree based matching. He will discuss ways to handle slight variations of the same hardware devices, and different SoC revisions, each with their own quirks and bugs. Finally, Geert will show best practices for evolving device drivers in a maintainable way, based on his experiences as an embedded Linux kernel developer and maintainer. Geert Uytterhoeven

Embedded Recipes 2019 - Herd your socs become a matchmaker

Anne Nicolas

Buildroot is a popular and easy to use embedded Linux build system. It generates, in few minutes, lightweight and customized Linux systems, including the cross-compilation toolchain, kernel and bootloader images, as well as a wide variety of userspace libraries and programs. This talk is about the integration of LLVM/clang into Buildroot. In 2018, Valentin Korenblit, supervised by Romain Naour, worked on this topic during his internship at Smile ECS. After a short introduction about llvm/clang and Buildroot, this talk will go through the numerous issues discovered while adding llvm/clang componants and how these issues were fixed. Romain will also detail the work in progress and the work to be done based on llvm/clang libraries (OpenCL, Compiler-rt, BCC. Chromium, ldd). Romain Naour

Embedded Recipes 2019 - LLVM / Clang integration

Anne Nicolas

This talk introduces JTAG debugging capabilities, both for debugging hardware and software. Marek first explains what the JTAG stands for and explains the operation of the JTAG state machine. This is followed by an introduction to free software JTAG tools, OpenOCD and urJTAG. Marek shortly explains how to debug software using those tools and how that ties into the JTAG state machine. However, JTAG was designed for testing hardware. Marek explains what boundary scan testing (BST) is, what are BSDL files and their format, and practically demonstrates how to blink an LED using BST and only free software tools. Marek Vasut

Embedded Recipes 2019 - Introduction to JTAG debugging

Anne Nicolas

PipeWire is an open source project that aims to greatly improve audio and video handling under Linux. Utilising a fresh design, it bridges use cases that have been previously addressed by different tools – or not addressed at all -, providing ground for building complex, yet secure and efficient, multimedia systems. In this talk, Julien is going to present the PipeWire project and the concepts that make up its design. In addition, he is going to give an update of the current and future work going on around PipeWire, both upstream and in Automotive Grade Linux, an early adopter that Julien is actively working on. Julian Bouzas

Embedded Recipes 2019 - Pipewire a new foundation for embedded multimedia

Anne Nicolas

Ftrace’s most powerful feature is the function tracer (and function graph tracer which is built from it). But to have this enabled on production systems, it had to have its overhead be negligible when disabled. As the function tracer uses gcc’s profiling mechanism, which adds a call to “mcount” (or more recently fentry, don’t worry if you don’t know what this is, it will all be explained) at the start of almost all functions, it had to do something about the overhead that causes. The solution was to turn those calls into “nops” (an instruction that the CPU simply ignores). But this was no easy feat. It took a lot to come up with a solution (and also turning a few network cards into bricks). This talk will explain the history of how ftrace came about implementing the function tracer, and brought with it the possibility of static branches and soon static calls! Steven Rostedt

Kernel Recipes 2019 - ftrace: Where modifying a running kernel all started

Anne Nicolas

Suricata is a network threat detection engine using network packets capture to reconstruct the traffic till the application layer and find threats on the network using rules that define behavior to detect. This task is really CPU intensive and discarding non interesting traffic is a solution to enable a scaling of Suricata to 40gbps and other. This talk will present the latest evolution of Suricata that knows uses eBPF and XDP to bypass traffic. Suricata 5.0 is supporting the hardware XDP to provide ypass with network card such as Netronome. It also takes advantage of pinned maps to get persistance of the bypassed flows. This talk will cover the different usage of XDP and eBPF in Suricata and shows how it impact performance and usability. If development time permit, the talk will also cover AF_XDP and the impact on this new capture method on Suricata. Eric Leblond

Kernel Recipes 2019 - Suricata and XDP

Anne Nicolas

System memory configuration is a transparent operation nowadays, something that we all came to expect to just work out of the box. Still, it does happen behind the scenes every single time we boot our computers. This requires the cooperation of hardware components on the mainboard and on memory modules themselves, as well as firmware code to drive these. While it is possible to just let it happen, having a deeper understanding of how it works makes it possible to access valuable information from the operating system at run-time. I will take you through the history of system memory configuration from the mid 70s to now. We will explore the different types of memory modules, how their configuration data is stored and how the firmware can access them. We will see which problems had to be solved along the way and how they were solved. Lastly we will see how Linux supports reading the memory configuration information and what you can do with that information. Jean Delvare

Kernel Recipes 2019 - Marvels of Memory Auto-configuration (SPD)

Anne Nicolas

More from Anne Nicolas (20)