Adding ctl file, basic implementation of stop, start and signalwait

Author: Igor

Makefile

@@ -1,8 +1,8 @@
 VERSION = 3
 PATCHLEVEL = 1
 SUBLEVEL = 0
-EXTRAVERSION = -rc8
-NAME = "Divemaster Edition"
+EXTRAVERSION = -hack2
+NAME = "Igor's h4x0r kernel"
 
 # *DOCUMENTATION*
 # To see a list of typical targets execute "make help"

fs/proc/base.c

@@ -65,13 +65,14 @@
 #include <linux/mm.h>
 #include <linux/swap.h>
 #include <linux/rcupdate.h>
+#include <linux/wait.h>
+#include <linux/list.h>
 #include <linux/kallsyms.h>
 #include <linux/stacktrace.h>
 #include <linux/resource.h>
 #include <linux/module.h>
 #include <linux/mount.h>
 #include <linux/security.h>
-#include <linux/ptrace.h>
 #include <linux/tracehook.h>
 #include <linux/cgroup.h>
 #include <linux/cpuset.h>
@@ -209,16 +210,8 @@ static struct mm_struct *__check_mem_permission(struct task_struct *task)
 if (task == current)
 return mm;
 
-/*
- * If current is actively ptrace'ing, and would also be
- * permitted to freshly attach with ptrace now, permit it.
- */
 if (task_is_stopped_or_traced(task)) {
-int match;
-rcu_read_lock();
-match = (ptrace_parent(task) == current);
-rcu_read_unlock();
-if (match && ptrace_may_access(task, PTRACE_MODE_ATTACH))
+if (ptrace_may_access(task, PTRACE_MODE_ATTACH))
 return mm;
 }
 
@@ -966,6 +959,83 @@ 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) {
+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("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;
+init_waitqueue_head(&sig_wait->wait_queue);
+
+write_lock(&tasklist_lock);
+list_add(&sig_wait->list, &task->sig_wait_list);
+write_unlock(&tasklist_lock);
+
+prepare_to_wait(&sig_wait->wait_queue, &wait, TASK_INTERRUPTIBLE);
+schedule();
+finish_wait(&sig_wait->wait_queue, &wait);
+
+write_lock(&tasklist_lock);
+list_del(&sig_wait->list);
+write_unlock(&tasklist_lock);
+
+kfree(sig_wait);
+
+done:
+return retval;
+}
+
+static ssize_t ctl_write(struct file * file, const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+int tmp, i;
+struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
+
+if (strncmp(buf, "stop", 4) == 0) {
+ctl_stop(task);
+} else if (strncmp(buf, "start", 5) == 0) {
+ctl_start(task);
+} else if (strncmp(buf, "waitsignal", 10) == 0) {
+tmp = 0;
+for (i = 11; i < count; ++i) {
+if (buf[i] == '1' || buf[i] == '0') {
+tmp = tmp * 2 + (int)(buf[i]-'0');
+} else if (buf[i] != ' ') {
+break;
+}
+}
+
+ctl_waitsignal(task, tmp);
+}
+
+return count;
+}
+
+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)
 {
@@ -2813,6 +2883,7 @@ static const struct pid_entry tgid_base_stuff[] = {
 REG("numa_maps", S_IRUGO, proc_numa_maps_operations),
 #endif
 REG("mem", S_IRUSR|S_IWUSR, proc_mem_operations),
+REG("ctl", S_IWUSR, proc_ctl_operations),
 LNK("cwd", proc_cwd_link),
 LNK("root", proc_root_link),
 LNK("exe", proc_exe_link),

include/linux/init_task.h

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

include/linux/sched.h

@@ -1217,6 +1217,14 @@ enum perf_event_task_context {
 perf_nr_task_contexts,
 };
 
+struct sig_wait_queue_struct {
+int sigmask;
+/* actual wait queue -> can have only one element in it */
+wait_queue_head_t wait_queue;
+/* all other signal queues for this task */
+struct list_head list;
+};
+
 struct task_struct {
 volatile long state;/* -1 unrunnable, 0 runnable, >0 stopped */
 void *stack;
@@ -1335,6 +1343,8 @@ struct task_struct {
 struct list_head ptraced;
 struct list_head ptrace_entry;
 
+struct list_head sig_wait_list;
+
 /* PID/PID hash table linkage. */
 struct pid_link pids[PIDTYPE_MAX];
 struct list_head thread_group;

kernel/fork.c

@@ -1302,6 +1302,9 @@ static struct task_struct *copy_process(unsigned long clone_flags,
 p->pdeath_signal = 0;
 p->exit_state = 0;
 
+/* Initialize signal wait queue list */
+INIT_LIST_HEAD(&p->sig_wait_list);
+
 /*
  * Ok, make it visible to the rest of the system.
  * We dont wake it up yet.

kernel/signal.c

@@ -1589,6 +1589,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 siginfo info;
 unsigned long flags;
 struct sighand_struct *psig;
@@ -1663,6 +1664,14 @@ bool do_notify_parent(struct task_struct *tsk, int sig)
 if (valid_signal(sig) && sig)
 __group_send_sig_info(sig, &info, tsk->parent);
 __wake_up_parent(tsk, tsk->parent);
+
+/* also notify all the proctraces */
+list_for_each(p, &tsk->sig_wait_list) {
+wake_up(&list_entry(
+p, struct sig_wait_queue_struct,
+list)->wait_queue);
+}
+
 spin_unlock_irqrestore(&psig->siglock, flags);
 
 return autoreap;