DEV Community: Vivek P

CPU Registers

Vivek P — Sat, 19 Oct 2024 19:42:08 +0000

CPU Registers

CPU registers are small storage locations within the CPU used to hold data temporarily for processing. They are crucial for the CPU's operation, enabling quick access to data and efficient execution of instructions. Registers are much faster than other memory types (like RAM), and they play a central role in the CPU's architecture. Below are the key types of CPU registers:

Types of Registers

1. General-Purpose Registers (GPRs)

These registers are used for various general operations such as arithmetic, logic, and data transfer. Common examples include:

AX, BX, CX, DX (in x86 architecture):
- AX (Accumulator Register): Often used for arithmetic and logic operations.
- BX (Base Register): Used as a base pointer for memory addressing.
- CX (Count Register): Typically used for loop control in repetitive operations.
- DX (Data Register): Used in I/O operations and some arithmetic functions.

2. Segment Registers

Segment registers store segment addresses for accessing memory segments. They are used for different types of memory segments in a program:

CS (Code Segment): Points to the segment containing the code being executed.
DS (Data Segment): Points to the segment containing the data used by the program.
SS (Stack Segment): Points to the segment containing the stack.
ES, FS, GS: Additional segment registers for specific data segments.

3. Special-Purpose Registers

These registers have specific functions:

Instruction Pointer (IP): Holds the address of the next instruction to be executed.
Flags Register (EFLAGS/RFLAGS): Contains flags that indicate the state of the CPU (e.g., zero flag, carry flag, overflow flag).
Stack Pointer (SP): Points to the top of the stack, used for stack operations.
Base Pointer (BP): Used as a reference point for accessing stack data.

4. Floating-Point Registers (FPRs)

Used in processors with Floating Point Units (FPUs) for performing arithmetic operations on floating-point numbers. In x86, these are often referred to as ST0, ST1, ... ST7.

5. Control Registers

These registers control various aspects of the CPU's operation:

CR0: Controls the operating mode of the CPU (e.g., enabling/disabling protected mode).
CR2: Contains the Page Fault Linear Address.
CR3: Holds the address of the page directory (used in paging).
CR4: Controls advanced features such as Virtual-8086 mode, protected-mode virtual interrupts, and others.

6. Debug Registers

These registers (DR0–DR7) are used to manage hardware breakpoints for debugging purposes.

7. Model-Specific Registers (MSRs)

These are special registers specific to a particular CPU model, used for configuring or reading specific CPU features.

Summary

CPU registers are essential for the CPU's efficient operation, providing quick access to data and control information. Understanding registers is fundamental for low-level programming and optimizing code for performance.

IPC Mechanisms in Linux

Vivek P — Fri, 11 Oct 2024 07:30:31 +0000

In Linux, several Inter-Process Communication (IPC) mechanisms enable processes to communicate and share data. These mechanisms are critical for coordination between processes running in user space. Here are some of the most commonly used IPC mechanisms

IPC Mechanism	Key Features	Speed	Use Cases
Pipes	Unidirectional, suitable for parent-child processes.	Medium	Simple communication between related processes.
Message Queues	Queue messages, supports priority messages.	Medium	Asynchronous messaging between processes.
Shared Memory	Fastest IPC, shared memory region accessible by multiple processes.	Fast	High-speed data sharing between processes.
Semaphores	Synchronization of processes to avoid race conditions.	Medium	Controlling access to shared resources.
Signals	Asynchronous notification.	Fast	Event notification, process control.
Sockets	Network communication (or local via UNIX domain).	Medium/Slow	Network and local client-server communication.
Mmap	Memory-mapped files or devices, shared memory via file mapping.	Fast	Shared memory via file mappings.
D-Bus	High-level, inter-application communication (used in desktop environments).	Medium	Application-level IPC (e.g., GNOME, KDE).
Eventfd/Signalfd	File descriptor-based event and signal handling.	Fast	Handling events and signals in `poll` or `epoll`.
POSIX Message Queues	FIFO messaging with priorities, used in real-time applications.	Medium	Real-time message passing.
Files	Slow but simple, persistent data sharing through files.	Slow	Data persistence, logging, simple IPC.

