Embedded Linux Systems Programming (2023-02-13 - 2023-02-17)

Dates and Times

• Start on Monday 2023-02-13 9:00

Github Repository

• https://github.com/jfasch/2023-02-13

Toolchain (Raspberry Cross Build)

• Toolchain archive: armv8-rpi4-linux-gnueabihf.tar.xz

• CMake toolchain file: armv8-rpi4-linux-gnueabihf.cmake

PDF slides (unmaintained)

• Systems Programming: 020-linux-sysprog--en.pdf

• CMake: 045-cmake.pdf

Programming Environment

WSL For Core Linux Topics

If possible, we should use WSL for core Linux topics. Local editing in Visual Studio Code, local compilation on a virtualized Ubuntu, local running.

• Windows Subsystem for Linux (WSL) (my own $0.02)

• Microsoft: Set up a WSL development environment

• Get started using Visual Studio Code with Windows Subsystem for Linux

Cross Development For Hardware Topics

For the more involved hardware related topics, I’ll bring a Raspberry Pi and some network equipment and build up a local network where we can log in from our PCs.

Please check that connecting the course participants’ PCs to some foreign untrusted LAN is permitted IT-wise.

Day 1: Overview

Introductory Live Hacking

Hammering on a GPIO pin: a typical example of how hardware access works on Linux (from Introductory Live Hacking, Hardware-Wise (sysfs GPIO)).

• Intro: sysfs GPIO

• Get Value Of GPIO

• Interrupts In Userspace

The Shell

Using the Shell’s commandline, an overview is given about Unix system concepts like processes, files, and permissions. Many if not all of these concepts will be viewed programmatically in the remainder of the course. It will be no surprise, for example, that communication with hardware has to do with file I/O.

• From Introduction: Concepts and Terminology

  • Overview

  • Everything Is A File (Live Demo)

  • Processes, Scheduling, Address Spaces

  • Process Hierarchy (Parent, Child Process)

  • Environment (Variables)

• From The Shell (Bash - “Bourne Again Shell”)

  • Commandline

  • Absolute and Relative Paths

  • Special Paths

  • Directory Listings: The ls Command

  • Current Working Directory

  • Creating And Removing Files and Directories

  • Copying: cp

  • Moving and Renaming: mv

  • Exercises (from Exercises: The ls Command)

    • Exercise: Size of /etc/passwd

    • Exercise: File Types in /dev

    • Exercise: Permissions of Home Directory

  • Exercises (from Exercises: Create/Copy/Move/Remove)

    • Exercise: mkdir

    • Exercise: Create Files (I/O Redirection)

    • Exercise: Copy Files

    • Exercise: Move Files

    • Exercise: Verify, Repeat

    • Exercise: Copy Directory Tree

    • Exercise: Remove Directory Tree

    • Exercise: Funny Stuff

Day 2

Processes Quick Walk-Through

• From Linux Systems Programming

  • Process: Arguments, Exit Status

  • The Process Tree (And Environment, And procfs)

Permissions

From File System Permissions

• Permissions: Mode, User and Group Ownership

• SetUID Programs: passwd, sudo, …

• SetUID: Live Demo

• Default Permissions: umask

• Ugly Hack: Sticky Bit

• Exercises: File System Permissions

Development: CMake Quick Intro, And Git Quick Intro

• Setup Github project for local build: https://github.com/jfasch/2023-02-13

• ⟶ See instructions on that page

File IO

See also

• Linux Systems Programming

• Linux Systems Programming: Basics

  • System Calls vs. Library Functions

  • Error Handling

• File I/O

  • File I/O: Basics

Day 3

UART

• man -s 1 stty

• man -s 3 termios

• man -s 2 ioctl_tty

• man -s 8 setserial

• setserial source code on Github

• Linux kernel source code (e.g. on Github): drivers/tty/tty_io.c

• First try: four programs, two on either side (cat, and echo)

  • ⟶ weird output when used bidirectionally

  • Enable “raw mode” 🤔 ⟶ man -s 1 stty

  • ⟶ no special character handling in terminal driver. Want no terminal, want naked UART IO!!

  • ⟶ weird output still weird, but less so

• Dedicated input and output programs

  • tty-read.cpp

  • tty-write.cpp

  • First w/o termios and TIOCGSERIAL/TIOCSSERIAL/ASYNC_LOW_LATENCY

  • ⟶ better

