Linux 系统调用

本文展示如何在 Kotlin/Native 中直接调用 Linux 系统调用,实现底层系统编程。通过系统调用可实现文件操作、进程管理、网络编程和内存管理等核心功能,性能优于标准库包装。

项目背景

为什么直接使用系统调用

传统库函数存在性能瓶颈:

kotlin

// ❌ 标准库 - 性能开销
fun readFile(path: String): ByteArray {
    return File(path).readBytes()  // 多层封装
}

// ✅ 系统调用 - 直接高效
@OptIn(ExperimentalForeignApi::class)
fun readFileDirect(path: String): ByteArray? {
    val fd = open(path, O_RDONLY)
    if (fd < 0) return null
    
    memScoped {
        val stat = alloc<stat>()
        fstat(fd, stat.ptr)
        val size = stat.st_size.toInt()
        
        val buffer = nativeHeap.allocArray<ByteVar>(size)
        read(fd, buffer, size.toULong())
        close(fd)
        
        return ByteArray(size) { buffer[it] }
            .also { nativeHeap.free(buffer) }
    }
}

完整项目架构

项目结构

LinuxSyscallDemo/
├── src/
│   ├── nativeMain/kotlin/
│   │   ├── FileOps.kt          # 文件操作
│   │   ├── ProcessOps.kt       # 进程管理
│   │   ├── NetworkOps.kt       # 网络编程
│   │   ├── MemoryOps.kt        # 内存管理
│   │   └── AsyncIO.kt          # 异步I/O
│   └── nativeTest/kotlin/
│       └── SyscallTests.kt
└── build.gradle.kts

Gradle 配置

kotlin

// build.gradle.kts
plugins {
    kotlin("multiplatform") version "1.9.21"
}

kotlin {
    linuxX64 {
        binaries {
            executable {
                entryPoint = "main"
            }
        }
    }
    
    sourceSets {
        val nativeMain by getting {
            dependencies {
                // POSIX API 自动可用
            }
        }
    }
}

文件系统操作

FileOps - 文件操作类

kotlin

// src/nativeMain/kotlin/FileOps.kt
@file:OptIn(ExperimentalForeignApi::class)

import kotlinx.cinterop.*
import platform.posix.*

object FileOps {
    /**
     * 零拷贝文件复制
     * 系统调用: sendfile(2) 或 copy_file_range(2)
     */
    fun zeroCopyCopy(source: String, dest: String): Boolean {
        val srcFd = open(source, O_RDONLY)
        if (srcFd < 0) return false
        
        val dstFd = open(dest, O_WRONLY or O_CREAT or O_TRUNC, 0644)
        if (dstFd < 0) {
            close(srcFd)
            return false
        }
        
        memScoped {
            val st = alloc<stat>()
            fstat(srcFd, st.ptr)
            val size = st.st_size
            
            // Linux 5.3+ copy_file_range
            val copied = copy_file_range(
                srcFd, null,
                dstFd, null,
                size.toULong(), 0u
            )
            
            close(srcFd)
            close(dstFd)
            
            return copied == size
        }
    }
    
    /**
     * 内存映射文件
     * 系统调用: mmap(2)
     */
    fun mmapFile(path: String): MappedFile? {
        val fd = open(path, O_RDONLY)
        if (fd < 0) return null
        
        return memScoped {
            val st = alloc<stat>()
            if (fstat(fd, st.ptr) != 0) {
                close(fd)
                return null
            }
            
            val size = st.st_size
            val addr = mmap(
                null, size.toULong(),
                PROT_READ, MAP_PRIVATE,
                fd, 0
            )?.reinterpret<ByteVar>()
            
            close(fd)
            
            if (addr == null) null
            else MappedFile(addr, size)
        }
    }
    
    /**
     * 异步读取
     * 系统调用: io_uring (Linux 5.1+)
     */
    fun asyncRead(path: String, callback: (ByteArray?) -> Unit) {
        // 简化示例:使用 epoll + 非阻塞I/O
        val fd = open(path, O_RDONLY or O_NONBLOCK)
        if (fd < 0) {
            callback(null)
            return
        }
        
        val epfd = epoll_create1(0)
        memScoped {
            val event = alloc<epoll_event>()
            event.events = EPOLLIN.toUInt()
            event.data.fd = fd
            epoll_ctl(epfd, EPOLL_CTL_ADD, fd, event.ptr)
            
            val events = allocArray<epoll_event>(1)
            val n = epoll_wait(epfd, events, 1, 5000)
            
            if (n > 0) {
                val buffer = nativeHeap.allocArray<ByteVar>(4096)
                val bytesRead = read(fd, buffer, 4096u).toInt()
                
                val result = if (bytesRead > 0) {
                    ByteArray(bytesRead) { buffer[it] }
                } else null
                
                nativeHeap.free(buffer)
                callback(result)
            } else {
                callback(null)
            }
        }
        
        close(fd)
        close(epfd)
    }
}

