€•ª¨      Œsphinx.addnodes”Œdocument”“”)”}”(Œ	rawsource”Œ ”Œchildren”]”(Œtranslations”ŒLanguagesNode”“”)”}”(hhh]”(h Œpending_xref”“”)”}”(hhh]”Œdocutils.nodes”ŒText”“”ŒChinese (Simplified)”…””}”(hhŒparent”hubaŒ
attributes”}”(Œids”]”Œclasses”]”Œnames”]”Œdupnames”]”Œbackrefs”]”Œ	refdomain”Œstd”Œreftype”Œdoc”Œ	reftarget”Œ0/translations/zh_CN/power/suspend-and-cpuhotplug”Œmodname”NŒ	classname”NŒrefexplicit”ˆuŒtagname”hhhubh)”}”(hhh]”hŒChinese (Traditional)”…””}”(hhhh2ubah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ0/translations/zh_TW/power/suspend-and-cpuhotplug”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒItalian”…””}”(hhhhFubah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ0/translations/it_IT/power/suspend-and-cpuhotplug”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒJapanese”…””}”(hhhhZubah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ0/translations/ja_JP/power/suspend-and-cpuhotplug”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒKorean”…””}”(hhhhnubah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ0/translations/ko_KR/power/suspend-and-cpuhotplug”Œmodname”NŒ	classname”NŒrefexplicit”ˆuh1hhhubh)”}”(hhh]”hŒSpanish”…””}”(hhhh‚ubah}”(h]”h ]”h"]”h$]”h&]”Œ	refdomain”h)Œreftype”h+Œ	reftarget”Œ0/translations/sp_SP/power/suspend-and-cpuhotplug”Œ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Œsection”“”)”}”(hhh]”(hŒtitle”“”)”}”(hŒDInteraction of Suspend code (S3) with the CPU hotplug infrastructure”h]”hŒDInteraction of Suspend code (S3) with the CPU hotplug infrastructure”…””}”(hhªhh¨hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¦hh£hžhhŸŒJ/var/lib/git/docbuild/linux/Documentation/power/suspend-and-cpuhotplug.rst”h KubhŒenumerated_list”“”)”}”(hhh]”hŒ	list_item”“”)”}”(hŒA2011 - 2014 Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>

