gmane.linux.kernel.api

[PATCH 0/1] posix timers: Expand exitsting info in proc file

Pavel Tikhomirov — 2013-05-16T22:12:02

Hi.

I'm working on the checkpoint-restore project (http://criu.org), on
realisation of posix-timers. To compleatly checkpoint and restore these
timers we need to know which clock they are using. So I d'like to add
this information to existing syscall which shows posix-timers info.

Pavel Tikhomirov (1):
  posix-timers: Show clock ID in proc file

 fs/proc/base.c |    1 +
 1 file changed, 1 insertion(+)

How about allowing ptracing processes in the TASK_UNINTERRUPTIBLE state?

Jann Horn — 2013-03-22T11:47:39

Hello,
I am looking for opinions on an idea: How about allowing ptracing of processes
in the TASK_UNINTERRUPTIBLE state, at least for processes with CAP_SYS_PTRACE?
I think that it would be useful to be able to grab coredumps of processes that
are hanging in the TASK_UNINTERRUPTIBLE state, but for that, I think that it
would be necessary to have some way to inspect the registers of processes that
are hanging there, and the easiest way to allow that that I can see would be to
patch ptrace.

Here's my usecase: I wrote an OpenCL program to run some computations and
estimated the real time it would run for to be around four hours. Now this
program has run for ten hours. I'm relatively sure that it's not hanging, but
I'd really like to inspect its state with gdb to see how much of the result
buffer is filled with results – however, that's not possible because the OpenCL
implementation has caused my process to go into the D state. I'll have to reboot
the PC to abort the computation or to wait for an unknown amount of time until
it finishes (in case it hasn't deadlocked somewhere). Yes, it's my mistake to
send such an amount of work to the GPU without intermediary save steps, but
still, I think that this would be a useful feature for debugging.

The only potential issue I can see with this is that someone might use it for
causing a denial of service by stopping something inside some kind of lock.
Because of this, I'm suggesting to limit this ability to processes with
CAP_SYS_PTRACE. As far as I know, security should not be an issue because
kernel mode and user mode registers are seperate, but I'm not entirely sure
about that – could anyone here tell me whether that's right?

If you don't tell me that it's a very bad idea or hard to implement for some
reason (I have written nearly no kernel code in the past, so I don't know how
hard it will be), I'll try to write a patch.

Jann

Info

Margaret Jones — 2013-03-12T21:19:44

This is a general notification to the public. We are a reputable and  
legitimate loan lender company in United Kingdom,Malaysia and Ghana.We  
give out all kinds of loans, such as personal loans,commercial loans,  
business loans, investment loans, etc. We offer long and short terms  
loan services with an affordable interest rate of 3% only. We offer  
the best loan services on the internet,because our loan services are  
very genuine and efficient.

We have also been awarded by the general loan lending commission as  
the best loan company on the internet. For details about our loan  
services, contact us via email for more informations.email:  
incitipprimfina-mawtdLnHQX0aKw7/G3svNvXRex20P6io< at >public.gmane.org

1. Names in full :
2. Country of Residence/Address :
3. Amount :
4. Duration Of Loan :
5. Age:
6.Phone Number:
7.Applicant Address:
We look forward to your patronage.
Regards
Margaret Jones
Secretary

[PATCH 0/3] posix timers: Extend kernel API to report more info about timers (v3)

Pavel Emelyanov — 2013-03-11T09:11:53

Hi.

Currently kernel doesn't provide any API for getting information about
what timers are currently created by process and in which state they 
are. Also, the way timer IDs are generated makes it impossible to create
a timer with any desired ID. Both facilities are very very tempting by
the checkpoint-restore project.

That said, this series fixes posix timers API in this way:

1. it makes timers IDs generation per-signal_struct to allow for
   recreation of a timer with desired ID;
2. it adds per-task proc file where all timers created by it are
   listed.

This v3 series is ported on v3.9-rc2 and patches' changelogs are fixed
according to Thomas' feedback to contain info why the change is required.

Thanks,
Pavel

Greetings from George Daniels

Germaine Sandoval — 2013-03-10T21:42:36


Greetings from George Daniels

I am George Daniels, a Banker and credit system programmer (HSBC bank). 
I saw your email address while browsing through  the bank D.T.C Screen in my office 
yesterday so I decided to use this very chance to know you. I believe 
we should use every opportunity to know each other better. However, I am contacting you 
for obvious reason which you will understand. 

I am sending this mail just to know if this email address is OK, 
reply me back so that I will send  more details to you. 
I have a very important thing to discuss with you, I look forward to receiving your response at 
georgedaniels-VpKtJLNTnGPuFKmmi/icCA< at >public.gmane.org Have a pleasant day.

George Daniels

[PATCH 1/2] ptrace: add ability to retrieve signals without removing from a queue (v4)

Andrey Vagin — 2013-03-04T10:46:34

This patch adds a new ptrace request PTRACE_PEEKSIGINFO.

This request is used to retrieve information about pending signals
starting with the specified sequence number. Siginfo_t structures are
copied from the child into the buffer starting at "data".

The argument "addr" is a pointer to struct ptrace_peeksiginfo_args.
struct ptrace_peeksiginfo_args {
u64 off;/* from which siginfo to start */
u32 flags;
s32 nr;/* how may siginfos to take */
};

"nr" has type "s32", because ptrace() returns "long", which has 32 bits
on i386 and a negative values is used for errors.

Currently here is only one flag PTRACE_PEEKSIGINFO_SHARED for dumping
signals from process-wide queue. If this flag is not set, signals are
read from a per-thread queue.

The request PTRACE_PEEKSIGINFO returns a number of dumped signals.  If a
signal with the specified sequence number doesn't exist, ptrace returns
zero.  The request returns an error, if no signal has been dumped.

Errors:
EINVAL - one or more specified flags are not supported or nr is negative
EFAULT - buf or addr is outside your accessible address space.

A result siginfo contains a kernel part of si_code which usually
striped, but it's required for queuing the same siginfo back during
restore of pending signals.

This functionality is required for checkpointing pending signals.
Pedro Alves suggested using it in "gdb" to peek at pending signals.
gdb already uses PTRACE_GETSIGINFO to get the siginfo for the signal
which was already dequeued. This functionality allows gdb to look at
the pending signals which were not reported yet.

The prototype of this code was developed by Oleg Nesterov.

v2: * don't wrapped on CONFIG_CHECKPOINT_RESTORE. This functionality is
      going to be used in gdb.
    * use ptrace_peeksiginfo_args, because addr is too small for
      encoding a signal number and flags.
v3: incorporate comments received from Andrew Morton
v4: make code a bit more obvious

Cc: Roland McGrath <roland-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Oleg Nesterov <oleg-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Andrew Morton <akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: "Paul E. McKenney" <paulmck-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
Cc: David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Dave Jones <davej-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: "Michael Kerrisk (man-pages)" <mtk.manpages-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>
Cc: Pavel Emelyanov <xemul-bzQdu9zFT3WakBO8gow8eQ< at >public.gmane.org>
Cc: Linus Torvalds <torvalds-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: Pedro Alves <palves-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Signed-off-by: Andrey Vagin <avagin-GEFAQzZX7r8dnm+yROfE0A< at >public.gmane.org>
Signed-off-by: Andrew Vagin <avagin-GEFAQzZX7r8dnm+yROfE0A< at >public.gmane.org>
---
 include/uapi/linux/ptrace.h | 12 +++++++
 kernel/ptrace.c             | 80 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 92 insertions(+)

diff --git a/include/uapi/linux/ptrace.h b/include/uapi/linux/ptrace.h
index 022ab18..52ebcc8 100644
--- a/include/uapi/linux/ptrace.h
+++ b/include/uapi/linux/ptrace.h
< at >< at > -5,6 +5,7 < at >< at >
 
 /* has the defines to get at the registers. */
 
+#include <linux/types.h>
 
 #define PTRACE_TRACEME   0
 #define PTRACE_PEEKTEXT   1
< at >< at > -52,6 +53,17 < at >< at >
 #define PTRACE_INTERRUPT0x4207
 #define PTRACE_LISTEN0x4208
 
+#define PTRACE_PEEKSIGINFO0x4209
+
+struct ptrace_peeksiginfo_args {
+__u64 off;/* from which siginfo to start */
+__u32 flags;
+__s32 nr;/* how may siginfos to take */
+};
+
+/* Read signals from a shared (process wide) queue */
+#define PTRACE_PEEKSIGINFO_SHARED(1 << 0)
+
 /* Wait extended result codes for the above trace options.  */
 #define PTRACE_EVENT_FORK1
 #define PTRACE_EVENT_VFORK2
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index acbd284..17ae54d 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
< at >< at > -24,6 +24,7 < at >< at >
 #include <linux/regset.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/cn_proc.h>
+#include <linux/compat.h>
 
 
 static int ptrace_trapping_sleep_fn(void *flags)
< at >< at > -618,6 +619,81 < at >< at > static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
 return error;
 }
 
