€•[i      Œsphinx.addnodes”Œdocument”“”)”}”(Œ	rawsource”Œ ”Œchildren”]”(Œtranslations”ŒLanguagesNode”“”)”}”(hhh]”(h Œpending_xref”“”)”}”(hhh]”Œdocutils.nodes”ŒText”“”ŒChinese (Simplified)”…””}”Œparent”hsbaŒ
attributes”}”(Œids”]”Œclasses”]”Œnames”]”Œdupnames”]”Œbackrefs”]”Œ	refdomain”Œstd”Œreftype”Œdoc”Œ	reftarget”Œ/translations/zh_CN/RCU/UP”Œmodname”NŒ	classname”NŒrefexplicit”ˆuŒtagname”hhhubh)”}”(hhh]”hŒChinese (Traditional)”…””}”hh2sbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ/translations/zh_TW/RCU/UP”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒItalian”…””}”hhFsbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ/translations/it_IT/RCU/UP”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒJapanese”…””}”hhZsbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ/translations/ja_JP/RCU/UP”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒKorean”…””}”hhnsbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ/translations/ko_KR/RCU/UP”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒSpanish”…””}”hh‚sbah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ/translations/sp_SP/RCU/UP”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubeh}”(h]”h ]”h"]”h$]”h&]”Œcurrent_language”ŒEnglish”uh1h
hhŒ	_document”hŒsource”NŒline”NubhŒtarget”“”)”}”(hŒ.. _up_doc:”h]”h}”(h]”h ]”h"]”h$]”h&]”Œrefid”Œup-doc”uh1h¡h KhhhžhhŸŒ4/var/lib/git/docbuild/linux/Documentation/RCU/UP.rst”ubhŒsection”“”)”}”(hhh]”(hŒtitle”“”)”}”(hŒRCU on Uniprocessor Systems”h]”hŒRCU on Uniprocessor Systems”…””}”(hh·hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hµhh²hžhhŸh¯h KubhŒ	paragraph”“”)”}”(hXÿ  A common misconception is that, on UP systems, the call_rcu() primitive
may immediately invoke its function.  The basis of this misconception
is that since there is only one CPU, it should not be necessary to
wait for anything else to get done, since there are no other CPUs for
anything else to be happening on.  Although this approach will *sort of*
work a surprising amount of the time, it is a very bad idea in general.
This document presents three examples that demonstrate exactly how bad
an idea this is.”h]”(hXV  A common misconception is that, on UP systems, the call_rcu() primitive
may immediately invoke its function.  The basis of this misconception
is that since there is only one CPU, it should not be necessary to
wait for anything else to get done, since there are no other CPUs for
anything else to be happening on.  Although this approach will ”…””}”(hhÇhžhhŸNh NubhŒemphasis”“”)”}”(hŒ	*sort of*”h]”hŒsort of”…””}”(hhÑhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhhÇubhŒ 
work a surprising amount of the time, it is a very bad idea in general.
This document presents three examples that demonstrate exactly how bad
an idea this is.”…””}”(hhÇhžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h Khh²hžhubh±)”}”(hhh]”(h¶)”}”(hŒExample 1: softirq Suicide”h]”hŒExample 1: softirq Suicide”…””}”(hhìhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hµhhéhžhhŸh¯h KubhÆ)”}”(hXv  Suppose that an RCU-based algorithm scans a linked list containing
elements A, B, and C in process context, and can delete elements from
this same list in softirq context.  Suppose that the process-context scan
is referencing element B when it is interrupted by softirq processing,
which deletes element B, and then invokes call_rcu() to free element B
after a grace period.”h]”hXv  Suppose that an RCU-based algorithm scans a linked list containing
elements A, B, and C in process context, and can delete elements from
this same list in softirq context.  Suppose that the process-context scan
is referencing element B when it is interrupted by softirq processing,
which deletes element B, and then invokes call_rcu() to free element B
after a grace period.”…””}”(hhúhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KhhéhžhubhÆ)”}”(hŒæNow, if call_rcu() were to directly invoke its arguments, then upon return
from softirq, the list scan would find itself referencing a newly freed
element B.  This situation can greatly decrease the life expectancy of
your kernel.”h]”hŒæNow, if call_rcu() were to directly invoke its arguments, then upon return
from softirq, the list scan would find itself referencing a newly freed
element B.  This situation can greatly decrease the life expectancy of
your kernel.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KhhéhžhubhÆ)”}”(hŒWThis same problem can occur if call_rcu() is invoked from a hardware
interrupt handler.”h]”hŒWThis same problem can occur if call_rcu() is invoked from a hardware
interrupt handler.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h Khhéhžhubeh}”(h]”Œexample-1-softirq-suicide”ah ]”h"]”Œexample 1: softirq suicide”ah$]”h&]”uh1h°hh²hžhhŸh¯h Kubh±)”}”(hhh]”(h¶)”}”(hŒ!Example 2: Function-Call Fatality”h]”hŒ!Example 2: Function-Call Fatality”…””}”(hj/  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hµhj,  hžhhŸh¯h K"ubhÆ)”}”(hŒÕOf course, one could avert the suicide described in the preceding example
by having call_rcu() directly invoke its arguments only if it was called
from process context.  However, this can fail in a similar manner.”h]”hŒÕOf course, one could avert the suicide described in the preceding example
by having call_rcu() directly invoke its arguments only if it was called
from process context.  However, this can fail in a similar manner.”…””}”(hj=  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K$hj,  hžhubhÆ)”}”(hXÈ  Suppose that an RCU-based algorithm again scans a linked list containing
elements A, B, and C in process context, but that it invokes a function
on each element as it is scanned.  Suppose further that this function
deletes element B from the list, then passes it to call_rcu() for deferred
freeing.  This may be a bit unconventional, but it is perfectly legal
RCU usage, since call_rcu() must wait for a grace period to elapse.
Therefore, in this case, allowing call_rcu() to immediately invoke
its arguments would cause it to fail to make the fundamental guarantee
underlying RCU, namely that call_rcu() defers invoking its arguments until
all RCU read-side critical sections currently executing have completed.”h]”hXÈ  Suppose that an RCU-based algorithm again scans a linked list containing
elements A, B, and C in process context, but that it invokes a function
on each element as it is scanned.  Suppose further that this function
deletes element B from the list, then passes it to call_rcu() for deferred
freeing.  This may be a bit unconventional, but it is perfectly legal
RCU usage, since call_rcu() must wait for a grace period to elapse.
Therefore, in this case, allowing call_rcu() to immediately invoke
its arguments would cause it to fail to make the fundamental guarantee
underlying RCU, namely that call_rcu() defers invoking its arguments until
all RCU read-side critical sections currently executing have completed.”…””}”(hjK  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K(hj,  hžhubhŒdefinition_list”“”)”}”(hhh]”hŒdefinition_list_item”“”)”}”(hŒOQuick Quiz #1:
Why is it *not* legal to invoke synchronize_rcu() in this case?
”h]”(hŒterm”“”)”}”(hŒQuick Quiz #1:”h]”hŒQuick Quiz #1:”…””}”(hjf  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1jd  hŸh¯h K4hj`  ubhŒ
definition”“”)”}”(hhh]”hÆ)”}”(hŒ?Why is it *not* legal to invoke synchronize_rcu() in this case?”h]”(hŒ
Why is it ”…””}”(hjy  hžhhŸNh NubhÐ)”}”(hŒ*not*”h]”hŒnot”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhjy  ubhŒ0 legal to invoke synchronize_rcu() in this case?”…””}”(hjy  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K4hjv  ubah}”(h]”h ]”h"]”h$]”h&]”uh1jt  hj`  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1j^  hŸh¯h K4hj[  ubah}”(h]”h ]”h"]”h$]”h&]”uh1jY  hj,  hžhhŸh¯h NubhÆ)”}”(hŒ3:ref:`Answers to Quick Quiz <answer_quick_quiz_up>`”h]”h)”}”(hj­  h]”hŒinline”“”)”}”(hj­  h]”hŒAnswers to Quick Quiz”…””}”(hj´  hžhhŸNh Nubah}”(h]”h ]”(Œxref”Œstd”Œstd-ref”eh"]”h$]”h&]”uh1j²  hj¯  ubah}”(h]”h ]”h"]”h$]”h&]”Œrefdoc”ŒRCU/UP”Œ	refdomain”j¿  Œreftype”Œref”Œrefexplicit”ˆŒrefwarn”ˆŒ	reftarget”Œanswer_quick_quiz_up”uh1hhŸh¯h K6hj«  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K6hj,  hžhubeh}”(h]”Œ example-2-function-call-fatality”ah ]”h"]”Œ!example 2: function-call fatality”ah$]”h&]”uh1h°hh²hžhhŸh¯h K"ubh±)”}”(hhh]”(h¶)”}”(hŒExample 3: Death by Deadlock”h]”hŒExample 3: Death by Deadlock”…””}”(hjä  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hµhjá  hžhhŸh¯h K9ubhÆ)”}”(hX:  Suppose that call_rcu() is invoked while holding a lock, and that the
callback function must acquire this same lock.  In this case, if
call_rcu() were to directly invoke the callback, the result would
be self-deadlock *even if* this invocation occurred from a later
call_rcu() invocation a full grace period later.”h]”(hŒÚSuppose that call_rcu() is invoked while holding a lock, and that the
callback function must acquire this same lock.  In this case, if
call_rcu() were to directly invoke the callback, the result would
be self-deadlock ”…””}”(hjò  hžhhŸNh NubhÐ)”}”(hŒ	*even if*”h]”hŒeven if”…””}”(hjú  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhjò  ubhŒW this invocation occurred from a later
call_rcu() invocation a full grace period later.”…””}”(hjò  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K;hjá  hžhubhÆ)”}”(hŒ³In some cases, it would possible to restructure to code so that
the call_rcu() is delayed until after the lock is released.  However,
there are cases where this can be quite ugly:”h]”hŒ³In some cases, it would possible to restructure to code so that
the call_rcu() is delayed until after the lock is released.  However,
there are cases where this can be quite ugly:”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KAhjá  hžhubhŒenumerated_list”“”)”}”(hhh]”(hŒ	list_item”“”)”}”(hŒ½If a number of items need to be passed to call_rcu() within
the same critical section, then the code would need to create
a list of them, then traverse the list once the lock was
released.
”h]”hÆ)”}”(hŒ¼If a number of items need to be passed to call_rcu() within
the same critical section, then the code would need to create
a list of them, then traverse the list once the lock was
released.”h]”hŒ¼If a number of items need to be passed to call_rcu() within
the same critical section, then the code would need to create
a list of them, then traverse the list once the lock was
released.”…””}”(hj+  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KEhj'  ubah}”(h]”h ]”h"]”h$]”h&]”uh1j%  hj"  hžhhŸh¯h Nubj&  )”}”(hXa  In some cases, the lock will be held across some kernel API,
so that delaying the call_rcu() until the lock is released
requires that the data item be passed up via a common API.
It is far better to guarantee that callbacks are invoked
with no locks held than to have to modify such APIs to allow
arbitrary data items to be passed back up through them.
”h]”hÆ)”}”(hX`  In some cases, the lock will be held across some kernel API,
so that delaying the call_rcu() until the lock is released
requires that the data item be passed up via a common API.
It is far better to guarantee that callbacks are invoked
with no locks held than to have to modify such APIs to allow
arbitrary data items to be passed back up through them.”h]”hX`  In some cases, the lock will be held across some kernel API,
so that delaying the call_rcu() until the lock is released
requires that the data item be passed up via a common API.
It is far better to guarantee that callbacks are invoked
with no locks held than to have to modify such APIs to allow
arbitrary data items to be passed back up through them.”…””}”(hjC  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KJhj?  ubah}”(h]”h ]”h"]”h$]”h&]”uh1j%  hj"  hžhhŸh¯h Nubeh}”(h]”h ]”h"]”h$]”h&]”Œenumtype”Œarabic”Œprefix”hŒsuffix”Œ.”uh1j   hjá  hžhhŸh¯h KEubhÆ)”}”(hŒkIf call_rcu() directly invokes the callback, painful locking restrictions
or API changes would be required.”h]”hŒkIf call_rcu() directly invokes the callback, painful locking restrictions
or API changes would be required.”…””}”(hjb  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KQhjá  hžhubjZ  )”}”(hhh]”j_  )”}”(hŒDQuick Quiz #2:
What locking restriction must RCU callbacks respect?
”h]”(je  )”}”(hŒQuick Quiz #2:”h]”hŒQuick Quiz #2:”…””}”(hjw  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1jd  hŸh¯h KUhjs  ubju  )”}”(hhh]”hÆ)”}”(hŒ4What locking restriction must RCU callbacks respect?”h]”hŒ4What locking restriction must RCU callbacks respect?”…””}”(hjˆ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KUhj…  ubah}”(h]”h ]”h"]”h$]”h&]”uh1jt  hjs  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1j^  hŸh¯h KUhjp  ubah}”(h]”h ]”h"]”h$]”h&]”uh1jY  hjá  hžhhŸh¯h NubhÆ)”}”(hŒ3:ref:`Answers to Quick Quiz <answer_quick_quiz_up>`”h]”h)”}”(hjª  h]”j³  )”}”(hjª  h]”hŒAnswers to Quick Quiz”…””}”(hj¯  hžhhŸNh Nubah}”(h]”h ]”(j¾  Œstd”Œstd-ref”eh"]”h$]”h&]”uh1j²  hj¬  ubah}”(h]”h ]”h"]”h$]”h&]”Œrefdoc”jË  Œ	refdomain”j¹  Œreftype”Œref”Œrefexplicit”ˆŒrefwarn”ˆjÑ  Œanswer_quick_quiz_up”uh1hhŸh¯h KWhj¨  ubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KWhjá  hžhubhÆ)”}”(hXÐ  It is important to note that userspace RCU implementations *do*
permit call_rcu() to directly invoke callbacks, but only if a full
grace period has elapsed since those callbacks were queued.  This is
the case because some userspace environments are extremely constrained.
Nevertheless, people writing userspace RCU implementations are strongly
encouraged to avoid invoking callbacks from call_rcu(), thus obtaining
the deadlock-avoidance benefits called out above.”h]”(hŒ;It is important to note that userspace RCU implementations ”…””}”(hjÑ  hžhhŸNh NubhÐ)”}”(hŒ*do*”h]”hŒdo”…””}”(hjÙ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhjÑ  ubhX‘  
permit call_rcu() to directly invoke callbacks, but only if a full
grace period has elapsed since those callbacks were queued.  This is
the case because some userspace environments are extremely constrained.
Nevertheless, people writing userspace RCU implementations are strongly
encouraged to avoid invoking callbacks from call_rcu(), thus obtaining
the deadlock-avoidance benefits called out above.”…””}”(hjÑ  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h KYhjá  hžhubeh}”(h]”Œexample-3-death-by-deadlock”ah ]”h"]”Œexample 3: death by deadlock”ah$]”h&]”uh1h°hh²hžhhŸh¯h K9ubh±)”}”(hhh]”(h¶)”}”(hŒSummary”h]”hŒSummary”…””}”(hjü  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hµhjù  hžhhŸh¯h KbubhÆ)”}”(hX  Permitting call_rcu() to immediately invoke its arguments breaks RCU,
even on a UP system.  So do not do it!  Even on a UP system, the RCU
infrastructure *must* respect grace periods, and *must* invoke callbacks
from a known environment in which no locks are held.”h]”(hŒšPermitting call_rcu() to immediately invoke its arguments breaks RCU,
even on a UP system.  So do not do it!  Even on a UP system, the RCU
infrastructure ”…””}”(hj
  hžhhŸNh NubhÐ)”}”(hŒ*must*”h]”hŒmust”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhj
  ubhŒ respect grace periods, and ”…””}”(hj
  hžhhŸNh NubhÐ)”}”(hŒ*must*”h]”hŒmust”…””}”(hj$  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhj
  ubhŒF invoke callbacks
from a known environment in which no locks are held.”…””}”(hj
  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h Kdhjù  hžhubhÆ)”}”(hŒ…Note that it *is* safe for synchronize_rcu() to return immediately on
UP systems, including PREEMPT SMP builds running on UP systems.”h]”(hŒNote that it ”…””}”(hj<  hžhhŸNh NubhÐ)”}”(hŒ*is*”h]”hŒis”…””}”(hjD  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhj<  ubhŒt safe for synchronize_rcu() to return immediately on
UP systems, including PREEMPT SMP builds running on UP systems.”…””}”(hj<  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h Kihjù  hžhubjZ  )”}”(hhh]”j_  )”}”(hŒeQuick Quiz #3:
Why can't synchronize_rcu() return immediately on UP systems running
preemptible RCU?
”h]”(je  )”}”(hŒQuick Quiz #3:”h]”hŒQuick Quiz #3:”…””}”(hjc  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1jd  hŸh¯h Knhj_  ubju  )”}”(hhh]”hÆ)”}”(hŒUWhy can't synchronize_rcu() return immediately on UP systems running
preemptible RCU?”h]”hŒWWhy canâ€™t synchronize_rcu() return immediately on UP systems running
preemptible RCU?”…””}”(hjt  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h Kmhjq  ubah}”(h]”h ]”h"]”h$]”h&]”uh1jt  hj_  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1j^  hŸh¯h Knhj\  ubah}”(h]”h ]”h"]”h$]”h&]”uh1jY  hjù  hžhhŸh¯h Nubh¢)”}”(hŒ.. _answer_quick_quiz_up:”h]”h}”(h]”h ]”h"]”h$]”h&]”h­Œanswer-quick-quiz-up”uh1h¡h Kphjù  hžhhŸh¯ubjZ  )”}”(hhh]”(j_  )”}”(hXU  Answer to Quick Quiz #1:
Why is it *not* legal to invoke synchronize_rcu() in this case?

