A journal about debugging Rust on C integration
I enjoy system programming, and moving bits from here to there is one of the reasons why I love programming. Therefore, it is almost mandatory to know a bit about C, the most widely used language for system programming, especially if you want to integrate it with Rust, the most loved language currently. However, problems can occur, and in this article, I will discuss two issues that I faced and how I resolved them.
C is a general-purpose programming language that has been around for decades. It is widely used in operating systems, embedded systems, and application development. In fact, C has been a critical language in the development of Linux, one of the most popular operating systems used today.
Despite its importance, there has been a concern that C is not attracting new developers. This led to Linus Torvalds, the creator of Linux, deciding to integrate the Rust programming language into the Linux kernel in the hope of finding new contributors.
Rust strings on C
I recently delved into the world of C programming language again, in a try to learn a bit about the integration of these two languages, what, I believe, will be useful for my career in the future.
It is worth noting that despite the addition of Rust, Linux is still mainly written in C. The integration between Rust and C is important because it allows for better performance and safer coding practices in the Linux kernel. However, it also brings about some challenges.
One of the problems I encountered when working with both C and Rust was the difference between C and Rust strings. C strings end with a null terminator, \0, while Rust strings do not. To use a Rust string in C code, it needs to use a Rust-compatible type. If this is not done correctly, it can lead to segmentation faults, which can be challenging to debug. In my case, I faced this issue, and it took me some time to figure out what was causing it.
The solution was simple - I needed to use a Rust-compatible type when using Rust strings in C code. This can be achieved by using the
CString type, which is specifically designed for use with C code. These types automatically handle the null terminator, which is essential for avoiding segmentation faults.
Informing to Abort instead of Panic on C
Another issue I faced when trying to integrate Rust with an existing C codebase was related to a core panic error. Specifically, when I tried to add a little Rust code to the LXMusic from the LXDE project, my code would crash with a "core panic was not implemented" error message.
After some research, I discovered that this error message was related to Rust's panic system. In Rust, when an unexpected error occurs, the program panics, which means that it crashes and displays an error message. However, in C, this behavior is not supported, which is why the program was crashing with an error message.
The solution was to indicate to the Rust compiler that I wanted it to break up when some unexpected behavior happens. This can be done by adding the "panic=abort" flag to the Rust compiler. This tells the Rust compiler to abort the program when a panic occurs, which is supported by C.
In summary, integrating Rust and C can be challenging, but with the right resources and support, problems that seem huge can be solved with a simple solution. When encountering problems, it's important to start with a good search, well-written questions, and reading documentation before attempting to debug. Debugging is an important process, and it goes beyond just printing, breaking points, and stack traces. With the right approach, debugging can be a relatively simple and straightforward process.