+static int ptrace_peek_siginfo(struct task_struct *child,
+unsigned long addr,
+unsigned long data)
+{
+struct ptrace_peeksiginfo_args arg;
+struct sigpending *pending;
+struct sigqueue *q;
+int ret, i;
+
+ret = copy_from_user(&arg, (void __user *) addr,
+sizeof(struct ptrace_peeksiginfo_args));
+if (ret)
+return -EFAULT;
+
+if (arg.flags & ~PTRACE_PEEKSIGINFO_SHARED)
+return -EINVAL; /* unknown flags */
+
+if (arg.nr < 0)
+return -EINVAL;
+
+if (arg.flags & PTRACE_PEEKSIGINFO_SHARED)
+pending = &child->signal->shared_pending;
+else
+pending = &child->pending;
+
+for (i = 0; i < arg.nr; ) {
+siginfo_t info;
+s32 off = arg.off + i;
+
+spin_lock_irq(&child->sighand->siglock);
+list_for_each_entry(q, &pending->list, list) {
+if (!off--) {
+copy_siginfo(&info, &q->info);
+break;
+}
+}
+spin_unlock_irq(&child->sighand->siglock);
+
+if (off >= 0) /* beyond the end of the list */
+break;
+
+#ifdef CONFIG_COMPAT
+if (unlikely(is_compat_task())) {
+compat_siginfo_t __user *uinfo = compat_ptr(data);
+
+ret = copy_siginfo_to_user32(uinfo, &info);
+ret |= __put_user(info.si_code, &uinfo->si_code);
+} else
+#endif
+{
+siginfo_t __user *uinfo = (siginfo_t __user *) data;
+
+ret = copy_siginfo_to_user(uinfo, &info);
+ret |= __put_user(info.si_code, &uinfo->si_code);
+}
+
+if (ret) {
+ret = -EFAULT;
+break;
+}
+
+data += sizeof(siginfo_t);
+i++;
+
+if (signal_pending(current))
+break;
+
+cond_resched();
+}
+
+if (i > 0)
+return i;
+
+return ret;
+}
 
 #ifdef PTRACE_SINGLESTEP
 #define is_singlestep(request)((request) == PTRACE_SINGLESTEP)
