Take the 2-minute tour ×

I recently had a Linux process which "leaked" file descriptors: It opened them and didn't properly close some of them.

If I had monitored this, I could tell - in advance - that the process was reaching its limit.

Is there a nice, Bash\Python way to check the FD usage ratio for a given process in a Ubuntu Linux system?


I now know how to check how many open file descriptors are there; I only need to know how many file descriptors are allowed for a process. Some systems (like Amazon EC2) don't have the /proc/pid/limits file.



share|improve this question
What Amazon EC2 Linux OS are you using with no /proc/pid/limits? It is available on RHEL 5. If you want a solution for a different OS then tell us which one. –  mark4o Aug 31 '09 at 14:30
I have an Ubuntu EC2 server, but I'm interested with a more general solution that would apply for a wide variety of Linux Distros. –  Adam Matan Sep 5 '09 at 11:22
add comment

5 Answers

up vote 16 down vote accepted

Count the entries in /proc/<pid>/fd/. The hard and soft limits applying to the process can be found in /proc/<pid>/limits.

share|improve this answer
I think, this method may be more elegant than polling lsof –  Victor Sorokin Aug 31 '09 at 14:15
Yes, but some processes - like web servers - are asking for a larger quota using ulimit, and I want to monitor their FD usage. –  Adam Matan Sep 5 '09 at 11:41
No process will be allowed to raise its quota above the hardlimit, which can be viewed with ulimit -Hn. –  caf Sep 7 '09 at 1:17
add comment

The only interfaces provided by the Linux kernel to get resource limits are getrlimit() and /proc/pid/limits. getrlimit() can only get resource limits of the calling process. /proc/pid/limits allows you to get the resource limits of any process with the same user id, and is available on RHEL 5.2, RHEL 4.7, Ubuntu 9.04, and any distribution with a 2.6.24 or later kernel.

If you need to support older Linux systems then you will have to get the process itself to call getrlimit(). Of course the easiest way to do that is by modifying the program, or a library that it uses. If you are running the program then you could use LD_PRELOAD to load your own code into the program. If none of those are possible then you could attach to the process with gdb and have it execute the call within the process. You could also do the same thing yourself using ptrace() to attach to the process, insert the call in its memory, etc., however this is very complicated to get right and is not recommended.

With appropriate privileges, the other ways to do this would involve looking through kernel memory, loading a kernel module, or otherwise modifying the kernel, but I am assuming that these are out of the question.

share|improve this answer
add comment

You can try to write script which periodically call 'lsof' on given pid.

share|improve this answer
lsof gives a lot of irrelevant entries (like shared libraries in the memory). –  Adam Matan Aug 31 '09 at 13:29
I guess, it doesn't matter whether fds are connected to shared-memory libs or to 'usual' application-specific files -- these fds still use their share. –  Victor Sorokin Aug 31 '09 at 14:14
No, those are not open file descriptors and do not count toward the file descriptor limit. –  mark4o Aug 31 '09 at 14:25
Furthermore, lsof does not state the FD limitations per process. –  Adam Matan Sep 5 '09 at 19:29
add comment

You asked for bash/python methods. ulimit would be the best bash approach (short of munging through /proc/$pid/fd and the like by hand). For python, you could use the resource module.

import resource

print resource.getrlimit(resource.RLIMIT_NOFILE)

$ python test.py

(1024, 1024)

resource.getrlimit corresponds to the getrlimit call in a C program. The results represent the current and maximum values for the requested resource. In the above example, the current (soft) limit is 1024. The values are typical defaults on Linux systems these days.

share|improve this answer
resource.RLIMIT_NOFILE: The maximum number of open file descriptors for the current process, and I would like to get the results of ANOTHER process, not myself. –  Adam Matan Sep 5 '09 at 14:35
add comment

to see the top 20 file handle using processes:

for x in `ps -eF| awk '{ print $2 }'`;do echo `ls /proc/$x/fd 2> /dev/null | wc -l` $x `cat /proc/$x/cmdline 2> /dev/null`;done | sort -n -r | head -n 20

the output is in the format file handle count, pid, cmndline for process

example output

701 1216 /sbin/rsyslogd-n-c5
169 11835 postgres: spaceuser spaceschema [local] idle
164 13621 postgres: spaceuser spaceschema [local] idle
161 13622 postgres: spaceuser spaceschema [local] idle
161 13618 postgres: spaceuser spaceschema [local] idle
share|improve this answer
add comment

Your Answer


