1 files changed, 50 insertions, 32 deletions

diff --git a/kernel/fork.c b/kernel/fork.c
index b25802065031..ecc694debb50 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -568,21 +568,47 @@ static inline int copy_fs(unsigned long clone_flags, struct task_struct * tsk)
 static int count_open_files(struct files_struct *files, int size)
 {
         int i;
+        struct fdtable *fdt;
 
         /* Find the last open fd */
+        fdt = files_fdtable(files);
         for (i = size/(8*sizeof(long)); i > 0; ) {
-                if (files->open_fds->fds_bits[--i])
+                if (fdt->open_fds->fds_bits[--i])
                         break;
         }
         i = (i+1) * 8 * sizeof(long);
         return i;
 }
 
+static struct files_struct *alloc_files(void)
+{
+        struct files_struct *newf;
+        struct fdtable *fdt;
+
+        newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
+        if (!newf)
+                goto out;
+
+        atomic_set(&newf->count, 1);
+
+        spin_lock_init(&newf->file_lock);
+        fdt = files_fdtable(newf);
+        fdt->next_fd = 0;
+        fdt->max_fds = NR_OPEN_DEFAULT;
+        fdt->max_fdset = __FD_SETSIZE;
+        fdt->close_on_exec = &newf->close_on_exec_init;
+        fdt->open_fds = &newf->open_fds_init;
+        fdt->fd = &newf->fd_array[0];
+out:
+        return newf;
+}
+
 static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
 {
         struct files_struct *oldf, *newf;
         struct file **old_fds, **new_fds;
         int open_files, size, i, error = 0, expand;
+        struct fdtable *old_fdt, *new_fdt;
 
         /*
          * A background process may not have any files ...
@@ -603,35 +629,27 @@ static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
          */
         tsk->files = NULL;
         error = -ENOMEM;
-        newf = kmem_cache_alloc(files_cachep, SLAB_KERNEL);
-        if (!newf) 
+        newf = alloc_files();
+        if (!newf)
                 goto out;
 
-        atomic_set(&newf->count, 1);
-
-        spin_lock_init(&newf->file_lock);
-        newf->next_fd       = 0;
-        newf->max_fds       = NR_OPEN_DEFAULT;
-        newf->max_fdset     = __FD_SETSIZE;
-        newf->close_on_exec = &newf->close_on_exec_init;
-        newf->open_fds      = &newf->open_fds_init;
-        newf->fd            = &newf->fd_array[0];
-
         spin_lock(&oldf->file_lock);
-
-        open_files = count_open_files(oldf, oldf->max_fdset);
+        old_fdt = files_fdtable(oldf);
+        new_fdt = files_fdtable(newf);
+        size = old_fdt->max_fdset;
+        open_files = count_open_files(oldf, old_fdt->max_fdset);
         expand = 0;
 
         /*
          * Check whether we need to allocate a larger fd array or fd set.
          * Note: we're not a clone task, so the open count won't  change.
          */
-        if (open_files > newf->max_fdset) {
-                newf->max_fdset = 0;
+        if (open_files > new_fdt->max_fdset) {
+                new_fdt->max_fdset = 0;
                 expand = 1;
         }
-        if (open_files > newf->max_fds) {
-                newf->max_fds = 0;
+        if (open_files > new_fdt->max_fds) {
+                new_fdt->max_fds = 0;
                 expand = 1;
         }
 
@@ -646,11 +664,11 @@ static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
                 spin_lock(&oldf->file_lock);
         }
 
-        old_fds = oldf->fd;
-        new_fds = newf->fd;
+        old_fds = old_fdt->fd;
+        new_fds = new_fdt->fd;
 
-        memcpy(newf->open_fds->fds_bits, oldf->open_fds->fds_bits, open_files/8);
-        memcpy(newf->close_on_exec->fds_bits, oldf->close_on_exec->fds_bits, open_files/8);
+        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);
 
         for (i = open_files; i != 0; i--) {
                 struct file *f = *old_fds++;
@@ -663,24 +681,24 @@ static int copy_files(unsigned long clone_flags, struct task_struct * tsk)
                          * is partway through open().  So make sure that this
                          * fd is available to the new process.
                          */
-                        FD_CLR(open_files - i, newf->open_fds);
+                        FD_CLR(open_files - i, new_fdt->open_fds);
                 }
                 *new_fds++ = f;
         }
         spin_unlock(&oldf->file_lock);
 
         /* compute the remainder to be cleared */
-        size = (newf->max_fds - open_files) * sizeof(struct file *);
+        size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
 
         /* This is long word aligned thus could use a optimized version */ 
         memset(new_fds, 0, size); 
 
-        if (newf->max_fdset > open_files) {
-                int left = (newf->max_fdset-open_files)/8;
+        if (new_fdt->max_fdset > open_files) {
+                int left = (new_fdt->max_fdset-open_files)/8;
                 int start = open_files / (8 * sizeof(unsigned long));
 
-                memset(&newf->open_fds->fds_bits[start], 0, left);
-                memset(&newf->close_on_exec->fds_bits[start], 0, left);
+                memset(&new_fdt->open_fds->fds_bits[start], 0, left);
+                memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
         }
 
         tsk->files = newf;
@@ -689,9 +707,9 @@ out:
         return error;
 
 out_release:
-        free_fdset (newf->close_on_exec, newf->max_fdset);
-        free_fdset (newf->open_fds, newf->max_fdset);
-        free_fd_array(newf->fd, newf->max_fds);
+        free_fdset (new_fdt->close_on_exec, new_fdt->max_fdset);
+        free_fdset (new_fdt->open_fds, new_fdt->max_fdset);
+        free_fd_array(new_fdt->fd, new_fdt->max_fds);
         kmem_cache_free(files_cachep, newf);
         goto out;
 }