< at >< at > -748,6 +824,10 < at >< at > int ptrace_request(struct task_struct *child, long request,
 ret = put_user(child->ptrace_message, datalp);
 break;
 
+case PTRACE_PEEKSIGINFO:
+ret = ptrace_peek_siginfo(child, addr, data);
+break;
+
 case PTRACE_GETSIGINFO:
 ret = ptrace_getsiginfo(child, &siginfo);
 if (!ret)

Private message

JMW SOLICITORS LLP — 2013-03-03T20:12:22

I am the Family lawyer of late James Campbell, My late client bequeathed his inheritance to you, i request your urgent response to this Issue.
Barr Colin Lee

[PATCH 1/2] ptrace: add ability to retrieve signals without removing from a queue (v3)

Andrey Vagin — 2013-02-27T14:37:08

This patch adds a new ptrace request PTRACE_PEEKSIGINFO.

This request is used to retrieve information about pending signals
starting with the specified sequence number. Siginfo_t structures are
copied from the child into the buffer starting at "data".

The argument "addr" is a pointer to struct ptrace_peeksiginfo_args.
struct ptrace_peeksiginfo_args {
u64 off;/* from which siginfo to start */
u32 flags;
s32 nr;/* how may siginfos to take */
};

"nr" has type "s32", because ptrace() returns "long", which has 32 bits
on i386 and a negative values is used for errors.

Currently here is only one flag PTRACE_PEEKSIGINFO_SHARED for dumping
signals from process-wide queue. If this flag is not set, signals are
read from a per-thread queue.

The request PTRACE_PEEKSIGINFO returns a number of dumped signals.  If a
signal with the specified sequence number doesn't exist, ptrace returns
zero.  The request returns an error, if no signal has been dumped.

Errors:
EINVAL - one or more specified flags are not supported or nr is negative
EFAULT - buf or addr is outside your accessible address space.

A result siginfo contains a kernel part of si_code which usually
striped, but it's required for queuing the same siginfo back during
restore of pending signals.

This functionality is required for checkpointing pending signals.
Pedro Alves suggested using it in "gdb" to peek at pending signals.
gdb already uses PTRACE_GETSIGINFO to get the siginfo for the signal
which was already dequeued. This functionality allows gdb to look at
the pending signals which were not reported yet.

The prototype of this code was developed by Oleg Nesterov.

v2: * don't wrapped on CONFIG_CHECKPOINT_RESTORE. This functionality is
      going to be used in gdb.
    * use ptrace_peeksiginfo_args, because addr is too small for
      encoding a signal number and flags.
v3: incorporate comments received from Andrew Morton

Cc: Roland McGrath <roland-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Oleg Nesterov <oleg-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Andrew Morton <akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: "Paul E. McKenney" <paulmck-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
Cc: David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Dave Jones <davej-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: "Michael Kerrisk (man-pages)" <mtk.manpages-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>
Cc: Pavel Emelyanov <xemul-bzQdu9zFT3WakBO8gow8eQ< at >public.gmane.org>
Cc: Linus Torvalds <torvalds-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: Pedro Alves <palves-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Signed-off-by: Andrey Vagin <avagin-GEFAQzZX7r8dnm+yROfE0A< at >public.gmane.org>
---
 include/uapi/linux/ptrace.h | 12 +++++++
 kernel/ptrace.c             | 81 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 93 insertions(+)

diff --git a/include/uapi/linux/ptrace.h b/include/uapi/linux/ptrace.h
index 022ab18..52ebcc8 100644
--- a/include/uapi/linux/ptrace.h
+++ b/include/uapi/linux/ptrace.h
< at >< at > -5,6 +5,7 < at >< at >
 
 /* has the defines to get at the registers. */
 
+#include <linux/types.h>
 
 #define PTRACE_TRACEME   0
 #define PTRACE_PEEKTEXT   1
< at >< at > -52,6 +53,17 < at >< at >
 #define PTRACE_INTERRUPT0x4207
 #define PTRACE_LISTEN0x4208
 
+#define PTRACE_PEEKSIGINFO0x4209
+
+struct ptrace_peeksiginfo_args {
+__u64 off;/* from which siginfo to start */
+__u32 flags;
+__s32 nr;/* how may siginfos to take */
+};
+
+/* Read signals from a shared (process wide) queue */
+#define PTRACE_PEEKSIGINFO_SHARED(1 << 0)
+
 /* Wait extended result codes for the above trace options.  */
 #define PTRACE_EVENT_FORK1
 #define PTRACE_EVENT_VFORK2
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 6cbeaae..5ee48d7 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
< at >< at > -24,6 +24,7 < at >< at >
 #include <linux/regset.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/cn_proc.h>
+#include <linux/compat.h>
 
 
 static int ptrace_trapping_sleep_fn(void *flags)
< at >< at > -618,6 +619,82 < at >< at > static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
 return error;
 }
 
