Getting the highest allocated file descriptor

by

While portable, closing all file descriptors up to sysconf(_SC_OPEN_MAX) is not reliable, because on most systems this call returns the current file descriptor soft limit, which could have been lowered below the highest used file descriptor. Another issue is that on many systems sysconf(_SC_OPEN_MAX) may return INT_MAX, which can cause this approach to be unacceptably slow. Unfortunately, there is no reliable, portable alternative that does not involve iterating over every possible non-negative int file descriptor.

Although not portable, most operating systems in common use today provide one or more of the following solutions to this problem:

  1. A library function to close all open file descriptors >= fd or within a range. This is the simplest solution for the common case of closing all file descriptors, although it cannot be used for much else. To close all file descriptors except for a certain set, dup2 can be used to move them to the low end beforehand, and to move them back afterward if necessary.

    • closefrom(fd) (Linux with glibc 2.34+, Solaris 9+, FreeBSD 7.3+, NetBSD 3.0+, OpenBSD 3.5+)

    • fcntl(fd, F_CLOSEM, 0) (AIX, IRIX, NetBSD)

    • close_range(lowfd, highfd, 0) (Linux kernel 5.9+ with glibc 2.34+, FreeBSD 12.2+)

  2. A library function to provide the maximum file descriptor currently in use by the process. To close all file descriptors above a certain number, either close all of them up to this maximum, or continually get and close the highest file descriptor in a loop until the low bound is reached. Which is more efficient depends on the file descriptor density.

    • fcntl(0, F_MAXFD) (NetBSD)

    • pstat_getproc(&ps, sizeof(struct pst_status), (size_t)0, (int)getpid())
      Returns information about the process, including the highest file descriptor currently open in ps.pst_highestfd. (HP-UX)

  3. A library function to list all file descriptors currently in use by the process. This is more flexible in that it allows for closing all file descriptors, finding the highest file descriptor, or doing just about anything else on every open file descriptor, possibly even those of another process. Example (OpenSSH)

    • proc_pidinfo(getpid(), PROC_PIDLISTFDS, 0, fdinfo_buf, sz) (macOS)

  4. The number of file descriptor slots currently allocated for a process provides an upper bound on the file descriptor numbers currently in use. Example (Ruby)

    • “FDSize:” line in /proc/pid/status or /proc/self/status (Linux)

  5. A directory containing an entry for each open file descriptor. This is similar to #3 except that it isn’t a library function. This can be more complicated than the other approaches for the common uses, and can fail for a variety of reasons such as proc/fdescfs not mounted, a chroot environment, or no file descriptors available to open the directory (process or system limit). Therefore use of this approach is often combined with a fallback mechanism. Example (OpenSSH), another example (glib).

    • /proc/pid/fd/ or /proc/self/fd/ (Linux, Solaris, AIX, Cygwin, NetBSD)
      (AIX does not support “self“)

    • /dev/fd/ (FreeBSD, macOS)

It can be difficult to handle all corner cases reliably with this approach. For example consider the situation where all file descriptors >= fd are to be closed, but all file descriptors < fd are used, the current process resource limit is fd, and there are file descriptors >= fd in use. Because the process resource limit has been reached the directory cannot be opened. If closing every file descriptor from fd through the resource limit or sysconf(_SC_OPEN_MAX) is used as a fallback, nothing will be closed.

More Related Contents:

  1. How to construct a c++ fstream from a POSIX file descriptor?
  2. Automatically executed functions when loading shared libraries
  3. System V IPC vs POSIX IPC
  4. What can lead to “IOError: [Errno 9] Bad file descriptor” during os.system()?
  5. Why does SIGPIPE exist?
  6. How do I make this Linux program compile? [closed]
  7. Connecting n commands with pipes in a shell?
  8. Atomicity of `write(2)` to a local filesystem
  9. How can I catch a ctrl-c event?
  10. GCC with -std=c99 complains about not knowing struct timespec
  11. Why does the library linker flag sometimes have to go at the end using GCC?
  12. UDP-Broadcast on all interfaces
  13. Retrieving file descriptor from a std::fstream [duplicate]
  14. How are the O_SYNC and O_DIRECT flags in open(2) different/alike?
  15. How to get the current time in milliseconds from C in Linux?
  16. What’s the difference between a file descriptor and a file pointer?
  17. How do I check if a directory exists or not in a Bash shell script?
  18. Is snprintf() ALWAYS null terminating?
  19. What is the status of POSIX asynchronous I/O (AIO)?
  20. Where does Microsoft Windows’ 7 POSIX implementation currently stand?
  21. How to use nanosleep() in C? What are `tim.tv_sec` and `tim.tv_nsec`?
  22. Test for empty string with X”” [duplicate]
  23. What is path //, how is it different from /
  24. How to convert from UTC to local time in C?
  25. Linux shared memory: shmget() vs mmap()?
  26. Differences between System V and Posix semaphores
  27. Setting creation or change timestamps
  28. Reference a GNU C (POSIX) DLL built in GCC against Cygwin, from C#/NET
  29. How to get the username in C/C++ in Linux?
  30. popen equivalent in c++

Leave a Comment