Checking file descriptors linux

What are File Descriptors in Linux

In this article, you will learn everything about file descriptors, like their uses in Linux, what a file descriptor table is, how to view the file descriptors under a specific process, and how to change the limit of a file descriptor in Linux.

What are File Descriptors in Linux?

A file descriptor is a positive integer that acts as a unique identifier (or handle) for “files” and other I/O resources, such as pipes, sockets, blocks, devices, or terminal I/O.

All the file descriptor records are kept in a file descriptor table in the kernel. When a file is opened, a new file descriptor (or integer value) is given to that file in the file descriptor table.

For example, if you open a “example_file1.txt” file (which is nothing but a process), it will be allocated with the available file descriptor (for example, 101), and a new entry will be created in the file descriptor table.

And when you open another file like “example_file2.txt“, it will be allocated to another available file descriptor like 102, and another entry will be created in the file descriptor table.

File Descriptor	Process
101	example_file1.txt
102	example_file2.txt

The file descriptor for the referenced file will be available for use by another process once you close the file.

Short Recap : A file descriptor is a unique, non-negative number that is given to each process or other I/O resource (when they make a successful request) in the kernel’s file descriptor table. Once the file is closed, the file descriptor can be given to another process.

So, when you open hundreds of files or other I/O resources in your Linux system, there will be 100 entries in the file descriptor table, and each entry will reference a unique file descriptor (or integer value like 100, 102, 103…) to identify the file.

What is the File Descriptor Table in Linux?

When a process or I/O device makes a successful request, the kernel returns a file descriptor to that process and keeps the list of current and all running process file descriptors in the file descriptor table, which is somewhere in the kernel.

Now, your process might depend on other system resources like input and output; as this event is also a process, it also has a file descriptor, which will be attached to your process in the file descriptor table.

Each file descriptor in the file descriptor table points to an entry in the kernel’s global file table. The file table entry maintains the record of file (or other I/O resource) modes like (r)ead, (w)rite, and (e)xecute.

Also, the file table entry points to a third table known as the inode table that points to actual file information like size, modification date, pointer, etc.

Predefined File Descriptors

By default, three types of standard POSIX file descriptors exist in the file descriptor table, and you might already be familiar with them as data streams in Linux:

File Descriptor	Name	Abbreviation
0	Standard Input	stdin
1	Standard Output	stdout
2	Standard Error	stderr

Apart from them, every other process has its own set of file descriptors, but few of them (except for some daemons) also utilize the above mentioned file descriptors to handle input, output, and errors for the process.

To make sure that the process is using the above file descriptor, just look for the above file descriptor (in integer format) under “/proc/PID/fd/“, where PID stands for “process identifier.”

For example, I’ve started the GEDIT editor on my system, which uses all of the file descriptors mentioned above, as shown.

List all of a Running Process’s File Descriptors

As you just learned, each running process in Linux has its own set of file descriptors, but it also uses others to identify the specific file when communicating with kernel space via system calls or library calls.

Find the Process ID (or PID)

First, find out your process identifier (or PID) using the ps command before viewing the file descriptors under it.

$ ps aux | grep gedit

Replace “gedit” with your running process name, or you can place “$$” to pass the current bash session.

Now, you have two ways to list the file descriptors under a specific process, followed by:

Using the ls command

List all of the file descriptors and the files they refer to under a certain PID by listing the content of the “/proc/PID/fd/” path, where PID is the process ID using the ls command.

$ ls -la /proc/11472/fd/

Using the lsof command

The lsof command is used to list the information of running processes in the system and can also be used to list the file descriptor under a specific PID.

For that, use the “ -d ” flag to specify a range of file descriptors, with the “ -p ” option specifying the PID. To combine this selection, use the “ -a ” flag.

$ lsof -a -d 0-2147483647 -p 11472

What is the Purpose of File Descriptors in the First Place?

The file descriptor, along with the file table, keep track of each running process’s permissions in your system and maintain data integrity.

A running process can inherit the functionality of another process by inheriting its file descriptor, as you just learned in this article.

What Happens If You Run Out of File Descriptors?

This is crucial because a file descriptor is an integer value that the kernel returns to the process (or other I/O resource) after a successful attempt to open a file.

There is a limit to the number of file descriptors (or integer values) that can be given to a process. When that limit is reached, data can be lost.

In Linux, generally, there are two types of file descriptors: process-level file descriptors and system-level file descriptors.

Process-Level File Descriptor Limits

Check the current process-level file descriptor limit using the ulimit command.

Reset the limit by adding a custom positive number after the command.

$ ulimit -n 3276800

soft nofile 2048 hard nofile 8192

System-Level File Descriptor Limits

Check the limit of the system-level descriptor using the cat command.

$ cat /proc/sys/fs/file-max

Modify the file with the new value by using the “>” redirection symbol.

$ echo 90000 > /proc/sys/fs/file-max

After modifying the above file, modify the value in the “nr_open” file.

$ echo "50000" > /proc/sys/fs/nr_open

Final Tips!

I hope this article makes it clear for you to understand the workings of file descriptors in Linux computing.