Linux Developer Interview Questions.

Vivek P — Wed, 09 Oct 2024 16:16:01 +0000

Linux System Developer Interview Questions and Answers

Basic Linux Knowledge

Q: What happens when you type 'ls -l' in a terminal? Explain the entire process.

Answer: When you type 'ls -l' and press Enter, the following process occurs:

The shell (e.g., bash) reads the input and parses it.
The shell identifies 'ls' as an external command and '-l' as an argument.
The shell fork()s to create a child process.
The child process uses execve() to replace itself with the 'ls' program.
The 'ls' program:
- Parses command-line arguments
- Opens the current directory (or specified directory)
- Reads directory entries using getdents() system call
- For each file:
  - Calls stat() to get file information
  - Formats the output (permissions, owner, size, date, name)
- Writes the formatted output to stdout
The parent shell waits for the 'ls' command to complete
The shell displays a new prompt

Q: What is the Linux kernel?

A: The Linux kernel is the core component of Linux operating systems. It's a free and open-source, monolithic, modular Unix-like operating system kernel. It manages:

System hardware resources
Process scheduling
File systems
Device drivers
System calls

Key characteristics:

Written primarily in C
Created by Linus Torvalds in 1991
Released under GNU General Public License v2

Q: Explain the boot process of a Linux system.

Answer: The Linux boot process consists of the following stages:

BIOS/UEFI Stage
- Power-on self-test (POST)
- Identifies boot device
Bootloader Stage (e.g., GRUB)
- Loads kernel image into memory
- Passes control to kernel with initial RAM disk (initrd)
Kernel Stage
- Initializes hardware and memory
- Mounts root filesystem
- Starts init process (PID 1)
Init Stage
- SystemD or traditional SysV init
- Starts system services
- Brings up network interfaces
- Mounts additional filesystems
Runlevel/Target Stage
- Reaches the specified runlevel or target
- System is ready for use

Q: What is the difference between a soft link and a hard link?

Answer:

Hard Links:

Share the same inode number as the original file
Can't cross filesystem boundaries
Can't link to directories (usually)
File content is only deleted when all hard links are deleted
Same file size as the original file

Example creating a hard link:

ln original.txt hardlink.txt

Soft Links (Symbolic Links):

Contain a path to the original file
Can cross filesystem boundaries
Can link to directories
Can become dangling if original file is deleted
Very small in size (just contains the path)

Example creating a soft link:

ln -s original.txt softlink.txt

Q: Explain the difference between user space and kernel space.
A:
Kernel Space:

Highest privileged level (Ring 0)
Full access to hardware
Executes kernel code and device drivers
Cannot be accessed directly by user applications

User Space:

Lower privilege level (Ring 3)
Limited access to hardware
Executes user applications
Must use system calls to access kernel services

Example of crossing the boundary:

// User space code
int fd = open("file.txt", O_RDONLY);  // System call to kernel space

// Kernel space implementation
SYSCALL_DEFINE3(open, const char __user *, filename, int, flags, umode_t, mode)
{
    // Kernel code here
}

Q: What are system calls? List and explain five common ones.
A: System calls are interfaces between user space programs and the kernel.

Five common system calls:

fork()

pid_t pid = fork();

Creates a new process by duplicating the calling process

read()

ssize_t bytes = read(fd, buffer, count);

Reads data from a file descriptor

write()

ssize_t bytes = write(fd, buffer, count);

Writes data to a file descriptor

open()

int fd = open("file.txt", O_RDONLY);

Opens a file or creates it if it doesn't exist

close()

int status = close(fd);

Closes a file descriptor

Q: Explain the Linux process scheduling algorithm.

A: Linux uses the Completely Fair Scheduler (CFS):

Key concepts:

