During my training with STMicroelectronics, I underwent an extensive learning journey covering various aspects of embedded systems development, Linux fundamentals, and software engineering practices. This README provides an overview of the topics covered and the skills acquired during the training period.
- Overview
- Training Content
- Part 1: Introductory Training
- Part 2: Intermediate Training
- Part 3: Advanced Training
- Introduction to Assembly Language
- Tutorial on POSIX Threads
- Signals as a Means of Interprocess Communications
- Introduction to Kernel Modules
- Building Embedded Linux File Systems and Kernel using Yocto Build System
- Kernel Namespaces and Container Software
- Fundamentals of TCP/IP and Socket Programming
- Skills Acquired
- Instructor Information
- Conclusion
We delved into the history of Linux, exploring its origins, development milestones, and the philosophy behind open-source software.
Understanding the command line interface is fundamental to working with Linux-based embedded systems. We learned how to navigate the command line efficiently and explored the build process for compiling and linking software applications.
-
Process Overview: Understanding the concept of processes in Linux and how they interact with the operating system.
-
System Calls and Command Line Arguments: Exploring system calls and their role in process management, along with handling command line arguments in C programs.
-
Process Creation: Learning about process creation using functions such as
fork()andexec(). -
Orphan & Zombie Processes: Understanding the concepts of orphan and zombie processes and their implications on system resources.
-
Bash Features: Exploring advanced features of the Bash shell for scripting and automation.
-
Intro to Proc fs: Introduction to the
/procfilesystem and its role in providing information about processes and system resources. -
IO Redirection in the Shell: Mastering input/output redirection techniques in the shell for efficient command-line usage.
We covered user management concepts, including user account administration, permissions, and security practices.
-
Intro to HDD: Understanding hard disk drive (HDD) fundamentals and their role in storing data on embedded systems.
-
Parsing MBR Partition Tables: Exploring Master Boot Record (MBR) partition tables and techniques for parsing them.
-
File System Formatting, Mounting, and Architecture: Learning about file system formats, mounting procedures, and the underlying architecture of file systems.
-
Directories, Files, Links, and Permissions: Understanding the structure of directories and files, symbolic and hard links, and managing permissions for file access control.
-
Implementing “ls”: Developing a simplified version of the
lscommand to list directory contents.
In the second part of the training, we studied "The Linux Programming Interface," which provided an in-depth understanding of system programming concepts and APIs used in Linux.
As a practical application of the concepts learned, we developed a project focused on creating a Linux memory manager. This project involved:
- Memory Allocation and Deallocation: Implementing custom memory allocation and deallocation routines.
- Memory Mapping: Understanding and utilizing memory mapping techniques.
- Virtual Memory Management: Exploring virtual memory concepts and implementing a basic virtual memory manager.
- Objective: Demonstrate the portability of the UNIX/Linux interface through the use of assembly system calls in Glibc.
- Key Topics:
- Basics of assembly language and its importance in low-level programming.
- How system calls are implemented in assembly within the Glibc environment.
- Calling conventions across different processors (e.g., x86, ARM).
- Objective: Explore the Native POSIX Thread Library (NPTL) and relevant kernel implementations.
- Key Topics:
- Overview of POSIX threads (pthreads) and thread management.
- Detailed walkthrough of thread creation, synchronization, and management in Linux.
- Examination of kernel-level support for threading.
- Objective: Discuss the role of signals in IPC and related system concepts.
- Key Topics:
- Fundamentals of UNIX signals and their role in controlling processes.
- Process states, Job Control, and pseudo terminals (PTYs).
- Use cases and limitations of signals in modern IPC.
- Objective: Explore kernel modules and pseudo file systems crucial for system monitoring.
- Key Topics:
- Concepts and creation of Linux kernel modules.
- Deep dive into /proc, /sys filesystems and their role in the Linux ecosystem.
- Understanding Cgroup filesystem and its usage in resource management.
- Objective: Learn to build customized Linux environments using different build systems.
- Key Topics:
- Introduction to the Yocto project and its architecture.
- Building a minimal Linux system for embedded devices.
- Comparison with Debian-like file systems built using Bootstrap and Multistrap.
- Objective: Examine how Linux namespaces support containerization technologies.
- Key Topics:
- Overview of Linux namespaces (PID, net, IPC, mount, etc.).
- Practical demonstrations using Docker, Podman, and Systemd-nspawn.
- System calls associated with namespaces management.
- Objective: Detailed study of network programming and the Linux network stack.
- Key Topics:
- TCP/IP fundamentals and socket programming concepts.
- Exploring the Linux kernel network stack.
- Hands-on coding examples in creating network applications.
- Proficiency in using the Linux command line interface for system administration and software development tasks.
- Understanding of process management concepts and system calls in Linux.
- Knowledge of file system management, including formatting, mounting, and permissions.
- Familiarity with Bash scripting for automation and task automation.
- Ability to work with embedded systems and perform low-level tasks such as parsing MBR partition tables.
- In-depth understanding of system programming concepts from "The Linux Programming Interface."
- Practical experience in developing a Linux memory manager.
- Understanding of assembly language and its role in system calls.
- Knowledge of POSIX threads and multi-threading in Linux.
- Insights into interprocess communication using signals.
- Experience with Linux kernel modules and file systems.
- Skills in building embedded Linux systems using the Yocto project.
- Understanding of Linux namespaces and containerization.
- Fundamentals of TCP/IP and socket programming.
Instructor: Reda Maher
LinkedIn: Instructor's LinkedIn Profile URL
The training with STMicroelectronics provided a comprehensive understanding of Linux systems programming and equipped me with essential skills for working with Linux at a low level. The knowledge gained includes process management, file systems, system calls, multi-threading, interprocess communication, kernel modules, containerization, and network programming. This intensive training has prepared me to handle complex Linux programming tasks and contribute effectively in environments that require in-depth knowledge of Linux internals and systems programming.