The Application of C Language in System Calls: Accessing Low-Level System Functions

The C language is a powerful programming language widely used in the development of operating systems and embedded systems. It can interact directly with hardware and access low-level operating system functions through system calls. In this article, we will introduce what system calls are and how to use them in C to implement some basic functionalities.

What are System Calls?

System calls are the interfaces between user programs and the operating system kernel. Through these interfaces, user programs can request the operating system to perform specific tasks, such as file management, process control, and network communication. Common system calls in Linux/Unix include <span>open</span>, <span>read</span>, <span>write</span>, and <span>close</span>.

Example of System Calls

Below, we will demonstrate how to use C for file reading and writing through a simple example that involves several basic system calls.

Example Code: File Read and Write

The following code shows how to create a file, write data to it, and then read and print that data:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>

int main() {
    // Create and open a file
    int fd = open("example.txt", O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR);
    if (fd == -1) {
        perror("Error opening file");
        return EXIT_FAILURE;
    }

    // Write data to the file
    const char *text = "Hello, System Calls in C!\n";
    ssize_t bytes_written = write(fd, text, sizeof(text));
    if (bytes_written == -1) {
        perror("Error writing to file");
        close(fd);
        return EXIT_FAILURE;
    }

    // Close the file descriptor
    close(fd);

    // Reopen the file to read its contents
    fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("Error opening file for reading");
        return EXIT_FAILURE;
    }

    char buffer[100];
    ssize_t bytes_read = read(fd, buffer, sizeof(buffer) - 1);
    if (bytes_read == -1) {
        perror("Error reading from file");
        close(fd);
        return EXIT_FAILURE;
    }

    // Ensure the string is null-terminated
    buffer[bytes_read] = '\0';
    printf("Read from file: %s", buffer);

    // Close the file descriptor
    close(fd);
    return EXIT_SUCCESS;
}

Code Explanation

1. Include Header Files:

   #include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   #include <fcntl.h>

These lines of code include the necessary libraries, where <span>stdio.h</span> is used for standard input and output, <span>stdlib.h</span> provides some general utility functions, and <span>unistd.h</span> and <span>fcntl.h</span> provide support for POSIX APIs (such as open, read, and write).

1. Create and Open a New File:

int fd = open("example.txt", O_CREAT | O_WRONLY | O_TRUNC, S_IRUSR | S_IWUSR);

Here we use the <span>open()</span> function to create or open a new file named “example.txt”. If the file does not exist, it will be created; if it exists, it will be truncated (cleared). The permissions are set to allow only the current user to read and write.

1. Error Handling:

if (fd == -1) {

Check the return value; if it returns -1, it indicates an error. Use <span>perror()</span> to print the error message and exit the program.

1. Write Data to the File:

ssize_t bytes_written = write(fd, text, sizeof(text));

Use the <span>write()</span> function to write the string content to the previously opened file. Again, check the return value to ensure no errors occurred.

1. Close the Opened Descriptor:

close(fd);

After successfully completing an operation on a resource (such as a file), it is important to release the resource promptly to avoid memory leaks or other issues.

1. Reopen and Read Content: Use <span>open()</span> again to open the same text for reading, then use the <span>read()</span> function to retrieve data, ensuring to add a null character at the end to make it a valid string format for printing output.

2. Final Output Result: Finally, print the data read from the text and close the descriptor again to release resources.

Conclusion

This article introduced the basic concept of “system calls” in C language and how to utilize these interfaces to implement simple yet practical functionalities, such as creating, writing, and reading text. This is just one of many possibilities; mastering more about different types and their parameters can help you gain a deeper understanding of the underlying workings of computers, laying a solid foundation for future programming. We hope this article inspires you to further explore the C language and its potential in practical applications!