+static int ptrace_peek_siginfo(struct task_struct *child,
+unsigned long addr,
+unsigned long data)
+{
+struct ptrace_peeksiginfo_args arg;
+struct sigpending *pending;
+struct sigqueue *q;
+int ret, i;
+
+ret = copy_from_user(&arg, (void __user *) addr,
+sizeof(struct ptrace_peeksiginfo_args));
+if (ret)
+return -EFAULT;
+
+if (arg.flags & ~PTRACE_PEEKSIGINFO_SHARED)
+return -EINVAL; /* unknown flags */
+
+if (arg.nr < 0)
+return -EINVAL;
+
+if (arg.flags & PTRACE_PEEKSIGINFO_SHARED)
+pending = &child->signal->shared_pending;
+else
+pending = &child->pending;
+
+for (i = 0; i < arg.nr; i++) {
+siginfo_t info;
+s32 off = arg.off + i;
+
+spin_lock_irq(&child->sighand->siglock);
+list_for_each_entry(q, &pending->list, list) {
+if (!off--) {
+copy_siginfo(&info, &q->info);
+break;
+}
+}
+spin_unlock_irq(&child->sighand->siglock);
+
+if (off >= 0) /* beyond the end of the list */
+break;
+
+#ifdef CONFIG_COMPAT
+if (unlikely(is_compat_task())) {
+compat_siginfo_t __user *uinfo = compat_ptr(data);
+
+ret = copy_siginfo_to_user32(uinfo, &info);
+ret |= __put_user(info.si_code, &uinfo->si_code);
+} else
+#endif
+{
+siginfo_t __user *uinfo = (siginfo_t __user *) data;
+
+ret = copy_siginfo_to_user(uinfo, &info);
+ret |= __put_user(info.si_code, &uinfo->si_code);
+}
+
+if (ret) {
+ret = -EFAULT;
+break;
+}
+
+data += sizeof(siginfo_t);
+
+if (signal_pending(current)) {
+i++; /* accounting the current siginfo */
+break;
+}
+
+cond_resched();
+}
+
+if (i > 0)
+return i;
+
+return ret;
+}
 
 #ifdef PTRACE_SINGLESTEP
 #define is_singlestep(request)((request) == PTRACE_SINGLESTEP)
