写了个 200 行的工具,专门用来查「这个端口被谁占了」

工具Go命令行

起因很琐碎。我每天要在服务器上跑十几次类似这样的命令:

lsof -i :8080
# 或者
netstat -tlnp | grep 8080
# 有时候还不够,得再
ps -ef | grep <pid>

输出格式不统一,还得手动复制 pid 再查一次进程详情。次数多了就烦,于是写了个小工具。

想要的效果

$ port 8080
:8080  LISTEN  pid 21834  go-build  /opt/app/order-service
       用户 deploy  启动 3天前  内存 128MB
       父进程 1 (systemd)

$ port 8080 9090 3306      # 支持多个
$ port 8080 --kill          # 直接杀掉,省一步

大概 200 行就够,不引第三方库,只用标准库。

从 /proc/net/tcp 开始

第一步是拿到「哪些 socket 在这个端口上监听」。Linux 上这个信息在 /proc/net/tcp(IPv6 是 tcp6):

// 每一行长这样(字段以空格分隔)
// sl  local_address rem_address   st tx_queue rx_queue tr tm->when retrnsmt   uid  timeout inode
// 0:  00000000:1F90 00000000:0000 0A 00000000:00000000 00:00000000 00000000  1000        0 34567 1 ...

几个要注意的地方:

一、端口是十六进制,而且字节序是反的。 1F90 是 8080,这个直接读就行。但 local_address 的 IP 部分是小端存的,0100007F 其实是 127.0.0.1,要按字节倒过来。

func parseHexPort(s string) uint16 {
    v, err := strconv.ParseUint(s, 16, 16)
    if err != nil {
        return 0
    }
    return uint16(v)
}

func parseHexIP(s string) net.IP {
    v, err := strconv.ParseUint(s, 16, 32)
    if err != nil {
        return nil
    }
    // /proc 里是小端,手动拼字节
    return net.IPv4(byte(v), byte(v>>8), byte(v>>16), byte(v>>24))
}

tcp6 里的是 32 个十六进制字符,要拼成 16 字节,同样是每 4 个字符一组倒序。

二、状态字段 st。 0A 是 TCP_LISTEN,01 是 ESTABLISHED。常用的:

st状态
01ESTABLISHED
02SYN_SENT
06TIME_WAIT
08CLOSE_WAIT
0ALISTEN

三、inode 是把 socket 和进程连起来的桥梁。 这个数是关键,靠它去 /proc/<pid>/fd/ 里找哪个进程打开了这个 socket。

用 inode 找到进程

遍历 /proc 下所有数字目录,看它们的 fd 链接指向哪里:

func findPidByInode(inode string) int {
    target := "socket:[" + inode + "]"
    entries, _ := filepath.Glob("/proc/[0-9]*/fd")
    for _, fdDir := range entries {
        pidStr := strings.Split(fdDir, "/")[2]
        links, _ := filepath.Glob(fdDir + "/*")
        for _, l := range links {
            dest, err := os.Readlink(l)
            if err != nil {
                continue   // 权限不足,跳过
            }
            if strings.HasSuffix(dest, target) {
                pid, _ := strconv.Atoi(pidStr)
                return pid
            }
        }
    }
    return 0
}

这里有三个真实的坑:

坑一:权限。 读别人的 /proc/<pid>/fd/ 需要 root 或者 CAP_SYS_PTRACE。非 root 跑的时候只能看到自己的进程,Readlink 会返回 permission denied。这时候只能输出「inode 12345(无法确定进程,试试 sudo)」。

坑二:遍历代价。 /proc 下有几千个进程时,每个进程几十个 fd,全部 readlink 一遍要几十毫秒。可以优化:

  • 先按 uid 过滤(/proc/<pid>/status 里有 uid),只查和目标 uid 一致或者自己是 root 的
  • 或者反向来:先拿目标 socket 的 uid,只看那个用户或者 root 的进程

坑三:一个 socket 可能被多个进程持有。 fork 之后子进程会继承 fd,所以同一个 inode 可能对应多个 pid。应该收集所有命中的 pid 而不是返回第一个。

展示进程信息

拿到 pid 之后,从 /proc/<pid>/ 里读几样东西:

// 命令行参数
cmdline, _ := os.ReadFile(fmt.Sprintf("/proc/%d/cmdline", pid))
args := strings.Split(strings.TrimRight(string(cmdline), "\x00"), "\x00")

// 可执行文件的真实路径
exe, _ := os.Readlink(fmt.Sprintf("/proc/%d/exe", pid))

// 工作目录
cwd, _ := os.Readlink(fmt.Sprintf("/proc/%d/cwd", pid))

// 启动时间:进程目录的创建时间
fi, _ := os.Stat(fmt.Sprintf("/proc/%d", pid))
startTime := fi.ModTime()

// 内存(RSS)
status, _ := os.ReadFile(fmt.Sprintf("/proc/%d/status", pid))

/proc/<pid>/stat 里的第 22 个字段是启动时刻的系统 jiffies,拿到它再除以 sysconf(_SC_CLK_TCK) 就能算出准确启动时间戳。比用目录的 mtime 可靠——mtime 在容器里有时候不准。

/proc/<pid>/cmdline 用的是 \0 分隔而不是空格,所以进程名里带空格也不会解析错。这比 ps 的输出靠谱。

内存用 VmRSS,单位是 kB:

for _, line := range strings.Split(string(status), "\n") {
    if strings.HasPrefix(line, "VmRSS:") {
        fmt.Sscanf(line, "VmRSS: %d kB", &rssKB)
    }
}

一个额外的用处

写完之后发现,这工具用来查「一个端口上有没有多个进程监听」特别方便。

正常情况下一个端口只能被一个进程独占监听,但如果你用了 SO_REUSEPORT(Go 的 net.ListenConfig 里可以设),就会有多个进程同时监听同一个端口,由内核做负载均衡。

排查这种问题时,lsof -i :8080 只会给你一堆 pid,而我的工具会把它们都列出来,一眼能看出是 8 个 worker 在共享 8080,而不是出 bug 了。

还有 TIME_WAIT 堆积的时候也能看:

$ port 8080 --all-states
:8080  LISTEN       pid 21834  ...
:8080  TIME_WAIT    -          (1222 个)
:8080  ESTABLISHED  pid 21834  ...

TIME_WAIT 数量到几万的时候会影响新连接建立(如果没开 tcp_tw_reuse),这个视图比 netstat | wc -l 直观。

代码放哪

整个项目两个文件,main.go 加一个 README.md,没有依赖任何第三方库,go build 直接出静态二进制,扔到服务器上就能跑。

源码我放在 GitHub 上了,链接在关于页里。有需要的可以自己改。

一点感想

这个工具大概花了我两个周末,写成之后每天省下的时间可能不到一分钟。按投入产出算,完全是亏的。

但它有个别的好处:第一次认真读了 /proc 下这些文件的格式。 以前 lsof、netstat、ss、ps 都是黑盒,现在知道它们其实就是拼这些文件。后来排查一个容器里 /proc 被特殊挂载导致的问题时,这点理解直接用上了。

所以工具类的小项目,收获往往不在工具本身。