Virtual Runtime (vruntime)
- Tracks process execution time
- Normalized by process priority
Red-Black Tree
- Processes sorted by vruntime
- O(log n) insertion and removal

Example of how priority affects scheduling:

struct sched_param param;
param.sched_priority = 51;  // Range: 1-99 for real-time

sched_setscheduler(pid, SCHED_FIFO, &param);

Scheduler classes (in order of priority):

Stop scheduler (internal use)
Deadline scheduler
Real-time scheduler
CFS scheduler
Idle scheduler

Q: What is a page fault? Explain different types.

A: A page fault occurs when a program tries to access memory that is mapped in the virtual address space but not loaded in physical memory.

Types of page faults:

Minor Page Fault
- Page is in memory but not marked in MMU
- No disk I/O required
Major Page Fault
- Page must be loaded from disk
- Requires disk I/O
Invalid Page Fault
- Access to invalid memory address
- Results in segmentation fault

Example of handling page faults in kernel:

static int __do_page_fault(struct mm_struct *mm, unsigned long addr,
                          unsigned int flags, struct task_struct *tsk)
{
    struct vm_area_struct *vma;
    int fault;

    vma = find_vma(mm, addr);
    if (!vma)
        return VM_FAULT_BADMAP;

    fault = handle_mm_fault(vma, addr, flags);
    return fault;
}

Q: What are the different types of process states in Linux?

Answer: Linux processes can be in the following states:

Running (R)
- Currently executing on a CPU or waiting to be executed
Sleeping
- Interruptible Sleep (S): Waiting for an event, can be interrupted
- Uninterruptible Sleep (D): Usually I/O, can't be interrupted
Stopped (T)
- Process has been stopped, usually by user signal (SIGSTOP)
Zombie (Z)
- Process has completed but parent hasn't read its exit status
Dead (X)
- Process is being terminated

Example command to see process states:

ps aux | awk '{print $8}' | sort | uniq -c

System Programming

Q: What is the difference between a process and a thread?

Answer:

Processes:

Have separate memory spaces
Have their own file descriptors, program counter, stack
Communication between processes requires IPC mechanisms
Higher overhead for creation and context switching
More isolated and secure

Threads:

Share the same memory space within a process
Share file descriptors, code, and data segments
Can communicate through shared memory
Lower overhead for creation and context switching
Less isolated, potential for race conditions

Example of creating a process vs a thread:

// Process creation
#include <unistd.h>

pid_t pid = fork();
if (pid == 0) {
    // Child process
} else {
    // Parent process
}

// Thread creation
#include <pthread.h>

void* thread_function(void* arg) {
    // Thread code
    return NULL;
}

pthread_t thread;
pthread_create(&thread, NULL, thread_function, NULL);

6. Q: What are signals in Linux? How do you handle signals in a program?

Answer: Signals are software interrupts used for inter-process communication. They can be:

Sent by the kernel to processes
Sent by processes to other processes
Sent by processes to themselves

Common signals:

SIGTERM (15): Termination request
SIGKILL (9): Immediate termination
SIGINT (2): Interactive attention (Ctrl+C)
SIGSEGV (11): Segmentation violation

Example of signal handling:

#include <signal.h>
#include <stdio.h>

void signal_handler(int signum) {
    printf("Caught signal %d\n", signum);
}

int main() {
    // Register signal handler
    signal(SIGINT, signal_handler);

    while(1) {
        printf("Running...\n");
        sleep(1);
    }
    return 0;
}

Debugging & Performance

Q: How would you profile a Linux application for performance optimization?

Answer: Several tools and techniques can be used:

perf - Linux profiling tool

perf record ./myapp
perf report

gprof - GNU profiler

gcc -pg program.c -o program
./program
gprof program gmon.out > analysis.txt

Valgrind - Memory profiler

valgrind --tool=callgrind ./myapp

strace - Trace system calls

strace -c ./myapp

Key areas to look for:

