[Haifux] SSD and linux

gabik gabik at cs.technion.ac.il
Thu Sep 18 19:56:09 MSD 2008

You can work on 2.6.24 if you prefer. I just picked some version and checked
on it. (for some reason there is no arch/i386 in 2.6.24. Maybe they have
renamed it into x86?)
As for which function to use:
What you want to change is not the place where the io request is done, but
the place where the process puts itself in the wait queue, removes itself
from the runqueue and calls for schedule().
In 2.6.11 this is done in function block_wait_queue_running(q).
I have not checked what q->make_request_fn(q,bio)"  does exactly, but from
your description, it issues a request to the driver. This is probably done
by simply adding some request struct with instruction on what to do to the
driver request data structure (and maybe signaling the driver in some way).
After doing that the process puts itself to sleep (via
When the driver finishes handling the request (A LOT OF time from now), it
raises HW interrupt and this interrupt will wake the waiting process and put
it back in the run queue. Sometime later the process will be scheduled to
run and it will continue from the next place after the call for schedule().
P.S. I think it would be wise to check first what Muli has suggested -
compare times. 


From: Doron Zuckerman [mailto:doron.zuckerman at gmail.com] 
Sent: Thursday, September 18, 2008 6:29 PM
To: gabik; haifux at haifux.org
Cc: Ronen Gruengras
Subject: Re: [Haifux] SSD and linux

Hi Gabi,

First of all thanks for you're help.

We are currently using kernel 2.6.24, and couldn't find any call to the
function "block_wait_queue_running(q)" there. It seems to handle things a
bit differently.

Moreover I looked at the code of kernel 2.6.11 and from what I can
understand, it seems to me like the "block_wait_queue_running(q)" function
only waits on the IO queue for the IO to be ready, and not for the IO
request (reading the page from the disk) to be done (it is called before the
IO request is made).

Correct me if I'm wrong but isn't the call to the function
"q->make_request_fn(q,bio)" what makes the actual request to the device, and
therefore the place which is responsible for waiting for the result of that

I don't mind switching to kernel 2.6.11 (or any other for that matter) as
long as I can make the changes I need.

Ronen & Doron

On Thu, Sep 18, 2008 at 4:49 PM, gabik <gabik at cs.technion.ac.il> wrote:

Hi Doron
The place where the current process goes to sleep and waits until the page
is swapped in is indeed in generic_make_request() (called from submit_bio())
There is a call to block_wait_queue_running(q); which moves this process to
wait and calls for schedule() [prepare_to_wait_exclusive() and after that
Thus, this seems to be a place for a busy loop.
You must be careful though with what you change and make sure not to break
some other code path, that assumes certain things done in this code path.
For example, if you are not going to put this process in the wait queue, you
must be careful what will happen when the io operation will finish and will
want to remove this process from the wait queue and wake it up.
P.S. I was referring to version 2.6.11


From: Doron Zuckerman [mailto:doron.zuckerman at gmail.com
<https://mail.google.com/mail?view=cm&tf=0&to=doron.zuckerman@gmail.com> ] 
Sent: Thursday, September 18, 2008 12:28 PM
To: muli at il.ibm.com
<https://mail.google.com/mail?view=cm&tf=0&to=muli@il.ibm.com> ;
gabik at cs.technion.ac.il
<https://mail.google.com/mail?view=cm&tf=0&to=gabik@cs.technion.ac.il> ;
haifux at haifux.org
Subject: Re: [Haifux] SSD and linux

Hi Gabi and Muli,
I'm sorry about the mistake- you understood me correctly.

I'm not sure it will speed up the OS, however I'm doing an academic research
on the matter as part of a project I'm taking, and I plan to check this
The leading thought was that since the SSD is not a mechanical drive, pages
can be brought faster in this way, and there is no need to context switch,
thus, avoiding the overhead included.

Yes I plan to use the polling system (busy-wait) , and I'm looking for the
kernel part  in the pagefault handling mechanism in which the process is
suspended in order to prevent it.

So far I found the function "__generic_make_request" in file "ll_blk".
This function calls a sub function named "might_sleep".
I have deleted the call to this function whenever I'm in a pagefault,
however I'm not sure if this function casuses the sleep, or is just used for
debugging in order to check if we entered a suspend state.

My question is if this is the function I should change in order to accept
the change I'm willing to get, or if the change should be made in
which, according to my understanding, belongs to the specific driver I'm

Please help me find the specific place I'm looking for that would make the
desired change.

Thank you very much,

On Tue, Sep 16, 2008 at 2:42 PM, gabik <gabik at cs.technion.ac.il
<https://mail.google.com/mail?view=cm&tf=0&to=gabik@cs.technion.ac.il> >

Hello Doron
Why do you think it will speed up the OS?
What do you plan to do until the page is swapped in? Busy loop?
About your solution:
handle_mm_fault is called from within page fault handler (do_page_fault
<http://lxr.linux.no/linux+v2.6.26.5/+code=do_page_fault> ()).
So what is the rational behind calling handle_mm_fault not from inside
pagefault  handler?
Where would you call it from instead and what do you plan to do when you are
in the page fault?
Probably what you meant is, in order not to do context switch due to page
fault, is to call handle_mm_fault as usual, but not to raise need_resched
flag, so as not to trigger a context switch in case of a major page fault.


From: haifux-bounces at haifux.org
[mailto:haifux-bounces at haifux.org
<https://mail.google.com/mail?view=cm&tf=0&to=haifux-bounces@haifux.org> ]
On Behalf Of Doron Zuckerman
Sent: Tuesday, September 16, 2008 12:31 PM
To: haifux at haifux.org
Cc: Ronen Gruengras
Subject: [Haifux] SSD and linux

Hi all,

I have a question regarding the linux kernel (for those of you who are
familiar with it).

I'm looking for a way to add a change to the linux kernel in order to check
if I can make it more compatible with my Asus EEE-PC.
I would like to change the kernel in such way that it will not do a context
switch every time there is a page fault 
and will wait for the required page to be brought from the SSD (Solid State
Drive), then continue as usual.
In Such way, I plan to check if I can fasten the speed of the Operating
System (Ubuntu for EEE).
I thought of adding a TIF flag in the process descriptor (thread_info_32.h)
that will tell me if I'm currently in a pagefault and 
then change the fault_32.c in such way that it will do the
"handle_mm_fault(mm,vma, address, write_;" only if there is no 
pagefault at the moment.
Can you suggest any other solution possible or tell me what you think about
this solution.

I would really appreciate any help with this,

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://haifux.org/pipermail/haifux/attachments/20080918/efcab6a9/attachment.html 

More information about the Haifux mailing list