MAZE: Mazed processes monitor

This patch for linux-2.6.25-mm1 that is tested on x86_64 hardware.

...

kernel/maze.c new file +3 -0

+static struct proc_dir_entry *maze_proc_dir;
+
+static int maze_initialized;

kernel/maze.c new file +22 -0

+static inline void reset_maze_count(struct maze_context *context)
+{
+	context->reset_utime = context->task->utime;
+	context->reset_stime = context->task->stime;
+	context->flags = 0;
+}
+
+static inline cputime_t get_maze_count(struct maze_context *context)
+{
+	return (context->task->utime - context->reset_utime) +
+		(context->task->stime - context->reset_stime);
+}
+
+/*
+ * This function is called start_kernel()
+ */
+void maze_init_early(void)
+{
+	init_task.maze_context = NULL;
+}
+
+/*

kernel/maze.c new file +19 -0

+		if (task->maze_context->enqueue)
+			list_del(&task->maze_context->queue);
+		spin_unlock_irqrestore(&per_cpu(maze_queue_lock,
+										task->maze_context->enqueue_cpu), flags);
+
+		spin_lock(&maze_list_lock);
+		list_del(&task->maze_context->list);
+		spin_unlock(&maze_list_lock);
+
+		kfree(task->maze_context);
+		task->maze_context = NULL;
+	}
+	task_unlock(task);
+}
 
...
 
+/*
+ * Must be called under task_lock().
+ */
+static inline void enqueue(struct maze_context *context)
+{

kernel/maze.c new file +7 -0

+static void sched_out_event(struct preempt_notifier *notifier,
+							struct task_struct *next)
+{
+	task_lock(next);
+	if (next->maze_context)
+		enqueue(next->maze_context);
+	task_unlock(next);

kernel/maze.c new file +11 -0

+	if (unlikely(!task->maze_context)) {
+		ERRPRINT("fail to alloc maze_context.\n");
+		goto task_unlock;
+	}
+	task->maze_context->task = task;
+	task->maze_context->pid = task->pid;
+
+	copy_limit_and_signal(task->maze_context, current->maze_context);
+	preempt_notifier_init(&task->maze_context->notifier, &preempt_ops);
+
+	spin_lock(&maze_list_lock);

kernel/maze.c new file +21 -0

+{
+	if (!atomic_xchg(&context->registered_notifier, 1))
+		preempt_notifier_register(&context->notifier);
+}
+
+static int add_maze_context(struct maze_context *context)
+{
+	struct task_struct *task;
+	int ret = 0;
+
+	rcu_read_lock();
+
+	task = find_task_by_pid(context->pid);
+	if (unlikely(!task))
+		goto read_unlock;
+
+	task_lock(task);
+
+	if (!task->maze_context) {
+		task->maze_context = context;
+		context->task = task;

kernel/maze.c new file +23 -0

+	} else {
+		copy_limit_and_signal(task->maze_context, context);
+		ret = 1;
+	}
+
+	task_unlock(task);
+read_unlock:
+	rcu_read_unlock();
+	return ret;
+}
+
+static int build_maze_context(const char *read_line, struct maze_context *context)
+{
+	unsigned long soft_limit, hard_limit;
+	int soft_signal, hard_signal;
+	int pid, res;
+
+	res = sscanf(read_line, "%d %ld %ld %d %d", &pid, &soft_limit,
+				 &hard_limit, &soft_signal, &hard_signal);
+
+	if (res != 5 || pid < 0 ||
+		soft_limit < 0 || hard_limit < 0 ||
+		soft_signal < 0 || hard_signal < 0)

kernel/maze.c new file +17 -0

+	add_timer_on(t, cpu);
+}
 
...
 
+static void timer_handler(unsigned long data)
+{
+	struct maze_context *context, *next;
+
+	spin_lock(&__get_cpu_var(maze_queue_lock));
+
+	if (current->maze_context) {
+		set_preempt_notifir(current->maze_context);
+		if (!current->maze_context->enqueue)
+			check_limit(current->maze_context);
+	}
+
+	if (!list_empty(&__get_cpu_var(maze_queue))) {
+		list_for_each_entry_safe (context, next,
+								  &__get_cpu_var(maze_queue), queue) {

kernel/maze.c new file +34 -0

+
+static int maze_entries_file_show(struct seq_file *seq, void *nouse)
+{
+	struct maze_context *context;
+
+	spin_lock(&maze_list_lock);
+
+	list_for_each_entry(context, &maze_list, list) {
+		seq_printf(seq, "pid:%5d   ", context->pid);
+		seq_printf(seq, "count:%6ld  ", get_maze_count(context));
+		seq_printf(seq, "soft limit:%6ld  ", context->soft_limit);
+		seq_printf(seq, "hard limit:%6ld  ", context->hard_limit);
+		seq_printf(seq, "soft signal:%2d  ", context->soft_signal);
+		seq_printf(seq, "hard signal:%2d  ", context->hard_signal);
+		seq_printf(seq, "\n");
+	}
+
+	spin_unlock(&maze_list_lock);
+
+	return 0;
+}
 
...
 
+/*
+ * Write operation of /proc/maze/entries
+ */
+static ssize_t maze_entries_file_write(struct file *file,
+					const char __user *buffer,
+					size_t count, loff_t *ppos)
+{
+	struct maze_context *context;
+	char read_line[32];
+	int ret;
+
+	if (!capable(CAP_SYS_ADMIN))
+		return -EPERM;

kernel/maze.c new file +6 -0

+	if (unlikely(!context)) {
+		ERRPRINT("fail to alloc maze_context.\n");
+		return -ENOMEM;
+	}
+
+	ret = build_maze_context(read_line, context);

kernel/maze.c new file +5 -0

+/*
+ * Creating /proc/maze/
+ */
+static inline int init_dir(void)
+{

kernel/maze.c new file +16 -0

+
+/*
+ * Creating /proc/maze/entries
+ */
+static inline int init_entries(void)
+{
+	struct proc_dir_entry *p;
+
+	p = create_proc_entry("entries", S_IRUGO, maze_proc_dir);
+	if (p == NULL)
+		panic("fail to create /proc/maze/entries\n");
+
+	p->proc_fops = &maze_entries_file_ops;
+
+	return 0;
+}
 
...

kernel/sched.c +3 -0

@@ -68,6 +68,7 @@
 #include <linux/hrtimer.h>
 #include <linux/tick.h>
 #include <linux/ftrace.h>
+#include <linux/maze.h>
 
 #include <asm/tlb.h>
 #include <asm/irq_regs.h>

@@ -5157,6 +5158,8 @@ asmlinkage long sys_sched_yield(void)
 	_raw_spin_unlock(&rq->lock);
 	preempt_enable_no_resched();
 
+	maze_sched_yield(current);
+
 	schedule();
 
 	return 0;