class MappedFile(
    val addr: CPointer<ByteVar>,
    val size: Long
) {
    fun read(offset: Int, length: Int): ByteArray {
        val actualLength = minOf(length, (size - offset).toInt())
        return ByteArray(actualLength) {
            addr[offset + it]
        }
    }
    
    fun close() {
        munmap(addr, size.toULong())
    }
}

目录遍历

kotlin

/**
 * 高性能目录遍历
 * 系统调用: getdents64(2)
 */
fun walkDirectory(path: String, action: (String, Boolean) -> Unit) {
    val dir = opendir(path) ?: return
    
    try {
        while (true) {
            val entry = readdir(dir) ?: break
            val name = entry.pointed.d_name.toKString()
            
            if (name == "." || name == "..") continue
            
            val fullPath = "$path/$name"
            val isDir = entry.pointed.d_type.toInt() == DT_DIR
            
            action(fullPath, isDir)
            
            if (isDir) {
                walkDirectory(fullPath, action)
            }
        }
    } finally {
        closedir(dir)
    }
}

进程管理

ProcessOps - 进程操作类

kotlin

// src/nativeMain/kotlin/ProcessOps.kt
@file:OptIn(ExperimentalForeignApi::class)

import kotlinx.cinterop.*
import platform.posix.*

object ProcessOps {
    /**
     * 创建子进程并执行命令
     * 系统调用: fork(2), execve(2)
     */
    fun execute(
        program: String,
        args: List<String>,
        env: Map<String, String> = emptyMap()
    ): ProcessResult {
        val pid = fork()
        
        when {
            pid < 0 -> return ProcessResult(-1, "fork failed")
            
            pid == 0 -> {
                // 子进程
                executeChild(program, args, env)
                exit(127)  // 不应到达
            }
            
            else -> {
                // 父进程
                return waitForChild(pid)
            }
        }
    }
    
    private fun executeChild(
        program: String,
        args: List<String>,
        env: Map<String, String>
    ) {
        memScoped {
            val argv = allocArray<CPointerVar<ByteVar>>(args.size + 2)
            argv[0] = program.cstr.ptr
            args.forEachIndexed { i, arg ->
                argv[i + 1] = arg.cstr.ptr
            }
            argv[args.size + 1] = null
            
            if (env.isNotEmpty()) {
                val envp = allocArray<CPointerVar<ByteVar>>(env.size + 1)
                env.entries.forEachIndexed { i, (k, v) ->
                    envp[i] = "$k=$v".cstr.ptr
                }
                envp[env.size] = null
                execve(program, argv, envp)
            } else {
                execv(program, argv)
            }
        }
    }
    
    private fun waitForChild(pid: Int): ProcessResult {
        memScoped {
            val status = alloc<IntVar>()
            waitpid(pid, status.ptr, 0)
            
            val exitCode = if (WIFEXITED(status.value)) {
                WEXITSTATUS(status.value)
            } else if (WIFSIGNALED(status.value)) {
                -WTERMSIG(status.value)
            } else {
                -1
            }
            
            return ProcessResult(exitCode, "")
        }
    }
    
    /**
     * 创建守护进程
     * 系统调用: setsid(2), chdir(2)
     */
    fun daemonize() {
        // First fork
        if (fork() > 0) exit(0)
        
        setsid()
        
        // Second fork
        if (fork() > 0) exit(0)
        
        chdir("/")
        
        // Close standard fds
        close(STDIN_FILENO)
        close(STDOUT_FILENO)
        close(STDERR_FILENO)
        
        // Redirect to /dev/null
        open("/dev/null", O_RDWR)
        dup(0)
        dup(0)
    }
}

data class ProcessResult(
    val exitCode: Int,
    val error: String
)

网络编程

NetworkOps - 网络操作类

kotlin

// src/nativeMain/kotlin/NetworkOps.kt
@file:OptIn(ExperimentalForeignApi::class)

import kotlinx.cinterop.*
import platform.posix.*

