tree.c 132 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272
  1. /*
  2. * Read-Copy Update mechanism for mutual exclusion
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License as published by
  6. * the Free Software Foundation; either version 2 of the License, or
  7. * (at your option) any later version.
  8. *
  9. * This program is distributed in the hope that it will be useful,
  10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. * GNU General Public License for more details.
  13. *
  14. * You should have received a copy of the GNU General Public License
  15. * along with this program; if not, you can access it online at
  16. * http://www.gnu.org/licenses/gpl-2.0.html.
  17. *
  18. * Copyright IBM Corporation, 2008
  19. *
  20. * Authors: Dipankar Sarma <dipankar@in.ibm.com>
  21. * Manfred Spraul <manfred@colorfullife.com>
  22. * Paul E. McKenney <paulmck@linux.vnet.ibm.com> Hierarchical version
  23. *
  24. * Based on the original work by Paul McKenney <paulmck@us.ibm.com>
  25. * and inputs from Rusty Russell, Andrea Arcangeli and Andi Kleen.
  26. *
  27. * For detailed explanation of Read-Copy Update mechanism see -
  28. * Documentation/RCU
  29. */
  30. #include <linux/types.h>
  31. #include <linux/kernel.h>
  32. #include <linux/init.h>
  33. #include <linux/spinlock.h>
  34. #include <linux/smp.h>
  35. #include <linux/rcupdate_wait.h>
  36. #include <linux/interrupt.h>
  37. #include <linux/sched.h>
  38. #include <linux/sched/debug.h>
  39. #include <linux/nmi.h>
  40. #include <linux/atomic.h>
  41. #include <linux/bitops.h>
  42. #include <linux/export.h>
  43. #include <linux/completion.h>
  44. #include <linux/moduleparam.h>
  45. #include <linux/percpu.h>
  46. #include <linux/notifier.h>
  47. #include <linux/cpu.h>
  48. #include <linux/mutex.h>
  49. #include <linux/time.h>
  50. #include <linux/kernel_stat.h>
  51. #include <linux/wait.h>
  52. #include <linux/kthread.h>
  53. #include <uapi/linux/sched/types.h>
  54. #include <linux/prefetch.h>
  55. #include <linux/delay.h>
  56. #include <linux/stop_machine.h>
  57. #include <linux/random.h>
  58. #include <linux/trace_events.h>
  59. #include <linux/suspend.h>
  60. #include <linux/ftrace.h>
  61. #include "tree.h"
  62. #include "rcu.h"
  63. #ifdef MODULE_PARAM_PREFIX
  64. #undef MODULE_PARAM_PREFIX
  65. #endif
  66. #define MODULE_PARAM_PREFIX "rcutree."
  67. /* Data structures. */
  68. /*
  69. * In order to export the rcu_state name to the tracing tools, it
  70. * needs to be added in the __tracepoint_string section.
  71. * This requires defining a separate variable tp_<sname>_varname
  72. * that points to the string being used, and this will allow
  73. * the tracing userspace tools to be able to decipher the string
  74. * address to the matching string.
  75. */
  76. #ifdef CONFIG_TRACING
  77. # define DEFINE_RCU_TPS(sname) \
  78. static char sname##_varname[] = #sname; \
  79. static const char *tp_##sname##_varname __used __tracepoint_string = sname##_varname;
  80. # define RCU_STATE_NAME(sname) sname##_varname
  81. #else
  82. # define DEFINE_RCU_TPS(sname)
  83. # define RCU_STATE_NAME(sname) __stringify(sname)
  84. #endif
  85. #define RCU_STATE_INITIALIZER(sname, sabbr, cr) \
  86. DEFINE_RCU_TPS(sname) \
  87. static DEFINE_PER_CPU_SHARED_ALIGNED(struct rcu_data, sname##_data); \
  88. struct rcu_state sname##_state = { \
  89. .level = { &sname##_state.node[0] }, \
  90. .rda = &sname##_data, \
  91. .call = cr, \
  92. .gp_state = RCU_GP_IDLE, \
  93. .gpnum = 0UL - 300UL, \
  94. .completed = 0UL - 300UL, \
  95. .barrier_mutex = __MUTEX_INITIALIZER(sname##_state.barrier_mutex), \
  96. .name = RCU_STATE_NAME(sname), \
  97. .abbr = sabbr, \
  98. .exp_mutex = __MUTEX_INITIALIZER(sname##_state.exp_mutex), \
  99. .exp_wake_mutex = __MUTEX_INITIALIZER(sname##_state.exp_wake_mutex), \
  100. }
  101. RCU_STATE_INITIALIZER(rcu_sched, 's', call_rcu_sched);
  102. RCU_STATE_INITIALIZER(rcu_bh, 'b', call_rcu_bh);
  103. static struct rcu_state *const rcu_state_p;
  104. LIST_HEAD(rcu_struct_flavors);
  105. /* Dump rcu_node combining tree at boot to verify correct setup. */
  106. static bool dump_tree;
  107. module_param(dump_tree, bool, 0444);
  108. /* Control rcu_node-tree auto-balancing at boot time. */
  109. static bool rcu_fanout_exact;
  110. module_param(rcu_fanout_exact, bool, 0444);
  111. /* Increase (but not decrease) the RCU_FANOUT_LEAF at boot time. */
  112. static int rcu_fanout_leaf = RCU_FANOUT_LEAF;
  113. module_param(rcu_fanout_leaf, int, 0444);
  114. int rcu_num_lvls __read_mostly = RCU_NUM_LVLS;
  115. /* Number of rcu_nodes at specified level. */
  116. int num_rcu_lvl[] = NUM_RCU_LVL_INIT;
  117. int rcu_num_nodes __read_mostly = NUM_RCU_NODES; /* Total # rcu_nodes in use. */
  118. /* panic() on RCU Stall sysctl. */
  119. int sysctl_panic_on_rcu_stall __read_mostly;
  120. /*
  121. * The rcu_scheduler_active variable is initialized to the value
  122. * RCU_SCHEDULER_INACTIVE and transitions RCU_SCHEDULER_INIT just before the
  123. * first task is spawned. So when this variable is RCU_SCHEDULER_INACTIVE,
  124. * RCU can assume that there is but one task, allowing RCU to (for example)
  125. * optimize synchronize_rcu() to a simple barrier(). When this variable
  126. * is RCU_SCHEDULER_INIT, RCU must actually do all the hard work required
  127. * to detect real grace periods. This variable is also used to suppress
  128. * boot-time false positives from lockdep-RCU error checking. Finally, it
  129. * transitions from RCU_SCHEDULER_INIT to RCU_SCHEDULER_RUNNING after RCU
  130. * is fully initialized, including all of its kthreads having been spawned.
  131. */
  132. int rcu_scheduler_active __read_mostly;
  133. EXPORT_SYMBOL_GPL(rcu_scheduler_active);
  134. /*
  135. * The rcu_scheduler_fully_active variable transitions from zero to one
  136. * during the early_initcall() processing, which is after the scheduler
  137. * is capable of creating new tasks. So RCU processing (for example,
  138. * creating tasks for RCU priority boosting) must be delayed until after
  139. * rcu_scheduler_fully_active transitions from zero to one. We also
  140. * currently delay invocation of any RCU callbacks until after this point.
  141. *
  142. * It might later prove better for people registering RCU callbacks during
  143. * early boot to take responsibility for these callbacks, but one step at
  144. * a time.
  145. */
  146. static int rcu_scheduler_fully_active __read_mostly;
  147. static void rcu_init_new_rnp(struct rcu_node *rnp_leaf);
  148. static void rcu_cleanup_dead_rnp(struct rcu_node *rnp_leaf);
  149. static void rcu_boost_kthread_setaffinity(struct rcu_node *rnp, int outgoingcpu);
  150. static void invoke_rcu_core(void);
  151. static void invoke_rcu_callbacks(struct rcu_state *rsp, struct rcu_data *rdp);
  152. static void rcu_report_exp_rdp(struct rcu_state *rsp,
  153. struct rcu_data *rdp, bool wake);
  154. static void sync_sched_exp_online_cleanup(int cpu);
  155. /* rcuc/rcub kthread realtime priority */
  156. static int kthread_prio = IS_ENABLED(CONFIG_RCU_BOOST) ? 1 : 0;
  157. module_param(kthread_prio, int, 0644);
  158. /* Delay in jiffies for grace-period initialization delays, debug only. */
  159. static int gp_preinit_delay;
  160. module_param(gp_preinit_delay, int, 0444);
  161. static int gp_init_delay;
  162. module_param(gp_init_delay, int, 0444);
  163. static int gp_cleanup_delay;
  164. module_param(gp_cleanup_delay, int, 0444);
  165. /*
  166. * Number of grace periods between delays, normalized by the duration of
  167. * the delay. The longer the delay, the more the grace periods between
  168. * each delay. The reason for this normalization is that it means that,
  169. * for non-zero delays, the overall slowdown of grace periods is constant
  170. * regardless of the duration of the delay. This arrangement balances
  171. * the need for long delays to increase some race probabilities with the
  172. * need for fast grace periods to increase other race probabilities.
  173. */
  174. #define PER_RCU_NODE_PERIOD 3 /* Number of grace periods between delays. */
  175. /*
  176. * Track the rcutorture test sequence number and the update version
  177. * number within a given test. The rcutorture_testseq is incremented
  178. * on every rcutorture module load and unload, so has an odd value
  179. * when a test is running. The rcutorture_vernum is set to zero
  180. * when rcutorture starts and is incremented on each rcutorture update.
  181. * These variables enable correlating rcutorture output with the
  182. * RCU tracing information.
  183. */
  184. unsigned long rcutorture_testseq;
  185. unsigned long rcutorture_vernum;
  186. /*
  187. * Compute the mask of online CPUs for the specified rcu_node structure.
  188. * This will not be stable unless the rcu_node structure's ->lock is
  189. * held, but the bit corresponding to the current CPU will be stable
  190. * in most contexts.
  191. */
  192. unsigned long rcu_rnp_online_cpus(struct rcu_node *rnp)
  193. {
  194. return READ_ONCE(rnp->qsmaskinitnext);
  195. }
  196. /*
  197. * Return true if an RCU grace period is in progress. The READ_ONCE()s
  198. * permit this function to be invoked without holding the root rcu_node
  199. * structure's ->lock, but of course results can be subject to change.
  200. */
  201. static int rcu_gp_in_progress(struct rcu_state *rsp)
  202. {
  203. return READ_ONCE(rsp->completed) != READ_ONCE(rsp->gpnum);
  204. }
  205. /*
  206. * Note a quiescent state. Because we do not need to know
  207. * how many quiescent states passed, just if there was at least
  208. * one since the start of the grace period, this just sets a flag.
  209. * The caller must have disabled preemption.
  210. */
  211. void rcu_sched_qs(void)
  212. {
  213. RCU_LOCKDEP_WARN(preemptible(), "rcu_sched_qs() invoked with preemption enabled!!!");
  214. if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.s))
  215. return;
  216. trace_rcu_grace_period(TPS("rcu_sched"),
  217. __this_cpu_read(rcu_sched_data.gpnum),
  218. TPS("cpuqs"));
  219. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.norm, false);
  220. if (!__this_cpu_read(rcu_sched_data.cpu_no_qs.b.exp))
  221. return;
  222. __this_cpu_write(rcu_sched_data.cpu_no_qs.b.exp, false);
  223. rcu_report_exp_rdp(&rcu_sched_state,
  224. this_cpu_ptr(&rcu_sched_data), true);
  225. }
  226. void rcu_bh_qs(void)
  227. {
  228. RCU_LOCKDEP_WARN(preemptible(), "rcu_bh_qs() invoked with preemption enabled!!!");
  229. if (__this_cpu_read(rcu_bh_data.cpu_no_qs.s)) {
  230. trace_rcu_grace_period(TPS("rcu_bh"),
  231. __this_cpu_read(rcu_bh_data.gpnum),
  232. TPS("cpuqs"));
  233. __this_cpu_write(rcu_bh_data.cpu_no_qs.b.norm, false);
  234. }
  235. }
  236. /*
  237. * Steal a bit from the bottom of ->dynticks for idle entry/exit
  238. * control. Initially this is for TLB flushing.
  239. */
  240. #define RCU_DYNTICK_CTRL_MASK 0x1
  241. #define RCU_DYNTICK_CTRL_CTR (RCU_DYNTICK_CTRL_MASK + 1)
  242. #ifndef rcu_eqs_special_exit
  243. #define rcu_eqs_special_exit() do { } while (0)
  244. #endif
  245. static DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = {
  246. .dynticks_nesting = 1,
  247. .dynticks_nmi_nesting = DYNTICK_IRQ_NONIDLE,
  248. .dynticks = ATOMIC_INIT(RCU_DYNTICK_CTRL_CTR),
  249. };
  250. /*
  251. * Record entry into an extended quiescent state. This is only to be
  252. * called when not already in an extended quiescent state.
  253. */
  254. static void rcu_dynticks_eqs_enter(void)
  255. {
  256. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  257. int seq;
  258. /*
  259. * CPUs seeing atomic_add_return() must see prior RCU read-side
  260. * critical sections, and we also must force ordering with the
  261. * next idle sojourn.
  262. */
  263. seq = atomic_add_return(RCU_DYNTICK_CTRL_CTR, &rdtp->dynticks);
  264. /* Better be in an extended quiescent state! */
  265. WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  266. (seq & RCU_DYNTICK_CTRL_CTR));
  267. /* Better not have special action (TLB flush) pending! */
  268. WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  269. (seq & RCU_DYNTICK_CTRL_MASK));
  270. }
  271. /*
  272. * Record exit from an extended quiescent state. This is only to be
  273. * called from an extended quiescent state.
  274. */
  275. static void rcu_dynticks_eqs_exit(void)
  276. {
  277. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  278. int seq;
  279. /*
  280. * CPUs seeing atomic_add_return() must see prior idle sojourns,
  281. * and we also must force ordering with the next RCU read-side
  282. * critical section.
  283. */
  284. seq = atomic_add_return(RCU_DYNTICK_CTRL_CTR, &rdtp->dynticks);
  285. WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  286. !(seq & RCU_DYNTICK_CTRL_CTR));
  287. if (seq & RCU_DYNTICK_CTRL_MASK) {
  288. atomic_andnot(RCU_DYNTICK_CTRL_MASK, &rdtp->dynticks);
  289. smp_mb__after_atomic(); /* _exit after clearing mask. */
  290. /* Prefer duplicate flushes to losing a flush. */
  291. rcu_eqs_special_exit();
  292. }
  293. }
  294. /*
  295. * Reset the current CPU's ->dynticks counter to indicate that the
  296. * newly onlined CPU is no longer in an extended quiescent state.
  297. * This will either leave the counter unchanged, or increment it
  298. * to the next non-quiescent value.
  299. *
  300. * The non-atomic test/increment sequence works because the upper bits
  301. * of the ->dynticks counter are manipulated only by the corresponding CPU,
  302. * or when the corresponding CPU is offline.
  303. */
  304. static void rcu_dynticks_eqs_online(void)
  305. {
  306. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  307. if (atomic_read(&rdtp->dynticks) & RCU_DYNTICK_CTRL_CTR)
  308. return;
  309. atomic_add(RCU_DYNTICK_CTRL_CTR, &rdtp->dynticks);
  310. }
  311. /*
  312. * Is the current CPU in an extended quiescent state?
  313. *
  314. * No ordering, as we are sampling CPU-local information.
  315. */
  316. bool rcu_dynticks_curr_cpu_in_eqs(void)
  317. {
  318. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  319. return !(atomic_read(&rdtp->dynticks) & RCU_DYNTICK_CTRL_CTR);
  320. }
  321. /*
  322. * Snapshot the ->dynticks counter with full ordering so as to allow
  323. * stable comparison of this counter with past and future snapshots.
  324. */
  325. int rcu_dynticks_snap(struct rcu_dynticks *rdtp)
  326. {
  327. int snap = atomic_add_return(0, &rdtp->dynticks);
  328. return snap & ~RCU_DYNTICK_CTRL_MASK;
  329. }
  330. /*
  331. * Return true if the snapshot returned from rcu_dynticks_snap()
  332. * indicates that RCU is in an extended quiescent state.
  333. */
  334. static bool rcu_dynticks_in_eqs(int snap)
  335. {
  336. return !(snap & RCU_DYNTICK_CTRL_CTR);
  337. }
  338. /*
  339. * Return true if the CPU corresponding to the specified rcu_dynticks
  340. * structure has spent some time in an extended quiescent state since
  341. * rcu_dynticks_snap() returned the specified snapshot.
  342. */
  343. static bool rcu_dynticks_in_eqs_since(struct rcu_dynticks *rdtp, int snap)
  344. {
  345. return snap != rcu_dynticks_snap(rdtp);
  346. }
  347. /*
  348. * Do a double-increment of the ->dynticks counter to emulate a
  349. * momentary idle-CPU quiescent state.
  350. */
  351. static void rcu_dynticks_momentary_idle(void)
  352. {
  353. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  354. int special = atomic_add_return(2 * RCU_DYNTICK_CTRL_CTR,
  355. &rdtp->dynticks);
  356. /* It is illegal to call this from idle state. */
  357. WARN_ON_ONCE(!(special & RCU_DYNTICK_CTRL_CTR));
  358. }
  359. /*
  360. * Set the special (bottom) bit of the specified CPU so that it
  361. * will take special action (such as flushing its TLB) on the
  362. * next exit from an extended quiescent state. Returns true if
  363. * the bit was successfully set, or false if the CPU was not in
  364. * an extended quiescent state.
  365. */
  366. bool rcu_eqs_special_set(int cpu)
  367. {
  368. int old;
  369. int new;
  370. struct rcu_dynticks *rdtp = &per_cpu(rcu_dynticks, cpu);
  371. do {
  372. old = atomic_read(&rdtp->dynticks);
  373. if (old & RCU_DYNTICK_CTRL_CTR)
  374. return false;
  375. new = old | RCU_DYNTICK_CTRL_MASK;
  376. } while (atomic_cmpxchg(&rdtp->dynticks, old, new) != old);
  377. return true;
  378. }
  379. /*
  380. * Let the RCU core know that this CPU has gone through the scheduler,
  381. * which is a quiescent state. This is called when the need for a
  382. * quiescent state is urgent, so we burn an atomic operation and full
  383. * memory barriers to let the RCU core know about it, regardless of what
  384. * this CPU might (or might not) do in the near future.
  385. *
  386. * We inform the RCU core by emulating a zero-duration dyntick-idle period.
  387. *
  388. * The caller must have disabled interrupts.
  389. */
  390. static void rcu_momentary_dyntick_idle(void)
  391. {
  392. raw_cpu_write(rcu_dynticks.rcu_need_heavy_qs, false);
  393. rcu_dynticks_momentary_idle();
  394. }
  395. /*
  396. * Note a context switch. This is a quiescent state for RCU-sched,
  397. * and requires special handling for preemptible RCU.
  398. * The caller must have disabled interrupts.
  399. */
  400. void rcu_note_context_switch(bool preempt)
  401. {
  402. barrier(); /* Avoid RCU read-side critical sections leaking down. */
  403. trace_rcu_utilization(TPS("Start context switch"));
  404. rcu_sched_qs();
  405. rcu_preempt_note_context_switch(preempt);
  406. /* Load rcu_urgent_qs before other flags. */
  407. if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs)))
  408. goto out;
  409. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false);
  410. if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs)))
  411. rcu_momentary_dyntick_idle();
  412. this_cpu_inc(rcu_dynticks.rcu_qs_ctr);
  413. if (!preempt)
  414. rcu_note_voluntary_context_switch_lite(current);
  415. out:
  416. trace_rcu_utilization(TPS("End context switch"));
  417. barrier(); /* Avoid RCU read-side critical sections leaking up. */
  418. }
  419. EXPORT_SYMBOL_GPL(rcu_note_context_switch);
  420. /*
  421. * Register a quiescent state for all RCU flavors. If there is an
  422. * emergency, invoke rcu_momentary_dyntick_idle() to do a heavy-weight
  423. * dyntick-idle quiescent state visible to other CPUs (but only for those
  424. * RCU flavors in desperate need of a quiescent state, which will normally
  425. * be none of them). Either way, do a lightweight quiescent state for
  426. * all RCU flavors.
  427. *
  428. * The barrier() calls are redundant in the common case when this is
  429. * called externally, but just in case this is called from within this
  430. * file.
  431. *
  432. */
  433. void rcu_all_qs(void)
  434. {
  435. unsigned long flags;
  436. if (!raw_cpu_read(rcu_dynticks.rcu_urgent_qs))
  437. return;
  438. preempt_disable();
  439. /* Load rcu_urgent_qs before other flags. */
  440. if (!smp_load_acquire(this_cpu_ptr(&rcu_dynticks.rcu_urgent_qs))) {
  441. preempt_enable();
  442. return;
  443. }
  444. this_cpu_write(rcu_dynticks.rcu_urgent_qs, false);
  445. barrier(); /* Avoid RCU read-side critical sections leaking down. */
  446. if (unlikely(raw_cpu_read(rcu_dynticks.rcu_need_heavy_qs))) {
  447. local_irq_save(flags);
  448. rcu_momentary_dyntick_idle();
  449. local_irq_restore(flags);
  450. }
  451. if (unlikely(raw_cpu_read(rcu_sched_data.cpu_no_qs.b.exp)))
  452. rcu_sched_qs();
  453. this_cpu_inc(rcu_dynticks.rcu_qs_ctr);
  454. barrier(); /* Avoid RCU read-side critical sections leaking up. */
  455. preempt_enable();
  456. }
  457. EXPORT_SYMBOL_GPL(rcu_all_qs);
  458. #define DEFAULT_RCU_BLIMIT 10 /* Maximum callbacks per rcu_do_batch. */
  459. static long blimit = DEFAULT_RCU_BLIMIT;
  460. #define DEFAULT_RCU_QHIMARK 10000 /* If this many pending, ignore blimit. */
  461. static long qhimark = DEFAULT_RCU_QHIMARK;
  462. #define DEFAULT_RCU_QLOMARK 100 /* Once only this many pending, use blimit. */
  463. static long qlowmark = DEFAULT_RCU_QLOMARK;
  464. module_param(blimit, long, 0444);
  465. module_param(qhimark, long, 0444);
  466. module_param(qlowmark, long, 0444);
  467. static ulong jiffies_till_first_fqs = ULONG_MAX;
  468. static ulong jiffies_till_next_fqs = ULONG_MAX;
  469. static bool rcu_kick_kthreads;
  470. module_param(jiffies_till_first_fqs, ulong, 0644);
  471. module_param(jiffies_till_next_fqs, ulong, 0644);
  472. module_param(rcu_kick_kthreads, bool, 0644);
  473. /*
  474. * How long the grace period must be before we start recruiting
  475. * quiescent-state help from rcu_note_context_switch().
  476. */
  477. static ulong jiffies_till_sched_qs = HZ / 10;
  478. module_param(jiffies_till_sched_qs, ulong, 0444);
  479. static bool rcu_start_gp_advanced(struct rcu_state *rsp, struct rcu_node *rnp,
  480. struct rcu_data *rdp);
  481. static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *rsp));
  482. static void force_quiescent_state(struct rcu_state *rsp);
  483. static int rcu_pending(void);
  484. /*
  485. * Return the number of RCU batches started thus far for debug & stats.
  486. */
  487. unsigned long rcu_batches_started(void)
  488. {
  489. return rcu_state_p->gpnum;
  490. }
  491. EXPORT_SYMBOL_GPL(rcu_batches_started);
  492. /*
  493. * Return the number of RCU-sched batches started thus far for debug & stats.
  494. */
  495. unsigned long rcu_batches_started_sched(void)
  496. {
  497. return rcu_sched_state.gpnum;
  498. }
  499. EXPORT_SYMBOL_GPL(rcu_batches_started_sched);
  500. /*
  501. * Return the number of RCU BH batches started thus far for debug & stats.
  502. */
  503. unsigned long rcu_batches_started_bh(void)
  504. {
  505. return rcu_bh_state.gpnum;
  506. }
  507. EXPORT_SYMBOL_GPL(rcu_batches_started_bh);
  508. /*
  509. * Return the number of RCU batches completed thus far for debug & stats.
  510. */
  511. unsigned long rcu_batches_completed(void)
  512. {
  513. return rcu_state_p->completed;
  514. }
  515. EXPORT_SYMBOL_GPL(rcu_batches_completed);
  516. /*
  517. * Return the number of RCU-sched batches completed thus far for debug & stats.
  518. */
  519. unsigned long rcu_batches_completed_sched(void)
  520. {
  521. return rcu_sched_state.completed;
  522. }
  523. EXPORT_SYMBOL_GPL(rcu_batches_completed_sched);
  524. /*
  525. * Return the number of RCU BH batches completed thus far for debug & stats.
  526. */
  527. unsigned long rcu_batches_completed_bh(void)
  528. {
  529. return rcu_bh_state.completed;
  530. }
  531. EXPORT_SYMBOL_GPL(rcu_batches_completed_bh);
  532. /*
  533. * Return the number of RCU expedited batches completed thus far for
  534. * debug & stats. Odd numbers mean that a batch is in progress, even
  535. * numbers mean idle. The value returned will thus be roughly double
  536. * the cumulative batches since boot.
  537. */
  538. unsigned long rcu_exp_batches_completed(void)
  539. {
  540. return rcu_state_p->expedited_sequence;
  541. }
  542. EXPORT_SYMBOL_GPL(rcu_exp_batches_completed);
  543. /*
  544. * Return the number of RCU-sched expedited batches completed thus far
  545. * for debug & stats. Similar to rcu_exp_batches_completed().
  546. */
  547. unsigned long rcu_exp_batches_completed_sched(void)
  548. {
  549. return rcu_sched_state.expedited_sequence;
  550. }
  551. EXPORT_SYMBOL_GPL(rcu_exp_batches_completed_sched);
  552. /*
  553. * Force a quiescent state.
  554. */
  555. void rcu_force_quiescent_state(void)
  556. {
  557. force_quiescent_state(rcu_state_p);
  558. }
  559. EXPORT_SYMBOL_GPL(rcu_force_quiescent_state);
  560. /*
  561. * Force a quiescent state for RCU BH.
  562. */
  563. void rcu_bh_force_quiescent_state(void)
  564. {
  565. force_quiescent_state(&rcu_bh_state);
  566. }
  567. EXPORT_SYMBOL_GPL(rcu_bh_force_quiescent_state);
  568. /*
  569. * Force a quiescent state for RCU-sched.
  570. */
  571. void rcu_sched_force_quiescent_state(void)
  572. {
  573. force_quiescent_state(&rcu_sched_state);
  574. }
  575. EXPORT_SYMBOL_GPL(rcu_sched_force_quiescent_state);
  576. /*
  577. * Show the state of the grace-period kthreads.
  578. */
  579. void show_rcu_gp_kthreads(void)
  580. {
  581. struct rcu_state *rsp;
  582. for_each_rcu_flavor(rsp) {
  583. pr_info("%s: wait state: %d ->state: %#lx\n",
  584. rsp->name, rsp->gp_state, rsp->gp_kthread->state);
  585. /* sched_show_task(rsp->gp_kthread); */
  586. }
  587. }
  588. EXPORT_SYMBOL_GPL(show_rcu_gp_kthreads);
  589. /*
  590. * Record the number of times rcutorture tests have been initiated and
  591. * terminated. This information allows the debugfs tracing stats to be
  592. * correlated to the rcutorture messages, even when the rcutorture module
  593. * is being repeatedly loaded and unloaded. In other words, we cannot
  594. * store this state in rcutorture itself.
  595. */
  596. void rcutorture_record_test_transition(void)
  597. {
  598. rcutorture_testseq++;
  599. rcutorture_vernum = 0;
  600. }
  601. EXPORT_SYMBOL_GPL(rcutorture_record_test_transition);
  602. /*
  603. * Send along grace-period-related data for rcutorture diagnostics.
  604. */
  605. void rcutorture_get_gp_data(enum rcutorture_type test_type, int *flags,
  606. unsigned long *gpnum, unsigned long *completed)
  607. {
  608. struct rcu_state *rsp = NULL;
  609. switch (test_type) {
  610. case RCU_FLAVOR:
  611. rsp = rcu_state_p;
  612. break;
  613. case RCU_BH_FLAVOR:
  614. rsp = &rcu_bh_state;
  615. break;
  616. case RCU_SCHED_FLAVOR:
  617. rsp = &rcu_sched_state;
  618. break;
  619. default:
  620. break;
  621. }
  622. if (rsp == NULL)
  623. return;
  624. *flags = READ_ONCE(rsp->gp_flags);
  625. *gpnum = READ_ONCE(rsp->gpnum);
  626. *completed = READ_ONCE(rsp->completed);
  627. }
  628. EXPORT_SYMBOL_GPL(rcutorture_get_gp_data);
  629. /*
  630. * Record the number of writer passes through the current rcutorture test.
  631. * This is also used to correlate debugfs tracing stats with the rcutorture
  632. * messages.
  633. */
  634. void rcutorture_record_progress(unsigned long vernum)
  635. {
  636. rcutorture_vernum++;
  637. }
  638. EXPORT_SYMBOL_GPL(rcutorture_record_progress);
  639. /*
  640. * Return the root node of the specified rcu_state structure.
  641. */
  642. static struct rcu_node *rcu_get_root(struct rcu_state *rsp)
  643. {
  644. return &rsp->node[0];
  645. }
  646. /*
  647. * Is there any need for future grace periods?
  648. * Interrupts must be disabled. If the caller does not hold the root
  649. * rnp_node structure's ->lock, the results are advisory only.
  650. */
  651. static int rcu_future_needs_gp(struct rcu_state *rsp)
  652. {
  653. struct rcu_node *rnp = rcu_get_root(rsp);
  654. int idx = (READ_ONCE(rnp->completed) + 1) & 0x1;
  655. int *fp = &rnp->need_future_gp[idx];
  656. lockdep_assert_irqs_disabled();
  657. return READ_ONCE(*fp);
  658. }
  659. /*
  660. * Does the current CPU require a not-yet-started grace period?
  661. * The caller must have disabled interrupts to prevent races with
  662. * normal callback registry.
  663. */
  664. static bool
  665. cpu_needs_another_gp(struct rcu_state *rsp, struct rcu_data *rdp)
  666. {
  667. lockdep_assert_irqs_disabled();
  668. if (rcu_gp_in_progress(rsp))
  669. return false; /* No, a grace period is already in progress. */
  670. if (rcu_future_needs_gp(rsp))
  671. return true; /* Yes, a no-CBs CPU needs one. */
  672. if (!rcu_segcblist_is_enabled(&rdp->cblist))
  673. return false; /* No, this is a no-CBs (or offline) CPU. */
  674. if (!rcu_segcblist_restempty(&rdp->cblist, RCU_NEXT_READY_TAIL))
  675. return true; /* Yes, CPU has newly registered callbacks. */
  676. if (rcu_segcblist_future_gp_needed(&rdp->cblist,
  677. READ_ONCE(rsp->completed)))
  678. return true; /* Yes, CBs for future grace period. */
  679. return false; /* No grace period needed. */
  680. }
  681. /*
  682. * rcu_eqs_enter_common - current CPU is entering an extended quiescent state
  683. *
  684. * Enter idle, doing appropriate accounting. The caller must have
  685. * disabled interrupts.
  686. */
  687. static void rcu_eqs_enter_common(bool user)
  688. {
  689. struct rcu_state *rsp;
  690. struct rcu_data *rdp;
  691. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  692. lockdep_assert_irqs_disabled();
  693. trace_rcu_dyntick(TPS("Start"), rdtp->dynticks_nesting, 0);
  694. if (IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  695. !user && !is_idle_task(current)) {
  696. struct task_struct *idle __maybe_unused =
  697. idle_task(smp_processor_id());
  698. trace_rcu_dyntick(TPS("Error on entry: not idle task"), rdtp->dynticks_nesting, 0);
  699. rcu_ftrace_dump(DUMP_ORIG);
  700. WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s",
  701. current->pid, current->comm,
  702. idle->pid, idle->comm); /* must be idle task! */
  703. }
  704. for_each_rcu_flavor(rsp) {
  705. rdp = this_cpu_ptr(rsp->rda);
  706. do_nocb_deferred_wakeup(rdp);
  707. }
  708. rcu_prepare_for_idle();
  709. rdtp->dynticks_nesting = 0;
  710. rcu_dynticks_eqs_enter();
  711. rcu_dynticks_task_enter();
  712. /*
  713. * It is illegal to enter an extended quiescent state while
  714. * in an RCU read-side critical section.
  715. */
  716. RCU_LOCKDEP_WARN(lock_is_held(&rcu_lock_map),
  717. "Illegal idle entry in RCU read-side critical section.");
  718. RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map),
  719. "Illegal idle entry in RCU-bh read-side critical section.");
  720. RCU_LOCKDEP_WARN(lock_is_held(&rcu_sched_lock_map),
  721. "Illegal idle entry in RCU-sched read-side critical section.");
  722. }
  723. /*
  724. * Enter an RCU extended quiescent state, which can be either the
  725. * idle loop or adaptive-tickless usermode execution.
  726. *
  727. * We crowbar the ->dynticks_nmi_nesting field to zero to allow for
  728. * the possibility of usermode upcalls having messed up our count
  729. * of interrupt nesting level during the prior busy period.
  730. */
  731. static void rcu_eqs_enter(bool user)
  732. {
  733. struct rcu_dynticks *rdtp;
  734. rdtp = this_cpu_ptr(&rcu_dynticks);
  735. WRITE_ONCE(rdtp->dynticks_nmi_nesting, 0);
  736. WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  737. rdtp->dynticks_nesting == 0);
  738. if (rdtp->dynticks_nesting == 1)
  739. rcu_eqs_enter_common(user);
  740. else
  741. rdtp->dynticks_nesting--;
  742. }
  743. /**
  744. * rcu_idle_enter - inform RCU that current CPU is entering idle
  745. *
  746. * Enter idle mode, in other words, -leave- the mode in which RCU
  747. * read-side critical sections can occur. (Though RCU read-side
  748. * critical sections can occur in irq handlers in idle, a possibility
  749. * handled by irq_enter() and irq_exit().)
  750. *
  751. * If you add or remove a call to rcu_idle_enter(), be sure to test with
  752. * CONFIG_RCU_EQS_DEBUG=y.
  753. */
  754. void rcu_idle_enter(void)
  755. {
  756. lockdep_assert_irqs_disabled();
  757. rcu_eqs_enter(false);
  758. }
  759. #ifdef CONFIG_NO_HZ_FULL
  760. /**
  761. * rcu_user_enter - inform RCU that we are resuming userspace.
  762. *
  763. * Enter RCU idle mode right before resuming userspace. No use of RCU
  764. * is permitted between this call and rcu_user_exit(). This way the
  765. * CPU doesn't need to maintain the tick for RCU maintenance purposes
  766. * when the CPU runs in userspace.
  767. *
  768. * If you add or remove a call to rcu_user_enter(), be sure to test with
  769. * CONFIG_RCU_EQS_DEBUG=y.
  770. */
  771. void rcu_user_enter(void)
  772. {
  773. lockdep_assert_irqs_disabled();
  774. rcu_eqs_enter(true);
  775. }
  776. #endif /* CONFIG_NO_HZ_FULL */
  777. /**
  778. * rcu_nmi_exit - inform RCU of exit from NMI context
  779. *
  780. * If we are returning from the outermost NMI handler that interrupted an
  781. * RCU-idle period, update rdtp->dynticks and rdtp->dynticks_nmi_nesting
  782. * to let the RCU grace-period handling know that the CPU is back to
  783. * being RCU-idle.
  784. *
  785. * If you add or remove a call to rcu_nmi_exit(), be sure to test
  786. * with CONFIG_RCU_EQS_DEBUG=y.
  787. */
  788. void rcu_nmi_exit(void)
  789. {
  790. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  791. /*
  792. * Check for ->dynticks_nmi_nesting underflow and bad ->dynticks.
  793. * (We are exiting an NMI handler, so RCU better be paying attention
  794. * to us!)
  795. */
  796. WARN_ON_ONCE(rdtp->dynticks_nmi_nesting <= 0);
  797. WARN_ON_ONCE(rcu_dynticks_curr_cpu_in_eqs());
  798. /*
  799. * If the nesting level is not 1, the CPU wasn't RCU-idle, so
  800. * leave it in non-RCU-idle state.
  801. */
  802. if (rdtp->dynticks_nmi_nesting != 1) {
  803. WRITE_ONCE(rdtp->dynticks_nmi_nesting, /* No store tearing. */
  804. rdtp->dynticks_nmi_nesting - 2);
  805. return;
  806. }
  807. /* This NMI interrupted an RCU-idle CPU, restore RCU-idleness. */
  808. WRITE_ONCE(rdtp->dynticks_nmi_nesting, 0); /* Avoid store tearing. */
  809. rcu_dynticks_eqs_enter();
  810. }
  811. /**
  812. * rcu_irq_exit - inform RCU that current CPU is exiting irq towards idle
  813. *
  814. * Exit from an interrupt handler, which might possibly result in entering
  815. * idle mode, in other words, leaving the mode in which read-side critical
  816. * sections can occur. The caller must have disabled interrupts.
  817. *
  818. * This code assumes that the idle loop never does anything that might
  819. * result in unbalanced calls to irq_enter() and irq_exit(). If your
  820. * architecture's idle loop violates this assumption, RCU will give you what
  821. * you deserve, good and hard. But very infrequently and irreproducibly.
  822. *
  823. * Use things like work queues to work around this limitation.
  824. *
  825. * You have been warned.
  826. *
  827. * If you add or remove a call to rcu_irq_exit(), be sure to test with
  828. * CONFIG_RCU_EQS_DEBUG=y.
  829. */
  830. void rcu_irq_exit(void)
  831. {
  832. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  833. lockdep_assert_irqs_disabled();
  834. if (rdtp->dynticks_nmi_nesting == 1)
  835. rcu_prepare_for_idle();
  836. rcu_nmi_exit();
  837. if (rdtp->dynticks_nmi_nesting == 0)
  838. rcu_dynticks_task_enter();
  839. }
  840. /*
  841. * Wrapper for rcu_irq_exit() where interrupts are enabled.
  842. *
  843. * If you add or remove a call to rcu_irq_exit_irqson(), be sure to test
  844. * with CONFIG_RCU_EQS_DEBUG=y.
  845. */
  846. void rcu_irq_exit_irqson(void)
  847. {
  848. unsigned long flags;
  849. local_irq_save(flags);
  850. rcu_irq_exit();
  851. local_irq_restore(flags);
  852. }
  853. /*
  854. * rcu_eqs_exit_common - current CPU moving away from extended quiescent state
  855. *
  856. * If the new value of the ->dynticks_nesting counter was previously zero,
  857. * we really have exited idle, and must do the appropriate accounting.
  858. * The caller must have disabled interrupts.
  859. */
  860. static void rcu_eqs_exit_common(long long newval, int user)
  861. {
  862. RCU_TRACE(struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);)
  863. rcu_dynticks_task_exit();
  864. rcu_dynticks_eqs_exit();
  865. rcu_cleanup_after_idle();
  866. trace_rcu_dyntick(TPS("End"), rdtp->dynticks_nesting, newval);
  867. if (IS_ENABLED(CONFIG_RCU_EQS_DEBUG) &&
  868. !user && !is_idle_task(current)) {
  869. struct task_struct *idle __maybe_unused =
  870. idle_task(smp_processor_id());
  871. trace_rcu_dyntick(TPS("Error on exit: not idle task"),
  872. rdtp->dynticks_nesting, newval);
  873. rcu_ftrace_dump(DUMP_ORIG);
  874. WARN_ONCE(1, "Current pid: %d comm: %s / Idle pid: %d comm: %s",
  875. current->pid, current->comm,
  876. idle->pid, idle->comm); /* must be idle task! */
  877. }
  878. }
  879. /*
  880. * Exit an RCU extended quiescent state, which can be either the
  881. * idle loop or adaptive-tickless usermode execution.
  882. *
  883. * We crowbar the ->dynticks_nmi_nesting field to DYNTICK_IRQ_NONIDLE to
  884. * allow for the possibility of usermode upcalls messing up our count of
  885. * interrupt nesting level during the busy period that is just now starting.
  886. */
  887. static void rcu_eqs_exit(bool user)
  888. {
  889. struct rcu_dynticks *rdtp;
  890. long long oldval;
  891. lockdep_assert_irqs_disabled();
  892. rdtp = this_cpu_ptr(&rcu_dynticks);
  893. oldval = rdtp->dynticks_nesting;
  894. WARN_ON_ONCE(IS_ENABLED(CONFIG_RCU_EQS_DEBUG) && oldval < 0);
  895. if (oldval) {
  896. rdtp->dynticks_nesting++;
  897. } else {
  898. rcu_eqs_exit_common(1, user);
  899. rdtp->dynticks_nesting = 1;
  900. WRITE_ONCE(rdtp->dynticks_nmi_nesting, DYNTICK_IRQ_NONIDLE);
  901. }
  902. }
  903. /**
  904. * rcu_idle_exit - inform RCU that current CPU is leaving idle
  905. *
  906. * Exit idle mode, in other words, -enter- the mode in which RCU
  907. * read-side critical sections can occur.
  908. *
  909. * If you add or remove a call to rcu_idle_exit(), be sure to test with
  910. * CONFIG_RCU_EQS_DEBUG=y.
  911. */
  912. void rcu_idle_exit(void)
  913. {
  914. unsigned long flags;
  915. local_irq_save(flags);
  916. rcu_eqs_exit(false);
  917. local_irq_restore(flags);
  918. }
  919. #ifdef CONFIG_NO_HZ_FULL
  920. /**
  921. * rcu_user_exit - inform RCU that we are exiting userspace.
  922. *
  923. * Exit RCU idle mode while entering the kernel because it can
  924. * run a RCU read side critical section anytime.
  925. *
  926. * If you add or remove a call to rcu_user_exit(), be sure to test with
  927. * CONFIG_RCU_EQS_DEBUG=y.
  928. */
  929. void rcu_user_exit(void)
  930. {
  931. rcu_eqs_exit(1);
  932. }
  933. #endif /* CONFIG_NO_HZ_FULL */
  934. /**
  935. * rcu_nmi_enter - inform RCU of entry to NMI context
  936. *
  937. * If the CPU was idle from RCU's viewpoint, update rdtp->dynticks and
  938. * rdtp->dynticks_nmi_nesting to let the RCU grace-period handling know
  939. * that the CPU is active. This implementation permits nested NMIs, as
  940. * long as the nesting level does not overflow an int. (You will probably
  941. * run out of stack space first.)
  942. *
  943. * If you add or remove a call to rcu_nmi_enter(), be sure to test
  944. * with CONFIG_RCU_EQS_DEBUG=y.
  945. */
  946. void rcu_nmi_enter(void)
  947. {
  948. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  949. int incby = 2;
  950. /* Complain about underflow. */
  951. WARN_ON_ONCE(rdtp->dynticks_nmi_nesting < 0);
  952. /*
  953. * If idle from RCU viewpoint, atomically increment ->dynticks
  954. * to mark non-idle and increment ->dynticks_nmi_nesting by one.
  955. * Otherwise, increment ->dynticks_nmi_nesting by two. This means
  956. * if ->dynticks_nmi_nesting is equal to one, we are guaranteed
  957. * to be in the outermost NMI handler that interrupted an RCU-idle
  958. * period (observation due to Andy Lutomirski).
  959. */
  960. if (rcu_dynticks_curr_cpu_in_eqs()) {
  961. rcu_dynticks_eqs_exit();
  962. incby = 1;
  963. }
  964. WRITE_ONCE(rdtp->dynticks_nmi_nesting, /* Prevent store tearing. */
  965. rdtp->dynticks_nmi_nesting + incby);
  966. barrier();
  967. }
  968. /**
  969. * rcu_irq_enter - inform RCU that current CPU is entering irq away from idle
  970. *
  971. * Enter an interrupt handler, which might possibly result in exiting
  972. * idle mode, in other words, entering the mode in which read-side critical
  973. * sections can occur. The caller must have disabled interrupts.
  974. *
  975. * Note that the Linux kernel is fully capable of entering an interrupt
  976. * handler that it never exits, for example when doing upcalls to user mode!
  977. * This code assumes that the idle loop never does upcalls to user mode.
  978. * If your architecture's idle loop does do upcalls to user mode (or does
  979. * anything else that results in unbalanced calls to the irq_enter() and
  980. * irq_exit() functions), RCU will give you what you deserve, good and hard.
  981. * But very infrequently and irreproducibly.
  982. *
  983. * Use things like work queues to work around this limitation.
  984. *
  985. * You have been warned.
  986. *
  987. * If you add or remove a call to rcu_irq_enter(), be sure to test with
  988. * CONFIG_RCU_EQS_DEBUG=y.
  989. */
  990. void rcu_irq_enter(void)
  991. {
  992. struct rcu_dynticks *rdtp = this_cpu_ptr(&rcu_dynticks);
  993. lockdep_assert_irqs_disabled();
  994. if (rdtp->dynticks_nmi_nesting == 0)
  995. rcu_dynticks_task_exit();
  996. rcu_nmi_enter();
  997. if (rdtp->dynticks_nmi_nesting == 1)
  998. rcu_cleanup_after_idle();
  999. }
  1000. /*
  1001. * Wrapper for rcu_irq_enter() where interrupts are enabled.
  1002. *
  1003. * If you add or remove a call to rcu_irq_enter_irqson(), be sure to test
  1004. * with CONFIG_RCU_EQS_DEBUG=y.
  1005. */
  1006. void rcu_irq_enter_irqson(void)
  1007. {
  1008. unsigned long flags;
  1009. local_irq_save(flags);
  1010. rcu_irq_enter();
  1011. local_irq_restore(flags);
  1012. }
  1013. /**
  1014. * rcu_is_watching - see if RCU thinks that the current CPU is idle
  1015. *
  1016. * Return true if RCU is watching the running CPU, which means that this
  1017. * CPU can safely enter RCU read-side critical sections. In other words,
  1018. * if the current CPU is in its idle loop and is neither in an interrupt
  1019. * or NMI handler, return true.
  1020. */
  1021. bool notrace rcu_is_watching(void)
  1022. {
  1023. bool ret;
  1024. preempt_disable_notrace();
  1025. ret = !rcu_dynticks_curr_cpu_in_eqs();
  1026. preempt_enable_notrace();
  1027. return ret;
  1028. }
  1029. EXPORT_SYMBOL_GPL(rcu_is_watching);
  1030. /*
  1031. * If a holdout task is actually running, request an urgent quiescent
  1032. * state from its CPU. This is unsynchronized, so migrations can cause
  1033. * the request to go to the wrong CPU. Which is OK, all that will happen
  1034. * is that the CPU's next context switch will be a bit slower and next
  1035. * time around this task will generate another request.
  1036. */
  1037. void rcu_request_urgent_qs_task(struct task_struct *t)
  1038. {
  1039. int cpu;
  1040. barrier();
  1041. cpu = task_cpu(t);
  1042. if (!task_curr(t))
  1043. return; /* This task is not running on that CPU. */
  1044. smp_store_release(per_cpu_ptr(&rcu_dynticks.rcu_urgent_qs, cpu), true);
  1045. }
  1046. #if defined(CONFIG_PROVE_RCU) && defined(CONFIG_HOTPLUG_CPU)
  1047. /*
  1048. * Is the current CPU online? Disable preemption to avoid false positives
  1049. * that could otherwise happen due to the current CPU number being sampled,
  1050. * this task being preempted, its old CPU being taken offline, resuming
  1051. * on some other CPU, then determining that its old CPU is now offline.
  1052. * It is OK to use RCU on an offline processor during initial boot, hence
  1053. * the check for rcu_scheduler_fully_active. Note also that it is OK
  1054. * for a CPU coming online to use RCU for one jiffy prior to marking itself
  1055. * online in the cpu_online_mask. Similarly, it is OK for a CPU going
  1056. * offline to continue to use RCU for one jiffy after marking itself
  1057. * offline in the cpu_online_mask. This leniency is necessary given the
  1058. * non-atomic nature of the online and offline processing, for example,
  1059. * the fact that a CPU enters the scheduler after completing the teardown
  1060. * of the CPU.
  1061. *
  1062. * This is also why RCU internally marks CPUs online during in the
  1063. * preparation phase and offline after the CPU has been taken down.
  1064. *
  1065. * Disable checking if in an NMI handler because we cannot safely report
  1066. * errors from NMI handlers anyway.
  1067. */
  1068. bool rcu_lockdep_current_cpu_online(void)
  1069. {
  1070. struct rcu_data *rdp;
  1071. struct rcu_node *rnp;
  1072. bool ret;
  1073. if (in_nmi())
  1074. return true;
  1075. preempt_disable();
  1076. rdp = this_cpu_ptr(&rcu_sched_data);
  1077. rnp = rdp->mynode;
  1078. ret = (rdp->grpmask & rcu_rnp_online_cpus(rnp)) ||
  1079. !rcu_scheduler_fully_active;
  1080. preempt_enable();
  1081. return ret;
  1082. }
  1083. EXPORT_SYMBOL_GPL(rcu_lockdep_current_cpu_online);
  1084. #endif /* #if defined(CONFIG_PROVE_RCU) && defined(CONFIG_HOTPLUG_CPU) */
  1085. /**
  1086. * rcu_is_cpu_rrupt_from_idle - see if idle or immediately interrupted from idle
  1087. *
  1088. * If the current CPU is idle or running at a first-level (not nested)
  1089. * interrupt from idle, return true. The caller must have at least
  1090. * disabled preemption.
  1091. */
  1092. static int rcu_is_cpu_rrupt_from_idle(void)
  1093. {
  1094. return __this_cpu_read(rcu_dynticks.dynticks_nesting) <= 0 &&
  1095. __this_cpu_read(rcu_dynticks.dynticks_nmi_nesting) <= 1;
  1096. }
  1097. /*
  1098. * We are reporting a quiescent state on behalf of some other CPU, so
  1099. * it is our responsibility to check for and handle potential overflow
  1100. * of the rcu_node ->gpnum counter with respect to the rcu_data counters.
  1101. * After all, the CPU might be in deep idle state, and thus executing no
  1102. * code whatsoever.
  1103. */
  1104. static void rcu_gpnum_ovf(struct rcu_node *rnp, struct rcu_data *rdp)
  1105. {
  1106. lockdep_assert_held(&rnp->lock);
  1107. if (ULONG_CMP_LT(READ_ONCE(rdp->gpnum) + ULONG_MAX / 4, rnp->gpnum))
  1108. WRITE_ONCE(rdp->gpwrap, true);
  1109. if (ULONG_CMP_LT(rdp->rcu_iw_gpnum + ULONG_MAX / 4, rnp->gpnum))
  1110. rdp->rcu_iw_gpnum = rnp->gpnum + ULONG_MAX / 4;
  1111. }
  1112. /*
  1113. * Snapshot the specified CPU's dynticks counter so that we can later
  1114. * credit them with an implicit quiescent state. Return 1 if this CPU
  1115. * is in dynticks idle mode, which is an extended quiescent state.
  1116. */
  1117. static int dyntick_save_progress_counter(struct rcu_data *rdp)
  1118. {
  1119. rdp->dynticks_snap = rcu_dynticks_snap(rdp->dynticks);
  1120. if (rcu_dynticks_in_eqs(rdp->dynticks_snap)) {
  1121. trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("dti"));
  1122. rcu_gpnum_ovf(rdp->mynode, rdp);
  1123. return 1;
  1124. }
  1125. return 0;
  1126. }
  1127. /*
  1128. * Handler for the irq_work request posted when a grace period has
  1129. * gone on for too long, but not yet long enough for an RCU CPU
  1130. * stall warning. Set state appropriately, but just complain if
  1131. * there is unexpected state on entry.
  1132. */
  1133. static void rcu_iw_handler(struct irq_work *iwp)
  1134. {
  1135. struct rcu_data *rdp;
  1136. struct rcu_node *rnp;
  1137. rdp = container_of(iwp, struct rcu_data, rcu_iw);
  1138. rnp = rdp->mynode;
  1139. raw_spin_lock_rcu_node(rnp);
  1140. if (!WARN_ON_ONCE(!rdp->rcu_iw_pending)) {
  1141. rdp->rcu_iw_gpnum = rnp->gpnum;
  1142. rdp->rcu_iw_pending = false;
  1143. }
  1144. raw_spin_unlock_rcu_node(rnp);
  1145. }
  1146. /*
  1147. * Return true if the specified CPU has passed through a quiescent
  1148. * state by virtue of being in or having passed through an dynticks
  1149. * idle state since the last call to dyntick_save_progress_counter()
  1150. * for this same CPU, or by virtue of having been offline.
  1151. */
  1152. static int rcu_implicit_dynticks_qs(struct rcu_data *rdp)
  1153. {
  1154. unsigned long jtsq;
  1155. bool *rnhqp;
  1156. bool *ruqp;
  1157. struct rcu_node *rnp = rdp->mynode;
  1158. /*
  1159. * If the CPU passed through or entered a dynticks idle phase with
  1160. * no active irq/NMI handlers, then we can safely pretend that the CPU
  1161. * already acknowledged the request to pass through a quiescent
  1162. * state. Either way, that CPU cannot possibly be in an RCU
  1163. * read-side critical section that started before the beginning
  1164. * of the current RCU grace period.
  1165. */
  1166. if (rcu_dynticks_in_eqs_since(rdp->dynticks, rdp->dynticks_snap)) {
  1167. trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("dti"));
  1168. rdp->dynticks_fqs++;
  1169. rcu_gpnum_ovf(rnp, rdp);
  1170. return 1;
  1171. }
  1172. /*
  1173. * Has this CPU encountered a cond_resched_rcu_qs() since the
  1174. * beginning of the grace period? For this to be the case,
  1175. * the CPU has to have noticed the current grace period. This
  1176. * might not be the case for nohz_full CPUs looping in the kernel.
  1177. */
  1178. jtsq = jiffies_till_sched_qs;
  1179. ruqp = per_cpu_ptr(&rcu_dynticks.rcu_urgent_qs, rdp->cpu);
  1180. if (time_after(jiffies, rdp->rsp->gp_start + jtsq) &&
  1181. READ_ONCE(rdp->rcu_qs_ctr_snap) != per_cpu(rcu_dynticks.rcu_qs_ctr, rdp->cpu) &&
  1182. READ_ONCE(rdp->gpnum) == rnp->gpnum && !rdp->gpwrap) {
  1183. trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("rqc"));
  1184. rcu_gpnum_ovf(rnp, rdp);
  1185. return 1;
  1186. } else if (time_after(jiffies, rdp->rsp->gp_start + jtsq)) {
  1187. /* Load rcu_qs_ctr before store to rcu_urgent_qs. */
  1188. smp_store_release(ruqp, true);
  1189. }
  1190. /* Check for the CPU being offline. */
  1191. if (!(rdp->grpmask & rcu_rnp_online_cpus(rnp))) {
  1192. trace_rcu_fqs(rdp->rsp->name, rdp->gpnum, rdp->cpu, TPS("ofl"));
  1193. rdp->offline_fqs++;
  1194. rcu_gpnum_ovf(rnp, rdp);
  1195. return 1;
  1196. }
  1197. /*
  1198. * A CPU running for an extended time within the kernel can
  1199. * delay RCU grace periods. When the CPU is in NO_HZ_FULL mode,
  1200. * even context-switching back and forth between a pair of
  1201. * in-kernel CPU-bound tasks cannot advance grace periods.
  1202. * So if the grace period is old enough, make the CPU pay attention.
  1203. * Note that the unsynchronized assignments to the per-CPU
  1204. * rcu_need_heavy_qs variable are safe. Yes, setting of
  1205. * bits can be lost, but they will be set again on the next
  1206. * force-quiescent-state pass. So lost bit sets do not result
  1207. * in incorrect behavior, merely in a grace period lasting
  1208. * a few jiffies longer than it might otherwise. Because
  1209. * there are at most four threads involved, and because the
  1210. * updates are only once every few jiffies, the probability of
  1211. * lossage (and thus of slight grace-period extension) is
  1212. * quite low.
  1213. */
  1214. rnhqp = &per_cpu(rcu_dynticks.rcu_need_heavy_qs, rdp->cpu);
  1215. if (!READ_ONCE(*rnhqp) &&
  1216. (time_after(jiffies, rdp->rsp->gp_start + jtsq) ||
  1217. time_after(jiffies, rdp->rsp->jiffies_resched))) {
  1218. WRITE_ONCE(*rnhqp, true);
  1219. /* Store rcu_need_heavy_qs before rcu_urgent_qs. */
  1220. smp_store_release(ruqp, true);
  1221. rdp->rsp->jiffies_resched += jtsq; /* Re-enable beating. */
  1222. }
  1223. /*
  1224. * If more than halfway to RCU CPU stall-warning time, do a
  1225. * resched_cpu() to try to loosen things up a bit. Also check to
  1226. * see if the CPU is getting hammered with interrupts, but only
  1227. * once per grace period, just to keep the IPIs down to a dull roar.
  1228. */
  1229. if (jiffies - rdp->rsp->gp_start > rcu_jiffies_till_stall_check() / 2) {
  1230. resched_cpu(rdp->cpu);
  1231. if (IS_ENABLED(CONFIG_IRQ_WORK) &&
  1232. !rdp->rcu_iw_pending && rdp->rcu_iw_gpnum != rnp->gpnum &&
  1233. (rnp->ffmask & rdp->grpmask)) {
  1234. init_irq_work(&rdp->rcu_iw, rcu_iw_handler);
  1235. rdp->rcu_iw_pending = true;
  1236. rdp->rcu_iw_gpnum = rnp->gpnum;
  1237. irq_work_queue_on(&rdp->rcu_iw, rdp->cpu);
  1238. }
  1239. }
  1240. return 0;
  1241. }
  1242. static void record_gp_stall_check_time(struct rcu_state *rsp)
  1243. {
  1244. unsigned long j = jiffies;
  1245. unsigned long j1;
  1246. rsp->gp_start = j;
  1247. smp_wmb(); /* Record start time before stall time. */
  1248. j1 = rcu_jiffies_till_stall_check();
  1249. WRITE_ONCE(rsp->jiffies_stall, j + j1);
  1250. rsp->jiffies_resched = j + j1 / 2;
  1251. rsp->n_force_qs_gpstart = READ_ONCE(rsp->n_force_qs);
  1252. }
  1253. /*
  1254. * Convert a ->gp_state value to a character string.
  1255. */
  1256. static const char *gp_state_getname(short gs)
  1257. {
  1258. if (gs < 0 || gs >= ARRAY_SIZE(gp_state_names))
  1259. return "???";
  1260. return gp_state_names[gs];
  1261. }
  1262. /*
  1263. * Complain about starvation of grace-period kthread.
  1264. */
  1265. static void rcu_check_gp_kthread_starvation(struct rcu_state *rsp)
  1266. {
  1267. unsigned long gpa;
  1268. unsigned long j;
  1269. j = jiffies;
  1270. gpa = READ_ONCE(rsp->gp_activity);
  1271. if (j - gpa > 2 * HZ) {
  1272. pr_err("%s kthread starved for %ld jiffies! g%lu c%lu f%#x %s(%d) ->state=%#lx ->cpu=%d\n",
  1273. rsp->name, j - gpa,
  1274. rsp->gpnum, rsp->completed,
  1275. rsp->gp_flags,
  1276. gp_state_getname(rsp->gp_state), rsp->gp_state,
  1277. rsp->gp_kthread ? rsp->gp_kthread->state : ~0,
  1278. rsp->gp_kthread ? task_cpu(rsp->gp_kthread) : -1);
  1279. if (rsp->gp_kthread) {
  1280. sched_show_task(rsp->gp_kthread);
  1281. wake_up_process(rsp->gp_kthread);
  1282. }
  1283. }
  1284. }
  1285. /*
  1286. * Dump stacks of all tasks running on stalled CPUs. First try using
  1287. * NMIs, but fall back to manual remote stack tracing on architectures
  1288. * that don't support NMI-based stack dumps. The NMI-triggered stack
  1289. * traces are more accurate because they are printed by the target CPU.
  1290. */
  1291. static void rcu_dump_cpu_stacks(struct rcu_state *rsp)
  1292. {
  1293. int cpu;
  1294. unsigned long flags;
  1295. struct rcu_node *rnp;
  1296. rcu_for_each_leaf_node(rsp, rnp) {
  1297. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  1298. for_each_leaf_node_possible_cpu(rnp, cpu)
  1299. if (rnp->qsmask & leaf_node_cpu_bit(rnp, cpu))
  1300. if (!trigger_single_cpu_backtrace(cpu))
  1301. dump_cpu_task(cpu);
  1302. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  1303. }
  1304. }
  1305. /*
  1306. * If too much time has passed in the current grace period, and if
  1307. * so configured, go kick the relevant kthreads.
  1308. */
  1309. static void rcu_stall_kick_kthreads(struct rcu_state *rsp)
  1310. {
  1311. unsigned long j;
  1312. if (!rcu_kick_kthreads)
  1313. return;
  1314. j = READ_ONCE(rsp->jiffies_kick_kthreads);
  1315. if (time_after(jiffies, j) && rsp->gp_kthread &&
  1316. (rcu_gp_in_progress(rsp) || READ_ONCE(rsp->gp_flags))) {
  1317. WARN_ONCE(1, "Kicking %s grace-period kthread\n", rsp->name);
  1318. rcu_ftrace_dump(DUMP_ALL);
  1319. wake_up_process(rsp->gp_kthread);
  1320. WRITE_ONCE(rsp->jiffies_kick_kthreads, j + HZ);
  1321. }
  1322. }
  1323. static inline void panic_on_rcu_stall(void)
  1324. {
  1325. if (sysctl_panic_on_rcu_stall)
  1326. panic("RCU Stall\n");
  1327. }
  1328. static void print_other_cpu_stall(struct rcu_state *rsp, unsigned long gpnum)
  1329. {
  1330. int cpu;
  1331. long delta;
  1332. unsigned long flags;
  1333. unsigned long gpa;
  1334. unsigned long j;
  1335. int ndetected = 0;
  1336. struct rcu_node *rnp = rcu_get_root(rsp);
  1337. long totqlen = 0;
  1338. /* Kick and suppress, if so configured. */
  1339. rcu_stall_kick_kthreads(rsp);
  1340. if (rcu_cpu_stall_suppress)
  1341. return;
  1342. /* Only let one CPU complain about others per time interval. */
  1343. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  1344. delta = jiffies - READ_ONCE(rsp->jiffies_stall);
  1345. if (delta < RCU_STALL_RAT_DELAY || !rcu_gp_in_progress(rsp)) {
  1346. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  1347. return;
  1348. }
  1349. WRITE_ONCE(rsp->jiffies_stall,
  1350. jiffies + 3 * rcu_jiffies_till_stall_check() + 3);
  1351. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  1352. /*
  1353. * OK, time to rat on our buddy...
  1354. * See Documentation/RCU/stallwarn.txt for info on how to debug
  1355. * RCU CPU stall warnings.
  1356. */
  1357. pr_err("INFO: %s detected stalls on CPUs/tasks:",
  1358. rsp->name);
  1359. print_cpu_stall_info_begin();
  1360. rcu_for_each_leaf_node(rsp, rnp) {
  1361. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  1362. ndetected += rcu_print_task_stall(rnp);
  1363. if (rnp->qsmask != 0) {
  1364. for_each_leaf_node_possible_cpu(rnp, cpu)
  1365. if (rnp->qsmask & leaf_node_cpu_bit(rnp, cpu)) {
  1366. print_cpu_stall_info(rsp, cpu);
  1367. ndetected++;
  1368. }
  1369. }
  1370. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  1371. }
  1372. print_cpu_stall_info_end();
  1373. for_each_possible_cpu(cpu)
  1374. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda,
  1375. cpu)->cblist);
  1376. pr_cont("(detected by %d, t=%ld jiffies, g=%ld, c=%ld, q=%lu)\n",
  1377. smp_processor_id(), (long)(jiffies - rsp->gp_start),
  1378. (long)rsp->gpnum, (long)rsp->completed, totqlen);
  1379. if (ndetected) {
  1380. rcu_dump_cpu_stacks(rsp);
  1381. /* Complain about tasks blocking the grace period. */
  1382. rcu_print_detail_task_stall(rsp);
  1383. } else {
  1384. if (READ_ONCE(rsp->gpnum) != gpnum ||
  1385. READ_ONCE(rsp->completed) == gpnum) {
  1386. pr_err("INFO: Stall ended before state dump start\n");
  1387. } else {
  1388. j = jiffies;
  1389. gpa = READ_ONCE(rsp->gp_activity);
  1390. pr_err("All QSes seen, last %s kthread activity %ld (%ld-%ld), jiffies_till_next_fqs=%ld, root ->qsmask %#lx\n",
  1391. rsp->name, j - gpa, j, gpa,
  1392. jiffies_till_next_fqs,
  1393. rcu_get_root(rsp)->qsmask);
  1394. /* In this case, the current CPU might be at fault. */
  1395. sched_show_task(current);
  1396. }
  1397. }
  1398. rcu_check_gp_kthread_starvation(rsp);
  1399. panic_on_rcu_stall();
  1400. force_quiescent_state(rsp); /* Kick them all. */
  1401. }
  1402. static void print_cpu_stall(struct rcu_state *rsp)
  1403. {
  1404. int cpu;
  1405. unsigned long flags;
  1406. struct rcu_data *rdp = this_cpu_ptr(rsp->rda);
  1407. struct rcu_node *rnp = rcu_get_root(rsp);
  1408. long totqlen = 0;
  1409. /* Kick and suppress, if so configured. */
  1410. rcu_stall_kick_kthreads(rsp);
  1411. if (rcu_cpu_stall_suppress)
  1412. return;
  1413. /*
  1414. * OK, time to rat on ourselves...
  1415. * See Documentation/RCU/stallwarn.txt for info on how to debug
  1416. * RCU CPU stall warnings.
  1417. */
  1418. pr_err("INFO: %s self-detected stall on CPU", rsp->name);
  1419. print_cpu_stall_info_begin();
  1420. raw_spin_lock_irqsave_rcu_node(rdp->mynode, flags);
  1421. print_cpu_stall_info(rsp, smp_processor_id());
  1422. raw_spin_unlock_irqrestore_rcu_node(rdp->mynode, flags);
  1423. print_cpu_stall_info_end();
  1424. for_each_possible_cpu(cpu)
  1425. totqlen += rcu_segcblist_n_cbs(&per_cpu_ptr(rsp->rda,
  1426. cpu)->cblist);
  1427. pr_cont(" (t=%lu jiffies g=%ld c=%ld q=%lu)\n",
  1428. jiffies - rsp->gp_start,
  1429. (long)rsp->gpnum, (long)rsp->completed, totqlen);
  1430. rcu_check_gp_kthread_starvation(rsp);
  1431. rcu_dump_cpu_stacks(rsp);
  1432. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  1433. if (ULONG_CMP_GE(jiffies, READ_ONCE(rsp->jiffies_stall)))
  1434. WRITE_ONCE(rsp->jiffies_stall,
  1435. jiffies + 3 * rcu_jiffies_till_stall_check() + 3);
  1436. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  1437. panic_on_rcu_stall();
  1438. /*
  1439. * Attempt to revive the RCU machinery by forcing a context switch.
  1440. *
  1441. * A context switch would normally allow the RCU state machine to make
  1442. * progress and it could be we're stuck in kernel space without context
  1443. * switches for an entirely unreasonable amount of time.
  1444. */
  1445. resched_cpu(smp_processor_id());
  1446. }
  1447. static void check_cpu_stall(struct rcu_state *rsp, struct rcu_data *rdp)
  1448. {
  1449. unsigned long completed;
  1450. unsigned long gpnum;
  1451. unsigned long gps;
  1452. unsigned long j;
  1453. unsigned long js;
  1454. struct rcu_node *rnp;
  1455. if ((rcu_cpu_stall_suppress && !rcu_kick_kthreads) ||
  1456. !rcu_gp_in_progress(rsp))
  1457. return;
  1458. rcu_stall_kick_kthreads(rsp);
  1459. j = jiffies;
  1460. /*
  1461. * Lots of memory barriers to reject false positives.
  1462. *
  1463. * The idea is to pick up rsp->gpnum, then rsp->jiffies_stall,
  1464. * then rsp->gp_start, and finally rsp->completed. These values
  1465. * are updated in the opposite order with memory barriers (or
  1466. * equivalent) during grace-period initialization and cleanup.
  1467. * Now, a false positive can occur if we get an new value of
  1468. * rsp->gp_start and a old value of rsp->jiffies_stall. But given
  1469. * the memory barriers, the only way that this can happen is if one
  1470. * grace period ends and another starts between these two fetches.
  1471. * Detect this by comparing rsp->completed with the previous fetch
  1472. * from rsp->gpnum.
  1473. *
  1474. * Given this check, comparisons of jiffies, rsp->jiffies_stall,
  1475. * and rsp->gp_start suffice to forestall false positives.
  1476. */
  1477. gpnum = READ_ONCE(rsp->gpnum);
  1478. smp_rmb(); /* Pick up ->gpnum first... */
  1479. js = READ_ONCE(rsp->jiffies_stall);
  1480. smp_rmb(); /* ...then ->jiffies_stall before the rest... */
  1481. gps = READ_ONCE(rsp->gp_start);
  1482. smp_rmb(); /* ...and finally ->gp_start before ->completed. */
  1483. completed = READ_ONCE(rsp->completed);
  1484. if (ULONG_CMP_GE(completed, gpnum) ||
  1485. ULONG_CMP_LT(j, js) ||
  1486. ULONG_CMP_GE(gps, js))
  1487. return; /* No stall or GP completed since entering function. */
  1488. rnp = rdp->mynode;
  1489. if (rcu_gp_in_progress(rsp) &&
  1490. (READ_ONCE(rnp->qsmask) & rdp->grpmask)) {
  1491. /* We haven't checked in, so go dump stack. */
  1492. print_cpu_stall(rsp);
  1493. } else if (rcu_gp_in_progress(rsp) &&
  1494. ULONG_CMP_GE(j, js + RCU_STALL_RAT_DELAY)) {
  1495. /* They had a few time units to dump stack, so complain. */
  1496. print_other_cpu_stall(rsp, gpnum);
  1497. }
  1498. }
  1499. /**
  1500. * rcu_cpu_stall_reset - prevent further stall warnings in current grace period
  1501. *
  1502. * Set the stall-warning timeout way off into the future, thus preventing
  1503. * any RCU CPU stall-warning messages from appearing in the current set of
  1504. * RCU grace periods.
  1505. *
  1506. * The caller must disable hard irqs.
  1507. */
  1508. void rcu_cpu_stall_reset(void)
  1509. {
  1510. struct rcu_state *rsp;
  1511. for_each_rcu_flavor(rsp)
  1512. WRITE_ONCE(rsp->jiffies_stall, jiffies + ULONG_MAX / 2);
  1513. }
  1514. /*
  1515. * Determine the value that ->completed will have at the end of the
  1516. * next subsequent grace period. This is used to tag callbacks so that
  1517. * a CPU can invoke callbacks in a timely fashion even if that CPU has
  1518. * been dyntick-idle for an extended period with callbacks under the
  1519. * influence of RCU_FAST_NO_HZ.
  1520. *
  1521. * The caller must hold rnp->lock with interrupts disabled.
  1522. */
  1523. static unsigned long rcu_cbs_completed(struct rcu_state *rsp,
  1524. struct rcu_node *rnp)
  1525. {
  1526. lockdep_assert_held(&rnp->lock);
  1527. /*
  1528. * If RCU is idle, we just wait for the next grace period.
  1529. * But we can only be sure that RCU is idle if we are looking
  1530. * at the root rcu_node structure -- otherwise, a new grace
  1531. * period might have started, but just not yet gotten around
  1532. * to initializing the current non-root rcu_node structure.
  1533. */
  1534. if (rcu_get_root(rsp) == rnp && rnp->gpnum == rnp->completed)
  1535. return rnp->completed + 1;
  1536. /*
  1537. * Otherwise, wait for a possible partial grace period and
  1538. * then the subsequent full grace period.
  1539. */
  1540. return rnp->completed + 2;
  1541. }
  1542. /*
  1543. * Trace-event helper function for rcu_start_future_gp() and
  1544. * rcu_nocb_wait_gp().
  1545. */
  1546. static void trace_rcu_future_gp(struct rcu_node *rnp, struct rcu_data *rdp,
  1547. unsigned long c, const char *s)
  1548. {
  1549. trace_rcu_future_grace_period(rdp->rsp->name, rnp->gpnum,
  1550. rnp->completed, c, rnp->level,
  1551. rnp->grplo, rnp->grphi, s);
  1552. }
  1553. /*
  1554. * Start some future grace period, as needed to handle newly arrived
  1555. * callbacks. The required future grace periods are recorded in each
  1556. * rcu_node structure's ->need_future_gp field. Returns true if there
  1557. * is reason to awaken the grace-period kthread.
  1558. *
  1559. * The caller must hold the specified rcu_node structure's ->lock.
  1560. */
  1561. static bool __maybe_unused
  1562. rcu_start_future_gp(struct rcu_node *rnp, struct rcu_data *rdp,
  1563. unsigned long *c_out)
  1564. {
  1565. unsigned long c;
  1566. bool ret = false;
  1567. struct rcu_node *rnp_root = rcu_get_root(rdp->rsp);
  1568. lockdep_assert_held(&rnp->lock);
  1569. /*
  1570. * Pick up grace-period number for new callbacks. If this
  1571. * grace period is already marked as needed, return to the caller.
  1572. */
  1573. c = rcu_cbs_completed(rdp->rsp, rnp);
  1574. trace_rcu_future_gp(rnp, rdp, c, TPS("Startleaf"));
  1575. if (rnp->need_future_gp[c & 0x1]) {
  1576. trace_rcu_future_gp(rnp, rdp, c, TPS("Prestartleaf"));
  1577. goto out;
  1578. }
  1579. /*
  1580. * If either this rcu_node structure or the root rcu_node structure
  1581. * believe that a grace period is in progress, then we must wait
  1582. * for the one following, which is in "c". Because our request
  1583. * will be noticed at the end of the current grace period, we don't
  1584. * need to explicitly start one. We only do the lockless check
  1585. * of rnp_root's fields if the current rcu_node structure thinks
  1586. * there is no grace period in flight, and because we hold rnp->lock,
  1587. * the only possible change is when rnp_root's two fields are
  1588. * equal, in which case rnp_root->gpnum might be concurrently
  1589. * incremented. But that is OK, as it will just result in our
  1590. * doing some extra useless work.
  1591. */
  1592. if (rnp->gpnum != rnp->completed ||
  1593. READ_ONCE(rnp_root->gpnum) != READ_ONCE(rnp_root->completed)) {
  1594. rnp->need_future_gp[c & 0x1]++;
  1595. trace_rcu_future_gp(rnp, rdp, c, TPS("Startedleaf"));
  1596. goto out;
  1597. }
  1598. /*
  1599. * There might be no grace period in progress. If we don't already
  1600. * hold it, acquire the root rcu_node structure's lock in order to
  1601. * start one (if needed).
  1602. */
  1603. if (rnp != rnp_root)
  1604. raw_spin_lock_rcu_node(rnp_root);
  1605. /*
  1606. * Get a new grace-period number. If there really is no grace
  1607. * period in progress, it will be smaller than the one we obtained
  1608. * earlier. Adjust callbacks as needed.
  1609. */
  1610. c = rcu_cbs_completed(rdp->rsp, rnp_root);
  1611. if (!rcu_is_nocb_cpu(rdp->cpu))
  1612. (void)rcu_segcblist_accelerate(&rdp->cblist, c);
  1613. /*
  1614. * If the needed for the required grace period is already
  1615. * recorded, trace and leave.
  1616. */
  1617. if (rnp_root->need_future_gp[c & 0x1]) {
  1618. trace_rcu_future_gp(rnp, rdp, c, TPS("Prestartedroot"));
  1619. goto unlock_out;
  1620. }
  1621. /* Record the need for the future grace period. */
  1622. rnp_root->need_future_gp[c & 0x1]++;
  1623. /* If a grace period is not already in progress, start one. */
  1624. if (rnp_root->gpnum != rnp_root->completed) {
  1625. trace_rcu_future_gp(rnp, rdp, c, TPS("Startedleafroot"));
  1626. } else {
  1627. trace_rcu_future_gp(rnp, rdp, c, TPS("Startedroot"));
  1628. ret = rcu_start_gp_advanced(rdp->rsp, rnp_root, rdp);
  1629. }
  1630. unlock_out:
  1631. if (rnp != rnp_root)
  1632. raw_spin_unlock_rcu_node(rnp_root);
  1633. out:
  1634. if (c_out != NULL)
  1635. *c_out = c;
  1636. return ret;
  1637. }
  1638. /*
  1639. * Clean up any old requests for the just-ended grace period. Also return
  1640. * whether any additional grace periods have been requested.
  1641. */
  1642. static int rcu_future_gp_cleanup(struct rcu_state *rsp, struct rcu_node *rnp)
  1643. {
  1644. int c = rnp->completed;
  1645. int needmore;
  1646. struct rcu_data *rdp = this_cpu_ptr(rsp->rda);
  1647. rnp->need_future_gp[c & 0x1] = 0;
  1648. needmore = rnp->need_future_gp[(c + 1) & 0x1];
  1649. trace_rcu_future_gp(rnp, rdp, c,
  1650. needmore ? TPS("CleanupMore") : TPS("Cleanup"));
  1651. return needmore;
  1652. }
  1653. /*
  1654. * Awaken the grace-period kthread for the specified flavor of RCU.
  1655. * Don't do a self-awaken, and don't bother awakening when there is
  1656. * nothing for the grace-period kthread to do (as in several CPUs
  1657. * raced to awaken, and we lost), and finally don't try to awaken
  1658. * a kthread that has not yet been created.
  1659. */
  1660. static void rcu_gp_kthread_wake(struct rcu_state *rsp)
  1661. {
  1662. if (current == rsp->gp_kthread ||
  1663. !READ_ONCE(rsp->gp_flags) ||
  1664. !rsp->gp_kthread)
  1665. return;
  1666. swake_up(&rsp->gp_wq);
  1667. }
  1668. /*
  1669. * If there is room, assign a ->completed number to any callbacks on
  1670. * this CPU that have not already been assigned. Also accelerate any
  1671. * callbacks that were previously assigned a ->completed number that has
  1672. * since proven to be too conservative, which can happen if callbacks get
  1673. * assigned a ->completed number while RCU is idle, but with reference to
  1674. * a non-root rcu_node structure. This function is idempotent, so it does
  1675. * not hurt to call it repeatedly. Returns an flag saying that we should
  1676. * awaken the RCU grace-period kthread.
  1677. *
  1678. * The caller must hold rnp->lock with interrupts disabled.
  1679. */
  1680. static bool rcu_accelerate_cbs(struct rcu_state *rsp, struct rcu_node *rnp,
  1681. struct rcu_data *rdp)
  1682. {
  1683. bool ret = false;
  1684. lockdep_assert_held(&rnp->lock);
  1685. /* If no pending (not yet ready to invoke) callbacks, nothing to do. */
  1686. if (!rcu_segcblist_pend_cbs(&rdp->cblist))
  1687. return false;
  1688. /*
  1689. * Callbacks are often registered with incomplete grace-period
  1690. * information. Something about the fact that getting exact
  1691. * information requires acquiring a global lock... RCU therefore
  1692. * makes a conservative estimate of the grace period number at which
  1693. * a given callback will become ready to invoke. The following
  1694. * code checks this estimate and improves it when possible, thus
  1695. * accelerating callback invocation to an earlier grace-period
  1696. * number.
  1697. */
  1698. if (rcu_segcblist_accelerate(&rdp->cblist, rcu_cbs_completed(rsp, rnp)))
  1699. ret = rcu_start_future_gp(rnp, rdp, NULL);
  1700. /* Trace depending on how much we were able to accelerate. */
  1701. if (rcu_segcblist_restempty(&rdp->cblist, RCU_WAIT_TAIL))
  1702. trace_rcu_grace_period(rsp->name, rdp->gpnum, TPS("AccWaitCB"));
  1703. else
  1704. trace_rcu_grace_period(rsp->name, rdp->gpnum, TPS("AccReadyCB"));
  1705. return ret;
  1706. }
  1707. /*
  1708. * Move any callbacks whose grace period has completed to the
  1709. * RCU_DONE_TAIL sublist, then compact the remaining sublists and
  1710. * assign ->completed numbers to any callbacks in the RCU_NEXT_TAIL
  1711. * sublist. This function is idempotent, so it does not hurt to
  1712. * invoke it repeatedly. As long as it is not invoked -too- often...
  1713. * Returns true if the RCU grace-period kthread needs to be awakened.
  1714. *
  1715. * The caller must hold rnp->lock with interrupts disabled.
  1716. */
  1717. static bool rcu_advance_cbs(struct rcu_state *rsp, struct rcu_node *rnp,
  1718. struct rcu_data *rdp)
  1719. {
  1720. lockdep_assert_held(&rnp->lock);
  1721. /* If no pending (not yet ready to invoke) callbacks, nothing to do. */
  1722. if (!rcu_segcblist_pend_cbs(&rdp->cblist))
  1723. return false;
  1724. /*
  1725. * Find all callbacks whose ->completed numbers indicate that they
  1726. * are ready to invoke, and put them into the RCU_DONE_TAIL sublist.
  1727. */
  1728. rcu_segcblist_advance(&rdp->cblist, rnp->completed);
  1729. /* Classify any remaining callbacks. */
  1730. return rcu_accelerate_cbs(rsp, rnp, rdp);
  1731. }
  1732. /*
  1733. * Update CPU-local rcu_data state to record the beginnings and ends of
  1734. * grace periods. The caller must hold the ->lock of the leaf rcu_node
  1735. * structure corresponding to the current CPU, and must have irqs disabled.
  1736. * Returns true if the grace-period kthread needs to be awakened.
  1737. */
  1738. static bool __note_gp_changes(struct rcu_state *rsp, struct rcu_node *rnp,
  1739. struct rcu_data *rdp)
  1740. {
  1741. bool ret;
  1742. bool need_gp;
  1743. lockdep_assert_held(&rnp->lock);
  1744. /* Handle the ends of any preceding grace periods first. */
  1745. if (rdp->completed == rnp->completed &&
  1746. !unlikely(READ_ONCE(rdp->gpwrap))) {
  1747. /* No grace period end, so just accelerate recent callbacks. */
  1748. ret = rcu_accelerate_cbs(rsp, rnp, rdp);
  1749. } else {
  1750. /* Advance callbacks. */
  1751. ret = rcu_advance_cbs(rsp, rnp, rdp);
  1752. /* Remember that we saw this grace-period completion. */
  1753. rdp->completed = rnp->completed;
  1754. trace_rcu_grace_period(rsp->name, rdp->gpnum, TPS("cpuend"));
  1755. }
  1756. if (rdp->gpnum != rnp->gpnum || unlikely(READ_ONCE(rdp->gpwrap))) {
  1757. /*
  1758. * If the current grace period is waiting for this CPU,
  1759. * set up to detect a quiescent state, otherwise don't
  1760. * go looking for one.
  1761. */
  1762. rdp->gpnum = rnp->gpnum;
  1763. trace_rcu_grace_period(rsp->name, rdp->gpnum, TPS("cpustart"));
  1764. need_gp = !!(rnp->qsmask & rdp->grpmask);
  1765. rdp->cpu_no_qs.b.norm = need_gp;
  1766. rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr);
  1767. rdp->core_needs_qs = need_gp;
  1768. zero_cpu_stall_ticks(rdp);
  1769. WRITE_ONCE(rdp->gpwrap, false);
  1770. rcu_gpnum_ovf(rnp, rdp);
  1771. }
  1772. return ret;
  1773. }
  1774. static void note_gp_changes(struct rcu_state *rsp, struct rcu_data *rdp)
  1775. {
  1776. unsigned long flags;
  1777. bool needwake;
  1778. struct rcu_node *rnp;
  1779. local_irq_save(flags);
  1780. rnp = rdp->mynode;
  1781. if ((rdp->gpnum == READ_ONCE(rnp->gpnum) &&
  1782. rdp->completed == READ_ONCE(rnp->completed) &&
  1783. !unlikely(READ_ONCE(rdp->gpwrap))) || /* w/out lock. */
  1784. !raw_spin_trylock_rcu_node(rnp)) { /* irqs already off, so later. */
  1785. local_irq_restore(flags);
  1786. return;
  1787. }
  1788. needwake = __note_gp_changes(rsp, rnp, rdp);
  1789. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  1790. if (needwake)
  1791. rcu_gp_kthread_wake(rsp);
  1792. }
  1793. static void rcu_gp_slow(struct rcu_state *rsp, int delay)
  1794. {
  1795. if (delay > 0 &&
  1796. !(rsp->gpnum % (rcu_num_nodes * PER_RCU_NODE_PERIOD * delay)))
  1797. schedule_timeout_uninterruptible(delay);
  1798. }
  1799. /*
  1800. * Initialize a new grace period. Return false if no grace period required.
  1801. */
  1802. static bool rcu_gp_init(struct rcu_state *rsp)
  1803. {
  1804. unsigned long oldmask;
  1805. struct rcu_data *rdp;
  1806. struct rcu_node *rnp = rcu_get_root(rsp);
  1807. WRITE_ONCE(rsp->gp_activity, jiffies);
  1808. raw_spin_lock_irq_rcu_node(rnp);
  1809. if (!READ_ONCE(rsp->gp_flags)) {
  1810. /* Spurious wakeup, tell caller to go back to sleep. */
  1811. raw_spin_unlock_irq_rcu_node(rnp);
  1812. return false;
  1813. }
  1814. WRITE_ONCE(rsp->gp_flags, 0); /* Clear all flags: New grace period. */
  1815. if (WARN_ON_ONCE(rcu_gp_in_progress(rsp))) {
  1816. /*
  1817. * Grace period already in progress, don't start another.
  1818. * Not supposed to be able to happen.
  1819. */
  1820. raw_spin_unlock_irq_rcu_node(rnp);
  1821. return false;
  1822. }
  1823. /* Advance to a new grace period and initialize state. */
  1824. record_gp_stall_check_time(rsp);
  1825. /* Record GP times before starting GP, hence smp_store_release(). */
  1826. smp_store_release(&rsp->gpnum, rsp->gpnum + 1);
  1827. trace_rcu_grace_period(rsp->name, rsp->gpnum, TPS("start"));
  1828. raw_spin_unlock_irq_rcu_node(rnp);
  1829. /*
  1830. * Apply per-leaf buffered online and offline operations to the
  1831. * rcu_node tree. Note that this new grace period need not wait
  1832. * for subsequent online CPUs, and that quiescent-state forcing
  1833. * will handle subsequent offline CPUs.
  1834. */
  1835. rcu_for_each_leaf_node(rsp, rnp) {
  1836. rcu_gp_slow(rsp, gp_preinit_delay);
  1837. raw_spin_lock_irq_rcu_node(rnp);
  1838. if (rnp->qsmaskinit == rnp->qsmaskinitnext &&
  1839. !rnp->wait_blkd_tasks) {
  1840. /* Nothing to do on this leaf rcu_node structure. */
  1841. raw_spin_unlock_irq_rcu_node(rnp);
  1842. continue;
  1843. }
  1844. /* Record old state, apply changes to ->qsmaskinit field. */
  1845. oldmask = rnp->qsmaskinit;
  1846. rnp->qsmaskinit = rnp->qsmaskinitnext;
  1847. /* If zero-ness of ->qsmaskinit changed, propagate up tree. */
  1848. if (!oldmask != !rnp->qsmaskinit) {
  1849. if (!oldmask) /* First online CPU for this rcu_node. */
  1850. rcu_init_new_rnp(rnp);
  1851. else if (rcu_preempt_has_tasks(rnp)) /* blocked tasks */
  1852. rnp->wait_blkd_tasks = true;
  1853. else /* Last offline CPU and can propagate. */
  1854. rcu_cleanup_dead_rnp(rnp);
  1855. }
  1856. /*
  1857. * If all waited-on tasks from prior grace period are
  1858. * done, and if all this rcu_node structure's CPUs are
  1859. * still offline, propagate up the rcu_node tree and
  1860. * clear ->wait_blkd_tasks. Otherwise, if one of this
  1861. * rcu_node structure's CPUs has since come back online,
  1862. * simply clear ->wait_blkd_tasks (but rcu_cleanup_dead_rnp()
  1863. * checks for this, so just call it unconditionally).
  1864. */
  1865. if (rnp->wait_blkd_tasks &&
  1866. (!rcu_preempt_has_tasks(rnp) ||
  1867. rnp->qsmaskinit)) {
  1868. rnp->wait_blkd_tasks = false;
  1869. rcu_cleanup_dead_rnp(rnp);
  1870. }
  1871. raw_spin_unlock_irq_rcu_node(rnp);
  1872. }
  1873. /*
  1874. * Set the quiescent-state-needed bits in all the rcu_node
  1875. * structures for all currently online CPUs in breadth-first order,
  1876. * starting from the root rcu_node structure, relying on the layout
  1877. * of the tree within the rsp->node[] array. Note that other CPUs
  1878. * will access only the leaves of the hierarchy, thus seeing that no
  1879. * grace period is in progress, at least until the corresponding
  1880. * leaf node has been initialized.
  1881. *
  1882. * The grace period cannot complete until the initialization
  1883. * process finishes, because this kthread handles both.
  1884. */
  1885. rcu_for_each_node_breadth_first(rsp, rnp) {
  1886. rcu_gp_slow(rsp, gp_init_delay);
  1887. raw_spin_lock_irq_rcu_node(rnp);
  1888. rdp = this_cpu_ptr(rsp->rda);
  1889. rcu_preempt_check_blocked_tasks(rnp);
  1890. rnp->qsmask = rnp->qsmaskinit;
  1891. WRITE_ONCE(rnp->gpnum, rsp->gpnum);
  1892. if (WARN_ON_ONCE(rnp->completed != rsp->completed))
  1893. WRITE_ONCE(rnp->completed, rsp->completed);
  1894. if (rnp == rdp->mynode)
  1895. (void)__note_gp_changes(rsp, rnp, rdp);
  1896. rcu_preempt_boost_start_gp(rnp);
  1897. trace_rcu_grace_period_init(rsp->name, rnp->gpnum,
  1898. rnp->level, rnp->grplo,
  1899. rnp->grphi, rnp->qsmask);
  1900. raw_spin_unlock_irq_rcu_node(rnp);
  1901. cond_resched_rcu_qs();
  1902. WRITE_ONCE(rsp->gp_activity, jiffies);
  1903. }
  1904. return true;
  1905. }
  1906. /*
  1907. * Helper function for swait_event_idle() wakeup at force-quiescent-state
  1908. * time.
  1909. */
  1910. static bool rcu_gp_fqs_check_wake(struct rcu_state *rsp, int *gfp)
  1911. {
  1912. struct rcu_node *rnp = rcu_get_root(rsp);
  1913. /* Someone like call_rcu() requested a force-quiescent-state scan. */
  1914. *gfp = READ_ONCE(rsp->gp_flags);
  1915. if (*gfp & RCU_GP_FLAG_FQS)
  1916. return true;
  1917. /* The current grace period has completed. */
  1918. if (!READ_ONCE(rnp->qsmask) && !rcu_preempt_blocked_readers_cgp(rnp))
  1919. return true;
  1920. return false;
  1921. }
  1922. /*
  1923. * Do one round of quiescent-state forcing.
  1924. */
  1925. static void rcu_gp_fqs(struct rcu_state *rsp, bool first_time)
  1926. {
  1927. struct rcu_node *rnp = rcu_get_root(rsp);
  1928. WRITE_ONCE(rsp->gp_activity, jiffies);
  1929. rsp->n_force_qs++;
  1930. if (first_time) {
  1931. /* Collect dyntick-idle snapshots. */
  1932. force_qs_rnp(rsp, dyntick_save_progress_counter);
  1933. } else {
  1934. /* Handle dyntick-idle and offline CPUs. */
  1935. force_qs_rnp(rsp, rcu_implicit_dynticks_qs);
  1936. }
  1937. /* Clear flag to prevent immediate re-entry. */
  1938. if (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) {
  1939. raw_spin_lock_irq_rcu_node(rnp);
  1940. WRITE_ONCE(rsp->gp_flags,
  1941. READ_ONCE(rsp->gp_flags) & ~RCU_GP_FLAG_FQS);
  1942. raw_spin_unlock_irq_rcu_node(rnp);
  1943. }
  1944. }
  1945. /*
  1946. * Clean up after the old grace period.
  1947. */
  1948. static void rcu_gp_cleanup(struct rcu_state *rsp)
  1949. {
  1950. unsigned long gp_duration;
  1951. bool needgp = false;
  1952. int nocb = 0;
  1953. struct rcu_data *rdp;
  1954. struct rcu_node *rnp = rcu_get_root(rsp);
  1955. struct swait_queue_head *sq;
  1956. WRITE_ONCE(rsp->gp_activity, jiffies);
  1957. raw_spin_lock_irq_rcu_node(rnp);
  1958. gp_duration = jiffies - rsp->gp_start;
  1959. if (gp_duration > rsp->gp_max)
  1960. rsp->gp_max = gp_duration;
  1961. /*
  1962. * We know the grace period is complete, but to everyone else
  1963. * it appears to still be ongoing. But it is also the case
  1964. * that to everyone else it looks like there is nothing that
  1965. * they can do to advance the grace period. It is therefore
  1966. * safe for us to drop the lock in order to mark the grace
  1967. * period as completed in all of the rcu_node structures.
  1968. */
  1969. raw_spin_unlock_irq_rcu_node(rnp);
  1970. /*
  1971. * Propagate new ->completed value to rcu_node structures so
  1972. * that other CPUs don't have to wait until the start of the next
  1973. * grace period to process their callbacks. This also avoids
  1974. * some nasty RCU grace-period initialization races by forcing
  1975. * the end of the current grace period to be completely recorded in
  1976. * all of the rcu_node structures before the beginning of the next
  1977. * grace period is recorded in any of the rcu_node structures.
  1978. */
  1979. rcu_for_each_node_breadth_first(rsp, rnp) {
  1980. raw_spin_lock_irq_rcu_node(rnp);
  1981. WARN_ON_ONCE(rcu_preempt_blocked_readers_cgp(rnp));
  1982. WARN_ON_ONCE(rnp->qsmask);
  1983. WRITE_ONCE(rnp->completed, rsp->gpnum);
  1984. rdp = this_cpu_ptr(rsp->rda);
  1985. if (rnp == rdp->mynode)
  1986. needgp = __note_gp_changes(rsp, rnp, rdp) || needgp;
  1987. /* smp_mb() provided by prior unlock-lock pair. */
  1988. nocb += rcu_future_gp_cleanup(rsp, rnp);
  1989. sq = rcu_nocb_gp_get(rnp);
  1990. raw_spin_unlock_irq_rcu_node(rnp);
  1991. rcu_nocb_gp_cleanup(sq);
  1992. cond_resched_rcu_qs();
  1993. WRITE_ONCE(rsp->gp_activity, jiffies);
  1994. rcu_gp_slow(rsp, gp_cleanup_delay);
  1995. }
  1996. rnp = rcu_get_root(rsp);
  1997. raw_spin_lock_irq_rcu_node(rnp); /* Order GP before ->completed update. */
  1998. rcu_nocb_gp_set(rnp, nocb);
  1999. /* Declare grace period done. */
  2000. WRITE_ONCE(rsp->completed, rsp->gpnum);
  2001. trace_rcu_grace_period(rsp->name, rsp->completed, TPS("end"));
  2002. rsp->gp_state = RCU_GP_IDLE;
  2003. rdp = this_cpu_ptr(rsp->rda);
  2004. /* Advance CBs to reduce false positives below. */
  2005. needgp = rcu_advance_cbs(rsp, rnp, rdp) || needgp;
  2006. if (needgp || cpu_needs_another_gp(rsp, rdp)) {
  2007. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT);
  2008. trace_rcu_grace_period(rsp->name,
  2009. READ_ONCE(rsp->gpnum),
  2010. TPS("newreq"));
  2011. }
  2012. raw_spin_unlock_irq_rcu_node(rnp);
  2013. }
  2014. /*
  2015. * Body of kthread that handles grace periods.
  2016. */
  2017. static int __noreturn rcu_gp_kthread(void *arg)
  2018. {
  2019. bool first_gp_fqs;
  2020. int gf;
  2021. unsigned long j;
  2022. int ret;
  2023. struct rcu_state *rsp = arg;
  2024. struct rcu_node *rnp = rcu_get_root(rsp);
  2025. rcu_bind_gp_kthread();
  2026. for (;;) {
  2027. /* Handle grace-period start. */
  2028. for (;;) {
  2029. trace_rcu_grace_period(rsp->name,
  2030. READ_ONCE(rsp->gpnum),
  2031. TPS("reqwait"));
  2032. rsp->gp_state = RCU_GP_WAIT_GPS;
  2033. swait_event_idle(rsp->gp_wq, READ_ONCE(rsp->gp_flags) &
  2034. RCU_GP_FLAG_INIT);
  2035. rsp->gp_state = RCU_GP_DONE_GPS;
  2036. /* Locking provides needed memory barrier. */
  2037. if (rcu_gp_init(rsp))
  2038. break;
  2039. cond_resched_rcu_qs();
  2040. WRITE_ONCE(rsp->gp_activity, jiffies);
  2041. WARN_ON(signal_pending(current));
  2042. trace_rcu_grace_period(rsp->name,
  2043. READ_ONCE(rsp->gpnum),
  2044. TPS("reqwaitsig"));
  2045. }
  2046. /* Handle quiescent-state forcing. */
  2047. first_gp_fqs = true;
  2048. j = jiffies_till_first_fqs;
  2049. if (j > HZ) {
  2050. j = HZ;
  2051. jiffies_till_first_fqs = HZ;
  2052. }
  2053. ret = 0;
  2054. for (;;) {
  2055. if (!ret) {
  2056. rsp->jiffies_force_qs = jiffies + j;
  2057. WRITE_ONCE(rsp->jiffies_kick_kthreads,
  2058. jiffies + 3 * j);
  2059. }
  2060. trace_rcu_grace_period(rsp->name,
  2061. READ_ONCE(rsp->gpnum),
  2062. TPS("fqswait"));
  2063. rsp->gp_state = RCU_GP_WAIT_FQS;
  2064. ret = swait_event_idle_timeout(rsp->gp_wq,
  2065. rcu_gp_fqs_check_wake(rsp, &gf), j);
  2066. rsp->gp_state = RCU_GP_DOING_FQS;
  2067. /* Locking provides needed memory barriers. */
  2068. /* If grace period done, leave loop. */
  2069. if (!READ_ONCE(rnp->qsmask) &&
  2070. !rcu_preempt_blocked_readers_cgp(rnp))
  2071. break;
  2072. /* If time for quiescent-state forcing, do it. */
  2073. if (ULONG_CMP_GE(jiffies, rsp->jiffies_force_qs) ||
  2074. (gf & RCU_GP_FLAG_FQS)) {
  2075. trace_rcu_grace_period(rsp->name,
  2076. READ_ONCE(rsp->gpnum),
  2077. TPS("fqsstart"));
  2078. rcu_gp_fqs(rsp, first_gp_fqs);
  2079. first_gp_fqs = false;
  2080. trace_rcu_grace_period(rsp->name,
  2081. READ_ONCE(rsp->gpnum),
  2082. TPS("fqsend"));
  2083. cond_resched_rcu_qs();
  2084. WRITE_ONCE(rsp->gp_activity, jiffies);
  2085. ret = 0; /* Force full wait till next FQS. */
  2086. j = jiffies_till_next_fqs;
  2087. if (j > HZ) {
  2088. j = HZ;
  2089. jiffies_till_next_fqs = HZ;
  2090. } else if (j < 1) {
  2091. j = 1;
  2092. jiffies_till_next_fqs = 1;
  2093. }
  2094. } else {
  2095. /* Deal with stray signal. */
  2096. cond_resched_rcu_qs();
  2097. WRITE_ONCE(rsp->gp_activity, jiffies);
  2098. WARN_ON(signal_pending(current));
  2099. trace_rcu_grace_period(rsp->name,
  2100. READ_ONCE(rsp->gpnum),
  2101. TPS("fqswaitsig"));
  2102. ret = 1; /* Keep old FQS timing. */
  2103. j = jiffies;
  2104. if (time_after(jiffies, rsp->jiffies_force_qs))
  2105. j = 1;
  2106. else
  2107. j = rsp->jiffies_force_qs - j;
  2108. }
  2109. }
  2110. /* Handle grace-period end. */
  2111. rsp->gp_state = RCU_GP_CLEANUP;
  2112. rcu_gp_cleanup(rsp);
  2113. rsp->gp_state = RCU_GP_CLEANED;
  2114. }
  2115. }
  2116. /*
  2117. * Start a new RCU grace period if warranted, re-initializing the hierarchy
  2118. * in preparation for detecting the next grace period. The caller must hold
  2119. * the root node's ->lock and hard irqs must be disabled.
  2120. *
  2121. * Note that it is legal for a dying CPU (which is marked as offline) to
  2122. * invoke this function. This can happen when the dying CPU reports its
  2123. * quiescent state.
  2124. *
  2125. * Returns true if the grace-period kthread must be awakened.
  2126. */
  2127. static bool
  2128. rcu_start_gp_advanced(struct rcu_state *rsp, struct rcu_node *rnp,
  2129. struct rcu_data *rdp)
  2130. {
  2131. lockdep_assert_held(&rnp->lock);
  2132. if (!rsp->gp_kthread || !cpu_needs_another_gp(rsp, rdp)) {
  2133. /*
  2134. * Either we have not yet spawned the grace-period
  2135. * task, this CPU does not need another grace period,
  2136. * or a grace period is already in progress.
  2137. * Either way, don't start a new grace period.
  2138. */
  2139. return false;
  2140. }
  2141. WRITE_ONCE(rsp->gp_flags, RCU_GP_FLAG_INIT);
  2142. trace_rcu_grace_period(rsp->name, READ_ONCE(rsp->gpnum),
  2143. TPS("newreq"));
  2144. /*
  2145. * We can't do wakeups while holding the rnp->lock, as that
  2146. * could cause possible deadlocks with the rq->lock. Defer
  2147. * the wakeup to our caller.
  2148. */
  2149. return true;
  2150. }
  2151. /*
  2152. * Similar to rcu_start_gp_advanced(), but also advance the calling CPU's
  2153. * callbacks. Note that rcu_start_gp_advanced() cannot do this because it
  2154. * is invoked indirectly from rcu_advance_cbs(), which would result in
  2155. * endless recursion -- or would do so if it wasn't for the self-deadlock
  2156. * that is encountered beforehand.
  2157. *
  2158. * Returns true if the grace-period kthread needs to be awakened.
  2159. */
  2160. static bool rcu_start_gp(struct rcu_state *rsp)
  2161. {
  2162. struct rcu_data *rdp = this_cpu_ptr(rsp->rda);
  2163. struct rcu_node *rnp = rcu_get_root(rsp);
  2164. bool ret = false;
  2165. /*
  2166. * If there is no grace period in progress right now, any
  2167. * callbacks we have up to this point will be satisfied by the
  2168. * next grace period. Also, advancing the callbacks reduces the
  2169. * probability of false positives from cpu_needs_another_gp()
  2170. * resulting in pointless grace periods. So, advance callbacks
  2171. * then start the grace period!
  2172. */
  2173. ret = rcu_advance_cbs(rsp, rnp, rdp) || ret;
  2174. ret = rcu_start_gp_advanced(rsp, rnp, rdp) || ret;
  2175. return ret;
  2176. }
  2177. /*
  2178. * Report a full set of quiescent states to the specified rcu_state data
  2179. * structure. Invoke rcu_gp_kthread_wake() to awaken the grace-period
  2180. * kthread if another grace period is required. Whether we wake
  2181. * the grace-period kthread or it awakens itself for the next round
  2182. * of quiescent-state forcing, that kthread will clean up after the
  2183. * just-completed grace period. Note that the caller must hold rnp->lock,
  2184. * which is released before return.
  2185. */
  2186. static void rcu_report_qs_rsp(struct rcu_state *rsp, unsigned long flags)
  2187. __releases(rcu_get_root(rsp)->lock)
  2188. {
  2189. lockdep_assert_held(&rcu_get_root(rsp)->lock);
  2190. WARN_ON_ONCE(!rcu_gp_in_progress(rsp));
  2191. WRITE_ONCE(rsp->gp_flags, READ_ONCE(rsp->gp_flags) | RCU_GP_FLAG_FQS);
  2192. raw_spin_unlock_irqrestore_rcu_node(rcu_get_root(rsp), flags);
  2193. rcu_gp_kthread_wake(rsp);
  2194. }
  2195. /*
  2196. * Similar to rcu_report_qs_rdp(), for which it is a helper function.
  2197. * Allows quiescent states for a group of CPUs to be reported at one go
  2198. * to the specified rcu_node structure, though all the CPUs in the group
  2199. * must be represented by the same rcu_node structure (which need not be a
  2200. * leaf rcu_node structure, though it often will be). The gps parameter
  2201. * is the grace-period snapshot, which means that the quiescent states
  2202. * are valid only if rnp->gpnum is equal to gps. That structure's lock
  2203. * must be held upon entry, and it is released before return.
  2204. */
  2205. static void
  2206. rcu_report_qs_rnp(unsigned long mask, struct rcu_state *rsp,
  2207. struct rcu_node *rnp, unsigned long gps, unsigned long flags)
  2208. __releases(rnp->lock)
  2209. {
  2210. unsigned long oldmask = 0;
  2211. struct rcu_node *rnp_c;
  2212. lockdep_assert_held(&rnp->lock);
  2213. /* Walk up the rcu_node hierarchy. */
  2214. for (;;) {
  2215. if (!(rnp->qsmask & mask) || rnp->gpnum != gps) {
  2216. /*
  2217. * Our bit has already been cleared, or the
  2218. * relevant grace period is already over, so done.
  2219. */
  2220. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  2221. return;
  2222. }
  2223. WARN_ON_ONCE(oldmask); /* Any child must be all zeroed! */
  2224. WARN_ON_ONCE(rnp->level != rcu_num_lvls - 1 &&
  2225. rcu_preempt_blocked_readers_cgp(rnp));
  2226. rnp->qsmask &= ~mask;
  2227. trace_rcu_quiescent_state_report(rsp->name, rnp->gpnum,
  2228. mask, rnp->qsmask, rnp->level,
  2229. rnp->grplo, rnp->grphi,
  2230. !!rnp->gp_tasks);
  2231. if (rnp->qsmask != 0 || rcu_preempt_blocked_readers_cgp(rnp)) {
  2232. /* Other bits still set at this level, so done. */
  2233. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  2234. return;
  2235. }
  2236. mask = rnp->grpmask;
  2237. if (rnp->parent == NULL) {
  2238. /* No more levels. Exit loop holding root lock. */
  2239. break;
  2240. }
  2241. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  2242. rnp_c = rnp;
  2243. rnp = rnp->parent;
  2244. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  2245. oldmask = rnp_c->qsmask;
  2246. }
  2247. /*
  2248. * Get here if we are the last CPU to pass through a quiescent
  2249. * state for this grace period. Invoke rcu_report_qs_rsp()
  2250. * to clean up and start the next grace period if one is needed.
  2251. */
  2252. rcu_report_qs_rsp(rsp, flags); /* releases rnp->lock. */
  2253. }
  2254. /*
  2255. * Record a quiescent state for all tasks that were previously queued
  2256. * on the specified rcu_node structure and that were blocking the current
  2257. * RCU grace period. The caller must hold the specified rnp->lock with
  2258. * irqs disabled, and this lock is released upon return, but irqs remain
  2259. * disabled.
  2260. */
  2261. static void rcu_report_unblock_qs_rnp(struct rcu_state *rsp,
  2262. struct rcu_node *rnp, unsigned long flags)
  2263. __releases(rnp->lock)
  2264. {
  2265. unsigned long gps;
  2266. unsigned long mask;
  2267. struct rcu_node *rnp_p;
  2268. lockdep_assert_held(&rnp->lock);
  2269. if (rcu_state_p == &rcu_sched_state || rsp != rcu_state_p ||
  2270. rnp->qsmask != 0 || rcu_preempt_blocked_readers_cgp(rnp)) {
  2271. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  2272. return; /* Still need more quiescent states! */
  2273. }
  2274. rnp_p = rnp->parent;
  2275. if (rnp_p == NULL) {
  2276. /*
  2277. * Only one rcu_node structure in the tree, so don't
  2278. * try to report up to its nonexistent parent!
  2279. */
  2280. rcu_report_qs_rsp(rsp, flags);
  2281. return;
  2282. }
  2283. /* Report up the rest of the hierarchy, tracking current ->gpnum. */
  2284. gps = rnp->gpnum;
  2285. mask = rnp->grpmask;
  2286. raw_spin_unlock_rcu_node(rnp); /* irqs remain disabled. */
  2287. raw_spin_lock_rcu_node(rnp_p); /* irqs already disabled. */
  2288. rcu_report_qs_rnp(mask, rsp, rnp_p, gps, flags);
  2289. }
  2290. /*
  2291. * Record a quiescent state for the specified CPU to that CPU's rcu_data
  2292. * structure. This must be called from the specified CPU.
  2293. */
  2294. static void
  2295. rcu_report_qs_rdp(int cpu, struct rcu_state *rsp, struct rcu_data *rdp)
  2296. {
  2297. unsigned long flags;
  2298. unsigned long mask;
  2299. bool needwake;
  2300. struct rcu_node *rnp;
  2301. rnp = rdp->mynode;
  2302. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  2303. if (rdp->cpu_no_qs.b.norm || rdp->gpnum != rnp->gpnum ||
  2304. rnp->completed == rnp->gpnum || rdp->gpwrap) {
  2305. /*
  2306. * The grace period in which this quiescent state was
  2307. * recorded has ended, so don't report it upwards.
  2308. * We will instead need a new quiescent state that lies
  2309. * within the current grace period.
  2310. */
  2311. rdp->cpu_no_qs.b.norm = true; /* need qs for new gp. */
  2312. rdp->rcu_qs_ctr_snap = __this_cpu_read(rcu_dynticks.rcu_qs_ctr);
  2313. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  2314. return;
  2315. }
  2316. mask = rdp->grpmask;
  2317. if ((rnp->qsmask & mask) == 0) {
  2318. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  2319. } else {
  2320. rdp->core_needs_qs = false;
  2321. /*
  2322. * This GP can't end until cpu checks in, so all of our
  2323. * callbacks can be processed during the next GP.
  2324. */
  2325. needwake = rcu_accelerate_cbs(rsp, rnp, rdp);
  2326. rcu_report_qs_rnp(mask, rsp, rnp, rnp->gpnum, flags);
  2327. /* ^^^ Released rnp->lock */
  2328. if (needwake)
  2329. rcu_gp_kthread_wake(rsp);
  2330. }
  2331. }
  2332. /*
  2333. * Check to see if there is a new grace period of which this CPU
  2334. * is not yet aware, and if so, set up local rcu_data state for it.
  2335. * Otherwise, see if this CPU has just passed through its first
  2336. * quiescent state for this grace period, and record that fact if so.
  2337. */
  2338. static void
  2339. rcu_check_quiescent_state(struct rcu_state *rsp, struct rcu_data *rdp)
  2340. {
  2341. /* Check for grace-period ends and beginnings. */
  2342. note_gp_changes(rsp, rdp);
  2343. /*
  2344. * Does this CPU still need to do its part for current grace period?
  2345. * If no, return and let the other CPUs do their part as well.
  2346. */
  2347. if (!rdp->core_needs_qs)
  2348. return;
  2349. /*
  2350. * Was there a quiescent state since the beginning of the grace
  2351. * period? If no, then exit and wait for the next call.
  2352. */
  2353. if (rdp->cpu_no_qs.b.norm)
  2354. return;
  2355. /*
  2356. * Tell RCU we are done (but rcu_report_qs_rdp() will be the
  2357. * judge of that).
  2358. */
  2359. rcu_report_qs_rdp(rdp->cpu, rsp, rdp);
  2360. }
  2361. /*
  2362. * Trace the fact that this CPU is going offline.
  2363. */
  2364. static void rcu_cleanup_dying_cpu(struct rcu_state *rsp)
  2365. {
  2366. RCU_TRACE(unsigned long mask;)
  2367. RCU_TRACE(struct rcu_data *rdp = this_cpu_ptr(rsp->rda);)
  2368. RCU_TRACE(struct rcu_node *rnp = rdp->mynode;)
  2369. if (!IS_ENABLED(CONFIG_HOTPLUG_CPU))
  2370. return;
  2371. RCU_TRACE(mask = rdp->grpmask;)
  2372. trace_rcu_grace_period(rsp->name,
  2373. rnp->gpnum + 1 - !!(rnp->qsmask & mask),
  2374. TPS("cpuofl"));
  2375. }
  2376. /*
  2377. * All CPUs for the specified rcu_node structure have gone offline,
  2378. * and all tasks that were preempted within an RCU read-side critical
  2379. * section while running on one of those CPUs have since exited their RCU
  2380. * read-side critical section. Some other CPU is reporting this fact with
  2381. * the specified rcu_node structure's ->lock held and interrupts disabled.
  2382. * This function therefore goes up the tree of rcu_node structures,
  2383. * clearing the corresponding bits in the ->qsmaskinit fields. Note that
  2384. * the leaf rcu_node structure's ->qsmaskinit field has already been
  2385. * updated
  2386. *
  2387. * This function does check that the specified rcu_node structure has
  2388. * all CPUs offline and no blocked tasks, so it is OK to invoke it
  2389. * prematurely. That said, invoking it after the fact will cost you
  2390. * a needless lock acquisition. So once it has done its work, don't
  2391. * invoke it again.
  2392. */
  2393. static void rcu_cleanup_dead_rnp(struct rcu_node *rnp_leaf)
  2394. {
  2395. long mask;
  2396. struct rcu_node *rnp = rnp_leaf;
  2397. lockdep_assert_held(&rnp->lock);
  2398. if (!IS_ENABLED(CONFIG_HOTPLUG_CPU) ||
  2399. rnp->qsmaskinit || rcu_preempt_has_tasks(rnp))
  2400. return;
  2401. for (;;) {
  2402. mask = rnp->grpmask;
  2403. rnp = rnp->parent;
  2404. if (!rnp)
  2405. break;
  2406. raw_spin_lock_rcu_node(rnp); /* irqs already disabled. */
  2407. rnp->qsmaskinit &= ~mask;
  2408. rnp->qsmask &= ~mask;
  2409. if (rnp->qsmaskinit) {
  2410. raw_spin_unlock_rcu_node(rnp);
  2411. /* irqs remain disabled. */
  2412. return;
  2413. }
  2414. raw_spin_unlock_rcu_node(rnp); /* irqs remain disabled. */
  2415. }
  2416. }
  2417. /*
  2418. * The CPU has been completely removed, and some other CPU is reporting
  2419. * this fact from process context. Do the remainder of the cleanup.
  2420. * There can only be one CPU hotplug operation at a time, so no need for
  2421. * explicit locking.
  2422. */
  2423. static void rcu_cleanup_dead_cpu(int cpu, struct rcu_state *rsp)
  2424. {
  2425. struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu);
  2426. struct rcu_node *rnp = rdp->mynode; /* Outgoing CPU's rdp & rnp. */
  2427. if (!IS_ENABLED(CONFIG_HOTPLUG_CPU))
  2428. return;
  2429. /* Adjust any no-longer-needed kthreads. */
  2430. rcu_boost_kthread_setaffinity(rnp, -1);
  2431. }
  2432. /*
  2433. * Invoke any RCU callbacks that have made it to the end of their grace
  2434. * period. Thottle as specified by rdp->blimit.
  2435. */
  2436. static void rcu_do_batch(struct rcu_state *rsp, struct rcu_data *rdp)
  2437. {
  2438. unsigned long flags;
  2439. struct rcu_head *rhp;
  2440. struct rcu_cblist rcl = RCU_CBLIST_INITIALIZER(rcl);
  2441. long bl, count;
  2442. /* If no callbacks are ready, just return. */
  2443. if (!rcu_segcblist_ready_cbs(&rdp->cblist)) {
  2444. trace_rcu_batch_start(rsp->name,
  2445. rcu_segcblist_n_lazy_cbs(&rdp->cblist),
  2446. rcu_segcblist_n_cbs(&rdp->cblist), 0);
  2447. trace_rcu_batch_end(rsp->name, 0,
  2448. !rcu_segcblist_empty(&rdp->cblist),
  2449. need_resched(), is_idle_task(current),
  2450. rcu_is_callbacks_kthread());
  2451. return;
  2452. }
  2453. /*
  2454. * Extract the list of ready callbacks, disabling to prevent
  2455. * races with call_rcu() from interrupt handlers. Leave the
  2456. * callback counts, as rcu_barrier() needs to be conservative.
  2457. */
  2458. local_irq_save(flags);
  2459. WARN_ON_ONCE(cpu_is_offline(smp_processor_id()));
  2460. bl = rdp->blimit;
  2461. trace_rcu_batch_start(rsp->name, rcu_segcblist_n_lazy_cbs(&rdp->cblist),
  2462. rcu_segcblist_n_cbs(&rdp->cblist), bl);
  2463. rcu_segcblist_extract_done_cbs(&rdp->cblist, &rcl);
  2464. local_irq_restore(flags);
  2465. /* Invoke callbacks. */
  2466. rhp = rcu_cblist_dequeue(&rcl);
  2467. for (; rhp; rhp = rcu_cblist_dequeue(&rcl)) {
  2468. debug_rcu_head_unqueue(rhp);
  2469. if (__rcu_reclaim(rsp->name, rhp))
  2470. rcu_cblist_dequeued_lazy(&rcl);
  2471. /*
  2472. * Stop only if limit reached and CPU has something to do.
  2473. * Note: The rcl structure counts down from zero.
  2474. */
  2475. if (-rcl.len >= bl &&
  2476. (need_resched() ||
  2477. (!is_idle_task(current) && !rcu_is_callbacks_kthread())))
  2478. break;
  2479. }
  2480. local_irq_save(flags);
  2481. count = -rcl.len;
  2482. trace_rcu_batch_end(rsp->name, count, !!rcl.head, need_resched(),
  2483. is_idle_task(current), rcu_is_callbacks_kthread());
  2484. /* Update counts and requeue any remaining callbacks. */
  2485. rcu_segcblist_insert_done_cbs(&rdp->cblist, &rcl);
  2486. smp_mb(); /* List handling before counting for rcu_barrier(). */
  2487. rdp->n_cbs_invoked += count;
  2488. rcu_segcblist_insert_count(&rdp->cblist, &rcl);
  2489. /* Reinstate batch limit if we have worked down the excess. */
  2490. count = rcu_segcblist_n_cbs(&rdp->cblist);
  2491. if (rdp->blimit == LONG_MAX && count <= qlowmark)
  2492. rdp->blimit = blimit;
  2493. /* Reset ->qlen_last_fqs_check trigger if enough CBs have drained. */
  2494. if (count == 0 && rdp->qlen_last_fqs_check != 0) {
  2495. rdp->qlen_last_fqs_check = 0;
  2496. rdp->n_force_qs_snap = rsp->n_force_qs;
  2497. } else if (count < rdp->qlen_last_fqs_check - qhimark)
  2498. rdp->qlen_last_fqs_check = count;
  2499. WARN_ON_ONCE(rcu_segcblist_empty(&rdp->cblist) != (count == 0));
  2500. local_irq_restore(flags);
  2501. /* Re-invoke RCU core processing if there are callbacks remaining. */
  2502. if (rcu_segcblist_ready_cbs(&rdp->cblist))
  2503. invoke_rcu_core();
  2504. }
  2505. /*
  2506. * Check to see if this CPU is in a non-context-switch quiescent state
  2507. * (user mode or idle loop for rcu, non-softirq execution for rcu_bh).
  2508. * Also schedule RCU core processing.
  2509. *
  2510. * This function must be called from hardirq context. It is normally
  2511. * invoked from the scheduling-clock interrupt.
  2512. */
  2513. void rcu_check_callbacks(int user)
  2514. {
  2515. trace_rcu_utilization(TPS("Start scheduler-tick"));
  2516. increment_cpu_stall_ticks();
  2517. if (user || rcu_is_cpu_rrupt_from_idle()) {
  2518. /*
  2519. * Get here if this CPU took its interrupt from user
  2520. * mode or from the idle loop, and if this is not a
  2521. * nested interrupt. In this case, the CPU is in
  2522. * a quiescent state, so note it.
  2523. *
  2524. * No memory barrier is required here because both
  2525. * rcu_sched_qs() and rcu_bh_qs() reference only CPU-local
  2526. * variables that other CPUs neither access nor modify,
  2527. * at least not while the corresponding CPU is online.
  2528. */
  2529. rcu_sched_qs();
  2530. rcu_bh_qs();
  2531. } else if (!in_softirq()) {
  2532. /*
  2533. * Get here if this CPU did not take its interrupt from
  2534. * softirq, in other words, if it is not interrupting
  2535. * a rcu_bh read-side critical section. This is an _bh
  2536. * critical section, so note it.
  2537. */
  2538. rcu_bh_qs();
  2539. }
  2540. rcu_preempt_check_callbacks();
  2541. if (rcu_pending())
  2542. invoke_rcu_core();
  2543. if (user)
  2544. rcu_note_voluntary_context_switch(current);
  2545. trace_rcu_utilization(TPS("End scheduler-tick"));
  2546. }
  2547. /*
  2548. * Scan the leaf rcu_node structures, processing dyntick state for any that
  2549. * have not yet encountered a quiescent state, using the function specified.
  2550. * Also initiate boosting for any threads blocked on the root rcu_node.
  2551. *
  2552. * The caller must have suppressed start of new grace periods.
  2553. */
  2554. static void force_qs_rnp(struct rcu_state *rsp, int (*f)(struct rcu_data *rsp))
  2555. {
  2556. int cpu;
  2557. unsigned long flags;
  2558. unsigned long mask;
  2559. struct rcu_node *rnp;
  2560. rcu_for_each_leaf_node(rsp, rnp) {
  2561. cond_resched_rcu_qs();
  2562. mask = 0;
  2563. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  2564. if (rnp->qsmask == 0) {
  2565. if (rcu_state_p == &rcu_sched_state ||
  2566. rsp != rcu_state_p ||
  2567. rcu_preempt_blocked_readers_cgp(rnp)) {
  2568. /*
  2569. * No point in scanning bits because they
  2570. * are all zero. But we might need to
  2571. * priority-boost blocked readers.
  2572. */
  2573. rcu_initiate_boost(rnp, flags);
  2574. /* rcu_initiate_boost() releases rnp->lock */
  2575. continue;
  2576. }
  2577. if (rnp->parent &&
  2578. (rnp->parent->qsmask & rnp->grpmask)) {
  2579. /*
  2580. * Race between grace-period
  2581. * initialization and task exiting RCU
  2582. * read-side critical section: Report.
  2583. */
  2584. rcu_report_unblock_qs_rnp(rsp, rnp, flags);
  2585. /* rcu_report_unblock_qs_rnp() rlses ->lock */
  2586. continue;
  2587. }
  2588. }
  2589. for_each_leaf_node_possible_cpu(rnp, cpu) {
  2590. unsigned long bit = leaf_node_cpu_bit(rnp, cpu);
  2591. if ((rnp->qsmask & bit) != 0) {
  2592. if (f(per_cpu_ptr(rsp->rda, cpu)))
  2593. mask |= bit;
  2594. }
  2595. }
  2596. if (mask != 0) {
  2597. /* Idle/offline CPUs, report (releases rnp->lock. */
  2598. rcu_report_qs_rnp(mask, rsp, rnp, rnp->gpnum, flags);
  2599. } else {
  2600. /* Nothing to do here, so just drop the lock. */
  2601. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  2602. }
  2603. }
  2604. }
  2605. /*
  2606. * Force quiescent states on reluctant CPUs, and also detect which
  2607. * CPUs are in dyntick-idle mode.
  2608. */
  2609. static void force_quiescent_state(struct rcu_state *rsp)
  2610. {
  2611. unsigned long flags;
  2612. bool ret;
  2613. struct rcu_node *rnp;
  2614. struct rcu_node *rnp_old = NULL;
  2615. /* Funnel through hierarchy to reduce memory contention. */
  2616. rnp = __this_cpu_read(rsp->rda->mynode);
  2617. for (; rnp != NULL; rnp = rnp->parent) {
  2618. ret = (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) ||
  2619. !raw_spin_trylock(&rnp->fqslock);
  2620. if (rnp_old != NULL)
  2621. raw_spin_unlock(&rnp_old->fqslock);
  2622. if (ret) {
  2623. rsp->n_force_qs_lh++;
  2624. return;
  2625. }
  2626. rnp_old = rnp;
  2627. }
  2628. /* rnp_old == rcu_get_root(rsp), rnp == NULL. */
  2629. /* Reached the root of the rcu_node tree, acquire lock. */
  2630. raw_spin_lock_irqsave_rcu_node(rnp_old, flags);
  2631. raw_spin_unlock(&rnp_old->fqslock);
  2632. if (READ_ONCE(rsp->gp_flags) & RCU_GP_FLAG_FQS) {
  2633. rsp->n_force_qs_lh++;
  2634. raw_spin_unlock_irqrestore_rcu_node(rnp_old, flags);
  2635. return; /* Someone beat us to it. */
  2636. }
  2637. WRITE_ONCE(rsp->gp_flags, READ_ONCE(rsp->gp_flags) | RCU_GP_FLAG_FQS);
  2638. raw_spin_unlock_irqrestore_rcu_node(rnp_old, flags);
  2639. rcu_gp_kthread_wake(rsp);
  2640. }
  2641. /*
  2642. * This does the RCU core processing work for the specified rcu_state
  2643. * and rcu_data structures. This may be called only from the CPU to
  2644. * whom the rdp belongs.
  2645. */
  2646. static void
  2647. __rcu_process_callbacks(struct rcu_state *rsp)
  2648. {
  2649. unsigned long flags;
  2650. bool needwake;
  2651. struct rcu_data *rdp = raw_cpu_ptr(rsp->rda);
  2652. WARN_ON_ONCE(!rdp->beenonline);
  2653. /* Update RCU state based on any recent quiescent states. */
  2654. rcu_check_quiescent_state(rsp, rdp);
  2655. /* Does this CPU require a not-yet-started grace period? */
  2656. local_irq_save(flags);
  2657. if (cpu_needs_another_gp(rsp, rdp)) {
  2658. raw_spin_lock_rcu_node(rcu_get_root(rsp)); /* irqs disabled. */
  2659. needwake = rcu_start_gp(rsp);
  2660. raw_spin_unlock_irqrestore_rcu_node(rcu_get_root(rsp), flags);
  2661. if (needwake)
  2662. rcu_gp_kthread_wake(rsp);
  2663. } else {
  2664. local_irq_restore(flags);
  2665. }
  2666. /* If there are callbacks ready, invoke them. */
  2667. if (rcu_segcblist_ready_cbs(&rdp->cblist))
  2668. invoke_rcu_callbacks(rsp, rdp);
  2669. /* Do any needed deferred wakeups of rcuo kthreads. */
  2670. do_nocb_deferred_wakeup(rdp);
  2671. }
  2672. /*
  2673. * Do RCU core processing for the current CPU.
  2674. */
  2675. static __latent_entropy void rcu_process_callbacks(struct softirq_action *unused)
  2676. {
  2677. struct rcu_state *rsp;
  2678. if (cpu_is_offline(smp_processor_id()))
  2679. return;
  2680. trace_rcu_utilization(TPS("Start RCU core"));
  2681. for_each_rcu_flavor(rsp)
  2682. __rcu_process_callbacks(rsp);
  2683. trace_rcu_utilization(TPS("End RCU core"));
  2684. }
  2685. /*
  2686. * Schedule RCU callback invocation. If the specified type of RCU
  2687. * does not support RCU priority boosting, just do a direct call,
  2688. * otherwise wake up the per-CPU kernel kthread. Note that because we
  2689. * are running on the current CPU with softirqs disabled, the
  2690. * rcu_cpu_kthread_task cannot disappear out from under us.
  2691. */
  2692. static void invoke_rcu_callbacks(struct rcu_state *rsp, struct rcu_data *rdp)
  2693. {
  2694. if (unlikely(!READ_ONCE(rcu_scheduler_fully_active)))
  2695. return;
  2696. if (likely(!rsp->boost)) {
  2697. rcu_do_batch(rsp, rdp);
  2698. return;
  2699. }
  2700. invoke_rcu_callbacks_kthread();
  2701. }
  2702. static void invoke_rcu_core(void)
  2703. {
  2704. if (cpu_online(smp_processor_id()))
  2705. raise_softirq(RCU_SOFTIRQ);
  2706. }
  2707. /*
  2708. * Handle any core-RCU processing required by a call_rcu() invocation.
  2709. */
  2710. static void __call_rcu_core(struct rcu_state *rsp, struct rcu_data *rdp,
  2711. struct rcu_head *head, unsigned long flags)
  2712. {
  2713. bool needwake;
  2714. /*
  2715. * If called from an extended quiescent state, invoke the RCU
  2716. * core in order to force a re-evaluation of RCU's idleness.
  2717. */
  2718. if (!rcu_is_watching())
  2719. invoke_rcu_core();
  2720. /* If interrupts were disabled or CPU offline, don't invoke RCU core. */
  2721. if (irqs_disabled_flags(flags) || cpu_is_offline(smp_processor_id()))
  2722. return;
  2723. /*
  2724. * Force the grace period if too many callbacks or too long waiting.
  2725. * Enforce hysteresis, and don't invoke force_quiescent_state()
  2726. * if some other CPU has recently done so. Also, don't bother
  2727. * invoking force_quiescent_state() if the newly enqueued callback
  2728. * is the only one waiting for a grace period to complete.
  2729. */
  2730. if (unlikely(rcu_segcblist_n_cbs(&rdp->cblist) >
  2731. rdp->qlen_last_fqs_check + qhimark)) {
  2732. /* Are we ignoring a completed grace period? */
  2733. note_gp_changes(rsp, rdp);
  2734. /* Start a new grace period if one not already started. */
  2735. if (!rcu_gp_in_progress(rsp)) {
  2736. struct rcu_node *rnp_root = rcu_get_root(rsp);
  2737. raw_spin_lock_rcu_node(rnp_root);
  2738. needwake = rcu_start_gp(rsp);
  2739. raw_spin_unlock_rcu_node(rnp_root);
  2740. if (needwake)
  2741. rcu_gp_kthread_wake(rsp);
  2742. } else {
  2743. /* Give the grace period a kick. */
  2744. rdp->blimit = LONG_MAX;
  2745. if (rsp->n_force_qs == rdp->n_force_qs_snap &&
  2746. rcu_segcblist_first_pend_cb(&rdp->cblist) != head)
  2747. force_quiescent_state(rsp);
  2748. rdp->n_force_qs_snap = rsp->n_force_qs;
  2749. rdp->qlen_last_fqs_check = rcu_segcblist_n_cbs(&rdp->cblist);
  2750. }
  2751. }
  2752. }
  2753. /*
  2754. * RCU callback function to leak a callback.
  2755. */
  2756. static void rcu_leak_callback(struct rcu_head *rhp)
  2757. {
  2758. }
  2759. /*
  2760. * Helper function for call_rcu() and friends. The cpu argument will
  2761. * normally be -1, indicating "currently running CPU". It may specify
  2762. * a CPU only if that CPU is a no-CBs CPU. Currently, only _rcu_barrier()
  2763. * is expected to specify a CPU.
  2764. */
  2765. static void
  2766. __call_rcu(struct rcu_head *head, rcu_callback_t func,
  2767. struct rcu_state *rsp, int cpu, bool lazy)
  2768. {
  2769. unsigned long flags;
  2770. struct rcu_data *rdp;
  2771. /* Misaligned rcu_head! */
  2772. WARN_ON_ONCE((unsigned long)head & (sizeof(void *) - 1));
  2773. if (debug_rcu_head_queue(head)) {
  2774. /*
  2775. * Probable double call_rcu(), so leak the callback.
  2776. * Use rcu:rcu_callback trace event to find the previous
  2777. * time callback was passed to __call_rcu().
  2778. */
  2779. WARN_ONCE(1, "__call_rcu(): Double-freed CB %p->%pF()!!!\n",
  2780. head, head->func);
  2781. WRITE_ONCE(head->func, rcu_leak_callback);
  2782. return;
  2783. }
  2784. head->func = func;
  2785. head->next = NULL;
  2786. local_irq_save(flags);
  2787. rdp = this_cpu_ptr(rsp->rda);
  2788. /* Add the callback to our list. */
  2789. if (unlikely(!rcu_segcblist_is_enabled(&rdp->cblist)) || cpu != -1) {
  2790. int offline;
  2791. if (cpu != -1)
  2792. rdp = per_cpu_ptr(rsp->rda, cpu);
  2793. if (likely(rdp->mynode)) {
  2794. /* Post-boot, so this should be for a no-CBs CPU. */
  2795. offline = !__call_rcu_nocb(rdp, head, lazy, flags);
  2796. WARN_ON_ONCE(offline);
  2797. /* Offline CPU, _call_rcu() illegal, leak callback. */
  2798. local_irq_restore(flags);
  2799. return;
  2800. }
  2801. /*
  2802. * Very early boot, before rcu_init(). Initialize if needed
  2803. * and then drop through to queue the callback.
  2804. */
  2805. BUG_ON(cpu != -1);
  2806. WARN_ON_ONCE(!rcu_is_watching());
  2807. if (rcu_segcblist_empty(&rdp->cblist))
  2808. rcu_segcblist_init(&rdp->cblist);
  2809. }
  2810. rcu_segcblist_enqueue(&rdp->cblist, head, lazy);
  2811. if (!lazy)
  2812. rcu_idle_count_callbacks_posted();
  2813. if (__is_kfree_rcu_offset((unsigned long)func))
  2814. trace_rcu_kfree_callback(rsp->name, head, (unsigned long)func,
  2815. rcu_segcblist_n_lazy_cbs(&rdp->cblist),
  2816. rcu_segcblist_n_cbs(&rdp->cblist));
  2817. else
  2818. trace_rcu_callback(rsp->name, head,
  2819. rcu_segcblist_n_lazy_cbs(&rdp->cblist),
  2820. rcu_segcblist_n_cbs(&rdp->cblist));
  2821. /* Go handle any RCU core processing required. */
  2822. __call_rcu_core(rsp, rdp, head, flags);
  2823. local_irq_restore(flags);
  2824. }
  2825. /**
  2826. * call_rcu_sched() - Queue an RCU for invocation after sched grace period.
  2827. * @head: structure to be used for queueing the RCU updates.
  2828. * @func: actual callback function to be invoked after the grace period
  2829. *
  2830. * The callback function will be invoked some time after a full grace
  2831. * period elapses, in other words after all currently executing RCU
  2832. * read-side critical sections have completed. call_rcu_sched() assumes
  2833. * that the read-side critical sections end on enabling of preemption
  2834. * or on voluntary preemption.
  2835. * RCU read-side critical sections are delimited by:
  2836. *
  2837. * - rcu_read_lock_sched() and rcu_read_unlock_sched(), OR
  2838. * - anything that disables preemption.
  2839. *
  2840. * These may be nested.
  2841. *
  2842. * See the description of call_rcu() for more detailed information on
  2843. * memory ordering guarantees.
  2844. */
  2845. void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
  2846. {
  2847. __call_rcu(head, func, &rcu_sched_state, -1, 0);
  2848. }
  2849. EXPORT_SYMBOL_GPL(call_rcu_sched);
  2850. /**
  2851. * call_rcu_bh() - Queue an RCU for invocation after a quicker grace period.
  2852. * @head: structure to be used for queueing the RCU updates.
  2853. * @func: actual callback function to be invoked after the grace period
  2854. *
  2855. * The callback function will be invoked some time after a full grace
  2856. * period elapses, in other words after all currently executing RCU
  2857. * read-side critical sections have completed. call_rcu_bh() assumes
  2858. * that the read-side critical sections end on completion of a softirq
  2859. * handler. This means that read-side critical sections in process
  2860. * context must not be interrupted by softirqs. This interface is to be
  2861. * used when most of the read-side critical sections are in softirq context.
  2862. * RCU read-side critical sections are delimited by:
  2863. *
  2864. * - rcu_read_lock() and rcu_read_unlock(), if in interrupt context, OR
  2865. * - rcu_read_lock_bh() and rcu_read_unlock_bh(), if in process context.
  2866. *
  2867. * These may be nested.
  2868. *
  2869. * See the description of call_rcu() for more detailed information on
  2870. * memory ordering guarantees.
  2871. */
  2872. void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
  2873. {
  2874. __call_rcu(head, func, &rcu_bh_state, -1, 0);
  2875. }
  2876. EXPORT_SYMBOL_GPL(call_rcu_bh);
  2877. /*
  2878. * Queue an RCU callback for lazy invocation after a grace period.
  2879. * This will likely be later named something like "call_rcu_lazy()",
  2880. * but this change will require some way of tagging the lazy RCU
  2881. * callbacks in the list of pending callbacks. Until then, this
  2882. * function may only be called from __kfree_rcu().
  2883. */
  2884. void kfree_call_rcu(struct rcu_head *head,
  2885. rcu_callback_t func)
  2886. {
  2887. __call_rcu(head, func, rcu_state_p, -1, 1);
  2888. }
  2889. EXPORT_SYMBOL_GPL(kfree_call_rcu);
  2890. /*
  2891. * Because a context switch is a grace period for RCU-sched and RCU-bh,
  2892. * any blocking grace-period wait automatically implies a grace period
  2893. * if there is only one CPU online at any point time during execution
  2894. * of either synchronize_sched() or synchronize_rcu_bh(). It is OK to
  2895. * occasionally incorrectly indicate that there are multiple CPUs online
  2896. * when there was in fact only one the whole time, as this just adds
  2897. * some overhead: RCU still operates correctly.
  2898. */
  2899. static inline int rcu_blocking_is_gp(void)
  2900. {
  2901. int ret;
  2902. might_sleep(); /* Check for RCU read-side critical section. */
  2903. preempt_disable();
  2904. ret = num_online_cpus() <= 1;
  2905. preempt_enable();
  2906. return ret;
  2907. }
  2908. /**
  2909. * synchronize_sched - wait until an rcu-sched grace period has elapsed.
  2910. *
  2911. * Control will return to the caller some time after a full rcu-sched
  2912. * grace period has elapsed, in other words after all currently executing
  2913. * rcu-sched read-side critical sections have completed. These read-side
  2914. * critical sections are delimited by rcu_read_lock_sched() and
  2915. * rcu_read_unlock_sched(), and may be nested. Note that preempt_disable(),
  2916. * local_irq_disable(), and so on may be used in place of
  2917. * rcu_read_lock_sched().
  2918. *
  2919. * This means that all preempt_disable code sequences, including NMI and
  2920. * non-threaded hardware-interrupt handlers, in progress on entry will
  2921. * have completed before this primitive returns. However, this does not
  2922. * guarantee that softirq handlers will have completed, since in some
  2923. * kernels, these handlers can run in process context, and can block.
  2924. *
  2925. * Note that this guarantee implies further memory-ordering guarantees.
  2926. * On systems with more than one CPU, when synchronize_sched() returns,
  2927. * each CPU is guaranteed to have executed a full memory barrier since the
  2928. * end of its last RCU-sched read-side critical section whose beginning
  2929. * preceded the call to synchronize_sched(). In addition, each CPU having
  2930. * an RCU read-side critical section that extends beyond the return from
  2931. * synchronize_sched() is guaranteed to have executed a full memory barrier
  2932. * after the beginning of synchronize_sched() and before the beginning of
  2933. * that RCU read-side critical section. Note that these guarantees include
  2934. * CPUs that are offline, idle, or executing in user mode, as well as CPUs
  2935. * that are executing in the kernel.
  2936. *
  2937. * Furthermore, if CPU A invoked synchronize_sched(), which returned
  2938. * to its caller on CPU B, then both CPU A and CPU B are guaranteed
  2939. * to have executed a full memory barrier during the execution of
  2940. * synchronize_sched() -- even if CPU A and CPU B are the same CPU (but
  2941. * again only if the system has more than one CPU).
  2942. */
  2943. void synchronize_sched(void)
  2944. {
  2945. RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map) ||
  2946. lock_is_held(&rcu_lock_map) ||
  2947. lock_is_held(&rcu_sched_lock_map),
  2948. "Illegal synchronize_sched() in RCU-sched read-side critical section");
  2949. if (rcu_blocking_is_gp())
  2950. return;
  2951. if (rcu_gp_is_expedited())
  2952. synchronize_sched_expedited();
  2953. else
  2954. wait_rcu_gp(call_rcu_sched);
  2955. }
  2956. EXPORT_SYMBOL_GPL(synchronize_sched);
  2957. /**
  2958. * synchronize_rcu_bh - wait until an rcu_bh grace period has elapsed.
  2959. *
  2960. * Control will return to the caller some time after a full rcu_bh grace
  2961. * period has elapsed, in other words after all currently executing rcu_bh
  2962. * read-side critical sections have completed. RCU read-side critical
  2963. * sections are delimited by rcu_read_lock_bh() and rcu_read_unlock_bh(),
  2964. * and may be nested.
  2965. *
  2966. * See the description of synchronize_sched() for more detailed information
  2967. * on memory ordering guarantees.
  2968. */
  2969. void synchronize_rcu_bh(void)
  2970. {
  2971. RCU_LOCKDEP_WARN(lock_is_held(&rcu_bh_lock_map) ||
  2972. lock_is_held(&rcu_lock_map) ||
  2973. lock_is_held(&rcu_sched_lock_map),
  2974. "Illegal synchronize_rcu_bh() in RCU-bh read-side critical section");
  2975. if (rcu_blocking_is_gp())
  2976. return;
  2977. if (rcu_gp_is_expedited())
  2978. synchronize_rcu_bh_expedited();
  2979. else
  2980. wait_rcu_gp(call_rcu_bh);
  2981. }
  2982. EXPORT_SYMBOL_GPL(synchronize_rcu_bh);
  2983. /**
  2984. * get_state_synchronize_rcu - Snapshot current RCU state
  2985. *
  2986. * Returns a cookie that is used by a later call to cond_synchronize_rcu()
  2987. * to determine whether or not a full grace period has elapsed in the
  2988. * meantime.
  2989. */
  2990. unsigned long get_state_synchronize_rcu(void)
  2991. {
  2992. /*
  2993. * Any prior manipulation of RCU-protected data must happen
  2994. * before the load from ->gpnum.
  2995. */
  2996. smp_mb(); /* ^^^ */
  2997. /*
  2998. * Make sure this load happens before the purportedly
  2999. * time-consuming work between get_state_synchronize_rcu()
  3000. * and cond_synchronize_rcu().
  3001. */
  3002. return smp_load_acquire(&rcu_state_p->gpnum);
  3003. }
  3004. EXPORT_SYMBOL_GPL(get_state_synchronize_rcu);
  3005. /**
  3006. * cond_synchronize_rcu - Conditionally wait for an RCU grace period
  3007. *
  3008. * @oldstate: return value from earlier call to get_state_synchronize_rcu()
  3009. *
  3010. * If a full RCU grace period has elapsed since the earlier call to
  3011. * get_state_synchronize_rcu(), just return. Otherwise, invoke
  3012. * synchronize_rcu() to wait for a full grace period.
  3013. *
  3014. * Yes, this function does not take counter wrap into account. But
  3015. * counter wrap is harmless. If the counter wraps, we have waited for
  3016. * more than 2 billion grace periods (and way more on a 64-bit system!),
  3017. * so waiting for one additional grace period should be just fine.
  3018. */
  3019. void cond_synchronize_rcu(unsigned long oldstate)
  3020. {
  3021. unsigned long newstate;
  3022. /*
  3023. * Ensure that this load happens before any RCU-destructive
  3024. * actions the caller might carry out after we return.
  3025. */
  3026. newstate = smp_load_acquire(&rcu_state_p->completed);
  3027. if (ULONG_CMP_GE(oldstate, newstate))
  3028. synchronize_rcu();
  3029. }
  3030. EXPORT_SYMBOL_GPL(cond_synchronize_rcu);
  3031. /**
  3032. * get_state_synchronize_sched - Snapshot current RCU-sched state
  3033. *
  3034. * Returns a cookie that is used by a later call to cond_synchronize_sched()
  3035. * to determine whether or not a full grace period has elapsed in the
  3036. * meantime.
  3037. */
  3038. unsigned long get_state_synchronize_sched(void)
  3039. {
  3040. /*
  3041. * Any prior manipulation of RCU-protected data must happen
  3042. * before the load from ->gpnum.
  3043. */
  3044. smp_mb(); /* ^^^ */
  3045. /*
  3046. * Make sure this load happens before the purportedly
  3047. * time-consuming work between get_state_synchronize_sched()
  3048. * and cond_synchronize_sched().
  3049. */
  3050. return smp_load_acquire(&rcu_sched_state.gpnum);
  3051. }
  3052. EXPORT_SYMBOL_GPL(get_state_synchronize_sched);
  3053. /**
  3054. * cond_synchronize_sched - Conditionally wait for an RCU-sched grace period
  3055. *
  3056. * @oldstate: return value from earlier call to get_state_synchronize_sched()
  3057. *
  3058. * If a full RCU-sched grace period has elapsed since the earlier call to
  3059. * get_state_synchronize_sched(), just return. Otherwise, invoke
  3060. * synchronize_sched() to wait for a full grace period.
  3061. *
  3062. * Yes, this function does not take counter wrap into account. But
  3063. * counter wrap is harmless. If the counter wraps, we have waited for
  3064. * more than 2 billion grace periods (and way more on a 64-bit system!),
  3065. * so waiting for one additional grace period should be just fine.
  3066. */
  3067. void cond_synchronize_sched(unsigned long oldstate)
  3068. {
  3069. unsigned long newstate;
  3070. /*
  3071. * Ensure that this load happens before any RCU-destructive
  3072. * actions the caller might carry out after we return.
  3073. */
  3074. newstate = smp_load_acquire(&rcu_sched_state.completed);
  3075. if (ULONG_CMP_GE(oldstate, newstate))
  3076. synchronize_sched();
  3077. }
  3078. EXPORT_SYMBOL_GPL(cond_synchronize_sched);
  3079. /*
  3080. * Check to see if there is any immediate RCU-related work to be done
  3081. * by the current CPU, for the specified type of RCU, returning 1 if so.
  3082. * The checks are in order of increasing expense: checks that can be
  3083. * carried out against CPU-local state are performed first. However,
  3084. * we must check for CPU stalls first, else we might not get a chance.
  3085. */
  3086. static int __rcu_pending(struct rcu_state *rsp, struct rcu_data *rdp)
  3087. {
  3088. struct rcu_node *rnp = rdp->mynode;
  3089. rdp->n_rcu_pending++;
  3090. /* Check for CPU stalls, if enabled. */
  3091. check_cpu_stall(rsp, rdp);
  3092. /* Is this CPU a NO_HZ_FULL CPU that should ignore RCU? */
  3093. if (rcu_nohz_full_cpu(rsp))
  3094. return 0;
  3095. /* Is the RCU core waiting for a quiescent state from this CPU? */
  3096. if (rcu_scheduler_fully_active &&
  3097. rdp->core_needs_qs && rdp->cpu_no_qs.b.norm &&
  3098. rdp->rcu_qs_ctr_snap == __this_cpu_read(rcu_dynticks.rcu_qs_ctr)) {
  3099. rdp->n_rp_core_needs_qs++;
  3100. } else if (rdp->core_needs_qs && !rdp->cpu_no_qs.b.norm) {
  3101. rdp->n_rp_report_qs++;
  3102. return 1;
  3103. }
  3104. /* Does this CPU have callbacks ready to invoke? */
  3105. if (rcu_segcblist_ready_cbs(&rdp->cblist)) {
  3106. rdp->n_rp_cb_ready++;
  3107. return 1;
  3108. }
  3109. /* Has RCU gone idle with this CPU needing another grace period? */
  3110. if (cpu_needs_another_gp(rsp, rdp)) {
  3111. rdp->n_rp_cpu_needs_gp++;
  3112. return 1;
  3113. }
  3114. /* Has another RCU grace period completed? */
  3115. if (READ_ONCE(rnp->completed) != rdp->completed) { /* outside lock */
  3116. rdp->n_rp_gp_completed++;
  3117. return 1;
  3118. }
  3119. /* Has a new RCU grace period started? */
  3120. if (READ_ONCE(rnp->gpnum) != rdp->gpnum ||
  3121. unlikely(READ_ONCE(rdp->gpwrap))) { /* outside lock */
  3122. rdp->n_rp_gp_started++;
  3123. return 1;
  3124. }
  3125. /* Does this CPU need a deferred NOCB wakeup? */
  3126. if (rcu_nocb_need_deferred_wakeup(rdp)) {
  3127. rdp->n_rp_nocb_defer_wakeup++;
  3128. return 1;
  3129. }
  3130. /* nothing to do */
  3131. rdp->n_rp_need_nothing++;
  3132. return 0;
  3133. }
  3134. /*
  3135. * Check to see if there is any immediate RCU-related work to be done
  3136. * by the current CPU, returning 1 if so. This function is part of the
  3137. * RCU implementation; it is -not- an exported member of the RCU API.
  3138. */
  3139. static int rcu_pending(void)
  3140. {
  3141. struct rcu_state *rsp;
  3142. for_each_rcu_flavor(rsp)
  3143. if (__rcu_pending(rsp, this_cpu_ptr(rsp->rda)))
  3144. return 1;
  3145. return 0;
  3146. }
  3147. /*
  3148. * Return true if the specified CPU has any callback. If all_lazy is
  3149. * non-NULL, store an indication of whether all callbacks are lazy.
  3150. * (If there are no callbacks, all of them are deemed to be lazy.)
  3151. */
  3152. static bool __maybe_unused rcu_cpu_has_callbacks(bool *all_lazy)
  3153. {
  3154. bool al = true;
  3155. bool hc = false;
  3156. struct rcu_data *rdp;
  3157. struct rcu_state *rsp;
  3158. for_each_rcu_flavor(rsp) {
  3159. rdp = this_cpu_ptr(rsp->rda);
  3160. if (rcu_segcblist_empty(&rdp->cblist))
  3161. continue;
  3162. hc = true;
  3163. if (rcu_segcblist_n_nonlazy_cbs(&rdp->cblist) || !all_lazy) {
  3164. al = false;
  3165. break;
  3166. }
  3167. }
  3168. if (all_lazy)
  3169. *all_lazy = al;
  3170. return hc;
  3171. }
  3172. /*
  3173. * Helper function for _rcu_barrier() tracing. If tracing is disabled,
  3174. * the compiler is expected to optimize this away.
  3175. */
  3176. static void _rcu_barrier_trace(struct rcu_state *rsp, const char *s,
  3177. int cpu, unsigned long done)
  3178. {
  3179. trace_rcu_barrier(rsp->name, s, cpu,
  3180. atomic_read(&rsp->barrier_cpu_count), done);
  3181. }
  3182. /*
  3183. * RCU callback function for _rcu_barrier(). If we are last, wake
  3184. * up the task executing _rcu_barrier().
  3185. */
  3186. static void rcu_barrier_callback(struct rcu_head *rhp)
  3187. {
  3188. struct rcu_data *rdp = container_of(rhp, struct rcu_data, barrier_head);
  3189. struct rcu_state *rsp = rdp->rsp;
  3190. if (atomic_dec_and_test(&rsp->barrier_cpu_count)) {
  3191. _rcu_barrier_trace(rsp, TPS("LastCB"), -1,
  3192. rsp->barrier_sequence);
  3193. complete(&rsp->barrier_completion);
  3194. } else {
  3195. _rcu_barrier_trace(rsp, TPS("CB"), -1, rsp->barrier_sequence);
  3196. }
  3197. }
  3198. /*
  3199. * Called with preemption disabled, and from cross-cpu IRQ context.
  3200. */
  3201. static void rcu_barrier_func(void *type)
  3202. {
  3203. struct rcu_state *rsp = type;
  3204. struct rcu_data *rdp = raw_cpu_ptr(rsp->rda);
  3205. _rcu_barrier_trace(rsp, TPS("IRQ"), -1, rsp->barrier_sequence);
  3206. rdp->barrier_head.func = rcu_barrier_callback;
  3207. debug_rcu_head_queue(&rdp->barrier_head);
  3208. if (rcu_segcblist_entrain(&rdp->cblist, &rdp->barrier_head, 0)) {
  3209. atomic_inc(&rsp->barrier_cpu_count);
  3210. } else {
  3211. debug_rcu_head_unqueue(&rdp->barrier_head);
  3212. _rcu_barrier_trace(rsp, TPS("IRQNQ"), -1,
  3213. rsp->barrier_sequence);
  3214. }
  3215. }
  3216. /*
  3217. * Orchestrate the specified type of RCU barrier, waiting for all
  3218. * RCU callbacks of the specified type to complete.
  3219. */
  3220. static void _rcu_barrier(struct rcu_state *rsp)
  3221. {
  3222. int cpu;
  3223. struct rcu_data *rdp;
  3224. unsigned long s = rcu_seq_snap(&rsp->barrier_sequence);
  3225. _rcu_barrier_trace(rsp, TPS("Begin"), -1, s);
  3226. /* Take mutex to serialize concurrent rcu_barrier() requests. */
  3227. mutex_lock(&rsp->barrier_mutex);
  3228. /* Did someone else do our work for us? */
  3229. if (rcu_seq_done(&rsp->barrier_sequence, s)) {
  3230. _rcu_barrier_trace(rsp, TPS("EarlyExit"), -1,
  3231. rsp->barrier_sequence);
  3232. smp_mb(); /* caller's subsequent code after above check. */
  3233. mutex_unlock(&rsp->barrier_mutex);
  3234. return;
  3235. }
  3236. /* Mark the start of the barrier operation. */
  3237. rcu_seq_start(&rsp->barrier_sequence);
  3238. _rcu_barrier_trace(rsp, TPS("Inc1"), -1, rsp->barrier_sequence);
  3239. /*
  3240. * Initialize the count to one rather than to zero in order to
  3241. * avoid a too-soon return to zero in case of a short grace period
  3242. * (or preemption of this task). Exclude CPU-hotplug operations
  3243. * to ensure that no offline CPU has callbacks queued.
  3244. */
  3245. init_completion(&rsp->barrier_completion);
  3246. atomic_set(&rsp->barrier_cpu_count, 1);
  3247. get_online_cpus();
  3248. /*
  3249. * Force each CPU with callbacks to register a new callback.
  3250. * When that callback is invoked, we will know that all of the
  3251. * corresponding CPU's preceding callbacks have been invoked.
  3252. */
  3253. for_each_possible_cpu(cpu) {
  3254. if (!cpu_online(cpu) && !rcu_is_nocb_cpu(cpu))
  3255. continue;
  3256. rdp = per_cpu_ptr(rsp->rda, cpu);
  3257. if (rcu_is_nocb_cpu(cpu)) {
  3258. if (!rcu_nocb_cpu_needs_barrier(rsp, cpu)) {
  3259. _rcu_barrier_trace(rsp, TPS("OfflineNoCB"), cpu,
  3260. rsp->barrier_sequence);
  3261. } else {
  3262. _rcu_barrier_trace(rsp, TPS("OnlineNoCB"), cpu,
  3263. rsp->barrier_sequence);
  3264. smp_mb__before_atomic();
  3265. atomic_inc(&rsp->barrier_cpu_count);
  3266. __call_rcu(&rdp->barrier_head,
  3267. rcu_barrier_callback, rsp, cpu, 0);
  3268. }
  3269. } else if (rcu_segcblist_n_cbs(&rdp->cblist)) {
  3270. _rcu_barrier_trace(rsp, TPS("OnlineQ"), cpu,
  3271. rsp->barrier_sequence);
  3272. smp_call_function_single(cpu, rcu_barrier_func, rsp, 1);
  3273. } else {
  3274. _rcu_barrier_trace(rsp, TPS("OnlineNQ"), cpu,
  3275. rsp->barrier_sequence);
  3276. }
  3277. }
  3278. put_online_cpus();
  3279. /*
  3280. * Now that we have an rcu_barrier_callback() callback on each
  3281. * CPU, and thus each counted, remove the initial count.
  3282. */
  3283. if (atomic_dec_and_test(&rsp->barrier_cpu_count))
  3284. complete(&rsp->barrier_completion);
  3285. /* Wait for all rcu_barrier_callback() callbacks to be invoked. */
  3286. wait_for_completion(&rsp->barrier_completion);
  3287. /* Mark the end of the barrier operation. */
  3288. _rcu_barrier_trace(rsp, TPS("Inc2"), -1, rsp->barrier_sequence);
  3289. rcu_seq_end(&rsp->barrier_sequence);
  3290. /* Other rcu_barrier() invocations can now safely proceed. */
  3291. mutex_unlock(&rsp->barrier_mutex);
  3292. }
  3293. /**
  3294. * rcu_barrier_bh - Wait until all in-flight call_rcu_bh() callbacks complete.
  3295. */
  3296. void rcu_barrier_bh(void)
  3297. {
  3298. _rcu_barrier(&rcu_bh_state);
  3299. }
  3300. EXPORT_SYMBOL_GPL(rcu_barrier_bh);
  3301. /**
  3302. * rcu_barrier_sched - Wait for in-flight call_rcu_sched() callbacks.
  3303. */
  3304. void rcu_barrier_sched(void)
  3305. {
  3306. _rcu_barrier(&rcu_sched_state);
  3307. }
  3308. EXPORT_SYMBOL_GPL(rcu_barrier_sched);
  3309. /*
  3310. * Propagate ->qsinitmask bits up the rcu_node tree to account for the
  3311. * first CPU in a given leaf rcu_node structure coming online. The caller
  3312. * must hold the corresponding leaf rcu_node ->lock with interrrupts
  3313. * disabled.
  3314. */
  3315. static void rcu_init_new_rnp(struct rcu_node *rnp_leaf)
  3316. {
  3317. long mask;
  3318. struct rcu_node *rnp = rnp_leaf;
  3319. lockdep_assert_held(&rnp->lock);
  3320. for (;;) {
  3321. mask = rnp->grpmask;
  3322. rnp = rnp->parent;
  3323. if (rnp == NULL)
  3324. return;
  3325. raw_spin_lock_rcu_node(rnp); /* Interrupts already disabled. */
  3326. rnp->qsmaskinit |= mask;
  3327. raw_spin_unlock_rcu_node(rnp); /* Interrupts remain disabled. */
  3328. }
  3329. }
  3330. /*
  3331. * Do boot-time initialization of a CPU's per-CPU RCU data.
  3332. */
  3333. static void __init
  3334. rcu_boot_init_percpu_data(int cpu, struct rcu_state *rsp)
  3335. {
  3336. unsigned long flags;
  3337. struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu);
  3338. struct rcu_node *rnp = rcu_get_root(rsp);
  3339. /* Set up local state, ensuring consistent view of global state. */
  3340. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  3341. rdp->grpmask = leaf_node_cpu_bit(rdp->mynode, cpu);
  3342. rdp->dynticks = &per_cpu(rcu_dynticks, cpu);
  3343. WARN_ON_ONCE(rdp->dynticks->dynticks_nesting != 1);
  3344. WARN_ON_ONCE(rcu_dynticks_in_eqs(rcu_dynticks_snap(rdp->dynticks)));
  3345. rdp->cpu = cpu;
  3346. rdp->rsp = rsp;
  3347. rcu_boot_init_nocb_percpu_data(rdp);
  3348. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  3349. }
  3350. /*
  3351. * Initialize a CPU's per-CPU RCU data. Note that only one online or
  3352. * offline event can be happening at a given time. Note also that we
  3353. * can accept some slop in the rsp->completed access due to the fact
  3354. * that this CPU cannot possibly have any RCU callbacks in flight yet.
  3355. */
  3356. static void
  3357. rcu_init_percpu_data(int cpu, struct rcu_state *rsp)
  3358. {
  3359. unsigned long flags;
  3360. struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu);
  3361. struct rcu_node *rnp = rcu_get_root(rsp);
  3362. /* Set up local state, ensuring consistent view of global state. */
  3363. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  3364. rdp->qlen_last_fqs_check = 0;
  3365. rdp->n_force_qs_snap = rsp->n_force_qs;
  3366. rdp->blimit = blimit;
  3367. if (rcu_segcblist_empty(&rdp->cblist) && /* No early-boot CBs? */
  3368. !init_nocb_callback_list(rdp))
  3369. rcu_segcblist_init(&rdp->cblist); /* Re-enable callbacks. */
  3370. rdp->dynticks->dynticks_nesting = 1;
  3371. rcu_dynticks_eqs_online();
  3372. raw_spin_unlock_rcu_node(rnp); /* irqs remain disabled. */
  3373. /*
  3374. * Add CPU to leaf rcu_node pending-online bitmask. Any needed
  3375. * propagation up the rcu_node tree will happen at the beginning
  3376. * of the next grace period.
  3377. */
  3378. rnp = rdp->mynode;
  3379. raw_spin_lock_rcu_node(rnp); /* irqs already disabled. */
  3380. rdp->beenonline = true; /* We have now been online. */
  3381. rdp->gpnum = rnp->completed; /* Make CPU later note any new GP. */
  3382. rdp->completed = rnp->completed;
  3383. rdp->cpu_no_qs.b.norm = true;
  3384. rdp->rcu_qs_ctr_snap = per_cpu(rcu_dynticks.rcu_qs_ctr, cpu);
  3385. rdp->core_needs_qs = false;
  3386. rdp->rcu_iw_pending = false;
  3387. rdp->rcu_iw_gpnum = rnp->gpnum - 1;
  3388. trace_rcu_grace_period(rsp->name, rdp->gpnum, TPS("cpuonl"));
  3389. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  3390. }
  3391. /*
  3392. * Invoked early in the CPU-online process, when pretty much all
  3393. * services are available. The incoming CPU is not present.
  3394. */
  3395. int rcutree_prepare_cpu(unsigned int cpu)
  3396. {
  3397. struct rcu_state *rsp;
  3398. for_each_rcu_flavor(rsp)
  3399. rcu_init_percpu_data(cpu, rsp);
  3400. rcu_prepare_kthreads(cpu);
  3401. rcu_spawn_all_nocb_kthreads(cpu);
  3402. return 0;
  3403. }
  3404. /*
  3405. * Update RCU priority boot kthread affinity for CPU-hotplug changes.
  3406. */
  3407. static void rcutree_affinity_setting(unsigned int cpu, int outgoing)
  3408. {
  3409. struct rcu_data *rdp = per_cpu_ptr(rcu_state_p->rda, cpu);
  3410. rcu_boost_kthread_setaffinity(rdp->mynode, outgoing);
  3411. }
  3412. /*
  3413. * Near the end of the CPU-online process. Pretty much all services
  3414. * enabled, and the CPU is now very much alive.
  3415. */
  3416. int rcutree_online_cpu(unsigned int cpu)
  3417. {
  3418. unsigned long flags;
  3419. struct rcu_data *rdp;
  3420. struct rcu_node *rnp;
  3421. struct rcu_state *rsp;
  3422. for_each_rcu_flavor(rsp) {
  3423. rdp = per_cpu_ptr(rsp->rda, cpu);
  3424. rnp = rdp->mynode;
  3425. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  3426. rnp->ffmask |= rdp->grpmask;
  3427. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  3428. }
  3429. if (IS_ENABLED(CONFIG_TREE_SRCU))
  3430. srcu_online_cpu(cpu);
  3431. if (rcu_scheduler_active == RCU_SCHEDULER_INACTIVE)
  3432. return 0; /* Too early in boot for scheduler work. */
  3433. sync_sched_exp_online_cleanup(cpu);
  3434. rcutree_affinity_setting(cpu, -1);
  3435. return 0;
  3436. }
  3437. /*
  3438. * Near the beginning of the process. The CPU is still very much alive
  3439. * with pretty much all services enabled.
  3440. */
  3441. int rcutree_offline_cpu(unsigned int cpu)
  3442. {
  3443. unsigned long flags;
  3444. struct rcu_data *rdp;
  3445. struct rcu_node *rnp;
  3446. struct rcu_state *rsp;
  3447. for_each_rcu_flavor(rsp) {
  3448. rdp = per_cpu_ptr(rsp->rda, cpu);
  3449. rnp = rdp->mynode;
  3450. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  3451. rnp->ffmask &= ~rdp->grpmask;
  3452. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  3453. }
  3454. rcutree_affinity_setting(cpu, cpu);
  3455. if (IS_ENABLED(CONFIG_TREE_SRCU))
  3456. srcu_offline_cpu(cpu);
  3457. return 0;
  3458. }
  3459. /*
  3460. * Near the end of the offline process. We do only tracing here.
  3461. */
  3462. int rcutree_dying_cpu(unsigned int cpu)
  3463. {
  3464. struct rcu_state *rsp;
  3465. for_each_rcu_flavor(rsp)
  3466. rcu_cleanup_dying_cpu(rsp);
  3467. return 0;
  3468. }
  3469. /*
  3470. * The outgoing CPU is gone and we are running elsewhere.
  3471. */
  3472. int rcutree_dead_cpu(unsigned int cpu)
  3473. {
  3474. struct rcu_state *rsp;
  3475. for_each_rcu_flavor(rsp) {
  3476. rcu_cleanup_dead_cpu(cpu, rsp);
  3477. do_nocb_deferred_wakeup(per_cpu_ptr(rsp->rda, cpu));
  3478. }
  3479. return 0;
  3480. }
  3481. /*
  3482. * Mark the specified CPU as being online so that subsequent grace periods
  3483. * (both expedited and normal) will wait on it. Note that this means that
  3484. * incoming CPUs are not allowed to use RCU read-side critical sections
  3485. * until this function is called. Failing to observe this restriction
  3486. * will result in lockdep splats.
  3487. *
  3488. * Note that this function is special in that it is invoked directly
  3489. * from the incoming CPU rather than from the cpuhp_step mechanism.
  3490. * This is because this function must be invoked at a precise location.
  3491. */
  3492. void rcu_cpu_starting(unsigned int cpu)
  3493. {
  3494. unsigned long flags;
  3495. unsigned long mask;
  3496. int nbits;
  3497. unsigned long oldmask;
  3498. struct rcu_data *rdp;
  3499. struct rcu_node *rnp;
  3500. struct rcu_state *rsp;
  3501. for_each_rcu_flavor(rsp) {
  3502. rdp = per_cpu_ptr(rsp->rda, cpu);
  3503. rnp = rdp->mynode;
  3504. mask = rdp->grpmask;
  3505. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  3506. rnp->qsmaskinitnext |= mask;
  3507. oldmask = rnp->expmaskinitnext;
  3508. rnp->expmaskinitnext |= mask;
  3509. oldmask ^= rnp->expmaskinitnext;
  3510. nbits = bitmap_weight(&oldmask, BITS_PER_LONG);
  3511. /* Allow lockless access for expedited grace periods. */
  3512. smp_store_release(&rsp->ncpus, rsp->ncpus + nbits); /* ^^^ */
  3513. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  3514. }
  3515. smp_mb(); /* Ensure RCU read-side usage follows above initialization. */
  3516. }
  3517. #ifdef CONFIG_HOTPLUG_CPU
  3518. /*
  3519. * The CPU is exiting the idle loop into the arch_cpu_idle_dead()
  3520. * function. We now remove it from the rcu_node tree's ->qsmaskinit
  3521. * bit masks.
  3522. */
  3523. static void rcu_cleanup_dying_idle_cpu(int cpu, struct rcu_state *rsp)
  3524. {
  3525. unsigned long flags;
  3526. unsigned long mask;
  3527. struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu);
  3528. struct rcu_node *rnp = rdp->mynode; /* Outgoing CPU's rdp & rnp. */
  3529. /* Remove outgoing CPU from mask in the leaf rcu_node structure. */
  3530. mask = rdp->grpmask;
  3531. raw_spin_lock_irqsave_rcu_node(rnp, flags); /* Enforce GP memory-order guarantee. */
  3532. rnp->qsmaskinitnext &= ~mask;
  3533. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  3534. }
  3535. /*
  3536. * The outgoing function has no further need of RCU, so remove it from
  3537. * the list of CPUs that RCU must track.
  3538. *
  3539. * Note that this function is special in that it is invoked directly
  3540. * from the outgoing CPU rather than from the cpuhp_step mechanism.
  3541. * This is because this function must be invoked at a precise location.
  3542. */
  3543. void rcu_report_dead(unsigned int cpu)
  3544. {
  3545. struct rcu_state *rsp;
  3546. /* QS for any half-done expedited RCU-sched GP. */
  3547. preempt_disable();
  3548. rcu_report_exp_rdp(&rcu_sched_state,
  3549. this_cpu_ptr(rcu_sched_state.rda), true);
  3550. preempt_enable();
  3551. for_each_rcu_flavor(rsp)
  3552. rcu_cleanup_dying_idle_cpu(cpu, rsp);
  3553. }
  3554. /* Migrate the dead CPU's callbacks to the current CPU. */
  3555. static void rcu_migrate_callbacks(int cpu, struct rcu_state *rsp)
  3556. {
  3557. unsigned long flags;
  3558. struct rcu_data *my_rdp;
  3559. struct rcu_data *rdp = per_cpu_ptr(rsp->rda, cpu);
  3560. struct rcu_node *rnp_root = rcu_get_root(rdp->rsp);
  3561. if (rcu_is_nocb_cpu(cpu) || rcu_segcblist_empty(&rdp->cblist))
  3562. return; /* No callbacks to migrate. */
  3563. local_irq_save(flags);
  3564. my_rdp = this_cpu_ptr(rsp->rda);
  3565. if (rcu_nocb_adopt_orphan_cbs(my_rdp, rdp, flags)) {
  3566. local_irq_restore(flags);
  3567. return;
  3568. }
  3569. raw_spin_lock_rcu_node(rnp_root); /* irqs already disabled. */
  3570. rcu_advance_cbs(rsp, rnp_root, rdp); /* Leverage recent GPs. */
  3571. rcu_advance_cbs(rsp, rnp_root, my_rdp); /* Assign GP to pending CBs. */
  3572. rcu_segcblist_merge(&my_rdp->cblist, &rdp->cblist);
  3573. WARN_ON_ONCE(rcu_segcblist_empty(&my_rdp->cblist) !=
  3574. !rcu_segcblist_n_cbs(&my_rdp->cblist));
  3575. raw_spin_unlock_irqrestore_rcu_node(rnp_root, flags);
  3576. WARN_ONCE(rcu_segcblist_n_cbs(&rdp->cblist) != 0 ||
  3577. !rcu_segcblist_empty(&rdp->cblist),
  3578. "rcu_cleanup_dead_cpu: Callbacks on offline CPU %d: qlen=%lu, 1stCB=%p\n",
  3579. cpu, rcu_segcblist_n_cbs(&rdp->cblist),
  3580. rcu_segcblist_first_cb(&rdp->cblist));
  3581. }
  3582. /*
  3583. * The outgoing CPU has just passed through the dying-idle state,
  3584. * and we are being invoked from the CPU that was IPIed to continue the
  3585. * offline operation. We need to migrate the outgoing CPU's callbacks.
  3586. */
  3587. void rcutree_migrate_callbacks(int cpu)
  3588. {
  3589. struct rcu_state *rsp;
  3590. for_each_rcu_flavor(rsp)
  3591. rcu_migrate_callbacks(cpu, rsp);
  3592. }
  3593. #endif
  3594. /*
  3595. * On non-huge systems, use expedited RCU grace periods to make suspend
  3596. * and hibernation run faster.
  3597. */
  3598. static int rcu_pm_notify(struct notifier_block *self,
  3599. unsigned long action, void *hcpu)
  3600. {
  3601. switch (action) {
  3602. case PM_HIBERNATION_PREPARE:
  3603. case PM_SUSPEND_PREPARE:
  3604. if (nr_cpu_ids <= 256) /* Expediting bad for large systems. */
  3605. rcu_expedite_gp();
  3606. break;
  3607. case PM_POST_HIBERNATION:
  3608. case PM_POST_SUSPEND:
  3609. if (nr_cpu_ids <= 256) /* Expediting bad for large systems. */
  3610. rcu_unexpedite_gp();
  3611. break;
  3612. default:
  3613. break;
  3614. }
  3615. return NOTIFY_OK;
  3616. }
  3617. /*
  3618. * Spawn the kthreads that handle each RCU flavor's grace periods.
  3619. */
  3620. static int __init rcu_spawn_gp_kthread(void)
  3621. {
  3622. unsigned long flags;
  3623. int kthread_prio_in = kthread_prio;
  3624. struct rcu_node *rnp;
  3625. struct rcu_state *rsp;
  3626. struct sched_param sp;
  3627. struct task_struct *t;
  3628. /* Force priority into range. */
  3629. if (IS_ENABLED(CONFIG_RCU_BOOST) && kthread_prio < 1)
  3630. kthread_prio = 1;
  3631. else if (kthread_prio < 0)
  3632. kthread_prio = 0;
  3633. else if (kthread_prio > 99)
  3634. kthread_prio = 99;
  3635. if (kthread_prio != kthread_prio_in)
  3636. pr_alert("rcu_spawn_gp_kthread(): Limited prio to %d from %d\n",
  3637. kthread_prio, kthread_prio_in);
  3638. rcu_scheduler_fully_active = 1;
  3639. for_each_rcu_flavor(rsp) {
  3640. t = kthread_create(rcu_gp_kthread, rsp, "%s", rsp->name);
  3641. BUG_ON(IS_ERR(t));
  3642. rnp = rcu_get_root(rsp);
  3643. raw_spin_lock_irqsave_rcu_node(rnp, flags);
  3644. rsp->gp_kthread = t;
  3645. if (kthread_prio) {
  3646. sp.sched_priority = kthread_prio;
  3647. sched_setscheduler_nocheck(t, SCHED_FIFO, &sp);
  3648. }
  3649. raw_spin_unlock_irqrestore_rcu_node(rnp, flags);
  3650. wake_up_process(t);
  3651. }
  3652. rcu_spawn_nocb_kthreads();
  3653. rcu_spawn_boost_kthreads();
  3654. return 0;
  3655. }
  3656. early_initcall(rcu_spawn_gp_kthread);
  3657. /*
  3658. * This function is invoked towards the end of the scheduler's
  3659. * initialization process. Before this is called, the idle task might
  3660. * contain synchronous grace-period primitives (during which time, this idle
  3661. * task is booting the system, and such primitives are no-ops). After this
  3662. * function is called, any synchronous grace-period primitives are run as
  3663. * expedited, with the requesting task driving the grace period forward.
  3664. * A later core_initcall() rcu_set_runtime_mode() will switch to full
  3665. * runtime RCU functionality.
  3666. */
  3667. void rcu_scheduler_starting(void)
  3668. {
  3669. WARN_ON(num_online_cpus() != 1);
  3670. WARN_ON(nr_context_switches() > 0);
  3671. rcu_test_sync_prims();
  3672. rcu_scheduler_active = RCU_SCHEDULER_INIT;
  3673. rcu_test_sync_prims();
  3674. }
  3675. /*
  3676. * Helper function for rcu_init() that initializes one rcu_state structure.
  3677. */
  3678. static void __init rcu_init_one(struct rcu_state *rsp)
  3679. {
  3680. static const char * const buf[] = RCU_NODE_NAME_INIT;
  3681. static const char * const fqs[] = RCU_FQS_NAME_INIT;
  3682. static struct lock_class_key rcu_node_class[RCU_NUM_LVLS];
  3683. static struct lock_class_key rcu_fqs_class[RCU_NUM_LVLS];
  3684. int levelspread[RCU_NUM_LVLS]; /* kids/node in each level. */
  3685. int cpustride = 1;
  3686. int i;
  3687. int j;
  3688. struct rcu_node *rnp;
  3689. BUILD_BUG_ON(RCU_NUM_LVLS > ARRAY_SIZE(buf)); /* Fix buf[] init! */
  3690. /* Silence gcc 4.8 false positive about array index out of range. */
  3691. if (rcu_num_lvls <= 0 || rcu_num_lvls > RCU_NUM_LVLS)
  3692. panic("rcu_init_one: rcu_num_lvls out of range");
  3693. /* Initialize the level-tracking arrays. */
  3694. for (i = 1; i < rcu_num_lvls; i++)
  3695. rsp->level[i] = rsp->level[i - 1] + num_rcu_lvl[i - 1];
  3696. rcu_init_levelspread(levelspread, num_rcu_lvl);
  3697. /* Initialize the elements themselves, starting from the leaves. */
  3698. for (i = rcu_num_lvls - 1; i >= 0; i--) {
  3699. cpustride *= levelspread[i];
  3700. rnp = rsp->level[i];
  3701. for (j = 0; j < num_rcu_lvl[i]; j++, rnp++) {
  3702. raw_spin_lock_init(&ACCESS_PRIVATE(rnp, lock));
  3703. lockdep_set_class_and_name(&ACCESS_PRIVATE(rnp, lock),
  3704. &rcu_node_class[i], buf[i]);
  3705. raw_spin_lock_init(&rnp->fqslock);
  3706. lockdep_set_class_and_name(&rnp->fqslock,
  3707. &rcu_fqs_class[i], fqs[i]);
  3708. rnp->gpnum = rsp->gpnum;
  3709. rnp->completed = rsp->completed;
  3710. rnp->qsmask = 0;
  3711. rnp->qsmaskinit = 0;
  3712. rnp->grplo = j * cpustride;
  3713. rnp->grphi = (j + 1) * cpustride - 1;
  3714. if (rnp->grphi >= nr_cpu_ids)
  3715. rnp->grphi = nr_cpu_ids - 1;
  3716. if (i == 0) {
  3717. rnp->grpnum = 0;
  3718. rnp->grpmask = 0;
  3719. rnp->parent = NULL;
  3720. } else {
  3721. rnp->grpnum = j % levelspread[i - 1];
  3722. rnp->grpmask = 1UL << rnp->grpnum;
  3723. rnp->parent = rsp->level[i - 1] +
  3724. j / levelspread[i - 1];
  3725. }
  3726. rnp->level = i;
  3727. INIT_LIST_HEAD(&rnp->blkd_tasks);
  3728. rcu_init_one_nocb(rnp);
  3729. init_waitqueue_head(&rnp->exp_wq[0]);
  3730. init_waitqueue_head(&rnp->exp_wq[1]);
  3731. init_waitqueue_head(&rnp->exp_wq[2]);
  3732. init_waitqueue_head(&rnp->exp_wq[3]);
  3733. spin_lock_init(&rnp->exp_lock);
  3734. }
  3735. }
  3736. init_swait_queue_head(&rsp->gp_wq);
  3737. init_swait_queue_head(&rsp->expedited_wq);
  3738. rnp = rsp->level[rcu_num_lvls - 1];
  3739. for_each_possible_cpu(i) {
  3740. while (i > rnp->grphi)
  3741. rnp++;
  3742. per_cpu_ptr(rsp->rda, i)->mynode = rnp;
  3743. rcu_boot_init_percpu_data(i, rsp);
  3744. }
  3745. list_add(&rsp->flavors, &rcu_struct_flavors);
  3746. }
  3747. /*
  3748. * Compute the rcu_node tree geometry from kernel parameters. This cannot
  3749. * replace the definitions in tree.h because those are needed to size
  3750. * the ->node array in the rcu_state structure.
  3751. */
  3752. static void __init rcu_init_geometry(void)
  3753. {
  3754. ulong d;
  3755. int i;
  3756. int rcu_capacity[RCU_NUM_LVLS];
  3757. /*
  3758. * Initialize any unspecified boot parameters.
  3759. * The default values of jiffies_till_first_fqs and
  3760. * jiffies_till_next_fqs are set to the RCU_JIFFIES_TILL_FORCE_QS
  3761. * value, which is a function of HZ, then adding one for each
  3762. * RCU_JIFFIES_FQS_DIV CPUs that might be on the system.
  3763. */
  3764. d = RCU_JIFFIES_TILL_FORCE_QS + nr_cpu_ids / RCU_JIFFIES_FQS_DIV;
  3765. if (jiffies_till_first_fqs == ULONG_MAX)
  3766. jiffies_till_first_fqs = d;
  3767. if (jiffies_till_next_fqs == ULONG_MAX)
  3768. jiffies_till_next_fqs = d;
  3769. /* If the compile-time values are accurate, just leave. */
  3770. if (rcu_fanout_leaf == RCU_FANOUT_LEAF &&
  3771. nr_cpu_ids == NR_CPUS)
  3772. return;
  3773. pr_info("RCU: Adjusting geometry for rcu_fanout_leaf=%d, nr_cpu_ids=%u\n",
  3774. rcu_fanout_leaf, nr_cpu_ids);
  3775. /*
  3776. * The boot-time rcu_fanout_leaf parameter must be at least two
  3777. * and cannot exceed the number of bits in the rcu_node masks.
  3778. * Complain and fall back to the compile-time values if this
  3779. * limit is exceeded.
  3780. */
  3781. if (rcu_fanout_leaf < 2 ||
  3782. rcu_fanout_leaf > sizeof(unsigned long) * 8) {
  3783. rcu_fanout_leaf = RCU_FANOUT_LEAF;
  3784. WARN_ON(1);
  3785. return;
  3786. }
  3787. /*
  3788. * Compute number of nodes that can be handled an rcu_node tree
  3789. * with the given number of levels.
  3790. */
  3791. rcu_capacity[0] = rcu_fanout_leaf;
  3792. for (i = 1; i < RCU_NUM_LVLS; i++)
  3793. rcu_capacity[i] = rcu_capacity[i - 1] * RCU_FANOUT;
  3794. /*
  3795. * The tree must be able to accommodate the configured number of CPUs.
  3796. * If this limit is exceeded, fall back to the compile-time values.
  3797. */
  3798. if (nr_cpu_ids > rcu_capacity[RCU_NUM_LVLS - 1]) {
  3799. rcu_fanout_leaf = RCU_FANOUT_LEAF;
  3800. WARN_ON(1);
  3801. return;
  3802. }
  3803. /* Calculate the number of levels in the tree. */
  3804. for (i = 0; nr_cpu_ids > rcu_capacity[i]; i++) {
  3805. }
  3806. rcu_num_lvls = i + 1;
  3807. /* Calculate the number of rcu_nodes at each level of the tree. */
  3808. for (i = 0; i < rcu_num_lvls; i++) {
  3809. int cap = rcu_capacity[(rcu_num_lvls - 1) - i];
  3810. num_rcu_lvl[i] = DIV_ROUND_UP(nr_cpu_ids, cap);
  3811. }
  3812. /* Calculate the total number of rcu_node structures. */
  3813. rcu_num_nodes = 0;
  3814. for (i = 0; i < rcu_num_lvls; i++)
  3815. rcu_num_nodes += num_rcu_lvl[i];
  3816. }
  3817. /*
  3818. * Dump out the structure of the rcu_node combining tree associated
  3819. * with the rcu_state structure referenced by rsp.
  3820. */
  3821. static void __init rcu_dump_rcu_node_tree(struct rcu_state *rsp)
  3822. {
  3823. int level = 0;
  3824. struct rcu_node *rnp;
  3825. pr_info("rcu_node tree layout dump\n");
  3826. pr_info(" ");
  3827. rcu_for_each_node_breadth_first(rsp, rnp) {
  3828. if (rnp->level != level) {
  3829. pr_cont("\n");
  3830. pr_info(" ");
  3831. level = rnp->level;
  3832. }
  3833. pr_cont("%d:%d ^%d ", rnp->grplo, rnp->grphi, rnp->grpnum);
  3834. }
  3835. pr_cont("\n");
  3836. }
  3837. void __init rcu_init(void)
  3838. {
  3839. int cpu;
  3840. rcu_early_boot_tests();
  3841. rcu_bootup_announce();
  3842. rcu_init_geometry();
  3843. rcu_init_one(&rcu_bh_state);
  3844. rcu_init_one(&rcu_sched_state);
  3845. if (dump_tree)
  3846. rcu_dump_rcu_node_tree(&rcu_sched_state);
  3847. __rcu_init_preempt();
  3848. open_softirq(RCU_SOFTIRQ, rcu_process_callbacks);
  3849. /*
  3850. * We don't need protection against CPU-hotplug here because
  3851. * this is called early in boot, before either interrupts
  3852. * or the scheduler are operational.
  3853. */
  3854. pm_notifier(rcu_pm_notify, 0);
  3855. for_each_online_cpu(cpu) {
  3856. rcutree_prepare_cpu(cpu);
  3857. rcu_cpu_starting(cpu);
  3858. rcutree_online_cpu(cpu);
  3859. }
  3860. }
  3861. #include "tree_exp.h"
  3862. #include "tree_plugin.h"