”h]”hŒ	paragraph”“”)”}”(hŒ?2011 - 2014 Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>”h]”(hŒ2011 - 2014 Srivatsa S. Bhat <”…””}”(hŒ2011 - 2014 Srivatsa S. Bhat <”hhÄhžhhŸNh NubhŒ	reference”“”)”}”(hŒ srivatsa.bhat@linux.vnet.ibm.com”h]”hŒ srivatsa.bhat@linux.vnet.ibm.com”…””}”(hhhhÏhžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”Œrefuri”Œ'mailto:srivatsa.bhat@linux.vnet.ibm.com”uh1hÍhhÄubhŒ>”…””}”(hŒ>”hhÄhžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Khh¾ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hh¹hžhhŸh¶h Nubah}”(h]”h ]”h"]”h$]”h&]”Œenumtype”Œ
upperalpha”Œprefix”Œ(”Œsuffix”Œ)”Œstart”Kuh1h·hh£hžhhŸh¶h Kubh¢)”}”(hhh]”(h§)”}”(hŒ5I. Differences between CPU hotplug and Suspend-to-RAM”h]”hŒ5I. Differences between CPU hotplug and Suspend-to-RAM”…””}”(hj  hj   hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¦hhýhžhhŸh¶h K	ubhÃ)”}”(hŒHow does the regular CPU hotplug code differ from how the Suspend-to-RAM
infrastructure uses it internally? And where do they share common code?”h]”hŒHow does the regular CPU hotplug code differ from how the Suspend-to-RAM
infrastructure uses it internally? And where do they share common code?”…””}”(hj  hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KhhýhžhubhÃ)”}”(hŒEWell, a picture is worth a thousand words... So ASCII art follows :-)”h]”hŒEWell, a picture is worth a thousand words... So ASCII art follows :-)”…””}”(hj  hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KhhýhžhubhÃ)”}”(hXÖ  [This depicts the current design in the kernel, and focusses only on the
interactions involving the freezer and CPU hotplug and also tries to explain
the locking involved. It outlines the notifications involved as well.
But please note that here, only the call paths are illustrated, with the aim
of describing where they take different paths and where they share code.
What happens when regular CPU hotplug and Suspend-to-RAM race with each other
is not depicted here.]”h]”hXÖ  [This depicts the current design in the kernel, and focusses only on the
interactions involving the freezer and CPU hotplug and also tries to explain
the locking involved. It outlines the notifications involved as well.
But please note that here, only the call paths are illustrated, with the aim
of describing where they take different paths and where they share code.
What happens when regular CPU hotplug and Suspend-to-RAM race with each other
is not depicted here.]”…””}”(hj,  hj*  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KhhýhžhubhÃ)”}”(hŒ:On a high level, the suspend-resume cycle goes like this::”h]”hŒ9On a high level, the suspend-resume cycle goes like this:”…””}”(hŒ9On a high level, the suspend-resume cycle goes like this:”hj8  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KhhýhžhubhŒliteral_block”“”)”}”(hŒ™|Freeze| -> |Disable nonboot| -> |Do suspend| -> |Enable nonboot| -> |Thaw |
|tasks |    |     cpus      |    |          |    |     cpus     |    |tasks|”h]”hŒ™|Freeze| -> |Disable nonboot| -> |Do suspend| -> |Enable nonboot| -> |Thaw |
|tasks |    |     cpus      |    |          |    |     cpus     |    |tasks|”…””}”(hhhjI  ubah}”(h]”h ]”h"]”h$]”h&]”Œ	xml:space”Œpreserve”uh1jG  hŸh¶h KhhýhžhubhÃ)”}”(hŒMore details follow::”h]”hŒMore details follow:”…””}”(hŒMore details follow:”hjY  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KhhýhžhubjH  )”}”(hXJ                                Suspend call path
                              -----------------

                                Write 'mem' to
                              /sys/power/state
                                  sysfs file
                                      |
                                      v
                             Acquire system_transition_mutex lock
                                      |
                                      v
                           Send PM_SUSPEND_PREPARE
                                 notifications
                                      |
                                      v
                                 Freeze tasks
                                      |
                                      |
                                      v
                            freeze_secondary_cpus()
                                 /* start */
                                      |
                                      v
                          Acquire cpu_add_remove_lock
                                      |
                                      v
                           Iterate over CURRENTLY
                                 online CPUs
                                      |
                                      |
                                      |                ----------
                                      v                          | L
           ======>               _cpu_down()                     |
          |              [This takes cpuhotplug.lock             |
Common    |               before taking down the CPU             |
 code     |               and releases it when done]             | O
          |            While it is at it, notifications          |
          |            are sent when notable events occur,       |
           ======>     by running all registered callbacks.      |
                                      |                          | O
                                      |                          |
                                      |                          |
                                      v                          |
                          Note down these cpus in                | P
                              frozen_cpus mask         ----------
                                      |
                                      v
                         Disable regular cpu hotplug
                      by increasing cpu_hotplug_disabled
                                      |
                                      v
                          Release cpu_add_remove_lock
                                      |
                                      v
                     /* freeze_secondary_cpus() complete */
                                      |
                                      v
                                 Do suspend”h]”hXJ                                Suspend call path
                              -----------------

                                Write 'mem' to
                              /sys/power/state
                                  sysfs file
                                      |
                                      v
                             Acquire system_transition_mutex lock
                                      |
                                      v
                           Send PM_SUSPEND_PREPARE
                                 notifications
                                      |
                                      v
                                 Freeze tasks
                                      |
                                      |
                                      v
                            freeze_secondary_cpus()
                                 /* start */
                                      |
                                      v
                          Acquire cpu_add_remove_lock
                                      |
                                      v
                           Iterate over CURRENTLY
                                 online CPUs
                                      |
                                      |
                                      |                ----------
                                      v                          | L
           ======>               _cpu_down()                     |
          |              [This takes cpuhotplug.lock             |
Common    |               before taking down the CPU             |
 code     |               and releases it when done]             | O
          |            While it is at it, notifications          |
          |            are sent when notable events occur,       |
           ======>     by running all registered callbacks.      |
                                      |                          | O
                                      |                          |
                                      |                          |
                                      v                          |
                          Note down these cpus in                | P
                              frozen_cpus mask         ----------
                                      |
                                      v
                         Disable regular cpu hotplug
                      by increasing cpu_hotplug_disabled
                                      |
                                      v
                          Release cpu_add_remove_lock
                                      |
                                      v
                     /* freeze_secondary_cpus() complete */
                                      |
                                      v
                                 Do suspend”…””}”(hhhjh  ubah}”(h]”h ]”h"]”h$]”h&]”jW  jX  uh1jG  hŸh¶h K hhýhžhubhÃ)”}”(hŒaResuming back is likewise, with the counterparts being (in the order of
