Kernel Recipes 2013 - Viewing real time ltt trace using gtkwave

•

4 gostaram•2,597 visualizações

This presentation will explain how to use some ltt to be viewd in gtkwave, a graphical visualization tool, developped by the Parrot team. It will also explain why this tool was developed, review some of the problems that have been analyzed using these traces. It will finally end up on the ongoing integration with LTTng 2.x.

Tecnologia

Viewing LTTng traces with GTKWave
ivan.djelic@parrot.com
Sept 2013
LTTng+GTKWave

What is LTT ?
▶ Linux Trace Toolkit, appeared circa 1999 (http://www.opersys.com)
▶ Kernel patch + kernel module + userland daemon + tools
▶ Collects kernel event-data: interrupts, context switches, page faults,
syscalls, etc
▶ Userspace events also supported
▶ Traces can be post-processed and viewed with LTTV
▶ LTT now superseded by LTTng (http://lttng.org)
LTTng+GTKWave LTTng

LTTng 2.x
▶ Released in 2011
▶ Advanced low-overhead architecture
▶ Kernel patch no longer needed !
▶ Uses new trace format (CTF, Common Trace Format)
▶ LTTV support WIP
▶ Eclipse plugin:
http://www.eclipse.org/linuxtools/projectPages/lttng
▶ LTTng 2.x/0.x events are different: no compatibility with old LTTng
tools
LTTng+GTKWave LTTng

Eclipse LTTng perspective
LTTng+GTKWave LTTng

What is GTKWave ?
▶ GTK+ based waveform viewer
▶ Supports several le formats: FST, Verilog VCD, GHW, etc
▶ Handles large trace les and many trace signals at once
▶ Provides C library for creating traces in its native LXT le
format
LTTng+GTKWave GTKWave

LTTng+GTKWave
▶ A tool called ltt2lxt parses an LTT trace and generates two
les:
▶ a .lxt le (an LXT trace)
▶ a .sav le (a layout of the signals)
▶ Supports LTTng-0.x (legacy) traces, support for LTTng-2.x
trace is alpha
▶ Kernel symbols optionally used to convert addresses into
function():line strings
▶ Makes use of GTKWave nice zooming features
▶ Does not replace but complements LTTV and other tools
LTTng+GTKWave Viewing LTTng traces in GTKWave

Conversion tools: ltt2lxt and lttng2lxt
LTTng+GTKWave Viewing LTTng traces in GTKWave

An LTTng trace in GTKwave
LTTng+GTKWave Viewing LTTng traces in GTKWave

To contribute...
▶ https://github.com/idjelic/lttng2lxt
LTTng+GTKWave Viewing LTTng traces in GTKWave

Mais conteúdo relacionado

Mais procurados

Linux 开源操作系统发展新趋势

Anthony Wong

OpenWRT guide and memo

家榮吳

Agenda: * Background: namespaces/cgroups, the basis for container virtualization * Namespace implementation * The 6 kernel namespaces - some implementation details. * System calls for namespaces * Usage examples * cgroups kernel implementation * cgroup VFS * cgroup filesystem operations for handling cgroups examples * The cgroup implementation + some userspace examples * Checkpoint/Restore in brief

Namespaces and cgroups - the basis of Linux containers

Kernel TLV

OpenWrt is a Linux distribution for embedded systems that runs on many routers and networking devices today. In this session we'll talk about OpenWrt's origins, architecture and get down to building apps for the platform. Along the way we will touch on some basic firmware concepts and at last present the final working OpenWrt router and its capabilities. Anton Lerner, Architect at Sitaro, computer geek, developer and occasional maker. Sitaro provides total cyber protection for small business and home networks. Sitaro prevents massive scale IoT cyber attacks. Find out more information in the meetup event page - https://www.meetup.com/Tel-Aviv-Yafo-Linux-Kernel-Meetup/events/245319189/

OpenWrt From Top to Bottom

Kernel TLV

Automotive Grade Linux and systemd

Alison Chaiken

Containers are everywhere. But what exactly is a container? What are they made from? What's the difference between LXC, butts-nspawn, Docker, and the other container systems out there? And why should we bother about specific filesystems? In this talk, Jérôme will show the individual roles and behaviors of the components making up a container: namespaces, control groups, and copy-on-write systems. Then, he will use them to assemble a container from scratch, and highlight the differences (and likelinesses) with existing container systems.

Anatomy of a Container: Namespaces, cgroups & Some Filesystem Magic - LinuxCon

Jérôme Petazzoni

Full system roll-back and systemd in SUSE Linux Enterprise 12

Gábor Nyers

MOVED: RDK/WPE Port on DB410C - SFO17-206

Linaro

Linux Containers From Scratch

joshuasoundcloud

OpenWRT manual

fosk

Linux Container Technology inside Docker with RHEL7

Etsuji Nakai

Ubuntu 16.04 LTS Security Features

Dustin Kirkland

pkgsrc 2011 - the record of the past year

Akio OBATA

The latest releases of today’s popular Linux distributions include all the tools needed to do interesting things with Linux containers. For the Makefile MicroVPS project, I set out to build a minimal virtual private server-like environment in a Linux container from scratch. These are my requirements for the MicroVPS: Minimal init sequence Most of what happens in a rc.sysinit file is not needed (or wanted) in a container. However, to work like a virtual private server, the MicroVPS will need some kind of init system. The absolute minimum would be enough to start the network and at least one service. Native network namespace The MicroVPS will have a dedicated network namespace. It should be easy to configure. Native package management The package set installed in the container image will be managed using native tools like deb or rpm. Automated build An automated repeatable build process is a must. Fast iteration cycle The building and testing cycle must be fast enough not to drive me insane. Easy management It should be easy to distribute, monitor, and run a MicroVPS container. In this tutorial, I will show how to use the tools included with Linux to build a virtual private server in a Linux container from scratch, using GNU Make to automate the build process.

Linux Containers From Scratch: Makfile MicroVPS

joshuasoundcloud

Linux container (LXC) seems to be preferred technology for deployment of Platform as a service (PaaS) in cloud. Partly because it's easy to install on top of existing visualization platforms (KVM, VMware, VirtualBox), partly because it is lightweight solution to provide separation and process allocations between separate containers running under single kernel. In this talk we will take a look at LXC and try to explain how to combine it with mandatory access control (MAC) mechanisms within Linux kernel to provide secure separation between different users of applications.

Security of Linux containers in the cloud

Dobrica Pavlinušić

Rear automated testing with Bareos

Gratien D'haese

Software Packaging for Cross OS Distribution

Jian-Hong Pan

Storage based on_openstack_mariocho

Mario Cho

Effective service and resource management with systemd

David Timothy Strauss

GlusterFS Update and OpenStack Integration

Etsuji Nakai

Mais procurados (20)

Linux 开源操作系统发展新趋势

OpenWRT guide and memo

Namespaces and cgroups - the basis of Linux containers

OpenWrt From Top to Bottom

Automotive Grade Linux and systemd

Anatomy of a Container: Namespaces, cgroups & Some Filesystem Magic - LinuxCon

Full system roll-back and systemd in SUSE Linux Enterprise 12

MOVED: RDK/WPE Port on DB410C - SFO17-206

Linux Containers From Scratch

OpenWRT manual

Linux Container Technology inside Docker with RHEL7

Ubuntu 16.04 LTS Security Features

pkgsrc 2011 - the record of the past year

Linux Containers From Scratch: Makfile MicroVPS

Security of Linux containers in the cloud

Rear automated testing with Bareos

Software Packaging for Cross OS Distribution

Storage based on_openstack_mariocho

Effective service and resource management with systemd

GlusterFS Update and OpenStack Integration

Semelhante a Kernel Recipes 2013 - Viewing real time ltt trace using gtkwave

In the past, much effort has been invested in high performance kernel tracing tools, but now focus in the tracing community seems to be shifting over to efficient user space application tracing. By providing joint kernel and user space tracing, developers can have deeper insights in their applications latencies. This presentation covers the ongoing efforts within the LTTng project to enhance system-wide tracing at the user space level. It discusses instrumentation sources such as Tracepoints, Uprobes, and SystemTAP SDT providers, along with their integration with LTTng. A brief overview of the latest and upcoming features of the user space tracer is presented. It also discusses ongoing efforts in the area of trace format and control protocol standardisation. Finally, our presentation includes challenging glibc-related issues encountered during LTTng-UST development, opening the discussion on how to improve and collaborate on user-space instrumentation. The targeted audience is user space and kernel developers, those interested in tracing infrastructure, shared system libraries, and application instrumentation.

LTTng-UST: Efficient System-Wide User-Space Tracing

Christian Babeux

Presentation for Tizen Developer Conference 2015 Shenzhen. Tizen is an open source Linux based software platform for Internet of Things, mobile, wearable and embedded devices. Tizen:Common provides a generic development environment for Tizen 3 which key features include Wayland, Weston, EFL, and the Crosswalk web runtime. The Yocto Project offers easy to use tools to create meta layers for new Tizen 3 profiles that inherit and expand the features of Tizen:Common. This talk will focus the Tizen architecture and it will provide guidelines for creating and building new Tizen profiles, based on Tizen:Common, using the Yocto Project for devices with Intel or ARM processors. It will also provide information about hidden gems in Tizen on Yocto and practical examples for packaging and deploying HTML5 applications through Yocto recipes for the open source hardware development boards MinnowBoard Max (Intel) and Humming Board (Freescale I.MX6 ARM SoC).

Creating new Tizen profiles using the Yocto Project

Leon Anavi

Using GTP on Linux with libgtpnl

Kentaro Ebisawa

Tekton showcase - CDF Summit Kubecon Barcelona 2019

Christie Wilson

Scaling Django with gevent

Mahendra M

Watch the recording here: https://youtu.be/6_dlU9WYBeY Is your team stuck working weekends during an upgrade? Dealing with long deployment windows due to manual processes? Are you tired of dealing with too many vendor tools, or not having an audit trail for compliance? There's got to be a better way! There is, and during this session Priyanka "Pinky" Ravi will give you an overview of how to get better security, velocity, and reliability with GitOps, and then how to get GitOps going on your own machine! By the end of this talk, you'll see two easy paths to getting GitOps up and running using Flux on Kubernetes. You'll see GitOps in action with a sample app that you deploy and then customize using configs. And then you'll hear ways that delivery and platform teams today are benefitting from GitOps, saving them from headaches, boredom, fires, and saving them time and money. Join us! Resources: ⭐️ Weave GitOps - https://docs.gitops.weave.works/docs/getting-started/ ⭐️ Flux - the GitOps family of projects: fluxcd.io ⭐️ Get Started with Flux Guide: https://fluxcd.io/docs/get-started/ ⭐️ Flux GitHub Repo: https://github.com/fluxcd/flux2 ⭐️ Flux on CNCF Slack: https://cloud-native.slack.com/messages/flux (or get an invite here: https://slack.cncf.io/)

Get Started with Flux

Weaveworks

How to keep Eclipse on the bleeding edge in the Linux world

Arun Kumar Thondapu

Priyanka “Pinky” Ravi is an end user of GitOps and Flux (fluxcd.io), and now is advocating for others like you to enjoy the benefits of GitOps today! Pinky shares:  Benefits of GitOps and Flux! How GitOps and Flux bring you security, reliability, velocity and more - no more pagers on Saturdays! no more breaches to the cluster that you can't roll back. no more worrying about how you'll fare in the next security audit. Pinky shares from personal experience why GitOps has been an essential part of achieving a best-in-class delivery and platform team.  What is GitOps and Flux? For beginners and advanced users alike, Pinky gives a brief overview of definitions, CNCF-based principles, and Flux's capabilities: multi-tenancy, multi-cluster, (multi-everything!), for apps and infra, and more.  How Flux delivers these benefits Pinky covers a little of Flux's microservices architecture and how the various components deliver this robust, secure, and trusted open source solution. Through the components of the Flux project, users today are enjoying compatibility with Helm, Jenkins, Terraform, Prometheus, and more as well as with cloud providers such as AWS, Azure, Google Cloud, and more. Resources: ⭐️ Flux - the GitOps family of projects: fluxcd.io ⭐️ Flux Docs: https://fluxcd.io/docs/ ⭐️ Flux GitHub Repo: https://github.com/fluxcd/flux2 ⭐️ Flux on CNCF Slack: https://cloud-native.slack.com/messages/flux (or get an invite here: https://slack.cncf.io/)

GitOps & Flux - A Refresher with Priyanka Ravi

Weaveworks

Developing and Benchmarking Qt applications on Hawkboard with Xgxperf

Prabindh Sundareson

Intro to GitOps & Flux.pdf

Weaveworks

G T K+ 101

Ahmed Saeed

Slides Aquarium Paris 2008

julien.ponge

The QNX Photon MicroGUI was a technological feat in its time. It gained popularity in the mid-1990's when QNX released a 1.44Mb bootable floppy with the QNX Operating System, the Photon GUI, networking, web browser, file browser, and several demo applications. QNX continued to develop and support Photon through 2014, but as GUI development systems matured — and users' expectations for GUIs increased — Blackberry's QNX is now focusing on the basics of drawing to the screen (e.g. QNX Screen) and left other aspects of Graphical User Interfaces to those who do it best (e.g. Qt) This presentation would be of particular interest to people looking to upgrade their software from an existing Photon system to Qt. It discusses the differences and similarities between the Photon and Qt application development platforms and how one may migrate from one to the other.

Migrating from Photon to Qt

ICS

Migrating from Photon to Qt

Janel Heilbrunn

PyQt Application Development On Maemo

achipa

Treinamento Qt básico - aula I

Marcelo Barros de Almeida

Git

Embedding Qt

Qt Tutorial - Part 1

نگاهی به Gtk3

Semelhante a Kernel Recipes 2013 - Viewing real time ltt trace using gtkwave (20)

LTTng-UST: Efficient System-Wide User-Space Tracing

Creating new Tizen profiles using the Yocto Project

Using GTP on Linux with libgtpnl

Tekton showcase - CDF Summit Kubecon Barcelona 2019

Scaling Django with gevent

Get Started with Flux

How to keep Eclipse on the bleeding edge in the Linux world

GitOps & Flux - A Refresher with Priyanka Ravi

Developing and Benchmarking Qt applications on Hawkboard with Xgxperf

Intro to GitOps & Flux.pdf

G T K+ 101

Slides Aquarium Paris 2008

Migrating from Photon to Qt

PyQt Application Development On Maemo

Treinamento Qt básico - aula I

Git

Embedding Qt

Qt Tutorial - Part 1

نگاهی به Gtk3

Mais de 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

Mais de Anne Nicolas (20)