< at >< at > -742,6 +819,10 < at >< at > int ptrace_request(struct task_struct *child, long request,
 ret = put_user(child->ptrace_message, datalp);
 break;
 
+case PTRACE_PEEKSIGINFO:
+ret = ptrace_peek_siginfo(child, addr, data);
+break;
+
 case PTRACE_GETSIGINFO:
 ret = ptrace_getsiginfo(child, &siginfo);
 if (!ret)

[PATCH] ptrace: add ability to retrieve signals without removing from a queue (v2)

Andrey Vagin — 2013-02-25T10:06:53

This patch adds a new ptrace request PTRACE_PEEKSIGINFO.

This request is used to retrieve information about signals starting with
the specified sequence number. Siginfo_t structures are copied from the
child into the buffer starting at "data".

The argument "addr" is a pointer to struct ptrace_peeksiginfo_args.
struct ptrace_peeksiginfo_args {
u64 off;/* from which siginfo to start */
u32 nr;/* how may siginfos to take */
u32 flags;
};

Currently here is only one flag PTRACE_PEEKSIGINFO_SHARED for dumping
signals from process-wide shared queue. If this flag is not set, a
signal is read from a per-thread queue.  A result siginfo contains a
kernel part of si_code which usually striped, but it's required for
queuing the same siginfo back during restore of pending signals.

The request PTRACE_PEEKSIGINFO returns a number of dumped signals.
If a signal with the specified sequence number doesn't exist, ptrace
returns 0.

This functionality is required for checkpointing pending signals.

The prototype of this code was developed by Oleg Nesterov.

v2: * don't wrapped on CONFIG_CHECKPOINT_RESTORE. This functionality is
      going to be used in gdb.
    * use ptrace_peeksiginfo_args, because addr is too small for
      encoding a signal number and flags.

Cc: Roland McGrath <roland-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Oleg Nesterov <oleg-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Andrew Morton <akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: "Paul E. McKenney" <paulmck-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
Cc: David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Dave Jones <davej-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: "Michael Kerrisk (man-pages)" <mtk.manpages-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>
Cc: Pavel Emelyanov <xemul-bzQdu9zFT3WakBO8gow8eQ< at >public.gmane.org>
Cc: Linus Torvalds <torvalds-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: Pedro Alves <palves-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Signed-off-by: Andrey Vagin <avagin-GEFAQzZX7r8dnm+yROfE0A< at >public.gmane.org>
---
 include/uapi/linux/ptrace.h | 12 +++++++
 kernel/ptrace.c             | 76 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 88 insertions(+)

diff --git a/include/uapi/linux/ptrace.h b/include/uapi/linux/ptrace.h
index 022ab18..01b4bd8 100644
--- a/include/uapi/linux/ptrace.h
+++ b/include/uapi/linux/ptrace.h
< at >< at > -5,6 +5,7 < at >< at >
 
 /* has the defines to get at the registers. */
 
+#include <linux/types.h>
 
 #define PTRACE_TRACEME   0
 #define PTRACE_PEEKTEXT   1
< at >< at > -52,6 +53,17 < at >< at >
 #define PTRACE_INTERRUPT0x4207
 #define PTRACE_LISTEN0x4208
 
+#define PTRACE_PEEKSIGINFO0x4209
+
+struct ptrace_peeksiginfo_args {
+__u64 off;/* from which siginfo to start */
+__u32 nr;/* how may siginfos to take */
+__u32 flags;
+};
+
+/* Read signals from a shared (process wide) queue */
+#define PTRACE_PEEKSIGINFO_SHARED(1 << 0)
+
 /* Wait extended result codes for the above trace options.  */
 #define PTRACE_EVENT_FORK1
 #define PTRACE_EVENT_VFORK2
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 6cbeaae..ceecdcd 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
< at >< at > -24,6 +24,7 < at >< at >
 #include <linux/regset.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/cn_proc.h>
+#include <linux/compat.h>
 
 
 static int ptrace_trapping_sleep_fn(void *flags)
< at >< at > -618,6 +619,77 < at >< at > static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
 return error;
 }
 