CPU usage (user vs system time)
Memory allocation/deallocation patterns
I/O operations
Cache misses
System call usage

Example of using perf to find hotspots:

perf record -g ./myapp
perf report --stdio

Coding Questions

Q: Write a program to create a daemon process.

Answer:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <syslog.h>

int main() {
    // Fork off the parent process
    pid_t pid = fork();
    if (pid < 0) {
        exit(EXIT_FAILURE);
    }
    if (pid > 0) {
        exit(EXIT_SUCCESS);  // Parent exits
    }

    // Create new session
    if (setsid() < 0) {
        exit(EXIT_FAILURE);
    }

    // Fork again (recommended)
    pid = fork();
    if (pid < 0) {
        exit(EXIT_FAILURE);
    }
    if (pid > 0) {
        exit(EXIT_SUCCESS);
    }

    // Set file permissions
    umask(0);

    // Change working directory
    chdir("/");

    // Close all open file descriptors
    for (int x = sysconf(_SC_OPEN_MAX); x >= 0; x--) {
        close(x);
    }

    // Open logs
    openlog("mydaemon", LOG_PID, LOG_DAEMON);

    // Daemon-specific initialization
    while (1) {
        syslog(LOG_NOTICE, "Daemon is running");
        sleep(30);
    }

    closelog();
    return EXIT_SUCCESS;
}

Key points about daemons:

Double forking ensures the process isn't a session leader
Changing directory to / prevents locking mounted filesystems
Closing file descriptors prevents resource leaks
Using syslog for logging as stdout/stderr are closed

Q: What are signals in Linux? How do you handle them?
A: Signals are software interrupts used for inter-process communication.

Common signals:

SIGTERM (15) - Termination request
SIGKILL (9) - Immediate termination
SIGINT (2) - Interactive attention (Ctrl+C)
SIGSEGV (11) - Segmentation violation

Signal handling example:

#include <signal.h>

void signal_handler(int signum) {
    printf("Caught signal %d\n", signum);
}

int main() {
    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;

    sigaction(SIGINT, &sa, NULL);

    while(1) {
        sleep(1);
    }
    return 0;
}

Sending signals:

// Send signal to another process
kill(pid, SIGTERM);

// Send signal to process group
killpg(pgid, SIGTERM);

Q: What is a deadlock? How can you prevent it?

A: A deadlock occurs when two or more processes are waiting indefinitely for resources held by each other.

Four conditions for deadlock:

Mutual Exclusion
Hold and Wait
No Preemption
Circular Wait

Example of potential deadlock:

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

void* thread1_function(void* arg) {
    pthread_mutex_lock(&mutex1);
    sleep(1);  // Increase chance of deadlock
    pthread_mutex_lock(&mutex2);
    // ... critical section ...
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void* thread2_function(void* arg) {
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex1);
    // ... critical section ...
    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}

Prevention strategies:

Lock ordering
Lock timeout
Deadlock detection
Use lock-free algorithms

Q: Explain the difference between threads and processes.

Processes:

Separate address space
Higher creation overhead
More isolation
IPC required for communication

Threads:

Shared address space
Lower creation overhead
Less isolation
Can communicate through shared memory

Example of creating both:

// Process creation
pid_t pid = fork();
if (pid == 0) {
    // Child process
    exit(0);
}

// Thread creation
pthread_t thread;
pthread_create(&thread, NULL, thread_function, NULL);
pthread_join(thread, NULL);

Memory comparison:

// Process - separate memory
int main() {
    int x = 5;
    if (fork() == 0) {
        x = 6;  // Only changes in child
        exit(0);
    }
    // Parent's x is still 5
}

// Thread - shared memory
void* thread_func(void* arg) {
    int* x = (int*)arg;
    *x = 6;  // Changes for all threads
    return NULL;
}

Q: What is a race condition? How can you prevent it?

A: A race condition occurs when multiple threads access shared data concurrently, and the outcome depends on the order of execution.

Example of a race condition:

int counter = 0;

void* increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        counter++;  // Race condition here
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment, NULL);
    pthread_create(&t2, NULL, increment, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Counter: %d\n");  // Will be less than 2000000
}

Prevention methods:

Mutex

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

void* safe_increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&mutex);
        counter++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

Atomic Operations

#include <stdatomic.h>
atomic_int counter = 0;

void* atomic_increment(void* arg) {
    for (int i = 0; i < 1000000; i++) {
        atomic_fetch_add(&counter, 1);
    }
    return NULL;
}

Simple x86 Bootloader Project

Vivek P — Sun, 15 Sep 2024 13:30:57 +0000

Simple x86 Bootloader Project

Introduction
Prerequisites
Bootloader Code
Code Explanation
Bootloader Flow
Building the Bootloader
Testing the Bootloader
Troubleshooting
Further Learning
Conclusion

Introduction

This project demonstrates how to create a simple bootloader using x86 assembly language. The bootloader, when executed, prints the message "Hello World I am vivek" to the screen. This serves as an educational tool to understand the basics of how a computer boots up and how to write low-level code that interacts directly with the hardware.

Prerequisites

To work with this project, you'll need:

Basic understanding of assembly language concepts
An x86 assembler (like NASM or GNU Assembler)
A linker (like ld)
A virtualization tool (like QEMU) or a physical machine to test the bootloader
A text editor for writing code
A bash-compatible shell (for Unix-like systems) or equivalent for Windows

Bootloader Code

Save the following code in a file named sample_bootable.s:

.code16
.global init

init:
   mov $string, %si
   mov $0xe, %ah

print:
   lodsb
   cmp $0, %al
   je end
   int $0x10
   jmp print

end:
   hlt

string: .asciz "Hello World I am vivek"

.fill 510-(.-init), 1, 0
.word 0xaa55

Code Explanation

Let's break down each part of the code:

.code16: This directive tells the assembler to generate 16-bit code, which is what the BIOS expects when it first starts up.
.global init: This makes the init label globally visible, which is important for the linker.
init:: This label marks the entry point of our program.
mov $string, %si: This loads the address of our string into the SI (Source Index) register.
mov $0xe, %ah: This sets the AH register to 0xe, which is the BIOS teletype output function.
print:: This label marks the start of our printing loop.
lodsb: This loads a byte from the address in SI into AL and increments SI.
cmp $0, %al: This compares the loaded byte with 0 (our string terminator).
je end: If the byte is 0, we jump to the end label.
int $0x10: This calls BIOS interrupt 0x10, which prints the character in AL.
jmp print: This jumps back to the print label to process the next character.
end: hlt: This halts the CPU when we're done printing.
string: .asciz "Hello World I am vivek": This defines our null-terminated string.
.fill 510-(.-init), 1, 0: This pads our bootloader to 510 bytes with zeros.
.word 0xaa55: This is the boot signature that the BIOS looks for to determine if a sector is bootable.

Bootloader Flow

The BIOS loads our bootloader into memory at address 0x7C00.
Our code sets up the SI register to point to our string.
We enter a loop that prints each character of the string:
- Load a character
- Check if it's the end of the string (null terminator)
- If not, print it and continue
After printing the entire string, we halt the CPU.

Building the Bootloader

To build the bootloader, we'll use a bash script that assembles the code, links it, and prepares it for execution. Save the following script as build_bootloader.sh:

#!/usr/bin/env bash 
as sample_bootable.s -o sample_bootable.o
ld -o boot.bin --oformat binary -e init -Ttext 0x7c00 -o boot.bin sample_bootable.o
rm sample_bootable.o
echo "execute command  :- qemu-system-x86_64 boot.bin "

Here's what each line does:

