[PATCH] x86-64 TIF flags for debug regs and io bitmap in ctxsw

Hello,

Following my discussion with Andi. Here is a patch that introduces
two new TIF flags to simplify the context switch code in __switch_to().
The idea is to minimize the number of cache lines accessed in the common
case, i.e., when neither the debug registers nor the I/O bitmap are used.

This patch covers the x86-64 modifications. A patch for i386 follows.

Changelog:
	- add TIF_DEBUG to track when debug registers are active
	- add TIF_IO_BITMAP to track when I/O bitmap is used
	- modify __switch_to() to use the new TIF flags

<signed-off-by>: eranian@hpl.hp.com

Signed-off-by: Andi Kleen <ak@suse.de>

1 files changed, 42 insertions, 31 deletions

diff --git a/arch/x86_64/kernel/process.c b/arch/x86_64/kernel/process.c
index bb6745d13b8f..6e0527635b4c 100644
--- a/arch/x86_64/kernel/process.c
+++ b/arch/x86_64/kernel/process.c
@@ -350,6 +350,7 @@ void exit_thread(void)
 
                 kfree(t->io_bitmap_ptr);
                 t->io_bitmap_ptr = NULL;
+                clear_thread_flag(TIF_IO_BITMAP);
                 /*
                  * Careful, clear this in the TSS too:
                  */
@@ -369,6 +370,7 @@ void flush_thread(void)
                 if (t->flags & _TIF_IA32)
                         current_thread_info()->status |= TS_COMPAT;
         }
+        t->flags &= ~_TIF_DEBUG;
 
         tsk->thread.debugreg0 = 0;
         tsk->thread.debugreg1 = 0;
@@ -461,7 +463,7 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long rsp,
         asm("mov %%es,%0" : "=m" (p->thread.es));
         asm("mov %%ds,%0" : "=m" (p->thread.ds));
 
-        if (unlikely(me->thread.io_bitmap_ptr != NULL)) { 
+        if (unlikely(test_tsk_thread_flag(me, TIF_IO_BITMAP))) {
                 p->thread.io_bitmap_ptr = kmalloc(IO_BITMAP_BYTES, GFP_KERNEL);
                 if (!p->thread.io_bitmap_ptr) {
                         p->thread.io_bitmap_max = 0;
@@ -469,6 +471,7 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long rsp,
                 }
                 memcpy(p->thread.io_bitmap_ptr, me->thread.io_bitmap_ptr,
                                 IO_BITMAP_BYTES);
+                set_tsk_thread_flag(p, TIF_IO_BITMAP);
         } 
 
         /*
@@ -498,6 +501,40 @@ out:
  */
 #define loaddebug(thread,r) set_debugreg(thread->debugreg ## r, r)
 
+static inline void __switch_to_xtra(struct task_struct *prev_p,
+                                    struct task_struct *next_p,
+                                    struct tss_struct *tss)
+{
+        struct thread_struct *prev, *next;
+
+        prev = &prev_p->thread,
+        next = &next_p->thread;
+
+        if (test_tsk_thread_flag(next_p, TIF_DEBUG)) {
+                loaddebug(next, 0);
+                loaddebug(next, 1);
+                loaddebug(next, 2);
+                loaddebug(next, 3);
+                /* no 4 and 5 */
+                loaddebug(next, 6);
+                loaddebug(next, 7);
+        }
+
+        if (test_tsk_thread_flag(next_p, TIF_IO_BITMAP)) {
+                /*
+                 * Copy the relevant range of the IO bitmap.
+                 * Normally this is 128 bytes or less:
+                 */
+                memcpy(tss->io_bitmap, next->io_bitmap_ptr,
+                       max(prev->io_bitmap_max, next->io_bitmap_max));
+        } else if (test_tsk_thread_flag(prev_p, TIF_IO_BITMAP)) {
+                /*
+                 * Clear any possible leftover bits:
+                 */
+                memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
+        }
+}
+
 /*
  *      switch_to(x,y) should switch tasks from x to y.
  *
@@ -586,37 +623,11 @@ __switch_to(struct task_struct *prev_p, struct task_struct *next_p)
                   task_stack_page(next_p) + THREAD_SIZE - PDA_STACKOFFSET);
 
         /*
-         * Now maybe reload the debug registers
+         * Now maybe reload the debug registers and handle I/O bitmaps
          */
-        if (unlikely(next->debugreg7)) {
-                loaddebug(next, 0);
-                loaddebug(next, 1);
-                loaddebug(next, 2);
-                loaddebug(next, 3);
-                /* no 4 and 5 */
-                loaddebug(next, 6);
-                loaddebug(next, 7);
-        }
-
-
-        /* 
-         * Handle the IO bitmap 
-         */ 
-        if (unlikely(prev->io_bitmap_ptr || next->io_bitmap_ptr)) {
-                if (next->io_bitmap_ptr)
-                        /*
-                         * Copy the relevant range of the IO bitmap.
-                         * Normally this is 128 bytes or less:
-                         */
-                        memcpy(tss->io_bitmap, next->io_bitmap_ptr,
-                                max(prev->io_bitmap_max, next->io_bitmap_max));
-                else {
-                        /*
-                         * Clear any possible leftover bits:
-                         */
-                        memset(tss->io_bitmap, 0xff, prev->io_bitmap_max);
-                }
-        }
+        if (unlikely((task_thread_info(next_p)->flags & _TIF_WORK_CTXSW))
+            || test_tsk_thread_flag(prev_p, TIF_IO_BITMAP))
+                __switch_to_xtra(prev_p, next_p, tss);
 
         return prev_p;
 }