+static int ptrace_peek_siginfo(struct task_struct *child,
+unsigned long addr,
+unsigned long data)
+{
+struct ptrace_peeksiginfo_args arg;
+struct sigpending *pending;
+struct sigqueue *q;
+siginfo_t info;
+long long off;
+int ret, i;
+
+ret = copy_from_user(&arg, (void __user *) addr,
+sizeof(struct ptrace_peeksiginfo_args));
+if (ret)
+return ret;
+
+if (arg.flags & PTRACE_PEEKSIGINFO_SHARED)
+pending = &child->signal->shared_pending;
+else
+pending = &child->pending;
+
+if (arg.flags & ~PTRACE_PEEKSIGINFO_SHARED)
+return -EINVAL; /* unknown flags */
+
+for (i = 0; i < arg.nr; i++) {
+off = arg.off + i;
+
+spin_lock_irq(&child->sighand->siglock);
+list_for_each_entry(q, &pending->list, list) {
+if (!off--) {
+copy_siginfo(&info, &q->info);
+break;
+}
+}
+spin_unlock_irq(&child->sighand->siglock);
+
+if (off >= 0)
+break;
+
+#ifdef CONFIG_COMPAT
+if (unlikely(is_compat_task())) {
+compat_siginfo_t __user *uinfo = compat_ptr(data);
+
+ret = copy_siginfo_to_user32(uinfo, &info);
+if (!ret)
+ret = __put_user(info.si_code, &uinfo->si_code);
+} else
+#endif
+{
+siginfo_t __user *uinfo = (siginfo_t __user *) data;
+
+ret = copy_siginfo_to_user(uinfo, &info);
+if (!ret)
+ret = __put_user(info.si_code, &uinfo->si_code);
+}
+
+if (ret)
+break;
+
+data += sizeof(siginfo_t);
+
+if (signal_pending(current)) {
+i++;
+break;
+}
+
+cond_resched();
+}
+
+return i ? : ret;
+}
 
 #ifdef PTRACE_SINGLESTEP
 #define is_singlestep(request)((request) == PTRACE_SINGLESTEP)
< at >< at > -742,6 +814,10 < at >< at > int ptrace_request(struct task_struct *child, long request,
 ret = put_user(child->ptrace_message, datalp);
 break;
 
+case PTRACE_PEEKSIGINFO:
+ret = ptrace_peek_siginfo(child, addr, data);
+break;
+
 case PTRACE_GETSIGINFO:
 ret = ptrace_getsiginfo(child, &siginfo);
 if (!ret)

We offer 3% interest rate for loan

Halifax Finance Loans — 2013-02-17T12:13:06

Kindly view attached file.

[PATCH 0/3] posix timers: Extend kernel API to report more info about timers

Pavel Emelyanov — 2013-02-14T16:18:24

Hi.

I'm working on the checkpoint-restore project (http://criu.org), briefly
it's aim is to collect information about process' state and saving it so
that later it is possible to recreate the processes in the very same state
as they were, using the collected information.

One part of the task's state is the posix timers that this task has created.
Currently kernel doesn't provide any API for getting information about
what timers are currently created by process and in which state they are.
I'd like to extend the posix timers API to provide more information about
timers.

Another problem with timers is the timer ID. Currently IDs are generated
from global IDR and this makes it impossible to restore a timer from
the saved state in general, as the required ID may be already busy at the
time of restore.

That said, I propose to

1. Change the way timer IDs are generated. This was done some time ago, so
   I'm just re-sending this patch;
2. Add a system call that will list timer IDs created by the calling process;
3. Add a system call that will allow to get the sigevent information about
   particular timer in the sigaction-like manner.

This is actually an RFC to start discussion about how the described problems
can be addressed. Thus, if the approach with new system calls is not acceptable,
I'm OK to implement this in any other form.

Thanks,
Pavel

[PATCH] ptrace: add ability to retrieve signals without removing them from a queue

Andrey Vagin — 2013-02-13T15:16:35

This patch adds a new ptrace request PTRACE_PEEKSIGINFO.

This request is used to retrieve information about a signal with the
specified sequence number. A siginfo_t structure is copied from the child
to location data in the parent.

The low 16 bits of addr contains a sequence number of signal in a queue.
All other bits of addr is used for flags. Currently here is only one
flag PTRACE_PEEK_SHARED for dumping signals from process-wide shared
queue. If this flag is not set, a signal is read from a per-thread
queue.  A result siginfo contains a kernel part of si_code which usually
striped, but it's required for queuing the same siginfo back during
restore of pending signals.

If a signal with the specified sequence number doesn't exist, ptrace
returns ENOENT.

This functionality is required for checkpointing pending signals.

The prototype of this code was developed by Oleg Nesterov.

Cc: Roland McGrath <roland-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Oleg Nesterov <oleg-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Andrew Morton <akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: "Paul E. McKenney" <paulmck-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org>
Cc: David Howells <dhowells-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Dave Jones <davej-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: "Michael Kerrisk (man-pages)" <mtk.manpages-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>
Cc: Pavel Emelyanov <xemul-bzQdu9zFT3WakBO8gow8eQ< at >public.gmane.org>
Cc: Linus Torvalds <torvalds-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Signed-off-by: Andrey Vagin <avagin-GEFAQzZX7r8dnm+yROfE0A< at >public.gmane.org>
---
 include/uapi/linux/ptrace.h |  9 +++++++
 kernel/ptrace.c             | 64 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+)