• Add cfmakeraw() programmatically (the “non-cooked mode” from man -s 1 stty)

  • ⟶ this is what we want to see!

• “Realtime”: setserial /dev/ttyUSB0 low_latency (man -s 8 setserial), only programmatically

  • setserial source code on Github

  • Linux kernel source code: drivers/tty/tty_io.c

  • ioctl(fd, TIOCGSERIAL, &serial_struct)

  • serial_struct.flags |= ASYNC_LOW_LATENCY

  • ioctl(fd, TIOCSSERIAL, &serial_struct)

• tty-bidir-threads.cpp: not separate programs on different fds; two threads hammering on one fd

• Livehacking: transform that into event-driven (tty-bidir-events.cpp)

SUSI

• Advantec Marketingese. Security is the “S” in IoT … that library requires you to run your code as root. Considered cool nonetheless, and marketed heavily by Advantec.

  🖕

Exercise

Github Repository

• https://github.com/jfasch/2023-02-13

• Especially mycat.cpp: https://github.com/jfasch/2023-02-13/blob/main/exercises/mycat.cpp

Modify that program such that it mimicks cat:

• Is given on single filename argument

• Opens that file

• Reads its content, and outputs it on standard output

$ ./mycat /etc/passwd
... contents of /etc/passwd here ...

Cross Development

• From Toolchain, And Cross Development

  • Toolchain: Basics

  • Zooming In: Separate Compilation, and Linking Statically

  • Object Code Archives/Static Libraries

  • Shared Libraries (Shared Objects)

  • Cross Development

  • CMake

  • CMake: Local Build

  • CMake: Cross Build

  • Exercises: Toolchain

• Establish a custom built toolchain for Raspberry Pi cross development (from Case Study: Raspberry Toolchain)

  • Cross Toolchain Setup

  • Unpacking the toolchain archive: Archiving and Compression

  Have a look into how toolchains are made:

  • Building A Cross Toolchain For The Raspberry Pi, Using crosstool-ng

  • Building A Toolchain On Fedora For Ubuntu 18.04 (WSL)

Day 4

Secure Shell (SSH)

• From SSH: Secure Shell …

  • SSH: Basics

  • SSH: Public Key Authentication

  • SSH: Secure Copy (scp)

  • SSH File System (sshfs)

Miscellaneous Hardware

• From Linux Hardware Interfaces

  • CAN Bus With Linux And Python

  • Linux and OneWire (using DS18B20 Temperature Sensor as Slave)

  • Linux and I2C (using LM73 Temperature Sensor as Slave)

  • PWM Userspace Interface (using PCA9685)

Group Exercise

• Send sensor values (W1, and userspace LM73) over CAN

• Receive values, and show via a PWM’d LED

Day 5

• Some OO: PWM display (display-pwm.h, display-pwm.cpp), and associated program (show-pwm-temperature.cpp

• Show sine wave: show-pwm-temperature-sine.cpp

• Realtime sine waves on 2 LEDs (see make_realtime() in show-pwm-temperature-sine.cpp)

• More OO? Writing temperature to CAN could be viewed as another kind of display. A little C++ interfacery ( display.h, leading to display-can.h, display-can.cpp)

  • ⟶ is-a Display

• CIFS/Samba: mounting a Windows share on Linux: https://automationadmin.com/2016/12/mounting-a-samba-share-in-fedora/#gsc.tab=0

Untold

More From The Commandline

See also

• Shell scripting: 100-shell-scripting.pdf

• From The Shell (Bash - “Bourne Again Shell”)

  • Symbolic Links, Hard Links

  • Shell Configuration File: ~/.bashrc

• From I/O Redirection And Pipes

  • I/O Redirection

  • I/O Redirection: Swap stdout And stderr

  • Pipes

  • Exercises: IO-Redirection, Pipes

Multithreading (And C++)

From Linux Systems Programming: Multithreading:

• Race Conditions, and prevention thereof (mutexes)

• Communication mechanisms (condition variable)

• Atomics

• Realtime

From Multithreading

• Threads in C++

• std::mutex And Friends

• Scoped Locking

• std::atomic

• std::promise and std::future (And Some std::chrono) (Some Live Hacking)

• std::condition_variable (Live Hacking Multithreaded Queue)