asmlinkage long sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp)
    {
        struct timespec t;
        unsigned long expire;
        if(copy_from_user(&t, rqtp, sizeof(struct timespec)))
                return -EFAULT;
        if (t.tv_nsec >= 1000000000L || t.tv_nsec < 0 || t.tv_sec < 0)
                return -EINVAL;
        if (t.tv_sec == 0 && t.tv_nsec <= 2000000L &&
            current->policy != SCHED_OTHER)
        {
                udelay((t.tv_nsec + 999) / 1000);
                return 0;
        }
        expire = timespec_to_jiffies(&t) + (t.tv_sec || t.tv_nsec);
        current->state = TASK_INTERRUPTIBLE;
        expire = schedule_timeout(expire);
        if (expire) {
                if (rmtp) {
                        jiffies_to_timespec(expire, &t);
                        if (copy_to_user(rmtp, &t, sizeof(struct timespec)))
                                return -EFAULT;
                }
                return -EINTR;
        }
        return 0;
    }

1) 参数(struct timespec *rqtp, struct timespec *rmtp)
   rqtp是输入，即要睡眠的时间
   rmtp是输出，即还有多少时间没有睡眠。
2) if (t.tv_sec == 0 && t.tv_nsec <= 2000000L && current->policy != SCHED_OTHER)
   由于时钟中断的频率是100HZ，也就是时钟的精确度是10ms，而要求睡眠的时间小于2毫秒，并且是一个实时的进程，不能让这个进程进入睡眠，因为可能10毫秒之后醒来。
   这里是通过udelay，来消耗2毫秒对应的指令数。然后就完成了睡眠，返回到用户空间了。
3) expire = timespec_to_jiffies(&t) + (t.tv_sec || t.tv_nsec);
   把要睡眠的时间转换成时钟中断的次数。
4) current->state = TASK_INTERRUPTIBLE;
   更改状态。
5) expire = schedule_timeout(expire);
   显示触发一次的调度。
6) if (expire)
   进程已经完成了睡眠，expire是剩余的中断数。转换成时间拷贝到用户空间。

#define udelay(n) (__builtin_constant_p(n) ? \
        ((n) > 20000 ? __bad_udelay() : __const_udelay((n) * 0x10c6ul)) : \
        __udelay(n))

static void __loop_delay(unsigned long loops)
    {
        int d0;
        __asm__ __volatile__(
                "\tjmp 1f\n"
                ".align 16\n"
                "1:\tjmp 2f\n"
                ".align 16\n"
                "2:\tdecl %0\n\tjns 2b"
                :"=&a" (d0)
                :"0" (loops));
    }

最于短时间的delay，通过空转CPU实现。
有些外设要求两次外设操作之间要间隔一定的时间。

signed long schedule_timeout(signed long timeout)
    {
        struct timer_list timer;
        unsigned long expire;
        switch (timeout)
        {
        case MAX_SCHEDULE_TIMEOUT:
                schedule();
                goto out;
        default:
                if (timeout < 0)
                {
                        printk(KERN_ERR "schedule_timeout: wrong timeout "
                               "value %lx from %p\n", timeout,
                               __builtin_return_address(0));
                        current->state = TASK_RUNNING;
                        goto out;
                }
        }
        expire = timeout + jiffies;
        init_timer(&timer);
        timer.expires = expire;
        timer.data = (unsigned long) current;
        timer.function = process_timeout;
        add_timer(&timer);
        schedule();
        del_timer_sync(&timer);
        timeout = expire - jiffies;
    out:
        return timeout < 0 ? 0 : timeout;
    }

1) add_timer(&timer);
   定时器的插入，在每次时钟中断来了后，要能够快速的找到应该处理的定时器，也就是到时时间是当前的jiffies。
2) schedule();
   主动触发一次调度，当前进程在内核态就在schedule里面切换到了另外一个进程了。
   即，当前进程在执行到schedule被切换走了，等到被唤醒才能接着执行。
3) timeout = expire - jiffies;
   执行到这条指令，说明进程已经被唤醒了。计算出剩余的时间并且返回。
   实际上这个进程已经经历了从运行到调度出去，有回到运行的过程。
4) del_timer_sync(&timer);
   进程被唤醒后把timer从全局的定时器桶中删除。
   定时器在时钟中断已经删除了一次，这个地方为什么还是删除呢？原因进程可能收到了信号，提前醒来了。定时器桶没有机会在中断的驱动下被删除。