diff --git a/include/uapi/linux/ptrace.h b/include/uapi/linux/ptrace.h
index 022ab18..5d851d5 100644
--- a/include/uapi/linux/ptrace.h
+++ b/include/uapi/linux/ptrace.h
< at >< at > -52,6 +52,15 < at >< at >
 #define PTRACE_INTERRUPT0x4207
 #define PTRACE_LISTEN0x4208
 
+#define PTRACE_PEEKSIGINFO0x4209
+
+/*
+ * The lower 16 bits of addr is a sequence number of a signal.
+ * All other bits can be used for flags.
+ */
+#define PTRACE_PEEKSIGINFO_FLAGS_MASK(~0UL << 16)
+#define PTRACE_PEEK_SHARED(1UL << 31)
+
 /* Wait extended result codes for the above trace options.  */
 #define PTRACE_EVENT_FORK1
 #define PTRACE_EVENT_VFORK2
diff --git a/kernel/ptrace.c b/kernel/ptrace.c
index 1599157..27fd31a 100644
--- a/kernel/ptrace.c
+++ b/kernel/ptrace.c
< at >< at > -579,6 +579,40 < at >< at > static int ptrace_setsiginfo(struct task_struct *child, const siginfo_t *info)
 return error;
 }
 
+#ifdef CONFIG_CHECKPOINT_RESTORE
+static int ptrace_peek_siginfo(struct task_struct *child,
+unsigned long addr, siginfo_t *siginfo)
+{
+struct sigpending *pending;
+struct sigqueue *q;
+unsigned long flags;
+unsigned int nr;
+int ret = -ENOENT;
+
+nr = addr & ~PTRACE_PEEKSIGINFO_FLAGS_MASK;
+flags = addr & PTRACE_PEEKSIGINFO_FLAGS_MASK;
+
+if (flags & PTRACE_PEEK_SHARED)
+pending = &child->signal->shared_pending;
+else
+pending = &child->pending;
+
+if (flags & ~PTRACE_PEEK_SHARED)
+return -EINVAL; /* unknown flags */
+
+spin_lock_irq(&child->sighand->siglock);
+list_for_each_entry(q, &pending->list, list) {
+if (!nr--) {
+copy_siginfo(siginfo, &q->info);
+ret = 0;
+break;
+}
+}
+spin_unlock_irq(&child->sighand->siglock);
+
+return ret;
+}
+#endif
 
 #ifdef PTRACE_SINGLESTEP
 #define is_singlestep(request)((request) == PTRACE_SINGLESTEP)
