UBIFS: fix a bug in empty space fix-up
[linux-2.6.git] / fs / file.c
index d8773b1..ba3f605 100644 (file)
--- a/fs/file.c
+++ b/fs/file.c
@@ -6,9 +6,12 @@
  *  Manage the dynamic fd arrays in the process files_struct.
  */
 
+#include <linux/export.h>
 #include <linux/fs.h>
 #include <linux/mm.h>
+#include <linux/mmzone.h>
 #include <linux/time.h>
+#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/file.h>
@@ -37,28 +40,30 @@ int sysctl_nr_open_max = 1024 * 1024; /* raised later */
  */
 static DEFINE_PER_CPU(struct fdtable_defer, fdtable_defer_list);
 
-static inline void * alloc_fdmem(unsigned int size)
+static void *alloc_fdmem(size_t size)
 {
-       if (size <= PAGE_SIZE)
-               return kmalloc(size, GFP_KERNEL);
-       else
-               return vmalloc(size);
+       /*
+        * Very large allocations can stress page reclaim, so fall back to
+        * vmalloc() if the allocation size will be considered "large" by the VM.
+        */
+       if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {
+               void *data = kmalloc(size, GFP_KERNEL|__GFP_NOWARN);
+               if (data != NULL)
+                       return data;
+       }
+       return vmalloc(size);
 }
 
-static inline void free_fdarr(struct fdtable *fdt)
+static void free_fdmem(void *ptr)
 {
-       if (fdt->max_fds <= (PAGE_SIZE / sizeof(struct file *)))
-               kfree(fdt->fd);
-       else
-               vfree(fdt->fd);
+       is_vmalloc_addr(ptr) ? vfree(ptr) : kfree(ptr);
 }
 
-static inline void free_fdset(struct fdtable *fdt)
+static void __free_fdtable(struct fdtable *fdt)
 {
-       if (fdt->max_fds <= (PAGE_SIZE * BITS_PER_BYTE / 2))
-               kfree(fdt->open_fds);
-       else
-               vfree(fdt->open_fds);
+       free_fdmem(fdt->fd);
+       free_fdmem(fdt->open_fds);
+       kfree(fdt);
 }
 
 static void free_fdtable_work(struct work_struct *work)
@@ -73,9 +78,8 @@ static void free_fdtable_work(struct work_struct *work)
        spin_unlock_bh(&f->lock);
        while(fdt) {
                struct fdtable *next = fdt->next;
-               vfree(fdt->fd);
-               free_fdset(fdt);
-               kfree(fdt);
+
+               __free_fdtable(fdt);
                fdt = next;
        }
 }
@@ -96,7 +100,7 @@ void free_fdtable_rcu(struct rcu_head *rcu)
                                container_of(fdt, struct files_struct, fdtab));
                return;
        }
-       if (fdt->max_fds <= (PAGE_SIZE / sizeof(struct file *))) {
+       if (!is_vmalloc_addr(fdt->fd) && !is_vmalloc_addr(fdt->open_fds)) {
                kfree(fdt->fd);
                kfree(fdt->open_fds);
                kfree(fdt);
@@ -138,7 +142,7 @@ static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt)
 static struct fdtable * alloc_fdtable(unsigned int nr)
 {
        struct fdtable *fdt;
-       char *data;
+       void *data;
 
        /*
         * Figure out how many fds we actually want to support in this fdtable.
@@ -168,21 +172,21 @@ static struct fdtable * alloc_fdtable(unsigned int nr)
        data = alloc_fdmem(nr * sizeof(struct file *));
        if (!data)
                goto out_fdt;
-       fdt->fd = (struct file **)data;
-       data = alloc_fdmem(max_t(unsigned int,
+       fdt->fd = data;
+
+       data = alloc_fdmem(max_t(size_t,
                                 2 * nr / BITS_PER_BYTE, L1_CACHE_BYTES));
        if (!data)
                goto out_arr;
-       fdt->open_fds = (fd_set *)data;
+       fdt->open_fds = data;
        data += nr / BITS_PER_BYTE;
-       fdt->close_on_exec = (fd_set *)data;
-       INIT_RCU_HEAD(&fdt->rcu);
+       fdt->close_on_exec = data;
        fdt->next = NULL;
 
        return fdt;
 
 out_arr:
-       free_fdarr(fdt);
+       free_fdmem(fdt->fd);
 out_fdt:
        kfree(fdt);
 out:
@@ -212,9 +216,7 @@ static int expand_fdtable(struct files_struct *files, int nr)
         * caller and alloc_fdtable().  Cheaper to catch it here...
         */
        if (unlikely(new_fdt->max_fds <= nr)) {
-               free_fdarr(new_fdt);
-               free_fdset(new_fdt);
-               kfree(new_fdt);
+               __free_fdtable(new_fdt);
                return -EMFILE;
        }
        /*
@@ -230,9 +232,7 @@ static int expand_fdtable(struct files_struct *files, int nr)
                        free_fdtable(cur_fdt);
        } else {
                /* Somebody else expanded, so undo our attempt */
-               free_fdarr(new_fdt);
-               free_fdset(new_fdt);
-               kfree(new_fdt);
+               __free_fdtable(new_fdt);
        }
        return 1;
 }
