Question

我想在Linux中找到为进程打开的所有fds。

我可以使用glib库函数吗？

Answer 1

以下是我以前使用的一些代码，我不知道/ proc / self（thx Donal！），但这种方式可能更通用。我已经在顶部包含了所有功能所需的包含。

#include <string.h>
#include <stdio.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/resource.h>

#ifndef FALSE
#define FALSE (0)
#endif
#ifndef TRUE
#define TRUE (!FALSE)
#endif

/* implementation of Donal Fellows method */ 
int get_num_fds()
{
     int fd_count;
     char buf[64];
     struct dirent *dp;

     snprintf(buf, 64, "/proc/%i/fd/", getpid());

     fd_count = 0;
     DIR *dir = opendir(buf);
     while ((dp = readdir(dir)) != NULL) {
          fd_count++;
     }
     closedir(dir);
     return fd_count;
}

我遇到一个非常糟糕的问题，一次泄漏文件句柄，事实证明我实际编写了Tom H.建议的解决方案：

/* check whether a file-descriptor is valid */
int pth_util_fd_valid(int fd)
{
     if (fd < 3 || fd >= FD_SETSIZE)
          return FALSE;
     if (fcntl(fd, F_GETFL) == -1 && errno == EBADF)
          return FALSE;
     return TRUE;
}

/* check first 1024 (usual size of FD_SESIZE) file handles */
int test_fds()
{
     int i;
     int fd_dup;
     char errst[64];
     for (i = 0; i < FD_SETSIZE; i++) {
          *errst = 0;
          fd_dup = dup(i);
          if (fd_dup == -1) {
                strcpy(errst, strerror(errno));
                // EBADF  oldfd isnâ€™t an open file descriptor, or newfd is out of the allowed range for file descriptors.
                // EBUSY  (Linux only) This may be returned by dup2() during a race condition with open(2) and dup().
                // EINTR  The dup2() call was interrupted by a signal; see signal(7).
                // EMFILE The process already has the maximum number of file descriptors open and tried to open a new one.
          } else {
                close(fd_dup);
                strcpy(errst, "dup() ok");
          }
          printf("%4i: %5i %24s %s\n", i, fcntl(i, F_GETOWN), fd_info(i), errst);
     }
     return 0;
}

你可能也想要这些，以满足上面的最后一个印刷品......

char *fcntl_flags(int flags)
{
    static char output[128];
    *output = 0;

    if (flags & O_RDONLY)
        strcat(output, "O_RDONLY ");
    if (flags & O_WRONLY)
        strcat(output, "O_WRONLY ");
    if (flags & O_RDWR)
        strcat(output, "O_RDWR ");
    if (flags & O_CREAT)
        strcat(output, "O_CREAT ");
    if (flags & O_EXCL)
        strcat(output, "O_EXCL ");
    if (flags & O_NOCTTY)
        strcat(output, "O_NOCTTY ");
    if (flags & O_TRUNC)
        strcat(output, "O_TRUNC ");
    if (flags & O_APPEND)
        strcat(output, "O_APPEND ");
    if (flags & O_NONBLOCK)
        strcat(output, "O_NONBLOCK ");
    if (flags & O_SYNC)
        strcat(output, "O_SYNC ");
    if (flags & O_ASYNC)
        strcat(output, "O_ASYNC ");

    return output;
}

char *fd_info(int fd)
{
    if (fd < 0 || fd >= FD_SETSIZE)
        return FALSE;
    // if (fcntl(fd, F_GETFL) == -1 && errno == EBADF)
    int rv = fcntl(fd, F_GETFL);
    return (rv == -1) ? strerror(errno) : fcntl_flags(rv);
}

FD_SETSIZE通常为1024，每个进程的最大文件数通常为1024.如果您想确定，可以使用对此函数的调用替换它，如TomH所述。

#include <sys/time.h>
#include <sys/resource.h>

rlim_t get_rlimit_files()
{
    struct rlimit rlim;
    getrlimit(RLIMIT_NOFILE, &rlim);
    return rlim.rlim_cur;
}

如果你将所有这些放在一个文件中（我做了，只是为了检查它），你可以产生类似于此的输出，以确认它的工作方式与宣传的一样：

0:     0                  O_RDWR  dup() ok
1:     0                O_WRONLY  dup() ok
2:     0                  O_RDWR  dup() ok
3:     0              O_NONBLOCK  dup() ok
4:     0     O_WRONLY O_NONBLOCK  dup() ok
5:    -1      Bad file descriptor Bad file descriptor
6:    -1      Bad file descriptor Bad file descriptor
7:    -1      Bad file descriptor Bad file descriptor
8:    -1      Bad file descriptor Bad file descriptor
9:    -1      Bad file descriptor Bad file descriptor

我希望能回答你的任何问题，如果你想知道，我实际来到这里寻找OP提出的问题的答案，并在阅读答案后，记得我多年前已经编写了代码。享受。

Answer 2

由于您使用的是Linux，因此您（几乎可以肯定）安装了/proc个文件系统。这意味着最简单的方法是获取/proc/self/fd的内容列表;其中的每个文件都以FD命名。（当然，使用g_dir_open，g_dir_read_name和g_dir_close进行列表。）

获取信息非常尴尬（例如，没有有用的POSIX API;这是一个未标准化的区域。）

Answer 3

如果您可以通过pid识别流程，只需执行

即可

ls -l /proc/<pid>/fd | wc - l

在C语言中，您可以管道所有内容并重复使用输出，或者您可以在上述目录中自行计算文件（计数方法，例如此处Counting the number of files in a directory using C）

Answer 4

有时C ++是一个选项，Donal的解决方案使用boost :: filesystem：

#include <iostream>
#include <string>
#include <boost/filesystem.hpp>
#include <unistd.h>

namespace fs = boost::filesystem;

int main()
{
    std::string path = "/proc/" + std::to_string(::getpid()) + "/fd/";
    unsigned count = std::distance(fs::directory_iterator(path),
                                   fs::directory_iterator());
    std::cout << "Number of opened FDs: " << count << std::endl;
}

Answer 5

如果你的意思是如何从进程内以编程方式进行，那么正常（如果有点可怕）方法就是循环所有可能的描述符（使用getrlimit()来读取RLIMIT_NOFILE到找到范围）在每个上面调用类似fcntl(fd, F_GETFD, 0)的内容并检查EBADF响应以查看哪些没有打开。

如果您想要从shell中找到进程已打开的文件，那么lsof -p <pid>就是您想要的。

Answer 6

fstat命令列出了系统的所有正在运行的进程及其开放描述符，此外它还列出了它的描述符类型（文件，套接字，管道等），并尝试给出描述符正在读取或写入的内容的提示。作为什么文件系统和该文件系统上的inode编号

查找进程linux（C代码）的打开文件描述符？

6 个答案: