[PATCH] Update cfq io scheduler to time sliced design

This updates the CFQ io scheduler to the new time sliced design (cfq
v3).  It provides full process fairness, while giving excellent
aggregate system throughput even for many competing processes.  It
supports io priorities, either inherited from the cpu nice value or set
directly with the ioprio_get/set syscalls.  The latter closely mimic
set/getpriority.

This import is based on my latest from -mm.

Signed-off-by: Jens Axboe <axboe@suse.de>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 172 insertions, 0 deletions

diff --git a/fs/ioprio.c b/fs/ioprio.c
new file mode 100644
index 000000000000..663e420636d6
--- /dev/null
+++ b/fs/ioprio.c
@@ -0,0 +1,172 @@
+/*
+ * fs/ioprio.c
+ *
+ * Copyright (C) 2004 Jens Axboe <axboe@suse.de>
+ *
+ * Helper functions for setting/querying io priorities of processes. The
+ * system calls closely mimmick getpriority/setpriority, see the man page for
+ * those. The prio argument is a composite of prio class and prio data, where
+ * the data argument has meaning within that class. The standard scheduling
+ * classes have 8 distinct prio levels, with 0 being the highest prio and 7
+ * being the lowest.
+ *
+ * IOW, setting BE scheduling class with prio 2 is done ala:
+ *
+ * unsigned int prio = (IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT) | 2;
+ *
+ * ioprio_set(PRIO_PROCESS, pid, prio);
+ *
+ * See also Documentation/block/ioprio.txt
+ *
+ */
+#include <linux/kernel.h>
+#include <linux/ioprio.h>
+#include <linux/blkdev.h>
+
+static int set_task_ioprio(struct task_struct *task, int ioprio)
+{
+        struct io_context *ioc;
+
+        if (task->uid != current->euid &&
+            task->uid != current->uid && !capable(CAP_SYS_NICE))
+                return -EPERM;
+
+        task_lock(task);
+
+        task->ioprio = ioprio;
+
+        ioc = task->io_context;
+        if (ioc && ioc->set_ioprio)
+                ioc->set_ioprio(ioc, ioprio);
+
+        task_unlock(task);
+        return 0;
+}
+
+asmlinkage int sys_ioprio_set(int which, int who, int ioprio)
+{
+        int class = IOPRIO_PRIO_CLASS(ioprio);
+        int data = IOPRIO_PRIO_DATA(ioprio);
+        struct task_struct *p, *g;
+        struct user_struct *user;
+        int ret;
+
+        switch (class) {
+                case IOPRIO_CLASS_RT:
+                        if (!capable(CAP_SYS_ADMIN))
+                                return -EPERM;
+                        /* fall through, rt has prio field too */
+                case IOPRIO_CLASS_BE:
+                        if (data >= IOPRIO_BE_NR || data < 0)
+                                return -EINVAL;
+
+                        break;
+                case IOPRIO_CLASS_IDLE:
+                        break;
+                default:
+                        return -EINVAL;
+        }
+
+        ret = -ESRCH;
+        read_lock_irq(&tasklist_lock);
+        switch (which) {
+                case IOPRIO_WHO_PROCESS:
+                        if (!who)
+                                p = current;
+                        else
+                                p = find_task_by_pid(who);
+                        if (p)
+                                ret = set_task_ioprio(p, ioprio);
+                        break;
+                case IOPRIO_WHO_PGRP:
+                        if (!who)
+                                who = process_group(current);
+                        do_each_task_pid(who, PIDTYPE_PGID, p) {
+                                ret = set_task_ioprio(p, ioprio);
+                                if (ret)
+                                        break;
+                        } while_each_task_pid(who, PIDTYPE_PGID, p);
+                        break;
+                case IOPRIO_WHO_USER:
+                        if (!who)
+                                user = current->user;
+                        else
+                                user = find_user(who);
+
+                        if (!user)
+                                break;
+
+                        do_each_thread(g, p) {
+                                if (p->uid != who)
+                                        continue;
+                                ret = set_task_ioprio(p, ioprio);
+                                if (ret)
+                                        break;
+                        } while_each_thread(g, p);
+
+                        if (who)
+                                free_uid(user);
+                        break;
+                default:
+                        ret = -EINVAL;
+        }
+
+        read_unlock_irq(&tasklist_lock);
+        return ret;
+}
+
+asmlinkage int sys_ioprio_get(int which, int who)
+{
+        struct task_struct *g, *p;
+        struct user_struct *user;
+        int ret = -ESRCH;
+
+        read_lock_irq(&tasklist_lock);
+        switch (which) {
+                case IOPRIO_WHO_PROCESS:
+                        if (!who)
+                                p = current;
+                        else
+                                p = find_task_by_pid(who);
+                        if (p)
+                                ret = p->ioprio;
+                        break;
+                case IOPRIO_WHO_PGRP:
+                        if (!who)
+                                who = process_group(current);
+                        do_each_task_pid(who, PIDTYPE_PGID, p) {
+                                if (ret == -ESRCH)
+                                        ret = p->ioprio;
+                                else
+                                        ret = ioprio_best(ret, p->ioprio);
+                        } while_each_task_pid(who, PIDTYPE_PGID, p);
+                        break;
+                case IOPRIO_WHO_USER:
+                        if (!who)
+                                user = current->user;
+                        else
+                                user = find_user(who);
+
+                        if (!user)
+                                break;
+
+                        do_each_thread(g, p) {
+                                if (p->uid != user->uid)
+                                        continue;
+                                if (ret == -ESRCH)
+                                        ret = p->ioprio;
+                                else
+                                        ret = ioprio_best(ret, p->ioprio);
+                        } while_each_thread(g, p);
+
+                        if (who)
+                                free_uid(user);
+                        break;
+                default:
+                        ret = -EINVAL;
+        }
+
+        read_unlock_irq(&tasklist_lock);
+        return ret;
+}
+