If you have any questions or queries related to this topic, then feel free to ask them in the comment section.

Источник

How to list the open file descriptors (and the files they refer to) in my current bash session

I am running in an interactive bash session. I have created some file descriptors, using exec, and I would like to list what is the current status of my bash session. Is there a way to list the currently open file descriptors?

bash is not part of the kernel, so it can not know what other processes are doing, even those that it started.

@JuliePelletier: but child processes do not change the file descriptors of the parent process, do they?

5 Answers 5

Yes, this will list all open file descriptors:

$ ls -l /proc/$$/fd total 0 lrwx------ 1 isaac isaac 64 Dec 28 00:56 0 -> /dev/pts/6 lrwx------ 1 isaac isaac 64 Dec 28 00:56 1 -> /dev/pts/6 lrwx------ 1 isaac isaac 64 Dec 28 00:56 2 -> /dev/pts/6 lrwx------ 1 isaac isaac 64 Dec 28 00:56 255 -> /dev/pts/6 l-wx------ 1 isaac isaac 64 Dec 28 00:56 4 -> /home/isaac/testfile.txt 

Of course, as usual: 0 is stdin, 1 is stdout and 2 is stderr.
The 4th is an open file (to write) in this case.

@JZ. $$ will give the process ID of the currently running shell. Try echo $$ and ps and compare their outputs. Similar question here.

Assuming you want to list the file descriptors that are attached to any terminal, you can use lsof / fuser or similar like:

$ lsof -p $$ 2>/dev/null | awk '$NF ~ /\/pts\//' bash 32406 foobar 0u CHR 136,31 0t0 34 /dev/pts/31 bash 32406 foobar 1u CHR 136,31 0t0 34 /dev/pts/31 bash 32406 foobar 2u CHR 136,31 0t0 34 /dev/pts/31 bash 32406 foobar 3u CHR 136,31 0t0 34 /dev/pts/31 bash 32406 foobar 255u CHR 136,31 0t0 34 /dev/pts/31 

These tools basically parse /proc , so you can just access /proc/$$/fd/ too e.g.:

Use the lsof utility to print all file descriptors for the current shell process (process identified by -p $$ ) and ( -a ) where the file descriptor is numeric ( -d 0-256 ):

$ lsof -p $$ -a -d 0-256 COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME bash 16883 ant 0u CHR 136,15 0t0 18 /dev/pts/15 bash 16883 ant 1u CHR 136,15 0t0 18 /dev/pts/15 bash 16883 ant 2u CHR 136,15 0t0 18 /dev/pts/15 bash 16883 ant 255u CHR 136,15 0t0 18 /dev/pts/15 

Pipe into Awk to print only the file descriptor and its corresponding filename:

$ lsof -p $$ -a -d 0-256 | awk '< printf("%4s:\t%s\n", $4, $NF) >' FD: NAME 0u: /dev/pts/15 1u: /dev/pts/15 2u: /dev/pts/15 255u: /dev/pts/15 

Note: when lsof prints the file descriptors, it appends the following code to indicate the file access mode:

Источник

Linux Kernel — Check if a file descriptor is taken

In linux kernel programming, is there a way to check if a particular file descriptor is in use for a given process or if it’s available?

3 Answers 3

struct files_struct * files = task->files; struct fdtable *fdt; spin_lock(&files->file_lock); fdt = files_fdtable(files); if (test_bit(fd, fdt->open_fds->fds_bits)) < /* fd is in use */ >spin_unlock(&files->file_lock); 

However, the information is potentially out of date as soon as you unlock the files struct, so the real question is what you’re going to do with it?

Assuming you are in the kernel and have a process context in struct task_struct* proc and you only want to check that the given fd corresponds to an open file in that process and not actually use the file somehow:

int is_valid_fd_for_process(int fd, struct task_struct* proc) < int exists; rcu_read_lock(); exists = (NULL != fcheck_files(proc->files, fd)); rcu_read_unlock(); return exists; > 

In case you actually want to use the file struct that this fd addresses somehow or store it for later you should aquire a reference for it. See the code for fget which does that for the current process and adapt it for any process.

If you’re really programming in the Linux kernel then you’d look at the files_struct attached to the task_struct of the process you’re interested in.

But what I think you mean is that you’re writing a userspace program to run on Linux, using the kernel API. In which case it’s a little harder.

There isn’t a direct way to do it that I’m aware of. However you should be able to do a little hack with fcntl . Basically you query the status flags for the file descriptor, and if you get an error you know (more or less) that the file descriptor is invalid — and therefore usable.

However it’s racy if you have multiple threads. Another thread could use the file descriptor after you’ve checked it. If you actually want to use that file descriptor maybe you want dup2() or F_DUPFD , but I’m not sure what you’re actually trying to do.

#include #include #include #include int main(void) < int rc, fd; for (fd = 0; fd < 8; fd++) < errno = 0; rc = fcntl(fd, F_GETFL); if (rc >= 0) printf("fd %d is open\n", fd); else if (errno == EBADF) printf("fd %d is closed\n", fd); else printf("error %d querying fd %d \n", errno, fd); > return 0; > 

Источник