perf top: Add overwrite fall back

[linux-2.6-microblaze.git] / kernel / fork.c

diff --git a/kernel/fork.c b/kernel/fork.c
index 5e6cf0d..be8aa5b 100644 (file)
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -283,8 +283,9 @@ static void free_thread_stack(struct task_struct *tsk)
 
 void thread_stack_cache_init(void)
 {
-       thread_stack_cache = kmem_cache_create("thread_stack", THREAD_SIZE,
-                                             THREAD_SIZE, 0, NULL);
+       thread_stack_cache = kmem_cache_create_usercopy("thread_stack",
+                                       THREAD_SIZE, THREAD_SIZE, 0, 0,
+                                       THREAD_SIZE, NULL);
        BUG_ON(thread_stack_cache == NULL);
 }
 # endif
@@ -605,6 +606,11 @@ static void __mmdrop(struct mm_struct *mm)
 
 void mmdrop(struct mm_struct *mm)
 {
+       /*
+        * The implicit full barrier implied by atomic_dec_and_test() is
+        * required by the membarrier system call before returning to
+        * user-space, after storing to rq->curr.
+        */
        if (unlikely(atomic_dec_and_test(&mm->mm_count)))
                __mmdrop(mm);
 }
@@ -693,6 +699,21 @@ static void set_max_threads(unsigned int max_threads_suggested)
 int arch_task_struct_size __read_mostly;
 #endif
 
+static void task_struct_whitelist(unsigned long *offset, unsigned long *size)
+{
+       /* Fetch thread_struct whitelist for the architecture. */
+       arch_thread_struct_whitelist(offset, size);
+
+       /*
+        * Handle zero-sized whitelist or empty thread_struct, otherwise
+        * adjust offset to position of thread_struct in task_struct.
+        */
+       if (unlikely(*size == 0))
+               *offset = 0;
+       else
+               *offset += offsetof(struct task_struct, thread);
+}
+
 void __init fork_init(void)
 {
        int i;
@@ -701,11 +722,14 @@ void __init fork_init(void)
 #define ARCH_MIN_TASKALIGN     0
 #endif
        int align = max_t(int, L1_CACHE_BYTES, ARCH_MIN_TASKALIGN);
+       unsigned long useroffset, usersize;
 
        /* create a slab on which task_structs can be allocated */
-       task_struct_cachep = kmem_cache_create("task_struct",
+       task_struct_whitelist(&useroffset, &usersize);
+       task_struct_cachep = kmem_cache_create_usercopy("task_struct",
                        arch_task_struct_size, align,
-                       SLAB_PANIC|SLAB_ACCOUNT, NULL);
+                       SLAB_PANIC|SLAB_ACCOUNT,
+                       useroffset, usersize, NULL);
 #endif
 
        /* do the arch specific task caches init */
@@ -1568,6 +1592,10 @@ static __latent_entropy struct task_struct *copy_process(
        int retval;
        struct task_struct *p;
 
+       /*
+        * Don't allow sharing the root directory with processes in a different
+        * namespace
+        */
        if ((clone_flags & (CLONE_NEWNS|CLONE_FS)) == (CLONE_NEWNS|CLONE_FS))
                return ERR_PTR(-EINVAL);
 
@@ -2043,6 +2071,8 @@ long _do_fork(unsigned long clone_flags,
              int __user *child_tidptr,
              unsigned long tls)
 {
+       struct completion vfork;
+       struct pid *pid;
        struct task_struct *p;
        int trace = 0;
        long nr;
@@ -2068,43 +2098,40 @@ long _do_fork(unsigned long clone_flags,
        p = copy_process(clone_flags, stack_start, stack_size,
                         child_tidptr, NULL, trace, tls, NUMA_NO_NODE);
        add_latent_entropy();
+
+       if (IS_ERR(p))
+               return PTR_ERR(p);
+
        /*
         * Do this prior waking up the new thread - the thread pointer
         * might get invalid after that point, if the thread exits quickly.
         */
-       if (!IS_ERR(p)) {
-               struct completion vfork;
-               struct pid *pid;
-
-               trace_sched_process_fork(current, p);
-
-               pid = get_task_pid(p, PIDTYPE_PID);
-               nr = pid_vnr(pid);
+       trace_sched_process_fork(current, p);
 
-               if (clone_flags & CLONE_PARENT_SETTID)
-                       put_user(nr, parent_tidptr);
+       pid = get_task_pid(p, PIDTYPE_PID);
+       nr = pid_vnr(pid);
 
-               if (clone_flags & CLONE_VFORK) {
-                       p->vfork_done = &vfork;
-                       init_completion(&vfork);
-                       get_task_struct(p);
-               }
+       if (clone_flags & CLONE_PARENT_SETTID)
+               put_user(nr, parent_tidptr);
 
-               wake_up_new_task(p);
+       if (clone_flags & CLONE_VFORK) {
+               p->vfork_done = &vfork;
+               init_completion(&vfork);
+               get_task_struct(p);
+       }
 
-               /* forking complete and child started to run, tell ptracer */
-               if (unlikely(trace))
-                       ptrace_event_pid(trace, pid);
+       wake_up_new_task(p);
 
-               if (clone_flags & CLONE_VFORK) {
-                       if (!wait_for_vfork_done(p, &vfork))
-                               ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
-               }
+       /* forking complete and child started to run, tell ptracer */
+       if (unlikely(trace))
+               ptrace_event_pid(trace, pid);
 
-               put_pid(pid);
-       } else {
-               nr = PTR_ERR(p);
+       if (clone_flags & CLONE_VFORK) {
+               if (!wait_for_vfork_done(p, &vfork))
+                       ptrace_event_pid(PTRACE_EVENT_VFORK_DONE, pid);
        }
+
+       put_pid(pid);
        return nr;
 }
 
@@ -2248,9 +2275,11 @@ void __init proc_caches_init(void)
         * maximum number of CPU's we can ever have.  The cpumask_allocation
         * is at the end of the structure, exactly for that reason.
         */
-       mm_cachep = kmem_cache_create("mm_struct",
+       mm_cachep = kmem_cache_create_usercopy("mm_struct",
                        sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN,
                        SLAB_HWCACHE_ALIGN|SLAB_PANIC|SLAB_ACCOUNT,
+                       offsetof(struct mm_struct, saved_auxv),
+                       sizeof_field(struct mm_struct, saved_auxv),
                        NULL);
        vm_area_cachep = KMEM_CACHE(vm_area_struct, SLAB_PANIC|SLAB_ACCOUNT);
        mmap_init();