tunnels: fix netns vs proto registration ordering

[safe/jmp/linux-2.6] / fs / file.c

diff --git a/fs/file.c b/fs/file.c
index 0f705c7..87e1290 100644 (file)
--- a/fs/file.c
+++ b/fs/file.c
@@ -6,9 +6,11 @@
  *  Manage the dynamic fd arrays in the process files_struct.
  */
 
+#include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/time.h>
+#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/file.h>
@@ -26,6 +28,8 @@ struct fdtable_defer {
 };
 
 int sysctl_nr_open __read_mostly = 1024*1024;
+int sysctl_nr_open_min = BITS_PER_LONG;
+int sysctl_nr_open_max = 1024 * 1024; /* raised later */
 
 /*
  * We use this list to defer free fdtables that have vmalloced
@@ -248,9 +252,18 @@ int expand_files(struct files_struct *files, int nr)
        struct fdtable *fdt;
 
        fdt = files_fdtable(files);
+
+       /*
+        * N.B. For clone tasks sharing a files structure, this test
+        * will limit the total number of files that can be opened.
+        */
+       if (nr >= current->signal->rlim[RLIMIT_NOFILE].rlim_cur)
+               return -EMFILE;
+
        /* Do we need to expand? */
        if (nr < fdt->max_fds)
                return 0;
+
        /* Can we expand? */
        if (nr >= sysctl_nr_open)
                return -EMFILE;
@@ -405,6 +418,8 @@ void __init files_defer_init(void)
        int i;
        for_each_possible_cpu(i)
                fdtable_defer_list_init(i);
+       sysctl_nr_open_max = min((size_t)INT_MAX, ~(size_t)0/sizeof(void *)) &
+                            -BITS_PER_LONG;
 }
 
 struct files_struct init_files = {
@@ -419,3 +434,63 @@ struct files_struct init_files = {
        },
        .file_lock      = __SPIN_LOCK_UNLOCKED(init_task.file_lock),
 };
+
+/*
+ * allocate a file descriptor, mark it busy.
+ */
+int alloc_fd(unsigned start, unsigned flags)
+{
+       struct files_struct *files = current->files;
+       unsigned int fd;
+       int error;
+       struct fdtable *fdt;
+
+       spin_lock(&files->file_lock);
+repeat:
+       fdt = files_fdtable(files);
+       fd = start;
+       if (fd < files->next_fd)
+               fd = files->next_fd;
+
+       if (fd < fdt->max_fds)
+               fd = find_next_zero_bit(fdt->open_fds->fds_bits,
+                                          fdt->max_fds, fd);
+
+       error = expand_files(files, fd);
+       if (error < 0)
+               goto out;
+
+       /*
+        * If we needed to expand the fs array we
+        * might have blocked - try again.
+        */
+       if (error)
+               goto repeat;
+
+       if (start <= files->next_fd)
+               files->next_fd = fd + 1;
+
+       FD_SET(fd, fdt->open_fds);
+       if (flags & O_CLOEXEC)
+               FD_SET(fd, fdt->close_on_exec);
+       else
+               FD_CLR(fd, fdt->close_on_exec);
+       error = fd;
+#if 1
+       /* Sanity check */
+       if (rcu_dereference(fdt->fd[fd]) != NULL) {
+               printk(KERN_WARNING "alloc_fd: slot %d not NULL!\n", fd);
+               rcu_assign_pointer(fdt->fd[fd], NULL);
+       }
+#endif
+
+out:
+       spin_unlock(&files->file_lock);
+       return error;
+}
+
+int get_unused_fd(void)
+{
+       return alloc_fd(0, 0);
+}
+EXPORT_SYMBOL(get_unused_fd);