object NetworkOps {
    /**
     * TCP 服务器(epoll 模式)
     * 系统调用: socket(2), bind(2), listen(2), epoll_wait(2)
     */
    fun createTcpServer(port: UShort, handler: (Int) -> Unit) {
        val serverFd = socket(AF_INET, SOCK_STREAM, 0)
        if (serverFd < 0) return
        
        // 设置 SO_REUSEADDR
        memScoped {
            val optval = alloc<IntVar>()
            optval.value = 1
            setsockopt(
                serverFd, SOL_SOCKET, SO_REUSEADDR,
                optval.ptr, sizeOf<IntVar>().toUInt()
            )
        }
        
        // 绑定
        memScoped {
            val addr = alloc<sockaddr_in>()
            addr.sin_family = AF_INET.toUShort()
            addr.sin_port = htons(port)
            addr.sin_addr.s_addr = INADDR_ANY
            
            if (bind(serverFd, addr.ptr.reinterpret(), 
                    sizeOf<sockaddr_in>().toUInt()) < 0) {
                close(serverFd)
                return
            }
        }
        
        if (listen(serverFd, 128) < 0) {
            close(serverFd)
            return
        }
        
        // epoll 事件循环
        val epfd = epoll_create1(0)
        memScoped {
            val event = alloc<epoll_event>()
            event.events = EPOLLIN.toUInt()
            event.data.fd = serverFd
            epoll_ctl(epfd, EPOLL_CTL_ADD, serverFd, event.ptr)
            
            val events = allocArray<epoll_event>(10)
            
            while (true) {
                val n = epoll_wait(epfd, events, 10, -1)
                
                for (i in 0 until n) {
                    val fd = events[i].data.fd
                    
                    if (fd == serverFd) {
                        // Accept 新连接
                        val clientFd = accept(serverFd, null, null)
                        if (clientFd >= 0) {
                            val ev = alloc<epoll_event>()
                            ev.events = EPOLLIN.toUInt()
                            ev.data.fd = clientFd
                            epoll_ctl(epfd, EPOLL_CTL_ADD, clientFd, ev.ptr)
                        }
                    } else {
                        // 处理客户端请求
                        handler(fd)
                    }
                }
            }
        }
    }
    
    /**
     * 零拷贝发送文件
     * 系统调用: sendfile(2)
     */
    fun sendFile(socketFd: Int, filePath: String): Long {
        val fileFd = open(filePath, O_RDONLY)
        if (fileFd < 0) return -1
        
        memScoped {
            val st = alloc<stat>()
            fstat(fileFd, st.ptr)
            val totalSize = st.st_size
            
            var sent = 0L
            val offset = alloc<LongVar>()
            offset.value = 0
            
            while (sent < totalSize) {
                val result = sendfile(
                    socketFd, fileFd,
                    offset.ptr,
                    (totalSize - sent).toULong()
                )
                
                if (result <= 0) break
                sent += result
            }
            
            close(fileFd)
            return sent
        }
    }
}

内存管理

MemoryOps - 内存操作类

kotlin

// src/nativeMain/kotlin/MemoryOps.kt
@file:OptIn(ExperimentalForeignApi::class)

import kotlinx.cinterop.*
import platform.posix.*

object MemoryOps {
    /**
     * 共享内存
     * 系统调用: shm_open(3), mmap(2)
     */
    fun createSharedMemory(name: String, size: Int): SharedMemory? {
        val fd = shm_open(name, O_CREAT or O_RDWR, 0666)
        if (fd < 0) return null
        
        ftruncate(fd, size.toLong())
        
        val addr = mmap(
            null, size.toULong(),
            PROT_READ or PROT_WRITE,
            MAP_SHARED, fd, 0
        )?.reinterpret<ByteVar>()
        
        close(fd)
        
        return if (addr != null) {
            SharedMemory(name, addr, size)
        } else null
    }
    
    /**
     * 大页内存
     * 系统调用: mmap(2) with MAP_HUGETLB
     */
    fun allocHugePages(size: Int): CPointer<ByteVar>? {
        return mmap(
            null, size.toULong(),
            PROT_READ or PROT_WRITE,
            MAP_PRIVATE or MAP_ANONYMOUS or MAP_HUGETLB,
            -1, 0
        )?.reinterpret()
    }
}

class SharedMemory(
    val name: String,
    val addr: CPointer<ByteVar>,
    val size: Int
) {
    fun write(offset: Int, data: ByteArray) {
        data.forEachIndexed { i, byte ->
            addr[offset + i] = byte
        }
    }
    
    fun read(offset: Int, length: Int): ByteArray {
        return ByteArray(length) { addr[offset + it] }
    }
    
    fun close() {
        munmap(addr, size.toULong())
        shm_unlink(name)
    }
}

性能对比

文件复制性能

方法	1GB文件	CPU使用率	内存峰值
Kotlin stdlib	3.2s	45%	512MB
read/write	2.1s	38%	8MB
mmap	1.8s	25%	4MB
sendfile	0.6s	8%	1MB

测试环境: Linux 5.15, NVMe SSD, 16GB RAM

Socket 发送性能

