Add wait file

Author: igorcanadi

fs/proc/base.c

@@ -78,6 +78,7 @@
 #include <linux/cpuset.h>
 #include <linux/audit.h>
 #include <linux/poll.h>
+#include <linux/ptrace.h>
 #include <linux/nsproxy.h>
 #include <linux/oom.h>
 #include <linux/elf.h>
@@ -959,47 +960,44 @@ static const struct file_operations proc_mem_operations = {
 .open= mem_open,
 };
 
-static int ctl_stop(struct task_struct *task)
-{
-printk("PROCTRACE stopping %d task with %d\n", task->pid, current->pid);
-send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
-return 0;
-}
-
-static int ctl_start(struct task_struct *task) {
-printk("PROCTRACE continuing %d task with %d\n", task->pid, current->pid);
-wake_up_process(task);
-return 0;
-}
-
-static int ctl_waitsignal(struct task_struct *task, int sigmask, int start_the_task) {
+static int wait_waitsignal(struct task_struct *task, unsigned long long mask) {
 struct sig_wait_queue_struct *sig_wait;
 DEFINE_WAIT(wait);
 int retval = 0;
 
-printk("PROCTRACE waiting %d task with %d. sigmask %d\n", task->pid, current->pid, sigmask);
+printk("PROCTRACE waiting %d task with %d. mask %lld\n", task->pid, current->pid, mask);
 
 printk("Allocating new signal wait queue\n");
 sig_wait = kmalloc(sizeof(struct sig_wait_queue_struct), GFP_KERNEL);
 if (!sig_wait) {
 retval = -ENOMEM;
 goto done;
 }
-sig_wait->sigmask = sigmask;
+sig_wait->sigmask = mask;
 init_waitqueue_head(&sig_wait->wait_queue);
 
 write_lock(&tasklist_lock);
 list_add(&sig_wait->list, &task->sig_wait_list);
 write_unlock(&tasklist_lock);
 
-if (start_the_task) {
+if (mask & (1ULL << PROCTRACE_SYSTEM_CALLS)) {
+set_tsk_thread_flag(task, TIF_SYSCALL_TRACE);
+}
+
+if (mask & (1ULL << PROCTRACE_START_TASK)) {
 wake_up_process(task);
+// we don't need this flag anymore
+mask ^= 1ULL << PROCTRACE_START_TASK;
 }
 
 prepare_to_wait(&sig_wait->wait_queue, &wait, TASK_INTERRUPTIBLE);
 schedule();
 finish_wait(&sig_wait->wait_queue, &wait);
 
+if (mask & (1ULL << PROCTRACE_SYSTEM_CALLS)) {
+clear_tsk_thread_flag(task, TIF_SYSCALL_TRACE);
+}
+
 write_lock(&tasklist_lock);
 list_del(&sig_wait->list);
 write_unlock(&tasklist_lock);
@@ -1010,34 +1008,36 @@ static int ctl_waitsignal(struct task_struct *task, int sigmask, int start_the_t
 return retval;
 }
 
-static int ctl_get_sigmask(const char __user *buf, int count) {
-int i, retval = 0;
+static ssize_t wait_write(struct file *file, const char __user *buf,
+ size_t count, loff_t *ppos) {
+unsigned long long mask = 0;
+int i = 0;
+struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
 
-for (i = 0; i < count; ++i) {
-if (buf[i] == '1' || buf[i] == '0') {
-retval = retval * 2 + (int)(buf[i]-'0');
-} else if (buf[i] != ' ') {
-break;
-}
+for (i = 0; i < count && i < 8; ++i) {
+mask <<= 8;
+mask |= buf[i];
 }
 
-return retval;
-}
+wait_waitsignal(task, mask);
 
+return count;
+}
 
-static int ctl_wait(struct task_struct *task, int start_the_task) {
-DEFINE_WAIT(wait);
-
-printk("PROCTRACE waiting %d task with %d\n", task->pid, current->pid);
-
-if (start_the_task) {
-wake_up_process(task);
-}
+static const struct file_operations proc_wait_operations = {
+.write= wait_write,
+};
 
-prepare_to_wait(&task->wq_for_stop, &wait, TASK_INTERRUPTIBLE);
-schedule();
-finish_wait(&task->wq_for_stop, &wait);
+static int ctl_stop(struct task_struct *task)
+{
+printk("PROCTRACE stopping %d task with %d\n", task->pid, current->pid);
+send_sig_info(SIGSTOP, SEND_SIG_FORCED, task);
+return 0;
+}
 
+static int ctl_start(struct task_struct *task) {
+printk("PROCTRACE continuing %d task with %d\n", task->pid, current->pid);
+wake_up_process(task);
 return 0;
 }
 
@@ -1046,31 +1046,15 @@ static ssize_t ctl_write(struct file *file, const char __user *buf,
 {
 struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
 
-if (strncmp(buf, "waitsignal", 10) == 0) {
-ctl_waitsignal(task, ctl_get_sigmask(buf + 11, count - 11), 0);
-} else if (strncmp(buf, "startwaitsignal", 15) == 0) {
-ctl_waitsignal(task, ctl_get_sigmask(buf + 16, count - 16), 1);
-} else if (strncmp(buf, "waitsyscall", 9) == 0) {
-set_tsk_thread_flag(task, TIF_SYSCALL_TRACE);
-ctl_waitsignal(task, 1 << SIGTRAP, 0);
-clear_tsk_thread_flag(task, TIF_SYSCALL_TRACE);
-} else if (strncmp(buf, "startwaitsyscall", 9) == 0) {
-set_tsk_thread_flag(task, TIF_SYSCALL_TRACE);
-ctl_waitsignal(task, 1 << SIGTRAP, 1);
-clear_tsk_thread_flag(task, TIF_SYSCALL_TRACE);
-} else if (strncmp(buf, "startwait", 9) == 0) {
-ctl_wait(task, 1);
-} else if (strncmp(buf, "stop", 4) == 0) {
+if (strncmp(buf, "stop", 4) == 0) {
 ctl_stop(task);
 } else if (strncmp(buf, "start", 5) == 0) {
 ctl_start(task);
-} else if (strncmp(buf, "wait", 4) == 0) {
-ctl_wait(task, 0);
 } else if (strncmp(buf, "step", 4) == 0) {
 if (unlikely(!arch_has_block_step()))
 return -EIO;
 user_enable_block_step(task);
-ctl_waitsignal(task, 1 << SIGTRAP, 1);
+wait_waitsignal(task, (1ULL << SIGTRAP) | (1ULL << PROCTRACE_START_TASK));
 user_disable_single_step(task);
 }
 
@@ -1081,6 +1065,7 @@ static const struct file_operations proc_ctl_operations = {
 .write= ctl_write,
 };
 
+
 static ssize_t environ_read(struct file *file, char __user *buf,
 size_t count, loff_t *ppos)
 {
@@ -2929,6 +2914,7 @@ static const struct pid_entry tgid_base_stuff[] = {
 #endif
 REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),
 REG("ctl", S_IWUSR, proc_ctl_operations),
+REG("wait", S_IWUSR, proc_wait_operations),
 LNK("cwd", proc_cwd_link),
 LNK("root", proc_root_link),
 LNK("exe", proc_exe_link),

include/linux/init_task.h

@@ -155,7 +155,6 @@ extern struct cred init_cred;
 INIT_PUSHABLE_TASKS(tsk)	\
 .ptraced	= LIST_HEAD_INIT(tsk.ptraced),	\
 .ptrace_entry	= LIST_HEAD_INIT(tsk.ptrace_entry),	\
-.wq_for_stop	= __WAIT_QUEUE_HEAD_INITIALIZER(tsk.wq_for_stop),\
 .sig_wait_list = LIST_HEAD_INIT(tsk.sig_wait_list),	\
 .real_parent	= &tsk,	\
 .parent	= &tsk,	\

include/linux/ptrace.h

@@ -3,6 +3,17 @@
 /* ptrace.h */
 /* structs and defines to help the user use the ptrace system call. */
 
+/* stealing some space for proctrace */
+#define PROCTRACE_START_TASK 0
+#define PROCTRACE_SYSTEM_CALLS 33
+#define PROCTRACE_FORK 34
+#define PROCTRACE_VFORK 35
+#define PROCTRACE_CLONE 36
+#define PROCTRACE_EXEC 37
+#define PROCTRACE_VFORK_DONE 38
+#define PROCTRACE_EXIT 39
+
+
 /* has the defines to get at the registers. */
 
 #define PTRACE_TRACEME 0

include/linux/sched.h

@@ -1218,7 +1218,7 @@ enum perf_event_task_context {
 };
 
 struct sig_wait_queue_struct {
-int sigmask;
+unsigned long long sigmask;
 /* actual wait queue -> can have only one element in it */
 wait_queue_head_t wait_queue;
 /* all other signal queues for this task */
@@ -1343,8 +1343,6 @@ struct task_struct {
 struct list_head ptraced;
 struct list_head ptrace_entry;
 
-/* Debuggers waiting for child to stop or exit */
-wait_queue_head_t wq_for_stop;
 /* Debuggers waiting for child to get a signal or exit */
 struct list_head sig_wait_list;
 

include/linux/tracehook.h

@@ -72,7 +72,7 @@ static inline void ptrace_report_syscall(struct pt_regs *regs)
 }
 }
 if (!list_empty(&current->sig_wait_list)) {
-proctrace_notify(SIGTRAP);
+proctrace_notify(PROCTRACE_SYSTEM_CALLS);
 }
 }
 

kernel/fork.c

@@ -1303,7 +1303,6 @@ static struct task_struct *copy_process(unsigned long clone_flags,
 p->exit_state = 0;
 
 /* Initialize proctrace data structures */
-init_waitqueue_head(&p->wq_for_stop);
 INIT_LIST_HEAD(&p->sig_wait_list);
 
 /*

kernel/signal.c

@@ -1590,6 +1590,7 @@ int send_sigqueue(struct sigqueue *q, struct task_struct *t, int group)
 bool do_notify_parent(struct task_struct *tsk, int sig)
 {
 struct list_head *p;
+struct sig_wait_queue_struct *sig_wait;
 struct siginfo info;
 unsigned long flags;
 struct sighand_struct *psig;
@@ -1666,12 +1667,10 @@ bool do_notify_parent(struct task_struct *tsk, int sig)
 __wake_up_parent(tsk, tsk->parent);
 
 /* also notify all the proctraces */
-wake_up(&tsk->wq_for_stop);
 list_for_each(p, &tsk->sig_wait_list) {
 printk("PROCTRACE budim frajera jer je child umro\n");
-wake_up(&list_entry(
-p, struct sig_wait_queue_struct,
-list)->wait_queue);
+sig_wait = list_entry(p, struct sig_wait_queue_struct, list);
+wake_up(&sig_wait->wait_queue);
 }
 
 spin_unlock_irqrestore(&psig->siglock, flags);
@@ -1699,6 +1698,8 @@ static void do_notify_parent_cldstop(struct task_struct *tsk,
 unsigned long flags;
 struct task_struct *parent;
 struct sighand_struct *sighand;
+struct sig_wait_queue_struct *sig_wait;
+struct list_head *p;
 
 if (for_ptracer) {
 parent = tsk->parent;
@@ -1745,8 +1746,15 @@ static void do_notify_parent_cldstop(struct task_struct *tsk,
  */
 __wake_up_parent(tsk, parent);
 if (why == CLD_STOPPED) {
+printk("PROCTRACE child je stao\n");
 /* wake up all the proctraces waiting for stop */
-wake_up(&tsk->wq_for_stop);
+list_for_each(p, &tsk->sig_wait_list) {
+sig_wait = list_entry(p, struct sig_wait_queue_struct, list);
+if (sig_wait->sigmask == 0) {
+printk("PROCTRACE budim frajera jer je child stao\n");
+wake_up(&sig_wait->wait_queue);
+}
+}
 }
 spin_unlock_irqrestore(&sighand->siglock, flags);
 }
@@ -2117,7 +2125,7 @@ static int proctrace_signal(int signr) {
 printk("PROCTRACE provjeravam jedan proces\n");
 sig_wait = list_entry(p, struct sig_wait_queue_struct, list);
 
-if (sig_wait->sigmask & (1 << signr)) {
+if (sig_wait->sigmask & (1ULL << signr)) {
 printk("PROCTRACE Sigmask je dobar, budim debuggera\n");
 /* ignore the signal */
 retval = 0;