The students of INFO-0940 were asked to remove a task from it’s current scheduler class when calling a new syscall and put it back when we call again that syscall. The question is : what to do if the task is currently sleeping? Cause the timer will expire at one moment and maybe put back the state to TASK_RUNNING and run the task which should haven’t been able to run again. So either it expires after the processus is back in its previous scheduler, and that’s okay as it will reset it in a runnable state. Or it expires while it’s still removed, and that’s a problem as it will put it back in its previous state (or not, depending on how the syscall is implemented).
\nWarning : this post is just the result of a quick look. More to give you some ideas and basis for understanding the sleeping mechanism.<\/p>\n
<\/p>\n
So we should try to understand how sleep works.<\/p>\n
<\/p>\n
Let’s look at the nanosleep syscall (which is called when you user sleep() or usleep() functions in C).<\/p>\n
SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,\r\n\t\tstruct timespec __user *, rmtp)\r\n{\r\n\tstruct timespec tu;\r\n\r\n\tif (copy_from_user(&tu, rqtp, sizeof(tu)))\r\n\t\treturn -EFAULT;\r\n\r\n\tif (!timespec_valid(&tu))\r\n\t\treturn -EINVAL;\r\n\r\n\treturn hrtimer_nanosleep(&tu, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);\r\n}<\/pre>\nIt copies the userspace data, check that the time is valid and call hrtimer_nanosleep.<\/p>\n
long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,\r\n\t\t const enum hrtimer_mode mode, const clockid_t clockid)\r\n{\r\n\tstruct restart_block *restart;\r\n\tstruct hrtimer_sleeper t;\r\n\tint ret = 0;\r\n\tunsigned long slack;\r\n\r\n\tslack = current->timer_slack_ns;\r\n\tif (rt_task(current))\r\n\t\tslack = 0;\r\n\r\n\thrtimer_init_on_stack(&t.timer, clockid, mode);\r\n\thrtimer_set_expires_range_ns(&t.timer, timespec_to_ktime(*rqtp), slack);\r\n\tif (do_nanosleep(&t, mode))\r\n\t\tgoto out;\r\n\r\n\t\/* Absolute timers do not update the rmtp value and restart: *\/\r\n\tif (mode == HRTIMER_MODE_ABS) {\r\n\t\tret = -ERESTARTNOHAND;\r\n\t\tgoto out;\r\n\t}\r\n\r\n\tif (rmtp) {\r\n\t\tret = update_rmtp(&t.timer, rmtp);\r\n\t\tif (ret <= 0)\r\n\t\t\tgoto out;\r\n\t}\r\n\r\n\trestart = ¤t_thread_info()->restart_block;\r\n\trestart->fn = hrtimer_nanosleep_restart;\r\n\trestart->nanosleep.clockid = t.timer.base->clockid;\r\n\trestart->nanosleep.rmtp = rmtp;\r\n\trestart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);\r\n\r\n\tret = -ERESTART_RESTARTBLOCK;\r\nout:\r\n\tdestroy_hrtimer_on_stack(&t.timer);\r\n\treturn ret;\r\n}<\/pre>\nIt initialize a timer and call do_nanosleep giving it the timer. After do_nanosleep it will destroy\/free the timer structure.<\/p>\n
static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)\r\n{\r\n\thrtimer_init_sleeper(t, current);\r\n\r\n\tdo {\r\n\t\tset_current_state(TASK_INTERRUPTIBLE);\r\n\t\thrtimer_start_expires(&t->timer, mode);\r\n\t\tif (!hrtimer_active(&t->timer))\r\n\t\t\tt->task = NULL;\r\n\r\n\t\tif (likely(t->task))\r\n\t\t\tschedule();\r\n\r\n\t\thrtimer_cancel(&t->timer);\r\n\t\tmode = HRTIMER_MODE_ABS;\r\n\r\n\t} while (t->task && !signal_pending(current));\r\n\r\n\t__set_current_state(TASK_RUNNING);\r\n\r\n\treturn t->task == NULL;\r\n}<\/pre>\nThis is the interesting part.<\/p>\n
<\/p>\n
The first thing done is calling hrtimer_init_sleeper(); which will set parameters of the timer to call the function hrtimer_wakeup when the timer expires, and specify the task to wakeup at that time. hrtimer_wakeup will simply set the task to NULL and call wake_up_process() on that task. We’ll come back to wake_up_process(task) later.<\/p>\n
<\/p>\n
We see that after that the state is changed to TASK_INTERRUPTIBLE. Then it starts the timer strictly speaking, and go in schedule().<\/p>\n
<\/p>\n
Remember that schedule(), before scheduling a new task, will test the state of the current (which is now “previous”) task, and if the state is not TASK_RUNNING, it will remove that task from its runqueue (and that is the case as it is in the TASK_INTERRUPTIBLE state).<\/p>\n
<\/p>\n
Schedule() goes on and start scheduling another task, if there is not, it will run the “idle” task.<\/p>\n
<\/p>\n
At some point, the timer will expire. The timer rely on an hardware timer which will cause an interrupt, leaving any current task to process the interrupt handler (this is not the schedule() handler and so on !). The interrupt handler for the hardware timer is \u00a0hrtimer_interrupt() which will run\u00a0<\/span>hrtimer_wakeup() for all expired timer. As said before, outr timer for the sleeping mechanism will set the timer task as NULL, and call wake_up_process(). But that functions just put back the process in the runqueue and set its state to TASK_RUNNING, not actually scheduling it. The interrupt handler will finish and the CPU will go back to it’s currently running process (maybe the idle process, running the cpu_idle() function).\u00a0<\/span><\/p>\n <\/p>\n
That currently running process will eventually finish its processing or be preempted (the normal scheduling mechanism), and the process which was sleeping will re-run again when it will be picked again by pick_next_task().<\/p>\n
<\/p>\n
But where will this process restart? After the sleep() or usleep() call? No ! Where it was… in the nanosleep syscall. What does the syscall do after its call to schedule()? Put the state back to TASK_RUNNING and effectively running. That seems obvious as we said before that the syscall is taking care of destroying the timer structure, so it should not restart after the syscall.<\/p>\n
<\/p>\n
Note that I skipped the part where do_nanosleep() is looping and so on… I tried usleep(1) and sleep(1), and the loop never happend. I suspect it’s for very long timers, the kernel would’nt launch a timer of 1 hour long… But it’s just a guess.<\/p>\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
The students of INFO-0940 were asked to remove a task from it’s current scheduler class when calling a new syscall and put it back when we call again that syscall. The question is : what to do if the task is currently sleeping? Cause the timer will expire at one moment and maybe put back … <\/p>\n