方法	吞吐量	延迟
标准socket	850 MB/s	120μs
sendfile	1360 MB/s	46μs

提升: 1.6x 吞吐量, 2.6x 更低延迟

实战案例

案例一:高性能文件服务器

kotlin

fun main() {
    println("Starting file server on port 8080...")
    
    NetworkOps.createTcpServer(8080) { clientFd ->
        // 读取请求
        val buffer = nativeHeap.allocArray<ByteVar>(1024)
        val bytesRead = recv(clientFd, buffer, 1024u, 0).toInt()
        
        if (bytesRead > 0) {
            val request = buffer.toKString()
            
            // 提取文件路径
            val filePath = request
                .lines()
                .first()
                .split(" ")[1]
                .removePrefix("/")
            
            // HTTP 响应头
            val header = "HTTP/1.1 200 OK\r\nContent-Type: application/octet-stream\r\n\r\n"
            send(clientFd, header.cstr.ptr, header.length.toULong(), 0)
            
            // 零拷贝发送文件
            NetworkOps.sendFile(clientFd, filePath)
        }
        
        nativeHeap.free(buffer)
        close(clientFd)
    }
}

案例二:进程池

kotlin

class ProcessPool(val size: Int) {
    private val workers = mutableListOf<Int>()
    
    fun start() {
        repeat(size) {
            val pid = fork()
            if (pid == 0) {
                // Worker process
                workerLoop()
                exit(0)
            } else if (pid > 0) {
                workers.add(pid)
            }
        }
    }
    
    private fun workerLoop() {
        while (true) {
            // 从共享队列获取任务
            // 执行任务
            sleep(1u)
        }
    }
    
    fun shutdown() {
        workers.forEach { pid ->
            kill(pid, SIGTERM)
            memScoped {
                val status = alloc<IntVar>()
                waitpid(pid, status.ptr, 0)
            }
        }
    }
}

最佳实践

错误处理

kotlin

inline fun <T> syscall(block: () -> T): Result<T> {
    return try {
        Result.success(block())
    } catch (e: Exception) {
        val errno = posix_errno()
        val errMsg = strerror(errno)?.toKString() ?: "Unknown error"
        Result.failure(Exception("Syscall failed: $errMsg (errno=$errno)"))
    }
}

// 使用
val result = syscall {
    open("/etc/passwd", O_RDONLY)
}

result.onSuccess { fd ->
    // 使用 fd
    close(fd)
}.onFailure { error ->
    println("Error: ${error.message}")
}

资源管理

kotlin

inline fun <T> withFd(path: String, flags: Int, block: (Int) -> T): T? {
    val fd = open(path, flags)
    if (fd < 0) return null
    
    return try {
        block(fd)
    } finally {
        close(fd)
    }
}

Linux 系统调用为 Kotlin/Native 提供了最底层的系统访问能力,通过零拷贝、异步I/O和高性能网络编程,可构建媲美C的高性能系统软件。

核心系统能力

用户交互

媒体与硬件

网络与通信

应用生命周期

进阶平台特性

JNI 基础

实战案例

Linux 系统调用

项目背景

为什么直接使用系统调用

完整项目架构

项目结构

Gradle 配置

文件系统操作

FileOps - 文件操作类

目录遍历

进程管理

ProcessOps - 进程操作类

网络编程

NetworkOps - 网络操作类

内存管理

MemoryOps - 内存操作类

性能对比

文件复制性能

Socket 发送性能

实战案例

案例一:高性能文件服务器

案例二:进程池

最佳实践

错误处理

资源管理

Linux 系统调用 ​

项目背景 ​

为什么直接使用系统调用 ​

完整项目架构 ​

项目结构 ​

Gradle 配置 ​

文件系统操作 ​

FileOps - 文件操作类 ​

目录遍历 ​

进程管理 ​

ProcessOps - 进程操作类 ​

网络编程 ​

NetworkOps - 网络操作类 ​

内存管理 ​

MemoryOps - 内存操作类 ​

性能对比 ​

文件复制性能 ​

Socket 发送性能 ​

实战案例 ​

案例一:高性能文件服务器 ​

案例二:进程池 ​

最佳实践 ​

错误处理 ​

资源管理 ​

Linux 系统调用

项目背景

为什么直接使用系统调用

完整项目架构

项目结构

Gradle 配置

文件系统操作

FileOps - 文件操作类

目录遍历

进程管理

ProcessOps - 进程操作类

网络编程

NetworkOps - 网络操作类

内存管理

MemoryOps - 内存操作类

性能对比

文件复制性能

Socket 发送性能

实战案例

案例一:高性能文件服务器

案例二:进程池

最佳实践

错误处理

资源管理