@@ -255,7 +255,7 @@ int expand_files(struct files_struct *files, int nr)
         * 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)
+       if (nr >= rlimit(RLIMIT_NOFILE))
                return -EMFILE;
 
        /* Do we need to expand? */
@@ -276,11 +276,11 @@ static int count_open_files(struct fdtable *fdt)
        int i;
 
        /* Find the last open fd */
-       for (i = size/(8*sizeof(long)); i > 0; ) {
-               if (fdt->open_fds->fds_bits[--i])
+       for (i = size / BITS_PER_LONG; i > 0; ) {
+               if (fdt->open_fds[--i])
                        break;
        }
-       i = (i+1) * 8 * sizeof(long);
+       i = (i + 1) * BITS_PER_LONG;
        return i;
 }
 
@@ -307,10 +307,9 @@ struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
        newf->next_fd = 0;
        new_fdt = &newf->fdtab;
        new_fdt->max_fds = NR_OPEN_DEFAULT;
-       new_fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;
-       new_fdt->open_fds = (fd_set *)&newf->open_fds_init;
+       new_fdt->close_on_exec = newf->close_on_exec_init;
+       new_fdt->open_fds = newf->open_fds_init;
        new_fdt->fd = &newf->fd_array[0];
-       INIT_RCU_HEAD(&new_fdt->rcu);
        new_fdt->next = NULL;
 
        spin_lock(&oldf->file_lock);
@@ -323,11 +322,8 @@ struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
        while (unlikely(open_files > new_fdt->max_fds)) {
                spin_unlock(&oldf->file_lock);
 
-               if (new_fdt != &newf->fdtab) {
-                       free_fdarr(new_fdt);
-                       free_fdset(new_fdt);
-                       kfree(new_fdt);
-               }
+               if (new_fdt != &newf->fdtab)
+                       __free_fdtable(new_fdt);
 
                new_fdt = alloc_fdtable(open_files - 1);
                if (!new_fdt) {
@@ -337,9 +333,7 @@ struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
 
                /* beyond sysctl_nr_open; nothing to do */
                if (unlikely(new_fdt->max_fds < open_files)) {
-                       free_fdarr(new_fdt);
-                       free_fdset(new_fdt);
-                       kfree(new_fdt);
+                       __free_fdtable(new_fdt);
                        *errorp = -EMFILE;
                        goto out_release;
                }
@@ -357,10 +351,8 @@ struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
        old_fds = old_fdt->fd;
        new_fds = new_fdt->fd;
 
-       memcpy(new_fdt->open_fds->fds_bits,
-               old_fdt->open_fds->fds_bits, open_files/8);
-       memcpy(new_fdt->close_on_exec->fds_bits,
-               old_fdt->close_on_exec->fds_bits, open_files/8);
+       memcpy(new_fdt->open_fds, old_fdt->open_fds, open_files / 8);
+       memcpy(new_fdt->close_on_exec, old_fdt->close_on_exec, open_files / 8);
 
        for (i = open_files; i != 0; i--) {
                struct file *f = *old_fds++;
@@ -373,7 +365,7 @@ struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
                         * is partway through open().  So make sure that this
                         * fd is available to the new process.
                         */
-                       FD_CLR(open_files - i, new_fdt->open_fds);
+                       __clear_open_fd(open_files - i, new_fdt);
                }
                rcu_assign_pointer(*new_fds++, f);
        }
@@ -386,11 +378,11 @@ struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
        memset(new_fds, 0, size);
 
        if (new_fdt->max_fds > open_files) {
-               int left = (new_fdt->max_fds-open_files)/8;
-               int start = open_files / (8 * sizeof(unsigned long));
+               int left = (new_fdt->max_fds - open_files) / 8;
+               int start = open_files / BITS_PER_LONG;
 
-               memset(&new_fdt->open_fds->fds_bits[start], 0, left);
-               memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
+               memset(&new_fdt->open_fds[start], 0, left);
+               memset(&new_fdt->close_on_exec[start], 0, left);
        }
 
        rcu_assign_pointer(newf->fdt, new_fdt);
@@ -426,9 +418,67 @@ struct files_struct init_files = {
        .fdtab          = {
                .max_fds        = NR_OPEN_DEFAULT,
                .fd             = &init_files.fd_array[0],
-               .close_on_exec  = (fd_set *)&init_files.close_on_exec_init,
-               .open_fds       = (fd_set *)&init_files.open_fds_init,
-               .rcu            = RCU_HEAD_INIT,
+               .close_on_exec  = init_files.close_on_exec_init,
+               .open_fds       = init_files.open_fds_init,
        },
        .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, 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;
+
+       __set_open_fd(fd, fdt);
+       if (flags & O_CLOEXEC)
+               __set_close_on_exec(fd, fdt);
+       else
+               __clear_close_on_exec(fd, fdt);
+       error = fd;
+#if 1
+       /* Sanity check */
+       if (rcu_dereference_raw(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);