Book Image

Practical System Programming for Rust Developers

By : Prabhu Eshwarla
Book Image

Practical System Programming for Rust Developers

By: Prabhu Eshwarla

Overview of this book

Modern programming languages such as Python, JavaScript, and Java have become increasingly accepted for application-level programming, but for systems programming, C and C++ are predominantly used due to the need for low-level control of system resources. Rust promises the best of both worlds: the type safety of Java, and the speed and expressiveness of C++, while also including memory safety without a garbage collector. This book is a comprehensive introduction if you’re new to Rust and systems programming and are looking to build reliable and efficient systems software without C or C++. The book takes a unique approach by starting each topic with Linux kernel concepts and APIs relevant to that topic. You’ll also explore how system resources can be controlled from Rust. As you progress, you’ll delve into advanced topics. You’ll cover network programming, focusing on aspects such as working with low-level network primitives and protocols in Rust, before going on to learn how to use and compile Rust with WebAssembly. Later chapters will take you through practical code examples and projects to help you build on your knowledge. By the end of this Rust programming book, you will be equipped with practical skills to write systems software tools, libraries, and utilities in Rust.

Related Content you might be interested in

Current Title:

Small book image
Practical System Programming for Rust Developers
Prabhu Eshwarla
Dec, 2020 | 388 pages
Small book image
Mastering Rust.
Vesa Kaihlavirta | Rahul Sharma
Jan, 2019 | 554 pages
Small book image
Rust Essentials.
Ivo Balbaert
Nov, 2017 | 264 pages
Small book image
Learning Rust
Vesa Kaihlavirta | Paul Johnson
Nov, 2017 | 308 pages
Table of Contents (17 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
1
Section 1: Getting Started with System Programming in Rust
Section 1: Getting Started with System Programming in Rust
Free Chapter
2
Chapter 1: Tools of the Trade – Rust Toolchains and Project Structures
Chapter 1: Tools of the Trade – Rust Toolchains and Project Structures
Technical requirements
Choosing the right Rust configuration for your project
Introducing Cargo and project structures
Automating build management with Cargo
Automating dependency management
Writing and running automated tests
Documenting your project
Summary
Further reading
3
Chapter 2: A Tour of the Rust Programming Language
Chapter 2: A Tour of the Rust Programming Language
Technical requirements
Analyzing the problem domain
Modeling the system behavior
Building the tokenizer
Building the parser
Building the evaluator
Dealing with errors
Putting it all together
Summary
4
Chapter 3: Introduction to the Rust Standard Library
Chapter 3: Introduction to the Rust Standard Library
Technical requirements
The Rust Standard Library and systems programming
Exploring the Rust Standard Library
Building a template engine
Summary
Further reading
5
Chapter 4: Managing Environment, Command Line, and Time
Chapter 4: Managing Environment, Command Line, and Time
Technical requirements
Project scope and design overview
Coding the imagix library
Developing the command-line application and testing
Summary
6
Section 2: Managing and Controlling System Resources in Rust
Section 2: Managing and Controlling System Resources in Rust
7
Chapter 5: Memory Management in Rust
Chapter 5: Memory Management in Rust
Technical requirements
The basics of OS memory management
Understanding the memory layout of Rust programs
The Rust memory management lifecycle
Implementing a dynamic data structure
Summary
Further reading
8
Chapter 6: Working with Files and Directories in Rust
Chapter 6: Working with Files and Directories in Rust
Technical requirements
Understanding Linux system calls for file operations
Doing file I/O in Rust
Learning directory and path operations
Setting hard links, symbolic links, and performing queries
Writing a shell command in Rust (project)
Summary
9
Chapter 7: Implementing Terminal I/O in Rust
Chapter 7: Implementing Terminal I/O in Rust
Technical requirements
Introducing terminal I/O fundamentals
Working with the terminal UI (size, color, styles) and cursors
Processing keyboard inputs and scrolling
Processing mouse inputs
Summary
10
Chapter 8: Working with Processes and Signals
Chapter 8: Working with Processes and Signals
Technical requirements
Understanding Linux process concepts and syscalls
Spawning processes with Rust
Handling I/O and environment variables
Handling panic, errors, and signals
Writing a shell program in Rust (project)
Summary
11
Chapter 9: Managing Concurrency
Chapter 9: Managing Concurrency
Technical requirements
Reviewing concurrency basics
Spawning and configuring threads
Error handling in threads
Message passing between threads
Achieving concurrency with shared state
Pausing thread execution with timers
Summary
12
Section 3: Advanced Topics
Section 3: Advanced Topics
13
Chapter 10: Working with Device I/O
Chapter 10: Working with Device I/O
Technical requirements
Understanding device I/O fundamentals in Linux
Doing buffered reads and writes
Working with standard input and output
Chaining and iterators over I/O
Handling errors and returning values
Getting details of connected USB devices (project)
Summary
14
Chapter 11: Learning Network Programming
Chapter 11: Learning Network Programming
Technical requirements
Reviewing networking basics in Linux
Understanding networking primitives in the Rust standard library
Programming with TCP and UDP in Rust
Writing a TCP reverse proxy (project)
Summary
15
Chapter 12: Writing Unsafe Rust and FFI
Chapter 12: Writing Unsafe Rust and FFI
Technical requirements
Introducing unsafe Rust
Introducing FFIs
Reviewing guidelines for safe FFIs
Calling Rust from C (project)
Understanding the ABI
Summary
16
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

To get the most out of this book

Rustup must be installed in your local development environment. Use this link for installation: https://github.com/rust-lang/rustup.

Refer to the following link for official installation instructions: https://www.rust-lang.org/tools/install.

After installation, check whether rustc, and cargo have been installed correctly with the following commands:

rustc --version 
cargo –version

You can use Linux, macOS, or Windows.

While the Rust standard library largely is platform-independent, the general flavor of the book is oriented towards Linux/Unix-based systems. As a result, in a few chapters (or some sections within chapters) it is recommended to use a local Linux virtual machine, like Virtual box, (or if you have a cloud VM you may use it) for the code in the chapter to work. This may be because a command, or an external crate or a shared library used in example code and projects may be Linux/Unix specific.

Note for those using Windows for development

There are certain chapters that require a virtual machine or Docker image running Unix-like OSes (Unix/Linux/macOS).

There are two types of code in each chapter which are placed in the Packt GitHub repository for the book:

  • The code corresponding to the example projects (which are referred to by named source files within the chapter),
  • Independent code snippets, that are placed within the miscellaneous folder within each chapter (where applicable)

If you are using the digital version of this book, we advise you to type the code yourself or access the code via the GitHub repository (link available in the next section). Doing so will help you avoid any potential errors related to the copying and pasting of code.

While using cargo run command to build and run Rust programs, you may encounter 'permission denied' messages if the user ID with which the command is run does not have sufficient permissions to perform system-level operations (such as reading or writing to files). In such cases, one of the workarounds that can be used is to run the program with the following command:

sudo env "PATH=$PATH" cargo run
Previous Section
Next Section