static inline void internal_add_timer(struct timer_list *timer)
    {
        unsigned long expires = timer->expires;
        unsigned long idx = expires - timer_jiffies;
        struct list_head * vec;
        if (idx < TVR_SIZE) {
                int i = expires & TVR_MASK;
                vec = tv1.vec + i;
        } else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
                int i = (expires >> TVR_BITS) & TVN_MASK;
                vec = tv2.vec + i;
        } else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
                int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
                vec =  tv3.vec + i;
        } else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
                int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
                vec = tv4.vec + i;
        } else if ((signed long) idx < 0) {
                vec = tv1.vec + tv1.index;
        } else if (idx <= 0xffffffffUL) {
                int i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
                vec = tv5.vec + i;
        } else {
                INIT_LIST_HEAD(&timer->list);
                return;
        }
        list_add(&timer->list, vec->prev);
    }

首先在内核中把要到点的时间转换成jiffies来处理。
如何来维护定时器，保证在时间点到了后快速的找到要处理的定时器呢？
内核将32位的expire分解成了 6 + 6 + 6 + 6 + 8 一共5hash表来维护。
v1是最早到时的定时器，v2次之。每次时钟中断来了之后，都从v1中取定时器，并把v1的index往下面移动一位。如果index移动了256次，则从v2中取一批定时器，如果v2的index也走完了64次，则从更高级别的v3中取一批。
这个过程很像进位制，低位的定时器消耗完了，从高位的取一批定时器，把这批定时器分散到低位的操位里。

struct timer_vec {
        int index;
        struct list_head vec[6];
    };
    struct timer_vec_root {
        int index;
        struct list_head vec[8];
    };
    static struct timer_vec tv5;
    static struct timer_vec tv4;
    static struct timer_vec tv3;
    static struct timer_vec tv2;
    static struct timer_vec_root tv1;
    static struct timer_vec * const tvecs[] = {
        (struct timer_vec *)&tv1, &tv2, &tv3, &tv4, &tv5
    };

void timer_bh(void)
    {
        update_times();
        run_timer_list();
   }

这个函数是定时器的全部逻辑，共做了两件事情：
 1) 每当低位的定时器桶走完了256格，或者64格，就从高位‘借位’。
 2) 对指针tv1.index所指向的定时器桶，遍历处理。

static inline void run_timer_list(void)
    {
        spin_lock_irq(&timerlist_lock);
        while ((long)(jiffies - timer_jiffies) >= 0) {
                struct list_head *head, *curr;
                if (!tv1.index) {
                        int n = 1;
                        do {
                                cascade_timers(tvecs[n]);
                        } while (tvecs[n]->index == 1 && ++n < NOOF_TVECS);
                }
    repeat:
                head = tv1.vec + tv1.index;
                curr = head->next;
                if (curr != head) {
                        struct timer_list *timer;
                        void (*fn)(unsigned long);
                        unsigned long data;
                        timer = list_entry(curr, struct timer_list, list);
                         fn = timer->function;
                         data= timer->data;
                        detach_timer(timer);
                        timer->list.next = timer->list.prev = NULL;
                        timer_enter(timer);
                        spin_unlock_irq(&timerlist_lock);
                        fn(data);
                        spin_lock_irq(&timerlist_lock);
                        timer_exit();
                        goto repeat;
                }
                ++timer_jiffies; 
                tv1.index = (tv1.index + 1) & TVR_MASK;
        }
        spin_unlock_irq(&timerlist_lock);
    }

1) if (!tv1.index) {
            int n = 1;
            do {
                    cascade_timers(tvecs[n]);
            } while (tvecs[n]->index == 1 && ++n < NOOF_TVECS);
    }
   每当tv1.index走到0的时候，就从更高位的桶里获取定时器。
2) head = tv1.vec + tv1.index;
   处理指针tv1.index所指向的定时器桶。
3) if (curr != head)
   如果tv1.index所指向的定时器列表非空，则处理所有者个桶上的定时器。

在定时器到时后，会调用schedule_timeout设置的回调函数process_timeout

static void process_timeout(unsigned long __data)
    {
        struct task_struct * p = (struct task_struct *) __data;
        wake_up_process(p);
    }

至此，实现了进程的到时唤醒。把目标进程加入了runqueue中。