as sample_bootable.s -o sample_bootable.o: Assembles our source file into an object file.
ld -o boot.bin --oformat binary -e init -Ttext 0x7c00 -o boot.bin sample_bootable.o: Links the object file into a flat binary:
- --oformat binary: Outputs a flat binary file.
- -e init: Sets the entry point to our init label.
- -Ttext 0x7c00: Sets the starting address to 0x7c00, where the BIOS loads the bootloader.
rm sample_bootable.o: Removes the intermediate object file.
The echo command reminds you how to run the bootloader in QEMU.

Make the script executable and run it:

chmod +x build_bootloader.sh
./build_bootloader.sh

This will create your boot.bin file, which is your bootable image.

Testing the Bootloader

You can test your bootloader using QEMU:

qemu-system-x86_64 boot.bin

This will start QEMU, load your bootloader, and you should see your message "Hello World I am vivek" printed on the screen.

Troubleshooting

If you encounter issues:

Ensure your assembler and linker are correctly installed.
Check that the file paths in the build script match your directory structure.
Verify that QEMU is properly installed on your system.
If the message doesn't appear, double-check your assembly code for typos.

Further Learning

To expand your knowledge of bootloaders and low-level programming:

Modify the message or add more functionality to the bootloader.
Learn about loading larger programs from disk.
Study how real bootloaders transition from 16-bit real mode to 32-bit protected mode.
Explore multiboot-compliant bootloaders for loading modern operating systems.
Investigate UEFI (Unified Extensible Firmware Interface) bootloaders for newer systems.

Conclusion

Congratulations! You've created a simple bootloader that prints a message to the screen. This project demonstrates the basics of how a computer starts up and how we can run our own code at the very beginning of the boot process. While this bootloader is simple, it forms the foundation for understanding more complex boot processes used in real-world systems.

Remember, working with bootloaders means you're operating at a very low level. Always test in a virtual machine to avoid potentially damaging your computer's boot sector.

Happy coding and exploring the fascinating world of low-level programming!

github repo: https://github.com/Vivx701/simple_bootable

Linux System Information Files Reference

Vivek P — Sun, 08 Sep 2024 11:43:41 +0000

Linux System Information Files Reference

This guide provides an overview of important system information files in Linux, typically found in the /proc and /sys filesystems. These files offer valuable insights into the system's current state and configuration.

1. /proc/ioports

Purpose: Shows registered I/O port regions and their usage by devices or drivers.

Example content:

0000-0cf7 : PCI Bus 0000:00
  0000-001f : dma1
  0020-0021 : pic1
  0040-0043 : timer0
  ...

Usage: cat /proc/ioports

2. /proc/interrupts

Purpose: Displays information about system interrupts, including which are in use and by which devices.

Example content:

           CPU0       
  0:         36   IO-APIC-edge      timer
  1:          9   IO-APIC-edge      i8042
  ...

Usage: cat /proc/interrupts

3. /proc/meminfo

Purpose: Provides detailed information about system memory usage.

Example content:

MemTotal:        8174824 kB
MemFree:         3975548 kB
MemAvailable:    5631104 kB
...

Usage: cat /proc/meminfo

4. /proc/cpuinfo

Purpose: Contains detailed information about the system's CPU(s).

Example content:

processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 142
model name      : Intel(R) Core(TM) i7-8565U CPU @ 1.80GHz
...

Usage: cat /proc/cpuinfo

5. /proc/devices

Purpose: Lists all character and block devices currently configured in the kernel.

Example content:

Character devices:
  1 mem
  4 /dev/vc/0
  4 tty
  ...
Block devices:
  7 loop
  8 sd
 11 sr
...

Usage: cat /proc/devices

6. /proc/modules

Purpose: Lists all currently loaded kernel modules.

Example content:

snd_hda_codec_hdmi 49152 1 - Live 0x0000000000000000
snd_hda_codec_realtek 106496 1 - Live 0x0000000000000000
...

Usage: cat /proc/modules

7. /proc/version

Purpose: Shows the Linux kernel version and additional system information.

Example content:

Linux version 5.4.0-42-generic (buildd@lcy01-amd64-027) (gcc version 9.3.0 (Ubuntu 9.3.0-10ubuntu2)) #46-Ubuntu SMP Fri Jul 10 00:24:02 UTC 2020

