menios
menios copied to clipboard
pbalduino
Implement thread-aware system calls and kernel integration
Goal
Extend the system call interface and kernel to properly support multithreaded applications, ensuring thread-safe system call execution and proper integration with threading infrastructure.
Context
With threading support implemented (Issues #108-#112), the kernel system call interface needs to be made thread-aware. Many system calls need modification to handle multiple threads per process, thread-specific behavior, and proper resource management in a multithreaded environment.
Definition of Done
- Thread-safe system calls: All system calls safe for concurrent execution
- Thread-specific system calls: New syscalls for thread management
- Per-thread kernel state: Thread-specific kernel data structures
- Thread-aware process management: Process operations that handle threads
- Thread signal delivery: Proper signal routing to specific threads
- Thread-safe file operations: File descriptor operations with threading
- Thread memory management: Memory operations aware of threading
- Thread scheduling integration: System call integration with thread scheduler
Thread-Specific System Calls
// New system calls for threading support
long sys_thread_create(void *entry_point, void *arg, void *stack, size_t stack_size,
unsigned long flags);
long sys_thread_exit(void *exit_value);
long sys_thread_join(tid_t tid, void **exit_value);
long sys_thread_detach(tid_t tid);
long sys_thread_self(void);
long sys_thread_yield(void);
long sys_thread_kill(tid_t tid, int signal);
long sys_thread_sigmask(int how, const sigset_t *set, sigset_t *oldset);
long sys_thread_setname(tid_t tid, const char *name);
long sys_thread_getname(tid_t tid, char *name, size_t len);
// Thread synchronization system calls
long sys_futex(int *uaddr, int op, int val, const struct timespec *timeout,
int *uaddr2, int val3);
long sys_set_robust_list(struct robust_list_head *head, size_t len);
long sys_get_robust_list(int pid, struct robust_list_head **head_ptr, size_t *len_ptr);
Thread-Safe System Call Infrastructure
// Per-thread system call context
struct thread_syscall_context {
struct cpu_context *saved_context; // Saved user context
int syscall_number; // Current system call
unsigned long args[6]; // System call arguments
long return_value; // Return value
int error_code; // Error code
bool in_syscall; // Currently in system call
bool restartable; // System call can be restarted
sigset_t blocked_signals; // Blocked signals during syscall
};
// Thread-safe system call entry/exit
long thread_safe_syscall_entry(int syscall_num, unsigned long arg1,
unsigned long arg2, unsigned long arg3,
unsigned long arg4, unsigned long arg5,
unsigned long arg6);
void thread_safe_syscall_exit(long return_value);
int handle_syscall_signal(struct thread_syscall_context *context, int signal);
Thread-Aware Process Management
// Extended process structure for threading
struct process {
pid_t pid; // Process ID
struct list_head threads; // List of threads
atomic_t thread_count; // Number of threads
pthread_mutex_t thread_list_lock; // Protects thread list
struct thread *main_thread; // Main thread
struct mm_struct *mm; // Shared memory management
struct files_struct *files; // Shared file descriptors
struct signal_struct *signal; // Shared signal handling
// Thread-specific process operations
void (*thread_created)(struct thread *thread);
void (*thread_exited)(struct thread *thread);
void (*thread_group_exit)(int exit_code);
};
// Thread group operations
int process_add_thread(struct process *proc, struct thread *thread);
int process_remove_thread(struct process *proc, struct thread *thread);
void process_exit_all_threads(struct process *proc, int exit_code);
int process_send_signal_to_thread(struct process *proc, tid_t tid, int signal);
Thread-Aware Signal Handling
// Thread-specific signal delivery
struct thread_signal_queue {
sigset_t pending; // Pending signals for this thread
struct siginfo queue[SIGQUEUE_MAX]; // Queued signal information
int queue_count; // Number of queued signals
pthread_mutex_t lock; // Protects signal queue
};
// Signal delivery functions
int deliver_signal_to_thread(struct thread *thread, int signal,
struct siginfo *info);
int deliver_signal_to_process(struct process *proc, int signal,
struct siginfo *info);
struct thread *select_signal_thread(struct process *proc, int signal);
int handle_thread_signal(struct thread *thread, int signal);
Thread-Safe File Operations
// Thread-safe file descriptor operations
struct files_struct {
atomic_t count; // Reference count
pthread_rwlock_t file_lock; // Protects file descriptor table
struct file *fd_array[NR_OPEN]; // File descriptor array
fd_set close_on_exec; // Close-on-exec bitmap
fd_set open_fds; // Open file descriptors bitmap
int next_fd; // Next available fd
};
// Thread-safe file operations
int thread_safe_open(const char *pathname, int flags, mode_t mode);
int thread_safe_close(int fd);
ssize_t thread_safe_read(int fd, void *buf, size_t count);
ssize_t thread_safe_write(int fd, const void *buf, size_t count);
int thread_safe_dup(int oldfd);
int thread_safe_dup2(int oldfd, int newfd);
Thread Memory Management Integration
// Thread-aware memory management
struct mm_struct {
atomic_t mm_users; // Number of threads using this mm
pthread_rwlock_t mmap_lock; // Protects memory mappings
struct vm_area_struct *mmap; // Memory mappings
unsigned long start_code; // Code segment start
unsigned long end_code; // Code segment end
unsigned long start_data; // Data segment start
unsigned long end_data; // Data segment end
unsigned long start_brk; // Heap start
unsigned long brk; // Current heap end
unsigned long start_stack; // Stack segment start
// Thread-specific memory operations
struct vm_area_struct *(*get_thread_stack)(struct thread *thread);
int (*setup_thread_stack)(struct thread *thread, void *stack_addr, size_t size);
void (*cleanup_thread_stack)(struct thread *thread);
};
// Thread-aware memory system calls
long sys_mmap_thread(void *addr, size_t length, int prot, int flags,
int fd, off_t offset);
long sys_munmap_thread(void *addr, size_t length);
long sys_mprotect_thread(void *addr, size_t len, int prot);
long sys_brk_thread(void *addr);
Futex Implementation for User-Space Synchronization
// Futex (Fast Userspace Mutex) support
struct futex_hash_bucket {
pthread_spinlock_t lock; // Bucket lock
struct list_head chain; // Hash chain
};
struct futex_q {
struct list_head list; // Hash chain linkage
struct thread *thread; // Waiting thread
union futex_key key; // Futex key
int *uaddr; // User address
int val; // Expected value
};
// Futex operations
int futex_wait(int *uaddr, int val, const struct timespec *timeout);
int futex_wake(int *uaddr, int nr_wake);
int futex_requeue(int *uaddr1, int *uaddr2, int nr_wake, int nr_requeue);
int futex_cmp_requeue(int *uaddr1, int *uaddr2, int nr_wake, int nr_requeue, int val);
System Call Table Extensions
// Extended system call table for threading
static const sys_call_ptr_t sys_call_table[] = {
// ... existing system calls ...
// Threading system calls
[__NR_thread_create] = sys_thread_create,
[__NR_thread_exit] = sys_thread_exit,
[__NR_thread_join] = sys_thread_join,
[__NR_thread_detach] = sys_thread_detach,
[__NR_thread_self] = sys_thread_self,
[__NR_thread_yield] = sys_thread_yield,
[__NR_thread_kill] = sys_thread_kill,
[__NR_thread_sigmask] = sys_thread_sigmask,
[__NR_thread_setname] = sys_thread_setname,
[__NR_thread_getname] = sys_thread_getname,
// Synchronization system calls
[__NR_futex] = sys_futex,
[__NR_set_robust_list] = sys_set_robust_list,
[__NR_get_robust_list] = sys_get_robust_list,
// Thread-aware existing calls
[__NR_clone] = sys_clone_thread_aware,
[__NR_execve] = sys_execve_thread_aware,
[__NR_exit_group] = sys_exit_group,
};
Implementation Strategy
Phase 1: Basic Thread System Calls
- Implement core thread management system calls
- Add thread-specific kernel data structures
- Basic thread-safe system call infrastructure
- Thread creation/destruction integration
Phase 2: Thread-Safe Existing System Calls
- Audit and fix existing system calls for thread safety
- Implement proper locking for shared resources
- Add thread-aware signal delivery
- Thread-safe file descriptor operations
Phase 3: Advanced Threading Features
- Futex implementation for user-space synchronization
- Robust mutex support in kernel
- Thread-aware memory management
- Performance optimization for threading
Phase 4: Integration and Testing
- Integration with pthread library
- Comprehensive testing of thread safety
- Performance optimization
- Documentation and debugging support
Testing Strategy
- Stress testing of concurrent system calls
- Thread safety validation for all system calls
- Signal delivery correctness testing
- File descriptor sharing and isolation testing
- Memory management thread safety testing
- Futex operation correctness and performance testing
- Integration testing with pthread applications
Dependencies
- Kernel threading: Issue #108 - Core threading infrastructure
- pthread API: Issue #109 - User-space threading interface
- Signal handling: Issue #94 - Process signal handling
- File descriptors: Issue #96 - File descriptor management
- Memory management: Issues #57, #89 - Virtual memory and mmap
- Synchronization primitives: Issues #36-#40 - Kernel synchronization
Integration Points
- System call dispatcher modification for threading
- Scheduler integration for thread-aware system calls
- Signal subsystem integration for thread delivery
- Memory management integration for thread stacks
- File system integration for thread-safe operations
Security Considerations
- Thread isolation in system call execution
- Proper permission checking for thread operations
- Resource limit enforcement per thread and process
- Prevention of thread-based privilege escalation
- Secure handling of thread-specific data
Files to Create/Modify
- src/kernel/syscall/thread_syscalls.c - Thread-specific system calls
- src/kernel/syscall/syscall_thread_safe.c - Thread-safe syscall infrastructure
- src/kernel/futex.c - Futex implementation
- src/kernel/signal/thread_signal.c - Thread-aware signal handling
- src/kernel/fs/thread_safe_files.c - Thread-safe file operations
- include/uapi/linux/thread.h - Thread system call interface
- arch/x86_64/kernel/syscall_64.c - System call table updates
Performance Goals
- System call overhead < 10% increase for threading
- Futex operations < 500ns for uncontended case
- Thread creation system call < 50μs
- Signal delivery to specific thread < 5μs
- File descriptor operations overhead < 5%
Error Handling
- Proper error codes for thread-specific operations
- Graceful handling of thread termination during system calls
- Resource cleanup on abnormal thread termination
- Error isolation between threads
- Consistent error semantics across threaded operations
Standards Compliance
- Linux system call interface compatibility
- POSIX threading system call compliance
- SUSv4 threading requirements
- Linux futex interface compatibility
- Thread-safe system call semantics
Usage Examples
#include <unistd.h>
#include <sys/syscall.h>
#include <linux/futex.h>
// Create a new thread using system call
pid_t create_thread(void *entry_point, void *arg, void *stack, size_t stack_size) {
return syscall(__NR_thread_create, entry_point, arg, stack, stack_size, 0);
}
// Thread-safe file operations
void thread_safe_file_example() {
int fd = open("/tmp/shared_file", O_RDWR | O_CREAT, 0644);
if (fd >= 0) {
// Multiple threads can safely perform these operations
char buffer[1024];
ssize_t bytes = read(fd, buffer, sizeof(buffer));
write(fd, "thread data\n", 12);
close(fd);
}
}
// Futex-based synchronization
int atomic_int = 0;
void futex_wait_example() {
// Wait for atomic_int to become non-zero
while (atomic_int == 0) {
syscall(__NR_futex, &atomic_int, FUTEX_WAIT, 0, NULL, NULL, 0);
}
}
void futex_wake_example() {
// Set value and wake waiting threads
atomic_int = 1;
syscall(__NR_futex, &atomic_int, FUTEX_WAKE, INT_MAX, NULL, NULL, 0);
}
// Thread-specific signal handling
void setup_thread_signals() {
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGUSR1);
// Block SIGUSR1 for this thread only
syscall(__NR_thread_sigmask, SIG_BLOCK, &set, NULL);
}
int main() {
// Set thread name for debugging
syscall(__NR_thread_setname, syscall(__NR_thread_self), "main_thread");
// Create worker thread
void *stack = malloc(16384);
pid_t thread_id = create_thread(worker_function, work_data,
stack + 16384, 16384);
// Wait for thread completion
void *exit_value;
syscall(__NR_thread_join, thread_id, &exit_value);
free(stack);
return 0;
}
Related Issues
- Foundation for all multithreaded system programming
- Enables thread-safe application development
- Required for pthread library implementation
- Critical for server and database applications
- Enables modern parallel programming patterns