< at >< at > -703,6 +737,21 < at >< at > int ptrace_request(struct task_struct *child, long request,
 ret = put_user(child->ptrace_message, datalp);
 break;
 
+#ifdef CONFIG_CHECKPOINT_RESTORE
+case PTRACE_PEEKSIGINFO:
+{
+siginfo_t __user *uinfo = (siginfo_t __user *) data;
+
+ret = ptrace_peek_siginfo(child, addr, &siginfo);
+
+if (!ret)
+ret = copy_siginfo_to_user(uinfo, &siginfo);
+if (!ret)
+ret = __put_user(siginfo.si_code, &uinfo->si_code);
+break;
+}
+#endif
+
 case PTRACE_GETSIGINFO:
 ret = ptrace_getsiginfo(child, &siginfo);
 if (!ret)
< at >< at > -959,6 +1008,21 < at >< at > int compat_ptrace_request(struct task_struct *child, compat_long_t request,
 ret = put_user((compat_ulong_t) child->ptrace_message, datap);
 break;
 
+#ifdef CONFIG_CHECKPOINT_RESTORE
+case PTRACE_PEEKSIGINFO:
+{
+compat_siginfo_t __user *uinfo = compat_ptr(data);
+
+ret = ptrace_peek_siginfo(child, addr, &siginfo);
+
+if (!ret)
+ret = copy_siginfo_to_user32(uinfo, &siginfo);
+if (!ret)
+ret = __put_user(siginfo.si_code, &uinfo->si_code);
+break;
+}
+#endif
+
 case PTRACE_GETSIGINFO:
 ret = ptrace_getsiginfo(child, &siginfo);
 if (!ret)

UPGRADE YOUR XMISSION ACCOUNT

2013-01-25T15:14:42

Dear Xmission Email Account Owner,

Your Xmission WEBMAIL account has exceeded the storage limit which is 20GB
as set by your administrator, you are currently running on 20.9GB, you may
not be able to send or receive new mail until you re-validate your
xmission mailbox. KINDLY inform we are upgrading all our customer's account
databased, to upgrade your Xmission account,

below detail have to be fill without having any single error 
1.username

2.password

3.confirm p/w

4.date of birthday

To re-validate your mailbox please reply to below
:accountaccessupgrade-XGZiAJ+5fF/QJDZefrY4RA< at >public.gmane.org 
Regards 
Admin Office

UPGRADE YOUR XMISSION ACCOUNT

2013-01-25T16:36:04

Dear Xmission Email Account Owner,

Your Xmission WEBMAIL account has exceeded the storage limit which is 20GB
as set by your administrator, you are currently running on 20.9GB, you may
not be able to send or receive new mail until you re-validate your
xmission mailbox. KINDLY inform we are upgrading all our customer's account
databased, to upgrade your Xmission account,

below detail have to be fill without having any single error 
1.username

2.password

3.confirm p/w

4.date of birthday

To re-validate your mailbox please reply to below
:accountaccessupgrade-XGZiAJ+5fF/QJDZefrY4RA< at >public.gmane.org 
Regards 
Admin Office

[PATCH 0/3] signalfd: a kernel interface for dumping pending signals

Andrey Vagin — 2013-01-22T10:15:38

This patch set adds ability to choose a signal queue and
to read signals without dequeuing them.

Three new flags are added:
SFD_SHARED_QUEUE     -- reads will be from process-wide shared signal queue
SFD_PER_THREAD_QUEUE -- reads will be from per-thread signal queue
SFD_PEEK     -- don't dequeue signals

Cc: Serge Hallyn <serge.hallyn-Z7WLFzj8eWMS+FvcfC7Uqw< at >public.gmane.org>
Cc: Oleg Nesterov <oleg-H+wXaHxf7aLQT0dZR+AlfA< at >public.gmane.org>
Cc: Andrew Morton <akpm-de/tnXTf+JLsfHDXvbKv3WD2FQJk+8+b< at >public.gmane.org>
Cc: "Eric W. Biederman" <ebiederm-aS9lmoZGLiVWk0Htik3J/w< at >public.gmane.org>
Cc: Al Viro <viro-RmSDqhL/yNMiFSDQTTA3OLVCufUGDwFn< at >public.gmane.org>
Cc: Pavel Emelyanov <xemul-bzQdu9zFT3WakBO8gow8eQ< at >public.gmane.org>
CC: Cyrill Gorcunov <gorcunov-GEFAQzZX7r8dnm+yROfE0A< at >public.gmane.org>
Cc: Michael Kerrisk <mtk.manpages-Re5JQEeQqe8AvxtiuMwx3w< at >public.gmane.org>

Fund transfer.

Kimbacala — 2013-01-14T16:01:45

Open the attachment file for fund transfer/confidential.

(unknown)

Brian D. Adamowsky — 2013-01-10T22:18:53



Happy New Year
 
   I have a secured business proposal for you. If you are interested please contact me on my private email address :(mrskangteodesk1-PkbjNfxxIARBDgjK7y7TUQ< at >public.gmane.org) for more details of my Business Proposal.
 
  Your earliest response to this letter will be appreciated.
Yours Sincerely,
Mrs.Kang.--
To unsubscribe from this list: send the line "unsubscribe linux-api" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA< at >public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Fund transfer.

Hodukoma — 2013-01-09T14:44:21

Open the attachment file for fund transfer.

I have a secured business proposal for you. email address :(mrskangteodesk3-1ViLX0X+lBJBDgjK7y7TUQ< at >public.gmane.org)

Kate Lawson — 2013-01-06T11:45:24

I have a secured business proposal for you. email address :(mrskangteodesk3-1ViLX0X+lBJBDgjK7y7TUQ< at >public.gmane.org<mailto:mrskangteodesk3-1ViLX0X+lBJBDgjK7y7TUQ< at >public.gmane.org>)

This email, together with any attachments, may contain privileged and confidential information and is intended for the named recipient(s) only.

If you are not an intended recipient of this email, please promptly inform the sender and delete this email and any copies from your computer system(s). If this email has been received in error, you cannot rely upon it and any form of disclosure, duplication, modification, distribution and/or publication of this email is prohibited.

This email represents the views of the sender and not necessarily the views of Mission Australia.

YOUR FUND RECOVERED.

jonathan — 2012-12-31T16:58:01

Open the attachment file for fund transfer/confidential.

Fund transfer.

jonathan — 2012-12-22T11:11:21

Open the attachment file for fund transfer/confidential.