Usage: cat /proc/version

8. /proc/partitions

Purpose: Lists all partitions known to the system.

Example content:

major minor  #blocks  name
   8        0  976762584 sda
   8        1     524288 sda1
   8        2  976236544 sda2
 ...

Usage: cat /proc/partitions

9. /proc/mounts

Purpose: Shows currently mounted filesystems.

Example content:

sysfs /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0
proc /proc proc rw,nosuid,nodev,noexec,relatime 0 0
...

Usage: cat /proc/mounts

10. /proc/net/dev

Purpose: Provides statistics about network interfaces.

Example content:

Inter-|   Receive                                                |  Transmit
 face |bytes    packets errs drop fifo frame compressed multicast|bytes    packets errs drop fifo colls carrier compressed
    lo: 2816326   34851    0    0    0     0          0         0  2816326   34851    0    0    0     0       0          0
  eth0: 1215332    2535    0    0    0     0          0        19   187816    1353    0    0    0     0       0          0

Usage: cat /proc/net/dev

11. /sys/class/net

Purpose: Contains directories for each network interface, providing detailed information and controls.

Example usage:

ls /sys/class/net                     # List network interfaces
cat /sys/class/net/eth0/address       # Show MAC address of eth0
cat /sys/class/net/eth0/statistics/rx_bytes  # Show received bytes on eth0

12. /proc/uptime

Purpose: Shows how long the system has been running.

Example content:

350735.47 1395914.78

(The first number is total uptime in seconds, the second is idle time)

Usage: cat /proc/uptime

Additional Notes

These files are part of the procfs (process filesystem) and sysfs in Linux.
They provide real-time information about the system's current state.
The content of these files is generated on-the-fly when read.
Some files may require root privileges to access, depending on system configuration.
The /sys filesystem (sysfs) provides a more structured way to access kernel information and manipulate device parameters.

Remember to use these files responsibly, especially in production environments, as reading them can impact system performance if done excessively.

DEV Community: Vivek P

CPU Registers

CPU Registers

Types of Registers

1. General-Purpose Registers (GPRs)

2. Segment Registers

3. Special-Purpose Registers

4. Floating-Point Registers (FPRs)

5. Control Registers

6. Debug Registers

7. Model-Specific Registers (MSRs)

Summary

IPC Mechanisms in Linux

Linux Developer Interview Questions.

Linux System Developer Interview Questions and Answers

Basic Linux Knowledge

Q: What happens when you type 'ls -l' in a terminal? Explain the entire process.

Q: What is the Linux kernel?

Q: Explain the boot process of a Linux system.

Q: What is the difference between a soft link and a hard link?

Q: Explain the Linux process scheduling algorithm.

Q: What is a page fault? Explain different types.

Q: What are the different types of process states in Linux?

System Programming

Q: What is the difference between a process and a thread?

6. Q: What are signals in Linux? How do you handle signals in a program?

Debugging & Performance

Q: How would you profile a Linux application for performance optimization?

Coding Questions

Q: Write a program to create a daemon process.

Q: What is a deadlock? How can you prevent it?

Q: Explain the difference between threads and processes.

Q: What is a race condition? How can you prevent it?

Simple x86 Bootloader Project

Simple x86 Bootloader Project

Table of Contents

Introduction

Prerequisites

Bootloader Code

Code Explanation

Bootloader Flow

Building the Bootloader

Testing the Bootloader

Troubleshooting

Further Learning

Conclusion

Linux System Information Files Reference

Linux System Information Files Reference

1. /proc/ioports

2. /proc/interrupts

3. /proc/meminfo

4. /proc/cpuinfo

5. /proc/devices

6. /proc/modules

7. /proc/version

8. /proc/partitions

9. /proc/mounts

10. /proc/net/dev

11. /sys/class/net

12. /proc/uptime

Additional Notes