execution during resume):”h]”hŒaResuming back is likewise, with the counterparts being (in the order of
execution during resume):”…””}”(hjx  hjv  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K]hhýhžhubhŒbullet_list”“”)”}”(hhh]”(h½)”}”(hŒþthaw_secondary_cpus() which involves::

 |  Acquire cpu_add_remove_lock
 |  Decrease cpu_hotplug_disabled, thereby enabling regular cpu hotplug
 |  Call _cpu_up() [for all those cpus in the frozen_cpus mask, in a loop]
 |  Release cpu_add_remove_lock
 v
”h]”(hÃ)”}”(hŒ&thaw_secondary_cpus() which involves::”h]”hŒ%thaw_secondary_cpus() which involves:”…””}”(hŒ%thaw_secondary_cpus() which involves:”hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K`hj‰  ubjH  )”}”(hŒÐ|  Acquire cpu_add_remove_lock
|  Decrease cpu_hotplug_disabled, thereby enabling regular cpu hotplug
|  Call _cpu_up() [for all those cpus in the frozen_cpus mask, in a loop]
|  Release cpu_add_remove_lock
v”h]”hŒÐ|  Acquire cpu_add_remove_lock
|  Decrease cpu_hotplug_disabled, thereby enabling regular cpu hotplug
|  Call _cpu_up() [for all those cpus in the frozen_cpus mask, in a loop]
|  Release cpu_add_remove_lock
v”…””}”(hhhjœ  ubah}”(h]”h ]”h"]”h$]”h&]”jW  jX  uh1jG  hŸh¶h Kbhj‰  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj†  hžhhŸh¶h Nubh½)”}”(hŒ
thaw tasks”h]”hÃ)”}”(hj²  h]”hŒ
thaw tasks”…””}”(hj²  hj´  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Khhj°  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj†  hžhhŸh¶h Nubh½)”}”(hŒ"send PM_POST_SUSPEND notifications”h]”hÃ)”}”(hjÉ  h]”hŒ"send PM_POST_SUSPEND notifications”…””}”(hjÉ  hjË  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KihjÇ  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj†  hžhhŸh¶h Nubh½)”}”(hŒ'Release system_transition_mutex lock.

”h]”hÃ)”}”(hŒ%Release system_transition_mutex lock.”h]”hŒ%Release system_transition_mutex lock.”…””}”(hjä  hjâ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KjhjÞ  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj†  hžhhŸh¶h Nubeh}”(h]”h ]”h"]”h$]”h&]”Œbullet”Œ*”uh1j„  hŸh¶h K`hhýhžhubhÃ)”}”(hŒÝIt is to be noted here that the system_transition_mutex lock is acquired at the
very beginning, when we are just starting out to suspend, and then released only
after the entire cycle is complete (i.e., suspend + resume).”h]”hŒÝIt is to be noted here that the system_transition_mutex lock is acquired at the
very beginning, when we are just starting out to suspend, and then released only
after the entire cycle is complete (i.e., suspend + resume).”…””}”(hj   hjþ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KmhhýhžhubjH  )”}”(hXÝ                          Regular CPU hotplug call path
                        -----------------------------

                              Write 0 (or 1) to
                     /sys/devices/system/cpu/cpu*/online
                                  sysfs file
                                      |
                                      |
                                      v
                                  cpu_down()
                                      |
                                      v
                         Acquire cpu_add_remove_lock
                                      |
                                      v
                        If cpu_hotplug_disabled > 0
                              return gracefully
                                      |
                                      |
                                      v
           ======>                _cpu_down()
          |              [This takes cpuhotplug.lock
Common    |               before taking down the CPU
 code     |               and releases it when done]
          |            While it is at it, notifications
          |           are sent when notable events occur,
           ======>    by running all registered callbacks.
                                      |
                                      |
                                      v
                        Release cpu_add_remove_lock
                             [That's it!, for
                            regular CPU hotplug]”h]”hXÝ                          Regular CPU hotplug call path
                        -----------------------------

                              Write 0 (or 1) to
                     /sys/devices/system/cpu/cpu*/online
                                  sysfs file
                                      |
                                      |
                                      v
                                  cpu_down()
                                      |
                                      v
                         Acquire cpu_add_remove_lock
                                      |
                                      v
                        If cpu_hotplug_disabled > 0
                              return gracefully
                                      |
                                      |
                                      v
           ======>                _cpu_down()
          |              [This takes cpuhotplug.lock
Common    |               before taking down the CPU
 code     |               and releases it when done]
          |            While it is at it, notifications
          |           are sent when notable events occur,
           ======>    by running all registered callbacks.
                                      |
                                      |
                                      v
                        Release cpu_add_remove_lock
                             [That's it!, for
                            regular CPU hotplug]”…””}”(hhhj  ubah}”(h]”h ]”h"]”h$]”h&]”jW  jX  uh1jG  hŸh¶h KuhhýhžhubhÃ)”}”(hX&  So, as can be seen from the two diagrams (the parts marked as "Common code"),