Because the calling function is scanning an RCU-protected linked
list, and is therefore within an RCU read-side critical section.
Therefore, the called function has been invoked within an RCU
read-side critical section, and is not permitted to block.
”h]”(je  )”}”(hŒAnswer to Quick Quiz #1:”h]”hŒAnswer to Quick Quiz #1:”…””}”(hj¦  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1jd  hŸh¯h Kxhj¢  ubju  )”}”(hhh]”(hÆ)”}”(hŒ?Why is it *not* legal to invoke synchronize_rcu() in this case?”h]”(hŒ
Why is it ”…””}”(hj·  hžhhŸNh NubhÐ)”}”(hŒ*not*”h]”hŒnot”…””}”(hj¿  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhj·  ubhŒ0 legal to invoke synchronize_rcu() in this case?”…””}”(hj·  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h Kshj´  ubhÆ)”}”(hŒúBecause the calling function is scanning an RCU-protected linked
list, and is therefore within an RCU read-side critical section.
Therefore, the called function has been invoked within an RCU
read-side critical section, and is not permitted to block.”h]”hŒúBecause the calling function is scanning an RCU-protected linked
list, and is therefore within an RCU read-side critical section.
Therefore, the called function has been invoked within an RCU
read-side critical section, and is not permitted to block.”…””}”(hj×  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h Kuhj´  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1jt  hj¢  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1j^  hŸh¯h KxhjŸ  ubj_  )”}”(hX£  Answer to Quick Quiz #2:
What locking restriction must RCU callbacks respect?

Any lock that is acquired within an RCU callback must be acquired
elsewhere using an _bh variant of the spinlock primitive.
For example, if "mylock" is acquired by an RCU callback, then
a process-context acquisition of this lock must use something
like spin_lock_bh() to acquire the lock.  Please note that
it is also OK to use _irq variants of spinlocks, for example,
spin_lock_irqsave().

If the process-context code were to simply use spin_lock(),
then, since RCU callbacks can be invoked from softirq context,
the callback might be called from a softirq that interrupted
the process-context critical section.  This would result in
self-deadlock.

This restriction might seem gratuitous, since very few RCU
callbacks acquire locks directly.  However, a great many RCU
callbacks do acquire locks *indirectly*, for example, via
the kfree() primitive.
”h]”(je  )”}”(hŒAnswer to Quick Quiz #2:”h]”hŒAnswer to Quick Quiz #2:”…””}”(hjõ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1jd  hŸh¯h KŽhjñ  ubju  )”}”(hhh]”(hÆ)”}”(hŒ4What locking restriction must RCU callbacks respect?”h]”hŒ4What locking restriction must RCU callbacks respect?”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K{hj  ubhÆ)”}”(hX…  Any lock that is acquired within an RCU callback must be acquired
elsewhere using an _bh variant of the spinlock primitive.
For example, if "mylock" is acquired by an RCU callback, then
a process-context acquisition of this lock must use something
like spin_lock_bh() to acquire the lock.  Please note that
it is also OK to use _irq variants of spinlocks, for example,
spin_lock_irqsave().”h]”hX‰  Any lock that is acquired within an RCU callback must be acquired
elsewhere using an _bh variant of the spinlock primitive.
For example, if â€œmylockâ€ is acquired by an RCU callback, then
a process-context acquisition of this lock must use something
like spin_lock_bh() to acquire the lock.  Please note that
it is also OK to use _irq variants of spinlocks, for example,
spin_lock_irqsave().”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K}hj  ubhÆ)”}”(hX  If the process-context code were to simply use spin_lock(),
then, since RCU callbacks can be invoked from softirq context,
the callback might be called from a softirq that interrupted
the process-context critical section.  This would result in
self-deadlock.”h]”hX  If the process-context code were to simply use spin_lock(),
then, since RCU callbacks can be invoked from softirq context,
the callback might be called from a softirq that interrupted
the process-context critical section.  This would result in
self-deadlock.”…””}”(hj"  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K…hj  ubhÆ)”}”(hŒÈThis restriction might seem gratuitous, since very few RCU
callbacks acquire locks directly.  However, a great many RCU
callbacks do acquire locks *indirectly*, for example, via
the kfree() primitive.”h]”(hŒ“This restriction might seem gratuitous, since very few RCU
callbacks acquire locks directly.  However, a great many RCU
callbacks do acquire locks ”…””}”(hj0  hžhhŸNh NubhÐ)”}”(hŒ*indirectly*”h]”hŒ
indirectly”…””}”(hj8  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÏhj0  ubhŒ), for example, via
the kfree() primitive.”…””}”(hj0  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K‹hj  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1jt  hjñ  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1j^  hŸh¯h KŽhjŸ  hžhubj_  )”}”(hX—  Answer to Quick Quiz #3:
Why can't synchronize_rcu() return immediately on UP systems
running preemptible RCU?

Because some other task might have been preempted in the middle
of an RCU read-side critical section.  If synchronize_rcu()
simply immediately returned, it would prematurely signal the
end of the grace period, which would come as a nasty shock to
that other thread when it started running again.”h]”(je  )”}”(hŒAnswer to Quick Quiz #3:”h]”hŒAnswer to Quick Quiz #3:”…””}”(hj`  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1jd  hŸh¯h K—hj\  ubju  )”}”(hhh]”(hÆ)”}”(hŒUWhy can't synchronize_rcu() return immediately on UP systems
running preemptible RCU?”h]”hŒWWhy canâ€™t synchronize_rcu() return immediately on UP systems
running preemptible RCU?”…””}”(hjq  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K‘hjn  ubhÆ)”}”(hX'  Because some other task might have been preempted in the middle
of an RCU read-side critical section.  If synchronize_rcu()
simply immediately returned, it would prematurely signal the
end of the grace period, which would come as a nasty shock to
that other thread when it started running again.”h]”hX'  Because some other task might have been preempted in the middle
of an RCU read-side critical section.  If synchronize_rcu()
simply immediately returned, it would prematurely signal the
end of the grace period, which would come as a nasty shock to
that other thread when it started running again.”…””}”(hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhŸh¯h K”hjn  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1jt  hj\  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1j^  hŸh¯h K—hjŸ  hžhubeh}”(h]”jž  ah ]”h"]”Œanswer_quick_quiz_up”ah$]”h&]”uh1jY  hjù  hžhhŸh¯h NŒexpect_referenced_by_name”}”j  j”  sŒexpect_referenced_by_id”}”jž  j”  subeh}”(h]”Œsummary”ah ]”h"]”Œsummary”ah$]”h&]”uh1h°hh²hžhhŸh¯h Kbubeh}”(h]”(Œrcu-on-uniprocessor-systems”h®eh ]”h"]”(Œrcu on uniprocessor systems”Œup_doc”eh$]”h&]”uh1h°hhhžhhŸh¯h Kj   }”j²  h£sj¢  }”h®h£subeh}”(h]”h ]”h"]”h$]”h&]”Œsource”h¯uh1hŒcurrent_source”NŒcurrent_line”NŒsettings”Œdocutils.frontend”ŒValues”“”)”}”(hµNŒ	generator”NŒ	datestamp”NŒsource_link”NŒ
source_url”NŒtoc_backlinks”Œentry”Œfootnote_backlinks”KŒsectnum_xform”KŒstrip_comments”NŒstrip_elements_with_classes”NŒstrip_classes”NŒreport_level”KŒ
halt_level”KŒexit_status_level”KŒdebug”NŒwarning_stream”NŒ	traceback”ˆŒinput_encoding”Œ	utf-8-sig”Œinput_encoding_error_handler”Œstrict”Œoutput_encoding”Œutf-8”Œoutput_encoding_error_handler”jÚ  Œerror_encoding”Œutf-8”Œerror_encoding_error_handler”Œbackslashreplace”Œlanguage_code”Œen”Œrecord_dependencies”NŒconfig”NŒ	id_prefix”hŒauto_id_prefix”Œid”Œdump_settings”NŒdump_internals”NŒdump_transforms”NŒdump_pseudo_xml”NŒexpose_internals”NŒstrict_visitor”NŒ_disable_config”NŒ_source”h¯Œ_destination”NŒ_config_files”]”Œ7/var/lib/git/docbuild/linux/Documentation/docutils.conf”aŒfile_insertion_enabled”ˆŒraw_enabled”KŒline_length_limit”M'Œpep_references”NŒpep_base_url”Œhttps://peps.python.org/”Œpep_file_url_template”Œpep-%04d”Œrfc_references”NŒrfc_base_url”Œ&https://datatracker.ietf.org/doc/html/”Œ	tab_width”KŒtrim_footnote_reference_space”‰Œsyntax_highlight”Œlong”Œsmart_quotes”ˆŒsmartquotes_locales”]”Œcharacter_level_inline_markup”‰Œdoctitle_xform”‰Œdocinfo_xform”KŒsectsubtitle_xform”‰Œimage_loading”Œlink”Œembed_stylesheet”‰Œcloak_email_addresses”ˆŒsection_self_link”‰Œenv”NubŒreporter”NŒindirect_targets”]”Œsubstitution_defs”}”Œsubstitution_names”}”Œrefnames”}”Œrefids”}”(h®]”h£ajž  ]”j”  auŒnameids”}”(j²  h®j±  j®  j)  j&  jÞ  jÛ  jö  jó  j©  j¦  j  jž  uŒ	nametypes”}”(j²  ˆj±  ‰j)  ‰jÞ  ‰jö  ‰j©  ‰j  ˆuh}”(h®h²j®  h²j&  héjÛ  j,  jó  já  j¦  jù  jž  jŸ  uŒfootnote_refs”}”Œcitation_refs”}”Œautofootnotes”]”Œautofootnote_refs”]”Œsymbol_footnotes”]”Œsymbol_footnote_refs”]”Œ	footnotes”]”Œ	citations”]”Œautofootnote_start”KŒsymbol_footnote_start”K Œ
id_counter”Œcollections”ŒCounter”“”}”…”R”Œparse_messages”]”Œtransform_messages”]”(hŒsystem_message”“”)”}”(hhh]”hÆ)”}”(hhh]”hŒ,Hyperlink target "up-doc" is not referenced.”…””}”hjE  sbah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhjB  ubah}”(h]”h ]”h"]”h$]”h&]”Œlevel”KŒtype”ŒINFO”Œsource”h¯Œline”Kuh1j@  ubjA  )”}”(hhh]”hÆ)”}”(hhh]”hŒ:Hyperlink target "answer-quick-quiz-up" is not referenced.”…””}”hj`  sbah}”(h]”h ]”h"]”h$]”h&]”uh1hÅhj]  ubah}”(h]”h ]”h"]”h$]”h&]”Œlevel”KŒtype”jZ  Œsource”h¯Œline”Kpuh1j@  ubeŒtransformer”NŒinclude_log”]”Œ
decoration”Nhžhub.