In some cases during a threaded core dump not all 
the threads will have a full register set.  This
will cause problems when the sigkill is sent to
the thread
        
Signed-off-by: Mike Wolf <m...@linux.vnet.ibm.com>
-------

--- ptrace-signal.orig/arch/powerpc/kernel/ptrace.c     2011-02-20 
12:15:57.000000000 -0600
+++ ptrace-signal/arch/powerpc/kernel/ptrace.c  2011-02-21 12:39:17.000000000 
-0600
@@ -234,11 +234,23 @@
        if (target->thread.regs == NULL)
                return -EIO;
 
-       CHECK_FULL_REGS(target->thread.regs);
 
-       ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
-                                 target->thread.regs,
-                                 0, offsetof(struct pt_regs, msr));
+       if (!FULL_REGS(target->thread.regs)) {
+               ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                         target->thread.regs,
+                                         0, sizeof(long)*PT_R14);
+               if (!ret)
+                       ret = user_regset_copyout_poison(&pos, &count, &kbuf, 
&ubuf,
+                                                 sizeof(long)*PT_R14, 
offsetof(struct pt_regs, nip));
+               if (!ret)
+                       ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                                 target->thread.regs,
+                                                 offsetof(struct pt_regs, 
nip), offsetof(struct pt_regs, msr));
+               
+       } else 
+               ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
+                                         target->thread.regs,
+                                         0, offsetof(struct pt_regs, msr));
        if (!ret) {
                unsigned long msr = get_user_msr(target);
                ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf, &msr,
@@ -645,11 +657,24 @@
        if (target->thread.regs == NULL)
                return -EIO;
 
-       CHECK_FULL_REGS(target->thread.regs);
-
        pos /= sizeof(reg);
        count /= sizeof(reg);
 
+       if(!FULL_REGS(target->thread.regs)) {
+               if (kbuf) {
+                       for (; count > 0 && pos < PT_R14; --count)
+                               *k++ = regs[pos++];
+                       for (; count > 0 && pos < PT_R31; --count,pos++)
+                               *k++ = 0xdeadbeef;
+               } else { 
+                       for (; count > 0 && pos < PT_R14; --count)
+                               if (__put_user((compat_ulong_t) regs[pos++], 
u++))
+                                       return -EFAULT;
+                       for (; count > 0 && pos < PT_R31; --count,pos++)
+                               if (__put_user((compat_ulong_t) 0xdeadbeef, 
u++))
+                                       return -EFAULT;
+               }
+       }
        if (kbuf)
                for (; count > 0 && pos < PT_MSR; --count)
                        *k++ = regs[pos++];
--- ptrace-signal.orig/include/linux/regset.h   2011-02-20 12:15:57.000000000 
-0600
+++ ptrace-signal/include/linux/regset.h        2011-02-21 12:39:17.000000000 
-0600
@@ -240,6 +240,32 @@
        }
        return 0;
 }
+static inline int user_regset_copyout_poison(unsigned int *pos,
+                                          unsigned int *count,
+                                          void **kbuf, void __user **ubuf,
+                                          const int start_pos,
+                                          const int end_pos)
+{
+       long poison_data[17] = { [0 ... 16] = 0xdeadbeefdeadbeefUL };
+
+       if (*count == 0)
+               return 0;
+       BUG_ON(*pos < start_pos);
+       if (end_pos < 0 || *pos < end_pos) {
+               unsigned int copy = (end_pos < 0 ? *count
+                                    : min(*count, end_pos - *pos));
+               if (*kbuf) {
+                       memset(*kbuf, 0xdeadbeef, copy);
+                       *kbuf += copy;
+               } else if (__copy_to_user(*ubuf,poison_data, copy))
+                       return -EFAULT;
+               else
+                       *ubuf += copy;
+               *pos += copy;
+               *count -= copy;
+       }
+       return 0;
+}
 
 static inline int user_regset_copyin(unsigned int *pos, unsigned int *count,
                                     const void **kbuf,


_______________________________________________
Linuxppc-dev mailing list
Linuxppc-dev@lists.ozlabs.org
https://lists.ozlabs.org/listinfo/linuxppc-dev

Reply via email to