regular CPU hotplug and the suspend code path converge at the _cpu_down() and
_cpu_up() functions. They differ in the arguments passed to these functions,
in that during regular CPU hotplug, 0 is passed for the 'tasks_frozen'
argument. But during suspend, since the tasks are already frozen by the time
the non-boot CPUs are offlined or onlined, the _cpu_*() functions are called
with the 'tasks_frozen' argument set to 1.
[See below for some known issues regarding this.]”h]”hX2  So, as can be seen from the two diagrams (the parts marked as â€œCommon codeâ€),
regular CPU hotplug and the suspend code path converge at the _cpu_down() and
_cpu_up() functions. They differ in the arguments passed to these functions,
in that during regular CPU hotplug, 0 is passed for the â€˜tasks_frozenâ€™
argument. But during suspend, since the tasks are already frozen by the time
the non-boot CPUs are offlined or onlined, the _cpu_*() functions are called
with the â€˜tasks_frozenâ€™ argument set to 1.
[See below for some known issues regarding this.]”…””}”(hj  hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K™hhýhžhubh¢)”}”(hhh]”(h§)”}”(hŒ+Important files and functions/entry points:”h]”hŒ+Important files and functions/entry points:”…””}”(hj-  hj+  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¦hj(  hžhhŸh¶h K¤ubj…  )”}”(hhh]”(h½)”}”(hŒ=kernel/power/process.c : freeze_processes(), thaw_processes()”h]”hÃ)”}”(hj>  h]”hŒ=kernel/power/process.c : freeze_processes(), thaw_processes()”…””}”(hj>  hj@  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K¦hj<  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj9  hžhhŸh¶h Nubh½)”}”(hŒMkernel/power/suspend.c : suspend_prepare(), suspend_enter(), suspend_finish()”h]”hÃ)”}”(hjU  h]”hŒMkernel/power/suspend.c : suspend_prepare(), suspend_enter(), suspend_finish()”…””}”(hjU  hjW  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K§hjS  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj9  hžhhŸh¶h Nubh½)”}”(hŒSkernel/cpu.c: cpu_[up|down](), _cpu_[up|down](),
[disable|enable]_nonboot_cpus()


”h]”hÃ)”}”(hŒPkernel/cpu.c: cpu_[up|down](), _cpu_[up|down](),
[disable|enable]_nonboot_cpus()”h]”hŒPkernel/cpu.c: cpu_[up|down](), _cpu_[up|down](),
[disable|enable]_nonboot_cpus()”…””}”(hjp  hjn  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K¨hjj  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj9  hžhhŸh¶h Nubeh}”(h]”h ]”h"]”h$]”h&]”jü  Œ-”uh1j„  hŸh¶h K¦hj(  hžhubeh}”(h]”Œ*important-files-and-functions-entry-points”ah ]”h"]”Œ+important files and functions/entry points:”ah$]”h&]”uh1h¡hhýhžhhŸh¶h K¤ubh¢)”}”(hhh]”(h§)”}”(hŒ0II. What are the issues involved in CPU hotplug?”h]”hŒ0II. What are the issues involved in CPU hotplug?”…””}”(hj–  hj”  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¦hj‘  hžhhŸh¶h K®ubhÃ)”}”(hŒqThere are some interesting situations involving CPU hotplug and microcode
update on the CPUs, as discussed below:”h]”hŒqThere are some interesting situations involving CPU hotplug and microcode
update on the CPUs, as discussed below:”…””}”(hj¤  hj¢  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K°hj‘  hžhubhÃ)”}”(hŒ¨[Please bear in mind that the kernel requests the microcode images from
userspace, using the request_firmware() function defined in
drivers/base/firmware_loader/main.c]”h]”hŒ¨[Please bear in mind that the kernel requests the microcode images from
userspace, using the request_firmware() function defined in
drivers/base/firmware_loader/main.c]”…””}”(hj²  hj°  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K³hj‘  hžhubh¸)”}”(hhh]”(h½)”}”(hXù  When all the CPUs are identical:

This is the most common situation and it is quite straightforward: we want
to apply the same microcode revision to each of the CPUs.
To give an example of x86, the collect_cpu_info() function defined in
arch/x86/kernel/microcode_core.c helps in discovering the type of the CPU
and thereby in applying the correct microcode revision to it.
But note that the kernel does not maintain a common microcode image for the
all CPUs, in order to handle case 'b' described below.

”h]”(hÃ)”}”(hŒ When all the CPUs are identical:”h]”hŒ When all the CPUs are identical:”…””}”(hjÇ  hjÅ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h K¸hjÁ  ubhÃ)”}”(hXÕ  This is the most common situation and it is quite straightforward: we want
to apply the same microcode revision to each of the CPUs.
To give an example of x86, the collect_cpu_info() function defined in
arch/x86/kernel/microcode_core.c helps in discovering the type of the CPU
and thereby in applying the correct microcode revision to it.
But note that the kernel does not maintain a common microcode image for the
all CPUs, in order to handle case 'b' described below.”h]”hXÙ  This is the most common situation and it is quite straightforward: we want
to apply the same microcode revision to each of the CPUs.
To give an example of x86, the collect_cpu_info() function defined in
arch/x86/kernel/microcode_core.c helps in discovering the type of the CPU
and thereby in applying the correct microcode revision to it.
But note that the kernel does not maintain a common microcode image for the
all CPUs, in order to handle case â€˜bâ€™ described below.”…””}”(hjÕ  hjÓ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KºhjÁ  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj¾  hžhhŸh¶h Nubh½)”}”(hX4  When some of the CPUs are different than the rest:

In this case since we probably need to apply different microcode revisions
to different CPUs, the kernel maintains a copy of the correct microcode
image for each CPU (after appropriate CPU type/model discovery using
functions such as collect_cpu_info()).

”h]”(hÃ)”}”(hŒ2When some of the CPUs are different than the rest:”h]”hŒ2When some of the CPUs are different than the rest:”…””}”(hjí  hjë  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KÃhjç  ubhÃ)”}”(hŒþIn this case since we probably need to apply different microcode revisions
to different CPUs, the kernel maintains a copy of the correct microcode
image for each CPU (after appropriate CPU type/model discovery using
functions such as collect_cpu_info()).”h]”hŒþIn this case since we probably need to apply different microcode revisions
to different CPUs, the kernel maintains a copy of the correct microcode
image for each CPU (after appropriate CPU type/model discovery using
functions such as collect_cpu_info()).”…””}”(hjû  hjù  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KÅhjç  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj¾  hžhhŸh¶h Nubh½)”}”(hX‰  When a CPU is physically hot-unplugged and a new (and possibly different
type of) CPU is hot-plugged into the system:

In the current design of the kernel, whenever a CPU is taken offline during
a regular CPU hotplug operation, upon receiving the CPU_DEAD notification
(which is sent by the CPU hotplug code), the microcode update driver's
callback for that event reacts by freeing the kernel's copy of the
microcode image for that CPU.

Hence, when a new CPU is brought online, since the kernel finds that it
doesn't have the microcode image, it does the CPU type/model discovery
afresh and then requests the userspace for the appropriate microcode image
for that CPU, which is subsequently applied.

For example, in x86, the mc_cpu_callback() function (which is the microcode
update driver's callback registered for CPU hotplug events) calls
microcode_update_cpu() which would call microcode_init_cpu() in this case,
instead of microcode_resume_cpu() when it finds that the kernel doesn't
have a valid microcode image. This ensures that the CPU type/model
discovery is performed and the right microcode is applied to the CPU after
getting it from userspace.

”h]”(hÃ)”}”(hŒuWhen a CPU is physically hot-unplugged and a new (and possibly different
type of) CPU is hot-plugged into the system:”h]”hŒuWhen a CPU is physically hot-unplugged and a new (and possibly different
type of) CPU is hot-plugged into the system:”…””}”(hj  hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KËhj  ubhÃ)”}”(hX=  In the current design of the kernel, whenever a CPU is taken offline during
a regular CPU hotplug operation, upon receiving the CPU_DEAD notification
(which is sent by the CPU hotplug code), the microcode update driver's
callback for that event reacts by freeing the kernel's copy of the
microcode image for that CPU.”h]”hXA  In the current design of the kernel, whenever a CPU is taken offline during
a regular CPU hotplug operation, upon receiving the CPU_DEAD notification
(which is sent by the CPU hotplug code), the microcode update driverâ€™s
callback for that event reacts by freeing the kernelâ€™s copy of the
microcode image for that CPU.”…””}”(hj!  hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KÎhj  ubhÃ)”}”(hX  Hence, when a new CPU is brought online, since the kernel finds that it
doesn't have the microcode image, it does the CPU type/model discovery
afresh and then requests the userspace for the appropriate microcode image
for that CPU, which is subsequently applied.”h]”hX  Hence, when a new CPU is brought online, since the kernel finds that it
doesnâ€™t have the microcode image, it does the CPU type/model discovery
afresh and then requests the userspace for the appropriate microcode image
for that CPU, which is subsequently applied.”…””}”(hj/  hj-  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KÔhj  ubhÃ)”}”(hXÉ  For example, in x86, the mc_cpu_callback() function (which is the microcode
update driver's callback registered for CPU hotplug events) calls
microcode_update_cpu() which would call microcode_init_cpu() in this case,
instead of microcode_resume_cpu() when it finds that the kernel doesn't
have a valid microcode image. This ensures that the CPU type/model
discovery is performed and the right microcode is applied to the CPU after
getting it from userspace.”h]”hXÍ  For example, in x86, the mc_cpu_callback() function (which is the microcode
update driverâ€™s callback registered for CPU hotplug events) calls
microcode_update_cpu() which would call microcode_init_cpu() in this case,
instead of microcode_resume_cpu() when it finds that the kernel doesnâ€™t
have a valid microcode image. This ensures that the CPU type/model
discovery is performed and the right microcode is applied to the CPU after
getting it from userspace.”…””}”(hj=  hj;  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KÙhj  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj¾  hžhhŸh¶h Nubh½)”}”(hX   Handling microcode update during suspend/hibernate:

Strictly speaking, during a CPU hotplug operation which does not involve
physically removing or inserting CPUs, the CPUs are not actually powered
off during a CPU offline. They are just put to the lowest C-states possible.
Hence, in such a case, it is not really necessary to re-apply microcode
when the CPUs are brought back online, since they wouldn't have lost the
image during the CPU offline operation.

This is the usual scenario encountered during a resume after a suspend.
However, in the case of hibernation, since all the CPUs are completely
powered off, during restore it becomes necessary to apply the microcode
images to all the CPUs.

[Note that we don't expect someone to physically pull out nodes and insert
nodes with a different type of CPUs in-between a suspend-resume or a
hibernate/restore cycle.]

In the current design of the kernel however, during a CPU offline operation
as part of the suspend/hibernate cycle (cpuhp_tasks_frozen is set),
the existing copy of microcode image in the kernel is not freed up.
And during the CPU online operations (during resume/restore), since the
kernel finds that it already has copies of the microcode images for all the
CPUs, it just applies them to the CPUs, avoiding any re-discovery of CPU
type/model and the need for validating whether the microcode revisions are
right for the CPUs or not (due to the above assumption that physical CPU
hotplug will not be done in-between suspend/resume or hibernate/restore
cycles).

”h]”(hÃ)”}”(hŒ3Handling microcode update during suspend/hibernate:”h]”hŒ3Handling microcode update during suspend/hibernate:”…””}”(hjU  hjS  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KâhjO  ubhÃ)”}”(hX—  Strictly speaking, during a CPU hotplug operation which does not involve
physically removing or inserting CPUs, the CPUs are not actually powered
off during a CPU offline. They are just put to the lowest C-states possible.
Hence, in such a case, it is not really necessary to re-apply microcode
when the CPUs are brought back online, since they wouldn't have lost the
image during the CPU offline operation.”h]”hX™  Strictly speaking, during a CPU hotplug operation which does not involve
physically removing or inserting CPUs, the CPUs are not actually powered
off during a CPU offline. They are just put to the lowest C-states possible.
Hence, in such a case, it is not really necessary to re-apply microcode
when the CPUs are brought back online, since they wouldnâ€™t have lost the
image during the CPU offline operation.”…””}”(hjc  hja  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KähjO  ubhÃ)”}”(hŒîThis is the usual scenario encountered during a resume after a suspend.
However, in the case of hibernation, since all the CPUs are completely
powered off, during restore it becomes necessary to apply the microcode
images to all the CPUs.”h]”hŒîThis is the usual scenario encountered during a resume after a suspend.
However, in the case of hibernation, since all the CPUs are completely
powered off, during restore it becomes necessary to apply the microcode
images to all the CPUs.”…””}”(hjq  hjo  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KëhjO  ubhÃ)”}”(hŒ©[Note that we don't expect someone to physically pull out nodes and insert
nodes with a different type of CPUs in-between a suspend-resume or a
hibernate/restore cycle.]”h]”hŒ«[Note that we donâ€™t expect someone to physically pull out nodes and insert
nodes with a different type of CPUs in-between a suspend-resume or a
hibernate/restore cycle.]”…””}”(hj  hj}  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KðhjO  ubhÃ)”}”(hX•  In the current design of the kernel however, during a CPU offline operation
as part of the suspend/hibernate cycle (cpuhp_tasks_frozen is set),
the existing copy of microcode image in the kernel is not freed up.
And during the CPU online operations (during resume/restore), since the
kernel finds that it already has copies of the microcode images for all the
CPUs, it just applies them to the CPUs, avoiding any re-discovery of CPU
type/model and the need for validating whether the microcode revisions are
right for the CPUs or not (due to the above assumption that physical CPU
hotplug will not be done in-between suspend/resume or hibernate/restore
cycles).”h]”hX•  In the current design of the kernel however, during a CPU offline operation
as part of the suspend/hibernate cycle (cpuhp_tasks_frozen is set),
the existing copy of microcode image in the kernel is not freed up.
And during the CPU online operations (during resume/restore), since the
kernel finds that it already has copies of the microcode images for all the
CPUs, it just applies them to the CPUs, avoiding any re-discovery of CPU
type/model and the need for validating whether the microcode revisions are
right for the CPUs or not (due to the above assumption that physical CPU
hotplug will not be done in-between suspend/resume or hibernate/restore
cycles).”…””}”(hj  hj‹  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h KôhjO  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj¾  hžhhŸh¶h Nubeh}”(h]”h ]”h"]”h$]”h&]”höŒ
loweralpha”høhhúŒ.”uh1h·hj‘  hžhhŸh¶h K¸ubeh}”(h]”Œ.ii-what-are-the-issues-involved-in-cpu-hotplug”ah ]”h"]”Œ0ii. what are the issues involved in cpu hotplug?”ah$]”h&]”uh1h¡hhýhžhhŸh¶h K®ubeh}”(h]”Œ4i-differences-between-cpu-hotplug-and-suspend-to-ram”ah ]”h"]”Œ5i. differences between cpu hotplug and suspend-to-ram”ah$]”h&]”uh1h¡hh£hžhhŸh¶h K	ubh¢)”}”(hhh]”(h§)”}”(hŒIII. Known problems”h]”hŒIII. Known problems”…””}”(hj¼  hjº  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1h¦hj·  hžhhŸh¶h MubhÃ)”}”(hŒWAre there any known problems when regular CPU hotplug and suspend race
with each other?”h]”hŒWAre there any known problems when regular CPU hotplug and suspend race
with each other?”…””}”(hjÊ  hjÈ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhj·  hžhubhÃ)”}”(hŒYes, they are listed below:”h]”hŒYes, they are listed below:”…””}”(hjØ  hjÖ  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhj·  hžhubh¸)”}”(hhh]”(h½)”}”(hXÌ  When invoking regular CPU hotplug, the 'tasks_frozen' argument passed to
the _cpu_down() and _cpu_up() functions is *always* 0.
This might not reflect the true current state of the system, since the
tasks could have been frozen by an out-of-band event such as a suspend
operation in progress. Hence, the cpuhp_tasks_frozen variable will not
reflect the frozen state and the CPU hotplug callbacks which evaluate
that variable might execute the wrong code path.
”h]”hÃ)”}”(hXË  When invoking regular CPU hotplug, the 'tasks_frozen' argument passed to
the _cpu_down() and _cpu_up() functions is *always* 0.
This might not reflect the true current state of the system, since the
tasks could have been frozen by an out-of-band event such as a suspend
operation in progress. Hence, the cpuhp_tasks_frozen variable will not
reflect the frozen state and the CPU hotplug callbacks which evaluate
that variable might execute the wrong code path.”h]”(hŒxWhen invoking regular CPU hotplug, the â€˜tasks_frozenâ€™ argument passed to
the _cpu_down() and _cpu_up() functions is ”…””}”(hŒtWhen invoking regular CPU hotplug, the 'tasks_frozen' argument passed to
the _cpu_down() and _cpu_up() functions is ”hjë  hžhhŸNh NubhŒemphasis”“”)”}”(hŒ*always*”h]”hŒalways”…””}”(hhhjö  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1jô  hjë  ubhXO   0.
This might not reflect the true current state of the system, since the
tasks could have been frozen by an out-of-band event such as a suspend
operation in progress. Hence, the cpuhp_tasks_frozen variable will not
reflect the frozen state and the CPU hotplug callbacks which evaluate
that variable might execute the wrong code path.”…””}”(hXO   0.
This might not reflect the true current state of the system, since the
tasks could have been frozen by an out-of-band event such as a suspend
operation in progress. Hence, the cpuhp_tasks_frozen variable will not
reflect the frozen state and the CPU hotplug callbacks which evaluate
that variable might execute the wrong code path.”hjë  hžhhŸNh Nubeh}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhjç  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hjä  hžhhŸh¶h Nubh½)”}”(hXT  If a regular CPU hotplug stress test happens to race with the freezer due
to a suspend operation in progress at the same time, then we could hit the
situation described below:

 * A regular cpu online operation continues its journey from userspace
   into the kernel, since the freezing has not yet begun.
 * Then freezer gets to work and freezes userspace.
 * If cpu online has not yet completed the microcode update stuff by now,
   it will now start waiting on the frozen userspace in the
   TASK_UNINTERRUPTIBLE state, in order to get the microcode image.
 * Now the freezer continues and tries to freeze the remaining tasks. But
   due to this wait mentioned above, the freezer won't be able to freeze
   the cpu online hotplug task and hence freezing of tasks fails.

As a result of this task freezing failure, the suspend operation gets
aborted.”h]”(hÃ)”}”(hŒ¯If a regular CPU hotplug stress test happens to race with the freezer due
to a suspend operation in progress at the same time, then we could hit the
situation described below:”h]”hŒ¯If a regular CPU hotplug stress test happens to race with the freezer due
to a suspend operation in progress at the same time, then we could hit the
situation described below:”…””}”(hj  hj  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhj  ubhŒblock_quote”“”)”}”(hhh]”j…  )”}”(hhh]”(h½)”}”(hŒzA regular cpu online operation continues its journey from userspace
into the kernel, since the freezing has not yet begun.”h]”hÃ)”}”(hŒzA regular cpu online operation continues its journey from userspace
into the kernel, since the freezing has not yet begun.”h]”hŒzA regular cpu online operation continues its journey from userspace
into the kernel, since the freezing has not yet begun.”…””}”(hj5  hj3  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhj/  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj,  ubh½)”}”(hŒ0Then freezer gets to work and freezes userspace.”h]”hÃ)”}”(hjI  h]”hŒ0Then freezer gets to work and freezes userspace.”…””}”(hjI  hjK  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h MhjG  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj,  ubh½)”}”(hŒÀIf cpu online has not yet completed the microcode update stuff by now,
it will now start waiting on the frozen userspace in the
TASK_UNINTERRUPTIBLE state, in order to get the microcode image.”h]”hÃ)”}”(hŒÀIf cpu online has not yet completed the microcode update stuff by now,
it will now start waiting on the frozen userspace in the
TASK_UNINTERRUPTIBLE state, in order to get the microcode image.”h]”hŒÀIf cpu online has not yet completed the microcode update stuff by now,
it will now start waiting on the frozen userspace in the
TASK_UNINTERRUPTIBLE state, in order to get the microcode image.”…””}”(hjd  hjb  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhj^  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj,  ubh½)”}”(hŒÌNow the freezer continues and tries to freeze the remaining tasks. But
due to this wait mentioned above, the freezer won't be able to freeze
the cpu online hotplug task and hence freezing of tasks fails.
”h]”hÃ)”}”(hŒËNow the freezer continues and tries to freeze the remaining tasks. But
due to this wait mentioned above, the freezer won't be able to freeze
the cpu online hotplug task and hence freezing of tasks fails.”h]”hŒÍNow the freezer continues and tries to freeze the remaining tasks. But
due to this wait mentioned above, the freezer wonâ€™t be able to freeze
the cpu online hotplug task and hence freezing of tasks fails.”…””}”(hj|  hjz  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhjv  ubah}”(h]”h ]”h"]”h$]”h&]”uh1h¼hj,  ubeh}”(h]”h ]”h"]”h$]”h&]”jü  jý  uh1j„  hŸh¶h Mhj)  ubah}”(h]”h ]”h"]”h$]”h&]”uh1j'  hj  ubhÃ)”}”(hŒNAs a result of this task freezing failure, the suspend operation gets
aborted.”h]”hŒNAs a result of this task freezing failure, the suspend operation gets
aborted.”…””}”(hjœ  hjš  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhŸh¶h Mhj  ubeh}”(h]”h ]”h"]”h$]”h&]”uh1h¼hjä  hžhhŸh¶h Nubeh}”(h]”h ]”h"]”h$]”h&]”höŒarabic”høhhúj¦  uh1h·hj·  hžhhŸh¶h Mubeh}”(h]”Œiii-known-problems”ah ]”h"]”Œiii. known problems”ah$]”h&]”uh1h¡hh£hžhhŸh¶h Mubeh}”(h]”ŒBinteraction-of-suspend-code-s3-with-the-cpu-hotplug-infrastructure”ah ]”h"]”ŒDinteraction of suspend code (s3) with the cpu hotplug infrastructure”ah$]”h&]”uh1h¡hhhžhhŸh¶h Kubeh}”(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Œ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”‰Œfile_insertion_enabled”ˆŒraw_enabled”KŒline_length_limit”M'Œ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”‰Œembed_images”‰Œenv”NubŒreporter”NŒindirect_targets”]”Œsubstitution_defs”}”Œsubstitution_names”}”Œrefnames”}”Œrefids”}”Œnameids”}”(jÂ  j¿  j´  j±  jŽ  j‹  j¬  j©  jº  j·  uŒ	nametypes”}”(jÂ  Nj´  NjŽ  Nj¬  Njº  Nuh}”(j¿  h£j±  hý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”]”hŒsystem_message”“”)”}”(hhh]”hÃ)”}”(hŒ:Enumerated list start value not ordinal-1: "C" (ordinal 3)”h]”hŒ>Enumerated list start value not ordinal-1: â€œCâ€ (ordinal 3)”…””}”(hhhjP  hžhhŸNh Nubah}”(h]”h ]”h"]”h$]”h&]”uh1hÂhjM  ubah}”(h]”h ]”h"]”h$]”h&]”Œlevel”KŒtype”ŒINFO”Œsource”h¶Œline”Kuh1jK  hh£hžhhŸh¶h KubaŒtransform_messages”]”Œtransformer”NŒinclude_log”]”Œ
decoration”Nhžhub.