你的Go程序之所以会在Read()处挂起，核心原因是子进程继承了未关闭的PTY master/slave文件描述符，导致子进程退出后，PTY slave端的引用计数不为0，master端的read()无法检测到EOF，从而一直阻塞。下面是具体的修改步骤：

1. 替换syscall.ForkExec为syscall.Fork+手动exec #

syscall.ForkExec无法在exec前执行自定义操作（比如关闭不需要的FD），而你的C代码正是在fork后、exec前关闭了master和slave FD。所以我们需要用syscall.Fork创建子进程，然后在子进程中手动处理FD重定向、关闭冗余FD，再执行exec。

2. 移除不必要的Setsid: true #

你的C代码没有调用setsid()，而Go代码中设置Setsid: true会让子进程创建新会话，但并没有将PTY slave设为控制终端，反而可能导致终端行为异常，建议移除。

3. 确保子进程关闭冗余FD #

子进程需要关闭：

• PTY master FD（父进程才需要用它读取输出）
• 原PTY slave FD（因为已经通过dup2将stdout/stderr重定向到slave，原FD不再需要）
• 管道的写端（子进程只需要读端作为stdin）

修改后的完整Go代码 #

package main

/*
#include <stdlib.h>
#include <util.h>

// Wrapper function to call openpty
int open_pty(int *master_fd, int *slave_fd) {
    return openpty(master_fd, slave_fd, NULL, NULL, NULL);
}
*/
import "C"

import (
    "fmt"
    "log"
    "os"
    "syscall"
)

func main() {
    // Create pipe for stdin
    pipeFd := make([]int, 2)
    if err := syscall.Pipe(pipeFd); err != nil {
        fmt.Fprintf(os.Stderr, "pipe: %v\n", err)
        os.Exit(1)
    }

    // Create PTY for stdout/stderr using openpty(3)
    var masterFd, slaveFd C.int
    if C.open_pty(&masterFd, &slaveFd) == -1 {
        fmt.Fprintf(os.Stderr, "openpty failed\n")
        os.Exit(1)
    }
    masterInt := int(masterFd)
    slaveInt := int(slaveFd)

    pid, err := syscall.Fork()
    if err != nil {
        fmt.Fprintf(os.Stderr, "fork: %v\n", err)
        os.Exit(1)
    }

    if pid == 0 {
        // === Child process ===
        // Close pipe write end (child only needs read end)
        syscall.Close(pipeFd[1])
        // Redirect stdin to pipe read end
        syscall.Dup2(pipeFd[0], syscall.Stdin)
        syscall.Close(pipeFd[0])

        // Close PTY master (only parent uses this)
        syscall.Close(masterInt)

        // Redirect stdout/stderr to PTY slave
        syscall.Dup2(slaveInt, syscall.Stdout)
        syscall.Dup2(slaveInt, syscall.Stderr)
        // Close original PTY slave FD (we already duplicated it to stdout/stderr)
        syscall.Close(slaveInt)

        // Execute ggrep
        err := syscall.Exec(
            "/opt/homebrew/bin/ggrep",
            []string{"ggrep", "--color=auto", "-P", "hello"},
            os.Environ(),
        )
        // If exec fails
        fmt.Fprintf(os.Stderr, "exec: %v\n", err)
        os.Exit(1)
    } else {
        // === Parent process ===
        // Close pipe read end (child uses this)
        syscall.Close(pipeFd[0])
        // Close PTY slave (child uses this)
        syscall.Close(slaveInt)

        // Write test data to grep's stdin
        testData := []byte("hello world\n\n")
        _, err := syscall.Write(pipeFd[1], testData)
        if err != nil {
            log.Fatal(err)
        }
        // Close pipe write end to send EOF
        if err := syscall.Close(pipeFd[1]); err != nil {
            log.Fatal(err)
        }

        // Read grep's output from master PTY
        fmt.Println("=== Grep output (with color codes if terminal detected) ===")
        buffer := make([]byte, 1024)
        for {
            n, err := syscall.Read(masterInt, buffer)
            if err != nil || n == 0 {
                break
            }
            fmt.Print(string(buffer[:n]))
        }
        syscall.Close(masterInt)

        // Wait for child to finish
        var status syscall.WaitStatus
        _, err = syscall.Wait4(pid, &status, 0, nil)
        if err != nil {
            fmt.Fprintf(os.Stderr, "wait4: %v\n", err)
            os.Exit(1)
        }
        if status.Exited() {
            fmt.Printf("=== grep exited with status %d ===\n", status.ExitStatus())
        }
    }
}

关键修改说明 #

• 改用syscall.Fork+syscall.Exec：模拟C代码的fork+exec流程，允许我们在子进程exec前关闭冗余FD。
• 子进程关闭冗余FD：明确关闭PTY master、原PTY slave、管道写端，确保子进程退出后PTY slave的所有FD都被关闭，触发master端的EOF。
• 移除Setsid: true：避免不必要的会话创建，保持与C代码一致的终端行为。

这样修改后，你的Go程序就能和C代码表现一致：grep会识别stdout为TTY并输出颜色，关闭管道后grep会收到EOF并退出，父进程能正确读取输出直到EOF，不会挂起。

内容的提问来源于stack exchange，提问作者Udeshya D.