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

Calling Rust from C (project)

In this section, we will demonstrate the setup needed to build a Rust shared library (with a .so extension on Linux) incorporating an FFI interface and invoke it from a C program. The C program would be a simple program that just prints out a greeting message. The example is deliberately kept simple to enable you (as you're not expected to be familiar with complex C syntax) to focus on the steps involved, and for easy verification of this first FFI program in a variety of operating system environments.

Here are the steps that we will go through to develop and test a working example of a C program that calls a function from a Rust library using the FFI interface:

  1. Create a new Cargo lib project.
  2. Modify Cargo.toml to specify that we want a shared library to be built.
  3. Write an FFI in Rust (in the form of a C-compatible API).
  4. Build the Rust shared library.
  5. Verify whether the Rust shared library has been built correctly.
  6. Create...
Previous Section
End of Section 6
Next Section