File descriptors in the Linux kernel (VI) -- allocation of fd -- expand

Collect

Kernel version：2.6.14

CPU architecture：ARM920T

Author：ce123(http://blog.csdn.net/ce123)

Let's first post the source code of the expand_files function:

[plain] view plain copy

print?

int expand_files(struct files_struct *files, int nr)
{
int err, expand = 0;
struct fdtable *fdt;
fdt = files_fdtable(files);
if (nr >= fdt->max_fdset || nr >= fdt->max_fds) { // We have analyzed in the previous article that initially max_fdset = 1024, max_fds = 32
if (fdt->max_fdset >= NR_OPEN || //#define NR_OPEN (1024*1024) /* Absolute upper limit on fd num */
fdt->max_fds >= NR_OPEN || nr >= NR_OPEN) {
err = -EMFILE; //neither max_fdset nor max_fds can be greater than NR_OPEN, otherwise -EMFILE is returned, indicating that too many files are opened
goto out;
}
expand = 1;
if ((err = expand_fdtable(files, nr)))//actually expand
goto out;
}
err = expand;
out:
return err;
}

The expand_files function performs some checks and then calls expand_fdtable to expand the file descriptor table. The expand_fdtable function is analyzed below.

[plain] view plain copy

print?

static int expand_fdtable(struct files_struct *files, int nr)
__releases(files->file_lock)
__acquires(files->file_lock)
{
int error = 0;
struct fdtable *fdt;
struct fdtable *nfdt = NULL;
spin_unlock(&files->file_lock);
nfdt = alloc_fdtable(nr); //Recreate a new fdtable based on nr
if (!nfdt) {
error = -ENOMEM;
spin_lock(&files->file_lock);
goto out;
}
spin_lock(&files->file_lock);
fdt = files_fdtable(files);
/*
* Check again since another task may have expanded the
* fd table while we dropped the lock
*/
if (nr >= fdt->max_fds || nr >= fdt->max_fdset) { //nr value must be greater than max_fds and max_fdset values. Checking again here is to prevent another process from expanding
copy_fdtable(nfdt, fdt); //Copy the contents of the old fdtable to the new fdtable
} else {
/* Somebody expanded while we dropped file_lock */
spin_unlock(&files->file_lock);
__free_fdtable(nfdt);
spin_lock(&files->file_lock);
goto out;
}
rcu_assign_pointer(files->fdt, nfdt); //Replace the old fdtable with the new one
free_fdtable(fdt); //Release the old fdtable
out:
return error;
}

Let's take a look at the key function alloc_fdtable of the extended file descriptor table, which is defined as follows:

[plain] view plain copy

print?

static struct fdtable *alloc_fdtable(int nr)
{
struct fdtable *fdt = NULL;
int nfds = 0;
fd_set *new_openset = NULL, *new_execset = NULL;
struct file **new_fds;
fdt = kmalloc(sizeof(*fdt), GFP_KERNEL);
if (!fdt)
goto out;
memset(fdt, 0, sizeof(*fdt));
nfds = __FD_SETSIZE; //#define __FD_SETSIZE 1024
　　　　 // #define PAGE_SHIFT 12
　　　　 // #define PAGE_SIZE (1UL << PAGE_SHIFT)
/* Expand to the max in easy steps */
do {
if (nfds < (PAGE_SIZE * 8))//dfds = 1024
nfds = PAGE_SIZE * 8;
else {
nfds = nfds * 2;
if (nfds > NR_OPEN)
nfds = NR_OPEN;
}
} while (nfds <= nr); //When expanding for the first time, nr should be equal to 32
new_openset = alloc_fdset(nfds); // allocate open file bitmap
new_execset = alloc_fdset(nfds);
if (!new_openset || !new_execset)
goto out;
fdt->open_fds = new_openset;
fdt->close_on_exec = new_execset;
fdt->max_fdset = nfds; //Update max_fdset value, now the value is 32k
nfds = NR_OPEN_DEFAULT;//nfds = 32
/*
* Expand to the max in easy steps, and keep expanding it until
* we have enough for the requested fd array size.
*/
do {
#if NR_OPEN_DEFAULT < 256
if (nfds < 256)
nfds = 256;//nfds = 256（32->256->1024）
//Cannot exceed 1024, because it is checked at the very beginning and must be less than current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
else
#endif
if (nfds < (PAGE_SIZE / sizeof(struct file *)))
nfds = PAGE_SIZE / sizeof(struct file *);
else {
nfds = nfds * 2;
if (nfds > NR_OPEN)
nfds = NR_OPEN;
}
} while (nfds <= nr);
new_fds = alloc_fd_array(nfds); // allocate file descriptor array
if (!new_fds)
goto out;
fdt->fd = new_fds;
fdt->max_fds = nfds; //Update max_fds
fdt->free_files = NULL;
return fdt;
out:
if (new_openset)
free_fdset(new_openset, nfds);
if (new_execset)
free_fdset(new_execset, nfds);
kfree(fdt);
return NULL;
}

alloc_fd_array and alloc_fdset use kmalloc or vmalloc for memory allocation.

Reference address：File descriptors in the Linux kernel (VI) -- allocation of fd -- expand_files

Previous article：Likely and Unlikely in the Linux Kernel
Next article：File descriptors in the Linux kernel (V) -- allocation of fd -- locate_fd

Popular Resources
Popular amplifiers