sched.c 225 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421742274237424742574267427742874297430743174327433743474357436743774387439744074417442744374447445744674477448744974507451745274537454745574567457745874597460746174627463746474657466746774687469747074717472747374747475747674777478747974807481748274837484748574867487748874897490749174927493749474957496749774987499750075017502750375047505750675077508750975107511751275137514751575167517751875197520752175227523752475257526752775287529753075317532753375347535753675377538753975407541754275437544754575467547754875497550755175527553755475557556755775587559756075617562756375647565756675677568756975707571757275737574757575767577757875797580758175827583758475857586758775887589759075917592759375947595759675977598759976007601760276037604760576067607760876097610761176127613761476157616761776187619762076217622762376247625762676277628762976307631763276337634763576367637763876397640764176427643764476457646764776487649765076517652765376547655765676577658765976607661766276637664766576667667766876697670767176727673767476757676767776787679768076817682768376847685768676877688768976907691769276937694769576967697769876997700770177027703770477057706770777087709771077117712771377147715771677177718771977207721772277237724772577267727772877297730773177327733773477357736773777387739774077417742774377447745774677477748774977507751775277537754775577567757775877597760776177627763776477657766776777687769777077717772777377747775777677777778777977807781778277837784778577867787778877897790779177927793779477957796779777987799780078017802780378047805780678077808780978107811781278137814781578167817781878197820782178227823782478257826782778287829783078317832783378347835783678377838783978407841784278437844784578467847784878497850785178527853785478557856785778587859786078617862786378647865786678677868786978707871787278737874787578767877787878797880788178827883788478857886788778887889789078917892789378947895789678977898789979007901790279037904790579067907790879097910791179127913791479157916791779187919792079217922792379247925792679277928792979307931793279337934793579367937793879397940794179427943794479457946794779487949795079517952795379547955795679577958795979607961796279637964796579667967796879697970797179727973797479757976797779787979798079817982798379847985798679877988798979907991799279937994799579967997799879998000800180028003800480058006800780088009801080118012801380148015801680178018801980208021802280238024802580268027802880298030803180328033803480358036803780388039804080418042804380448045804680478048804980508051805280538054805580568057805880598060806180628063806480658066806780688069807080718072807380748075807680778078807980808081808280838084808580868087808880898090809180928093809480958096809780988099810081018102810381048105810681078108810981108111811281138114811581168117811881198120812181228123812481258126812781288129813081318132813381348135813681378138813981408141814281438144814581468147814881498150815181528153815481558156815781588159816081618162816381648165816681678168816981708171817281738174817581768177817881798180818181828183818481858186818781888189819081918192819381948195819681978198819982008201820282038204820582068207820882098210821182128213821482158216821782188219822082218222822382248225822682278228822982308231823282338234823582368237823882398240824182428243824482458246824782488249825082518252825382548255825682578258825982608261826282638264826582668267826882698270827182728273827482758276827782788279828082818282828382848285828682878288828982908291829282938294829582968297829882998300830183028303830483058306830783088309831083118312831383148315831683178318831983208321832283238324832583268327832883298330833183328333833483358336833783388339834083418342834383448345834683478348834983508351835283538354835583568357835883598360836183628363836483658366836783688369837083718372837383748375837683778378837983808381838283838384838583868387838883898390839183928393839483958396839783988399840084018402840384048405840684078408840984108411841284138414841584168417841884198420842184228423842484258426842784288429843084318432843384348435843684378438843984408441844284438444844584468447844884498450845184528453845484558456845784588459846084618462846384648465846684678468846984708471847284738474847584768477847884798480848184828483848484858486848784888489849084918492849384948495849684978498849985008501850285038504850585068507850885098510851185128513851485158516851785188519852085218522852385248525852685278528852985308531853285338534853585368537853885398540854185428543854485458546854785488549855085518552855385548555855685578558855985608561856285638564856585668567856885698570857185728573857485758576857785788579858085818582858385848585858685878588858985908591859285938594859585968597859885998600860186028603860486058606860786088609861086118612861386148615861686178618861986208621862286238624862586268627862886298630863186328633863486358636863786388639864086418642864386448645864686478648864986508651865286538654865586568657865886598660866186628663866486658666866786688669867086718672867386748675867686778678867986808681868286838684868586868687868886898690869186928693869486958696869786988699870087018702870387048705870687078708870987108711871287138714871587168717871887198720872187228723872487258726872787288729873087318732873387348735873687378738873987408741874287438744874587468747874887498750875187528753875487558756875787588759876087618762876387648765876687678768876987708771877287738774877587768777877887798780878187828783878487858786878787888789879087918792879387948795879687978798879988008801880288038804880588068807880888098810881188128813881488158816881788188819882088218822882388248825882688278828882988308831883288338834883588368837883888398840884188428843884488458846884788488849885088518852885388548855885688578858885988608861886288638864886588668867886888698870887188728873887488758876887788788879888088818882888388848885888688878888888988908891889288938894889588968897889888998900890189028903890489058906890789088909891089118912891389148915891689178918891989208921892289238924892589268927892889298930893189328933893489358936893789388939894089418942894389448945894689478948894989508951895289538954895589568957895889598960896189628963896489658966896789688969897089718972897389748975897689778978897989808981898289838984898589868987898889898990899189928993899489958996899789988999900090019002900390049005900690079008900990109011901290139014901590169017901890199020902190229023902490259026902790289029903090319032903390349035903690379038903990409041904290439044904590469047904890499050905190529053905490559056905790589059906090619062906390649065906690679068906990709071907290739074907590769077907890799080908190829083908490859086908790889089909090919092909390949095909690979098909991009101910291039104910591069107910891099110911191129113911491159116911791189119912091219122912391249125912691279128912991309131913291339134913591369137913891399140914191429143914491459146914791489149915091519152915391549155915691579158915991609161916291639164916591669167916891699170917191729173917491759176917791789179918091819182918391849185918691879188918991909191919291939194919591969197919891999200920192029203920492059206920792089209921092119212921392149215921692179218921992209221922292239224922592269227922892299230923192329233923492359236923792389239924092419242924392449245924692479248924992509251925292539254925592569257925892599260926192629263926492659266926792689269927092719272927392749275927692779278927992809281928292839284928592869287928892899290929192929293929492959296929792989299930093019302930393049305930693079308930993109311931293139314931593169317931893199320932193229323932493259326932793289329933093319332933393349335933693379338933993409341934293439344934593469347934893499350935193529353935493559356935793589359936093619362936393649365936693679368936993709371937293739374937593769377937893799380938193829383
  1. /*
  2. * kernel/sched.c
  3. *
  4. * Kernel scheduler and related syscalls
  5. *
  6. * Copyright (C) 1991-2002 Linus Torvalds
  7. *
  8. * 1996-12-23 Modified by Dave Grothe to fix bugs in semaphores and
  9. * make semaphores SMP safe
  10. * 1998-11-19 Implemented schedule_timeout() and related stuff
  11. * by Andrea Arcangeli
  12. * 2002-01-04 New ultra-scalable O(1) scheduler by Ingo Molnar:
  13. * hybrid priority-list and round-robin design with
  14. * an array-switch method of distributing timeslices
  15. * and per-CPU runqueues. Cleanups and useful suggestions
  16. * by Davide Libenzi, preemptible kernel bits by Robert Love.
  17. * 2003-09-03 Interactivity tuning by Con Kolivas.
  18. * 2004-04-02 Scheduler domains code by Nick Piggin
  19. * 2007-04-15 Work begun on replacing all interactivity tuning with a
  20. * fair scheduling design by Con Kolivas.
  21. * 2007-05-05 Load balancing (smp-nice) and other improvements
  22. * by Peter Williams
  23. * 2007-05-06 Interactivity improvements to CFS by Mike Galbraith
  24. * 2007-07-01 Group scheduling enhancements by Srivatsa Vaddagiri
  25. * 2007-11-29 RT balancing improvements by Steven Rostedt, Gregory Haskins,
  26. * Thomas Gleixner, Mike Kravetz
  27. */
  28. #include <linux/mm.h>
  29. #include <linux/module.h>
  30. #include <linux/nmi.h>
  31. #include <linux/init.h>
  32. #include <linux/uaccess.h>
  33. #include <linux/highmem.h>
  34. #include <linux/smp_lock.h>
  35. #include <asm/mmu_context.h>
  36. #include <linux/interrupt.h>
  37. #include <linux/capability.h>
  38. #include <linux/completion.h>
  39. #include <linux/kernel_stat.h>
  40. #include <linux/debug_locks.h>
  41. #include <linux/security.h>
  42. #include <linux/notifier.h>
  43. #include <linux/profile.h>
  44. #include <linux/freezer.h>
  45. #include <linux/vmalloc.h>
  46. #include <linux/blkdev.h>
  47. #include <linux/delay.h>
  48. #include <linux/pid_namespace.h>
  49. #include <linux/smp.h>
  50. #include <linux/threads.h>
  51. #include <linux/timer.h>
  52. #include <linux/rcupdate.h>
  53. #include <linux/cpu.h>
  54. #include <linux/cpuset.h>
  55. #include <linux/percpu.h>
  56. #include <linux/kthread.h>
  57. #include <linux/proc_fs.h>
  58. #include <linux/seq_file.h>
  59. #include <linux/sysctl.h>
  60. #include <linux/syscalls.h>
  61. #include <linux/times.h>
  62. #include <linux/tsacct_kern.h>
  63. #include <linux/kprobes.h>
  64. #include <linux/delayacct.h>
  65. #include <linux/reciprocal_div.h>
  66. #include <linux/unistd.h>
  67. #include <linux/pagemap.h>
  68. #include <linux/hrtimer.h>
  69. #include <linux/tick.h>
  70. #include <linux/bootmem.h>
  71. #include <linux/debugfs.h>
  72. #include <linux/ctype.h>
  73. #include <linux/ftrace.h>
  74. #include <trace/sched.h>
  75. #include <asm/tlb.h>
  76. #include <asm/irq_regs.h>
  77. #include "sched_cpupri.h"
  78. /*
  79. * Convert user-nice values [ -20 ... 0 ... 19 ]
  80. * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
  81. * and back.
  82. */
  83. #define NICE_TO_PRIO(nice) (MAX_RT_PRIO + (nice) + 20)
  84. #define PRIO_TO_NICE(prio) ((prio) - MAX_RT_PRIO - 20)
  85. #define TASK_NICE(p) PRIO_TO_NICE((p)->static_prio)
  86. /*
  87. * 'User priority' is the nice value converted to something we
  88. * can work with better when scaling various scheduler parameters,
  89. * it's a [ 0 ... 39 ] range.
  90. */
  91. #define USER_PRIO(p) ((p)-MAX_RT_PRIO)
  92. #define TASK_USER_PRIO(p) USER_PRIO((p)->static_prio)
  93. #define MAX_USER_PRIO (USER_PRIO(MAX_PRIO))
  94. /*
  95. * Helpers for converting nanosecond timing to jiffy resolution
  96. */
  97. #define NS_TO_JIFFIES(TIME) ((unsigned long)(TIME) / (NSEC_PER_SEC / HZ))
  98. #define NICE_0_LOAD SCHED_LOAD_SCALE
  99. #define NICE_0_SHIFT SCHED_LOAD_SHIFT
  100. /*
  101. * These are the 'tuning knobs' of the scheduler:
  102. *
  103. * default timeslice is 100 msecs (used only for SCHED_RR tasks).
  104. * Timeslices get refilled after they expire.
  105. */
  106. #define DEF_TIMESLICE (100 * HZ / 1000)
  107. /*
  108. * single value that denotes runtime == period, ie unlimited time.
  109. */
  110. #define RUNTIME_INF ((u64)~0ULL)
  111. #ifdef CONFIG_SMP
  112. /*
  113. * Divide a load by a sched group cpu_power : (load / sg->__cpu_power)
  114. * Since cpu_power is a 'constant', we can use a reciprocal divide.
  115. */
  116. static inline u32 sg_div_cpu_power(const struct sched_group *sg, u32 load)
  117. {
  118. return reciprocal_divide(load, sg->reciprocal_cpu_power);
  119. }
  120. /*
  121. * Each time a sched group cpu_power is changed,
  122. * we must compute its reciprocal value
  123. */
  124. static inline void sg_inc_cpu_power(struct sched_group *sg, u32 val)
  125. {
  126. sg->__cpu_power += val;
  127. sg->reciprocal_cpu_power = reciprocal_value(sg->__cpu_power);
  128. }
  129. #endif
  130. static inline int rt_policy(int policy)
  131. {
  132. if (unlikely(policy == SCHED_FIFO || policy == SCHED_RR))
  133. return 1;
  134. return 0;
  135. }
  136. static inline int task_has_rt_policy(struct task_struct *p)
  137. {
  138. return rt_policy(p->policy);
  139. }
  140. /*
  141. * This is the priority-queue data structure of the RT scheduling class:
  142. */
  143. struct rt_prio_array {
  144. DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */
  145. struct list_head queue[MAX_RT_PRIO];
  146. };
  147. struct rt_bandwidth {
  148. /* nests inside the rq lock: */
  149. spinlock_t rt_runtime_lock;
  150. ktime_t rt_period;
  151. u64 rt_runtime;
  152. struct hrtimer rt_period_timer;
  153. };
  154. static struct rt_bandwidth def_rt_bandwidth;
  155. static int do_sched_rt_period_timer(struct rt_bandwidth *rt_b, int overrun);
  156. static enum hrtimer_restart sched_rt_period_timer(struct hrtimer *timer)
  157. {
  158. struct rt_bandwidth *rt_b =
  159. container_of(timer, struct rt_bandwidth, rt_period_timer);
  160. ktime_t now;
  161. int overrun;
  162. int idle = 0;
  163. for (;;) {
  164. now = hrtimer_cb_get_time(timer);
  165. overrun = hrtimer_forward(timer, now, rt_b->rt_period);
  166. if (!overrun)
  167. break;
  168. idle = do_sched_rt_period_timer(rt_b, overrun);
  169. }
  170. return idle ? HRTIMER_NORESTART : HRTIMER_RESTART;
  171. }
  172. static
  173. void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime)
  174. {
  175. rt_b->rt_period = ns_to_ktime(period);
  176. rt_b->rt_runtime = runtime;
  177. spin_lock_init(&rt_b->rt_runtime_lock);
  178. hrtimer_init(&rt_b->rt_period_timer,
  179. CLOCK_MONOTONIC, HRTIMER_MODE_REL);
  180. rt_b->rt_period_timer.function = sched_rt_period_timer;
  181. rt_b->rt_period_timer.cb_mode = HRTIMER_CB_IRQSAFE_UNLOCKED;
  182. }
  183. static inline int rt_bandwidth_enabled(void)
  184. {
  185. return sysctl_sched_rt_runtime >= 0;
  186. }
  187. static void start_rt_bandwidth(struct rt_bandwidth *rt_b)
  188. {
  189. ktime_t now;
  190. if (rt_bandwidth_enabled() && rt_b->rt_runtime == RUNTIME_INF)
  191. return;
  192. if (hrtimer_active(&rt_b->rt_period_timer))
  193. return;
  194. spin_lock(&rt_b->rt_runtime_lock);
  195. for (;;) {
  196. if (hrtimer_active(&rt_b->rt_period_timer))
  197. break;
  198. now = hrtimer_cb_get_time(&rt_b->rt_period_timer);
  199. hrtimer_forward(&rt_b->rt_period_timer, now, rt_b->rt_period);
  200. hrtimer_start_expires(&rt_b->rt_period_timer,
  201. HRTIMER_MODE_ABS);
  202. }
  203. spin_unlock(&rt_b->rt_runtime_lock);
  204. }
  205. #ifdef CONFIG_RT_GROUP_SCHED
  206. static void destroy_rt_bandwidth(struct rt_bandwidth *rt_b)
  207. {
  208. hrtimer_cancel(&rt_b->rt_period_timer);
  209. }
  210. #endif
  211. /*
  212. * sched_domains_mutex serializes calls to arch_init_sched_domains,
  213. * detach_destroy_domains and partition_sched_domains.
  214. */
  215. static DEFINE_MUTEX(sched_domains_mutex);
  216. #ifdef CONFIG_GROUP_SCHED
  217. #include <linux/cgroup.h>
  218. struct cfs_rq;
  219. static LIST_HEAD(task_groups);
  220. /* task group related information */
  221. struct task_group {
  222. #ifdef CONFIG_CGROUP_SCHED
  223. struct cgroup_subsys_state css;
  224. #endif
  225. #ifdef CONFIG_FAIR_GROUP_SCHED
  226. /* schedulable entities of this group on each cpu */
  227. struct sched_entity **se;
  228. /* runqueue "owned" by this group on each cpu */
  229. struct cfs_rq **cfs_rq;
  230. unsigned long shares;
  231. #endif
  232. #ifdef CONFIG_RT_GROUP_SCHED
  233. struct sched_rt_entity **rt_se;
  234. struct rt_rq **rt_rq;
  235. struct rt_bandwidth rt_bandwidth;
  236. #endif
  237. struct rcu_head rcu;
  238. struct list_head list;
  239. struct task_group *parent;
  240. struct list_head siblings;
  241. struct list_head children;
  242. };
  243. #ifdef CONFIG_USER_SCHED
  244. /*
  245. * Root task group.
  246. * Every UID task group (including init_task_group aka UID-0) will
  247. * be a child to this group.
  248. */
  249. struct task_group root_task_group;
  250. #ifdef CONFIG_FAIR_GROUP_SCHED
  251. /* Default task group's sched entity on each cpu */
  252. static DEFINE_PER_CPU(struct sched_entity, init_sched_entity);
  253. /* Default task group's cfs_rq on each cpu */
  254. static DEFINE_PER_CPU(struct cfs_rq, init_cfs_rq) ____cacheline_aligned_in_smp;
  255. #endif /* CONFIG_FAIR_GROUP_SCHED */
  256. #ifdef CONFIG_RT_GROUP_SCHED
  257. static DEFINE_PER_CPU(struct sched_rt_entity, init_sched_rt_entity);
  258. static DEFINE_PER_CPU(struct rt_rq, init_rt_rq) ____cacheline_aligned_in_smp;
  259. #endif /* CONFIG_RT_GROUP_SCHED */
  260. #else /* !CONFIG_USER_SCHED */
  261. #define root_task_group init_task_group
  262. #endif /* CONFIG_USER_SCHED */
  263. /* task_group_lock serializes add/remove of task groups and also changes to
  264. * a task group's cpu shares.
  265. */
  266. static DEFINE_SPINLOCK(task_group_lock);
  267. #ifdef CONFIG_FAIR_GROUP_SCHED
  268. #ifdef CONFIG_USER_SCHED
  269. # define INIT_TASK_GROUP_LOAD (2*NICE_0_LOAD)
  270. #else /* !CONFIG_USER_SCHED */
  271. # define INIT_TASK_GROUP_LOAD NICE_0_LOAD
  272. #endif /* CONFIG_USER_SCHED */
  273. /*
  274. * A weight of 0 or 1 can cause arithmetics problems.
  275. * A weight of a cfs_rq is the sum of weights of which entities
  276. * are queued on this cfs_rq, so a weight of a entity should not be
  277. * too large, so as the shares value of a task group.
  278. * (The default weight is 1024 - so there's no practical
  279. * limitation from this.)
  280. */
  281. #define MIN_SHARES 2
  282. #define MAX_SHARES (1UL << 18)
  283. static int init_task_group_load = INIT_TASK_GROUP_LOAD;
  284. #endif
  285. /* Default task group.
  286. * Every task in system belong to this group at bootup.
  287. */
  288. struct task_group init_task_group;
  289. /* return group to which a task belongs */
  290. static inline struct task_group *task_group(struct task_struct *p)
  291. {
  292. struct task_group *tg;
  293. #ifdef CONFIG_USER_SCHED
  294. tg = p->user->tg;
  295. #elif defined(CONFIG_CGROUP_SCHED)
  296. tg = container_of(task_subsys_state(p, cpu_cgroup_subsys_id),
  297. struct task_group, css);
  298. #else
  299. tg = &init_task_group;
  300. #endif
  301. return tg;
  302. }
  303. /* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
  304. static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
  305. {
  306. #ifdef CONFIG_FAIR_GROUP_SCHED
  307. p->se.cfs_rq = task_group(p)->cfs_rq[cpu];
  308. p->se.parent = task_group(p)->se[cpu];
  309. #endif
  310. #ifdef CONFIG_RT_GROUP_SCHED
  311. p->rt.rt_rq = task_group(p)->rt_rq[cpu];
  312. p->rt.parent = task_group(p)->rt_se[cpu];
  313. #endif
  314. }
  315. #else
  316. static inline void set_task_rq(struct task_struct *p, unsigned int cpu) { }
  317. static inline struct task_group *task_group(struct task_struct *p)
  318. {
  319. return NULL;
  320. }
  321. #endif /* CONFIG_GROUP_SCHED */
  322. /* CFS-related fields in a runqueue */
  323. struct cfs_rq {
  324. struct load_weight load;
  325. unsigned long nr_running;
  326. u64 exec_clock;
  327. u64 min_vruntime;
  328. struct rb_root tasks_timeline;
  329. struct rb_node *rb_leftmost;
  330. struct list_head tasks;
  331. struct list_head *balance_iterator;
  332. /*
  333. * 'curr' points to currently running entity on this cfs_rq.
  334. * It is set to NULL otherwise (i.e when none are currently running).
  335. */
  336. struct sched_entity *curr, *next, *last;
  337. unsigned int nr_spread_over;
  338. #ifdef CONFIG_FAIR_GROUP_SCHED
  339. struct rq *rq; /* cpu runqueue to which this cfs_rq is attached */
  340. /*
  341. * leaf cfs_rqs are those that hold tasks (lowest schedulable entity in
  342. * a hierarchy). Non-leaf lrqs hold other higher schedulable entities
  343. * (like users, containers etc.)
  344. *
  345. * leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This
  346. * list is used during load balance.
  347. */
  348. struct list_head leaf_cfs_rq_list;
  349. struct task_group *tg; /* group that "owns" this runqueue */
  350. #ifdef CONFIG_SMP
  351. /*
  352. * the part of load.weight contributed by tasks
  353. */
  354. unsigned long task_weight;
  355. /*
  356. * h_load = weight * f(tg)
  357. *
  358. * Where f(tg) is the recursive weight fraction assigned to
  359. * this group.
  360. */
  361. unsigned long h_load;
  362. /*
  363. * this cpu's part of tg->shares
  364. */
  365. unsigned long shares;
  366. /*
  367. * load.weight at the time we set shares
  368. */
  369. unsigned long rq_weight;
  370. #endif
  371. #endif
  372. };
  373. /* Real-Time classes' related field in a runqueue: */
  374. struct rt_rq {
  375. struct rt_prio_array active;
  376. unsigned long rt_nr_running;
  377. #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
  378. int highest_prio; /* highest queued rt task prio */
  379. #endif
  380. #ifdef CONFIG_SMP
  381. unsigned long rt_nr_migratory;
  382. int overloaded;
  383. #endif
  384. int rt_throttled;
  385. u64 rt_time;
  386. u64 rt_runtime;
  387. /* Nests inside the rq lock: */
  388. spinlock_t rt_runtime_lock;
  389. #ifdef CONFIG_RT_GROUP_SCHED
  390. unsigned long rt_nr_boosted;
  391. struct rq *rq;
  392. struct list_head leaf_rt_rq_list;
  393. struct task_group *tg;
  394. struct sched_rt_entity *rt_se;
  395. #endif
  396. };
  397. #ifdef CONFIG_SMP
  398. /*
  399. * We add the notion of a root-domain which will be used to define per-domain
  400. * variables. Each exclusive cpuset essentially defines an island domain by
  401. * fully partitioning the member cpus from any other cpuset. Whenever a new
  402. * exclusive cpuset is created, we also create and attach a new root-domain
  403. * object.
  404. *
  405. */
  406. struct root_domain {
  407. atomic_t refcount;
  408. cpumask_t span;
  409. cpumask_t online;
  410. /*
  411. * The "RT overload" flag: it gets set if a CPU has more than
  412. * one runnable RT task.
  413. */
  414. cpumask_t rto_mask;
  415. atomic_t rto_count;
  416. #ifdef CONFIG_SMP
  417. struct cpupri cpupri;
  418. #endif
  419. };
  420. /*
  421. * By default the system creates a single root-domain with all cpus as
  422. * members (mimicking the global state we have today).
  423. */
  424. static struct root_domain def_root_domain;
  425. #endif
  426. /*
  427. * This is the main, per-CPU runqueue data structure.
  428. *
  429. * Locking rule: those places that want to lock multiple runqueues
  430. * (such as the load balancing or the thread migration code), lock
  431. * acquire operations must be ordered by ascending &runqueue.
  432. */
  433. struct rq {
  434. /* runqueue lock: */
  435. spinlock_t lock;
  436. /*
  437. * nr_running and cpu_load should be in the same cacheline because
  438. * remote CPUs use both these fields when doing load calculation.
  439. */
  440. unsigned long nr_running;
  441. #define CPU_LOAD_IDX_MAX 5
  442. unsigned long cpu_load[CPU_LOAD_IDX_MAX];
  443. unsigned char idle_at_tick;
  444. #ifdef CONFIG_NO_HZ
  445. unsigned long last_tick_seen;
  446. unsigned char in_nohz_recently;
  447. #endif
  448. /* capture load from *all* tasks on this cpu: */
  449. struct load_weight load;
  450. unsigned long nr_load_updates;
  451. u64 nr_switches;
  452. struct cfs_rq cfs;
  453. struct rt_rq rt;
  454. #ifdef CONFIG_FAIR_GROUP_SCHED
  455. /* list of leaf cfs_rq on this cpu: */
  456. struct list_head leaf_cfs_rq_list;
  457. #endif
  458. #ifdef CONFIG_RT_GROUP_SCHED
  459. struct list_head leaf_rt_rq_list;
  460. #endif
  461. /*
  462. * This is part of a global counter where only the total sum
  463. * over all CPUs matters. A task can increase this counter on
  464. * one CPU and if it got migrated afterwards it may decrease
  465. * it on another CPU. Always updated under the runqueue lock:
  466. */
  467. unsigned long nr_uninterruptible;
  468. struct task_struct *curr, *idle;
  469. unsigned long next_balance;
  470. struct mm_struct *prev_mm;
  471. u64 clock;
  472. atomic_t nr_iowait;
  473. #ifdef CONFIG_SMP
  474. struct root_domain *rd;
  475. struct sched_domain *sd;
  476. /* For active balancing */
  477. int active_balance;
  478. int push_cpu;
  479. /* cpu of this runqueue: */
  480. int cpu;
  481. int online;
  482. unsigned long avg_load_per_task;
  483. struct task_struct *migration_thread;
  484. struct list_head migration_queue;
  485. #endif
  486. #ifdef CONFIG_SCHED_HRTICK
  487. #ifdef CONFIG_SMP
  488. int hrtick_csd_pending;
  489. struct call_single_data hrtick_csd;
  490. #endif
  491. struct hrtimer hrtick_timer;
  492. #endif
  493. #ifdef CONFIG_SCHEDSTATS
  494. /* latency stats */
  495. struct sched_info rq_sched_info;
  496. /* sys_sched_yield() stats */
  497. unsigned int yld_exp_empty;
  498. unsigned int yld_act_empty;
  499. unsigned int yld_both_empty;
  500. unsigned int yld_count;
  501. /* schedule() stats */
  502. unsigned int sched_switch;
  503. unsigned int sched_count;
  504. unsigned int sched_goidle;
  505. /* try_to_wake_up() stats */
  506. unsigned int ttwu_count;
  507. unsigned int ttwu_local;
  508. /* BKL stats */
  509. unsigned int bkl_count;
  510. #endif
  511. };
  512. static DEFINE_PER_CPU_SHARED_ALIGNED(struct rq, runqueues);
  513. static inline void check_preempt_curr(struct rq *rq, struct task_struct *p, int sync)
  514. {
  515. rq->curr->sched_class->check_preempt_curr(rq, p, sync);
  516. }
  517. static inline int cpu_of(struct rq *rq)
  518. {
  519. #ifdef CONFIG_SMP
  520. return rq->cpu;
  521. #else
  522. return 0;
  523. #endif
  524. }
  525. /*
  526. * The domain tree (rq->sd) is protected by RCU's quiescent state transition.
  527. * See detach_destroy_domains: synchronize_sched for details.
  528. *
  529. * The domain tree of any CPU may only be accessed from within
  530. * preempt-disabled sections.
  531. */
  532. #define for_each_domain(cpu, __sd) \
  533. for (__sd = rcu_dereference(cpu_rq(cpu)->sd); __sd; __sd = __sd->parent)
  534. #define cpu_rq(cpu) (&per_cpu(runqueues, (cpu)))
  535. #define this_rq() (&__get_cpu_var(runqueues))
  536. #define task_rq(p) cpu_rq(task_cpu(p))
  537. #define cpu_curr(cpu) (cpu_rq(cpu)->curr)
  538. static inline void update_rq_clock(struct rq *rq)
  539. {
  540. rq->clock = sched_clock_cpu(cpu_of(rq));
  541. }
  542. /*
  543. * Tunables that become constants when CONFIG_SCHED_DEBUG is off:
  544. */
  545. #ifdef CONFIG_SCHED_DEBUG
  546. # define const_debug __read_mostly
  547. #else
  548. # define const_debug static const
  549. #endif
  550. /**
  551. * runqueue_is_locked
  552. *
  553. * Returns true if the current cpu runqueue is locked.
  554. * This interface allows printk to be called with the runqueue lock
  555. * held and know whether or not it is OK to wake up the klogd.
  556. */
  557. int runqueue_is_locked(void)
  558. {
  559. int cpu = get_cpu();
  560. struct rq *rq = cpu_rq(cpu);
  561. int ret;
  562. ret = spin_is_locked(&rq->lock);
  563. put_cpu();
  564. return ret;
  565. }
  566. /*
  567. * Debugging: various feature bits
  568. */
  569. #define SCHED_FEAT(name, enabled) \
  570. __SCHED_FEAT_##name ,
  571. enum {
  572. #include "sched_features.h"
  573. };
  574. #undef SCHED_FEAT
  575. #define SCHED_FEAT(name, enabled) \
  576. (1UL << __SCHED_FEAT_##name) * enabled |
  577. const_debug unsigned int sysctl_sched_features =
  578. #include "sched_features.h"
  579. 0;
  580. #undef SCHED_FEAT
  581. #ifdef CONFIG_SCHED_DEBUG
  582. #define SCHED_FEAT(name, enabled) \
  583. #name ,
  584. static __read_mostly char *sched_feat_names[] = {
  585. #include "sched_features.h"
  586. NULL
  587. };
  588. #undef SCHED_FEAT
  589. static int sched_feat_open(struct inode *inode, struct file *filp)
  590. {
  591. filp->private_data = inode->i_private;
  592. return 0;
  593. }
  594. static ssize_t
  595. sched_feat_read(struct file *filp, char __user *ubuf,
  596. size_t cnt, loff_t *ppos)
  597. {
  598. char *buf;
  599. int r = 0;
  600. int len = 0;
  601. int i;
  602. for (i = 0; sched_feat_names[i]; i++) {
  603. len += strlen(sched_feat_names[i]);
  604. len += 4;
  605. }
  606. buf = kmalloc(len + 2, GFP_KERNEL);
  607. if (!buf)
  608. return -ENOMEM;
  609. for (i = 0; sched_feat_names[i]; i++) {
  610. if (sysctl_sched_features & (1UL << i))
  611. r += sprintf(buf + r, "%s ", sched_feat_names[i]);
  612. else
  613. r += sprintf(buf + r, "NO_%s ", sched_feat_names[i]);
  614. }
  615. r += sprintf(buf + r, "\n");
  616. WARN_ON(r >= len + 2);
  617. r = simple_read_from_buffer(ubuf, cnt, ppos, buf, r);
  618. kfree(buf);
  619. return r;
  620. }
  621. static ssize_t
  622. sched_feat_write(struct file *filp, const char __user *ubuf,
  623. size_t cnt, loff_t *ppos)
  624. {
  625. char buf[64];
  626. char *cmp = buf;
  627. int neg = 0;
  628. int i;
  629. if (cnt > 63)
  630. cnt = 63;
  631. if (copy_from_user(&buf, ubuf, cnt))
  632. return -EFAULT;
  633. buf[cnt] = 0;
  634. if (strncmp(buf, "NO_", 3) == 0) {
  635. neg = 1;
  636. cmp += 3;
  637. }
  638. for (i = 0; sched_feat_names[i]; i++) {
  639. int len = strlen(sched_feat_names[i]);
  640. if (strncmp(cmp, sched_feat_names[i], len) == 0) {
  641. if (neg)
  642. sysctl_sched_features &= ~(1UL << i);
  643. else
  644. sysctl_sched_features |= (1UL << i);
  645. break;
  646. }
  647. }
  648. if (!sched_feat_names[i])
  649. return -EINVAL;
  650. filp->f_pos += cnt;
  651. return cnt;
  652. }
  653. static struct file_operations sched_feat_fops = {
  654. .open = sched_feat_open,
  655. .read = sched_feat_read,
  656. .write = sched_feat_write,
  657. };
  658. static __init int sched_init_debug(void)
  659. {
  660. debugfs_create_file("sched_features", 0644, NULL, NULL,
  661. &sched_feat_fops);
  662. return 0;
  663. }
  664. late_initcall(sched_init_debug);
  665. #endif
  666. #define sched_feat(x) (sysctl_sched_features & (1UL << __SCHED_FEAT_##x))
  667. /*
  668. * Number of tasks to iterate in a single balance run.
  669. * Limited because this is done with IRQs disabled.
  670. */
  671. const_debug unsigned int sysctl_sched_nr_migrate = 32;
  672. /*
  673. * ratelimit for updating the group shares.
  674. * default: 0.25ms
  675. */
  676. unsigned int sysctl_sched_shares_ratelimit = 250000;
  677. /*
  678. * Inject some fuzzyness into changing the per-cpu group shares
  679. * this avoids remote rq-locks at the expense of fairness.
  680. * default: 4
  681. */
  682. unsigned int sysctl_sched_shares_thresh = 4;
  683. /*
  684. * period over which we measure -rt task cpu usage in us.
  685. * default: 1s
  686. */
  687. unsigned int sysctl_sched_rt_period = 1000000;
  688. static __read_mostly int scheduler_running;
  689. /*
  690. * part of the period that we allow rt tasks to run in us.
  691. * default: 0.95s
  692. */
  693. int sysctl_sched_rt_runtime = 950000;
  694. static inline u64 global_rt_period(void)
  695. {
  696. return (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
  697. }
  698. static inline u64 global_rt_runtime(void)
  699. {
  700. if (sysctl_sched_rt_runtime < 0)
  701. return RUNTIME_INF;
  702. return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
  703. }
  704. #ifndef prepare_arch_switch
  705. # define prepare_arch_switch(next) do { } while (0)
  706. #endif
  707. #ifndef finish_arch_switch
  708. # define finish_arch_switch(prev) do { } while (0)
  709. #endif
  710. static inline int task_current(struct rq *rq, struct task_struct *p)
  711. {
  712. return rq->curr == p;
  713. }
  714. #ifndef __ARCH_WANT_UNLOCKED_CTXSW
  715. static inline int task_running(struct rq *rq, struct task_struct *p)
  716. {
  717. return task_current(rq, p);
  718. }
  719. static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
  720. {
  721. }
  722. static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
  723. {
  724. #ifdef CONFIG_DEBUG_SPINLOCK
  725. /* this is a valid case when another task releases the spinlock */
  726. rq->lock.owner = current;
  727. #endif
  728. /*
  729. * If we are tracking spinlock dependencies then we have to
  730. * fix up the runqueue lock - which gets 'carried over' from
  731. * prev into current:
  732. */
  733. spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
  734. spin_unlock_irq(&rq->lock);
  735. }
  736. #else /* __ARCH_WANT_UNLOCKED_CTXSW */
  737. static inline int task_running(struct rq *rq, struct task_struct *p)
  738. {
  739. #ifdef CONFIG_SMP
  740. return p->oncpu;
  741. #else
  742. return task_current(rq, p);
  743. #endif
  744. }
  745. static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
  746. {
  747. #ifdef CONFIG_SMP
  748. /*
  749. * We can optimise this out completely for !SMP, because the
  750. * SMP rebalancing from interrupt is the only thing that cares
  751. * here.
  752. */
  753. next->oncpu = 1;
  754. #endif
  755. #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
  756. spin_unlock_irq(&rq->lock);
  757. #else
  758. spin_unlock(&rq->lock);
  759. #endif
  760. }
  761. static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
  762. {
  763. #ifdef CONFIG_SMP
  764. /*
  765. * After ->oncpu is cleared, the task can be moved to a different CPU.
  766. * We must ensure this doesn't happen until the switch is completely
  767. * finished.
  768. */
  769. smp_wmb();
  770. prev->oncpu = 0;
  771. #endif
  772. #ifndef __ARCH_WANT_INTERRUPTS_ON_CTXSW
  773. local_irq_enable();
  774. #endif
  775. }
  776. #endif /* __ARCH_WANT_UNLOCKED_CTXSW */
  777. /*
  778. * __task_rq_lock - lock the runqueue a given task resides on.
  779. * Must be called interrupts disabled.
  780. */
  781. static inline struct rq *__task_rq_lock(struct task_struct *p)
  782. __acquires(rq->lock)
  783. {
  784. for (;;) {
  785. struct rq *rq = task_rq(p);
  786. spin_lock(&rq->lock);
  787. if (likely(rq == task_rq(p)))
  788. return rq;
  789. spin_unlock(&rq->lock);
  790. }
  791. }
  792. /*
  793. * task_rq_lock - lock the runqueue a given task resides on and disable
  794. * interrupts. Note the ordering: we can safely lookup the task_rq without
  795. * explicitly disabling preemption.
  796. */
  797. static struct rq *task_rq_lock(struct task_struct *p, unsigned long *flags)
  798. __acquires(rq->lock)
  799. {
  800. struct rq *rq;
  801. for (;;) {
  802. local_irq_save(*flags);
  803. rq = task_rq(p);
  804. spin_lock(&rq->lock);
  805. if (likely(rq == task_rq(p)))
  806. return rq;
  807. spin_unlock_irqrestore(&rq->lock, *flags);
  808. }
  809. }
  810. void task_rq_unlock_wait(struct task_struct *p)
  811. {
  812. struct rq *rq = task_rq(p);
  813. smp_mb(); /* spin-unlock-wait is not a full memory barrier */
  814. spin_unlock_wait(&rq->lock);
  815. }
  816. static void __task_rq_unlock(struct rq *rq)
  817. __releases(rq->lock)
  818. {
  819. spin_unlock(&rq->lock);
  820. }
  821. static inline void task_rq_unlock(struct rq *rq, unsigned long *flags)
  822. __releases(rq->lock)
  823. {
  824. spin_unlock_irqrestore(&rq->lock, *flags);
  825. }
  826. /*
  827. * this_rq_lock - lock this runqueue and disable interrupts.
  828. */
  829. static struct rq *this_rq_lock(void)
  830. __acquires(rq->lock)
  831. {
  832. struct rq *rq;
  833. local_irq_disable();
  834. rq = this_rq();
  835. spin_lock(&rq->lock);
  836. return rq;
  837. }
  838. #ifdef CONFIG_SCHED_HRTICK
  839. /*
  840. * Use HR-timers to deliver accurate preemption points.
  841. *
  842. * Its all a bit involved since we cannot program an hrt while holding the
  843. * rq->lock. So what we do is store a state in in rq->hrtick_* and ask for a
  844. * reschedule event.
  845. *
  846. * When we get rescheduled we reprogram the hrtick_timer outside of the
  847. * rq->lock.
  848. */
  849. /*
  850. * Use hrtick when:
  851. * - enabled by features
  852. * - hrtimer is actually high res
  853. */
  854. static inline int hrtick_enabled(struct rq *rq)
  855. {
  856. if (!sched_feat(HRTICK))
  857. return 0;
  858. if (!cpu_active(cpu_of(rq)))
  859. return 0;
  860. return hrtimer_is_hres_active(&rq->hrtick_timer);
  861. }
  862. static void hrtick_clear(struct rq *rq)
  863. {
  864. if (hrtimer_active(&rq->hrtick_timer))
  865. hrtimer_cancel(&rq->hrtick_timer);
  866. }
  867. /*
  868. * High-resolution timer tick.
  869. * Runs from hardirq context with interrupts disabled.
  870. */
  871. static enum hrtimer_restart hrtick(struct hrtimer *timer)
  872. {
  873. struct rq *rq = container_of(timer, struct rq, hrtick_timer);
  874. WARN_ON_ONCE(cpu_of(rq) != smp_processor_id());
  875. spin_lock(&rq->lock);
  876. update_rq_clock(rq);
  877. rq->curr->sched_class->task_tick(rq, rq->curr, 1);
  878. spin_unlock(&rq->lock);
  879. return HRTIMER_NORESTART;
  880. }
  881. #ifdef CONFIG_SMP
  882. /*
  883. * called from hardirq (IPI) context
  884. */
  885. static void __hrtick_start(void *arg)
  886. {
  887. struct rq *rq = arg;
  888. spin_lock(&rq->lock);
  889. hrtimer_restart(&rq->hrtick_timer);
  890. rq->hrtick_csd_pending = 0;
  891. spin_unlock(&rq->lock);
  892. }
  893. /*
  894. * Called to set the hrtick timer state.
  895. *
  896. * called with rq->lock held and irqs disabled
  897. */
  898. static void hrtick_start(struct rq *rq, u64 delay)
  899. {
  900. struct hrtimer *timer = &rq->hrtick_timer;
  901. ktime_t time = ktime_add_ns(timer->base->get_time(), delay);
  902. hrtimer_set_expires(timer, time);
  903. if (rq == this_rq()) {
  904. hrtimer_restart(timer);
  905. } else if (!rq->hrtick_csd_pending) {
  906. __smp_call_function_single(cpu_of(rq), &rq->hrtick_csd);
  907. rq->hrtick_csd_pending = 1;
  908. }
  909. }
  910. static int
  911. hotplug_hrtick(struct notifier_block *nfb, unsigned long action, void *hcpu)
  912. {
  913. int cpu = (int)(long)hcpu;
  914. switch (action) {
  915. case CPU_UP_CANCELED:
  916. case CPU_UP_CANCELED_FROZEN:
  917. case CPU_DOWN_PREPARE:
  918. case CPU_DOWN_PREPARE_FROZEN:
  919. case CPU_DEAD:
  920. case CPU_DEAD_FROZEN:
  921. hrtick_clear(cpu_rq(cpu));
  922. return NOTIFY_OK;
  923. }
  924. return NOTIFY_DONE;
  925. }
  926. static __init void init_hrtick(void)
  927. {
  928. hotcpu_notifier(hotplug_hrtick, 0);
  929. }
  930. #else
  931. /*
  932. * Called to set the hrtick timer state.
  933. *
  934. * called with rq->lock held and irqs disabled
  935. */
  936. static void hrtick_start(struct rq *rq, u64 delay)
  937. {
  938. hrtimer_start(&rq->hrtick_timer, ns_to_ktime(delay), HRTIMER_MODE_REL);
  939. }
  940. static inline void init_hrtick(void)
  941. {
  942. }
  943. #endif /* CONFIG_SMP */
  944. static void init_rq_hrtick(struct rq *rq)
  945. {
  946. #ifdef CONFIG_SMP
  947. rq->hrtick_csd_pending = 0;
  948. rq->hrtick_csd.flags = 0;
  949. rq->hrtick_csd.func = __hrtick_start;
  950. rq->hrtick_csd.info = rq;
  951. #endif
  952. hrtimer_init(&rq->hrtick_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
  953. rq->hrtick_timer.function = hrtick;
  954. rq->hrtick_timer.cb_mode = HRTIMER_CB_IRQSAFE_PERCPU;
  955. }
  956. #else /* CONFIG_SCHED_HRTICK */
  957. static inline void hrtick_clear(struct rq *rq)
  958. {
  959. }
  960. static inline void init_rq_hrtick(struct rq *rq)
  961. {
  962. }
  963. static inline void init_hrtick(void)
  964. {
  965. }
  966. #endif /* CONFIG_SCHED_HRTICK */
  967. /*
  968. * resched_task - mark a task 'to be rescheduled now'.
  969. *
  970. * On UP this means the setting of the need_resched flag, on SMP it
  971. * might also involve a cross-CPU call to trigger the scheduler on
  972. * the target CPU.
  973. */
  974. #ifdef CONFIG_SMP
  975. #ifndef tsk_is_polling
  976. #define tsk_is_polling(t) test_tsk_thread_flag(t, TIF_POLLING_NRFLAG)
  977. #endif
  978. static void resched_task(struct task_struct *p)
  979. {
  980. int cpu;
  981. assert_spin_locked(&task_rq(p)->lock);
  982. if (unlikely(test_tsk_thread_flag(p, TIF_NEED_RESCHED)))
  983. return;
  984. set_tsk_thread_flag(p, TIF_NEED_RESCHED);
  985. cpu = task_cpu(p);
  986. if (cpu == smp_processor_id())
  987. return;
  988. /* NEED_RESCHED must be visible before we test polling */
  989. smp_mb();
  990. if (!tsk_is_polling(p))
  991. smp_send_reschedule(cpu);
  992. }
  993. static void resched_cpu(int cpu)
  994. {
  995. struct rq *rq = cpu_rq(cpu);
  996. unsigned long flags;
  997. if (!spin_trylock_irqsave(&rq->lock, flags))
  998. return;
  999. resched_task(cpu_curr(cpu));
  1000. spin_unlock_irqrestore(&rq->lock, flags);
  1001. }
  1002. #ifdef CONFIG_NO_HZ
  1003. /*
  1004. * When add_timer_on() enqueues a timer into the timer wheel of an
  1005. * idle CPU then this timer might expire before the next timer event
  1006. * which is scheduled to wake up that CPU. In case of a completely
  1007. * idle system the next event might even be infinite time into the
  1008. * future. wake_up_idle_cpu() ensures that the CPU is woken up and
  1009. * leaves the inner idle loop so the newly added timer is taken into
  1010. * account when the CPU goes back to idle and evaluates the timer
  1011. * wheel for the next timer event.
  1012. */
  1013. void wake_up_idle_cpu(int cpu)
  1014. {
  1015. struct rq *rq = cpu_rq(cpu);
  1016. if (cpu == smp_processor_id())
  1017. return;
  1018. /*
  1019. * This is safe, as this function is called with the timer
  1020. * wheel base lock of (cpu) held. When the CPU is on the way
  1021. * to idle and has not yet set rq->curr to idle then it will
  1022. * be serialized on the timer wheel base lock and take the new
  1023. * timer into account automatically.
  1024. */
  1025. if (rq->curr != rq->idle)
  1026. return;
  1027. /*
  1028. * We can set TIF_RESCHED on the idle task of the other CPU
  1029. * lockless. The worst case is that the other CPU runs the
  1030. * idle task through an additional NOOP schedule()
  1031. */
  1032. set_tsk_thread_flag(rq->idle, TIF_NEED_RESCHED);
  1033. /* NEED_RESCHED must be visible before we test polling */
  1034. smp_mb();
  1035. if (!tsk_is_polling(rq->idle))
  1036. smp_send_reschedule(cpu);
  1037. }
  1038. #endif /* CONFIG_NO_HZ */
  1039. #else /* !CONFIG_SMP */
  1040. static void resched_task(struct task_struct *p)
  1041. {
  1042. assert_spin_locked(&task_rq(p)->lock);
  1043. set_tsk_need_resched(p);
  1044. }
  1045. #endif /* CONFIG_SMP */
  1046. #if BITS_PER_LONG == 32
  1047. # define WMULT_CONST (~0UL)
  1048. #else
  1049. # define WMULT_CONST (1UL << 32)
  1050. #endif
  1051. #define WMULT_SHIFT 32
  1052. /*
  1053. * Shift right and round:
  1054. */
  1055. #define SRR(x, y) (((x) + (1UL << ((y) - 1))) >> (y))
  1056. /*
  1057. * delta *= weight / lw
  1058. */
  1059. static unsigned long
  1060. calc_delta_mine(unsigned long delta_exec, unsigned long weight,
  1061. struct load_weight *lw)
  1062. {
  1063. u64 tmp;
  1064. if (!lw->inv_weight) {
  1065. if (BITS_PER_LONG > 32 && unlikely(lw->weight >= WMULT_CONST))
  1066. lw->inv_weight = 1;
  1067. else
  1068. lw->inv_weight = 1 + (WMULT_CONST-lw->weight/2)
  1069. / (lw->weight+1);
  1070. }
  1071. tmp = (u64)delta_exec * weight;
  1072. /*
  1073. * Check whether we'd overflow the 64-bit multiplication:
  1074. */
  1075. if (unlikely(tmp > WMULT_CONST))
  1076. tmp = SRR(SRR(tmp, WMULT_SHIFT/2) * lw->inv_weight,
  1077. WMULT_SHIFT/2);
  1078. else
  1079. tmp = SRR(tmp * lw->inv_weight, WMULT_SHIFT);
  1080. return (unsigned long)min(tmp, (u64)(unsigned long)LONG_MAX);
  1081. }
  1082. static inline void update_load_add(struct load_weight *lw, unsigned long inc)
  1083. {
  1084. lw->weight += inc;
  1085. lw->inv_weight = 0;
  1086. }
  1087. static inline void update_load_sub(struct load_weight *lw, unsigned long dec)
  1088. {
  1089. lw->weight -= dec;
  1090. lw->inv_weight = 0;
  1091. }
  1092. /*
  1093. * To aid in avoiding the subversion of "niceness" due to uneven distribution
  1094. * of tasks with abnormal "nice" values across CPUs the contribution that
  1095. * each task makes to its run queue's load is weighted according to its
  1096. * scheduling class and "nice" value. For SCHED_NORMAL tasks this is just a
  1097. * scaled version of the new time slice allocation that they receive on time
  1098. * slice expiry etc.
  1099. */
  1100. #define WEIGHT_IDLEPRIO 2
  1101. #define WMULT_IDLEPRIO (1 << 31)
  1102. /*
  1103. * Nice levels are multiplicative, with a gentle 10% change for every
  1104. * nice level changed. I.e. when a CPU-bound task goes from nice 0 to
  1105. * nice 1, it will get ~10% less CPU time than another CPU-bound task
  1106. * that remained on nice 0.
  1107. *
  1108. * The "10% effect" is relative and cumulative: from _any_ nice level,
  1109. * if you go up 1 level, it's -10% CPU usage, if you go down 1 level
  1110. * it's +10% CPU usage. (to achieve that we use a multiplier of 1.25.
  1111. * If a task goes up by ~10% and another task goes down by ~10% then
  1112. * the relative distance between them is ~25%.)
  1113. */
  1114. static const int prio_to_weight[40] = {
  1115. /* -20 */ 88761, 71755, 56483, 46273, 36291,
  1116. /* -15 */ 29154, 23254, 18705, 14949, 11916,
  1117. /* -10 */ 9548, 7620, 6100, 4904, 3906,
  1118. /* -5 */ 3121, 2501, 1991, 1586, 1277,
  1119. /* 0 */ 1024, 820, 655, 526, 423,
  1120. /* 5 */ 335, 272, 215, 172, 137,
  1121. /* 10 */ 110, 87, 70, 56, 45,
  1122. /* 15 */ 36, 29, 23, 18, 15,
  1123. };
  1124. /*
  1125. * Inverse (2^32/x) values of the prio_to_weight[] array, precalculated.
  1126. *
  1127. * In cases where the weight does not change often, we can use the
  1128. * precalculated inverse to speed up arithmetics by turning divisions
  1129. * into multiplications:
  1130. */
  1131. static const u32 prio_to_wmult[40] = {
  1132. /* -20 */ 48388, 59856, 76040, 92818, 118348,
  1133. /* -15 */ 147320, 184698, 229616, 287308, 360437,
  1134. /* -10 */ 449829, 563644, 704093, 875809, 1099582,
  1135. /* -5 */ 1376151, 1717300, 2157191, 2708050, 3363326,
  1136. /* 0 */ 4194304, 5237765, 6557202, 8165337, 10153587,
  1137. /* 5 */ 12820798, 15790321, 19976592, 24970740, 31350126,
  1138. /* 10 */ 39045157, 49367440, 61356676, 76695844, 95443717,
  1139. /* 15 */ 119304647, 148102320, 186737708, 238609294, 286331153,
  1140. };
  1141. static void activate_task(struct rq *rq, struct task_struct *p, int wakeup);
  1142. /*
  1143. * runqueue iterator, to support SMP load-balancing between different
  1144. * scheduling classes, without having to expose their internal data
  1145. * structures to the load-balancing proper:
  1146. */
  1147. struct rq_iterator {
  1148. void *arg;
  1149. struct task_struct *(*start)(void *);
  1150. struct task_struct *(*next)(void *);
  1151. };
  1152. #ifdef CONFIG_SMP
  1153. static unsigned long
  1154. balance_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest,
  1155. unsigned long max_load_move, struct sched_domain *sd,
  1156. enum cpu_idle_type idle, int *all_pinned,
  1157. int *this_best_prio, struct rq_iterator *iterator);
  1158. static int
  1159. iter_move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
  1160. struct sched_domain *sd, enum cpu_idle_type idle,
  1161. struct rq_iterator *iterator);
  1162. #endif
  1163. #ifdef CONFIG_CGROUP_CPUACCT
  1164. static void cpuacct_charge(struct task_struct *tsk, u64 cputime);
  1165. #else
  1166. static inline void cpuacct_charge(struct task_struct *tsk, u64 cputime) {}
  1167. #endif
  1168. static inline void inc_cpu_load(struct rq *rq, unsigned long load)
  1169. {
  1170. update_load_add(&rq->load, load);
  1171. }
  1172. static inline void dec_cpu_load(struct rq *rq, unsigned long load)
  1173. {
  1174. update_load_sub(&rq->load, load);
  1175. }
  1176. #if (defined(CONFIG_SMP) && defined(CONFIG_FAIR_GROUP_SCHED)) || defined(CONFIG_RT_GROUP_SCHED)
  1177. typedef int (*tg_visitor)(struct task_group *, void *);
  1178. /*
  1179. * Iterate the full tree, calling @down when first entering a node and @up when
  1180. * leaving it for the final time.
  1181. */
  1182. static int walk_tg_tree(tg_visitor down, tg_visitor up, void *data)
  1183. {
  1184. struct task_group *parent, *child;
  1185. int ret;
  1186. rcu_read_lock();
  1187. parent = &root_task_group;
  1188. down:
  1189. ret = (*down)(parent, data);
  1190. if (ret)
  1191. goto out_unlock;
  1192. list_for_each_entry_rcu(child, &parent->children, siblings) {
  1193. parent = child;
  1194. goto down;
  1195. up:
  1196. continue;
  1197. }
  1198. ret = (*up)(parent, data);
  1199. if (ret)
  1200. goto out_unlock;
  1201. child = parent;
  1202. parent = parent->parent;
  1203. if (parent)
  1204. goto up;
  1205. out_unlock:
  1206. rcu_read_unlock();
  1207. return ret;
  1208. }
  1209. static int tg_nop(struct task_group *tg, void *data)
  1210. {
  1211. return 0;
  1212. }
  1213. #endif
  1214. #ifdef CONFIG_SMP
  1215. static unsigned long source_load(int cpu, int type);
  1216. static unsigned long target_load(int cpu, int type);
  1217. static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
  1218. static unsigned long cpu_avg_load_per_task(int cpu)
  1219. {
  1220. struct rq *rq = cpu_rq(cpu);
  1221. if (rq->nr_running)
  1222. rq->avg_load_per_task = rq->load.weight / rq->nr_running;
  1223. return rq->avg_load_per_task;
  1224. }
  1225. #ifdef CONFIG_FAIR_GROUP_SCHED
  1226. static void __set_se_shares(struct sched_entity *se, unsigned long shares);
  1227. /*
  1228. * Calculate and set the cpu's group shares.
  1229. */
  1230. static void
  1231. update_group_shares_cpu(struct task_group *tg, int cpu,
  1232. unsigned long sd_shares, unsigned long sd_rq_weight)
  1233. {
  1234. int boost = 0;
  1235. unsigned long shares;
  1236. unsigned long rq_weight;
  1237. if (!tg->se[cpu])
  1238. return;
  1239. rq_weight = tg->cfs_rq[cpu]->load.weight;
  1240. /*
  1241. * If there are currently no tasks on the cpu pretend there is one of
  1242. * average load so that when a new task gets to run here it will not
  1243. * get delayed by group starvation.
  1244. */
  1245. if (!rq_weight) {
  1246. boost = 1;
  1247. rq_weight = NICE_0_LOAD;
  1248. }
  1249. if (unlikely(rq_weight > sd_rq_weight))
  1250. rq_weight = sd_rq_weight;
  1251. /*
  1252. * \Sum shares * rq_weight
  1253. * shares = -----------------------
  1254. * \Sum rq_weight
  1255. *
  1256. */
  1257. shares = (sd_shares * rq_weight) / (sd_rq_weight + 1);
  1258. shares = clamp_t(unsigned long, shares, MIN_SHARES, MAX_SHARES);
  1259. if (abs(shares - tg->se[cpu]->load.weight) >
  1260. sysctl_sched_shares_thresh) {
  1261. struct rq *rq = cpu_rq(cpu);
  1262. unsigned long flags;
  1263. spin_lock_irqsave(&rq->lock, flags);
  1264. /*
  1265. * record the actual number of shares, not the boosted amount.
  1266. */
  1267. tg->cfs_rq[cpu]->shares = boost ? 0 : shares;
  1268. tg->cfs_rq[cpu]->rq_weight = rq_weight;
  1269. __set_se_shares(tg->se[cpu], shares);
  1270. spin_unlock_irqrestore(&rq->lock, flags);
  1271. }
  1272. }
  1273. /*
  1274. * Re-compute the task group their per cpu shares over the given domain.
  1275. * This needs to be done in a bottom-up fashion because the rq weight of a
  1276. * parent group depends on the shares of its child groups.
  1277. */
  1278. static int tg_shares_up(struct task_group *tg, void *data)
  1279. {
  1280. unsigned long rq_weight = 0;
  1281. unsigned long shares = 0;
  1282. struct sched_domain *sd = data;
  1283. int i;
  1284. for_each_cpu_mask(i, sd->span) {
  1285. rq_weight += tg->cfs_rq[i]->load.weight;
  1286. shares += tg->cfs_rq[i]->shares;
  1287. }
  1288. if ((!shares && rq_weight) || shares > tg->shares)
  1289. shares = tg->shares;
  1290. if (!sd->parent || !(sd->parent->flags & SD_LOAD_BALANCE))
  1291. shares = tg->shares;
  1292. if (!rq_weight)
  1293. rq_weight = cpus_weight(sd->span) * NICE_0_LOAD;
  1294. for_each_cpu_mask(i, sd->span)
  1295. update_group_shares_cpu(tg, i, shares, rq_weight);
  1296. return 0;
  1297. }
  1298. /*
  1299. * Compute the cpu's hierarchical load factor for each task group.
  1300. * This needs to be done in a top-down fashion because the load of a child
  1301. * group is a fraction of its parents load.
  1302. */
  1303. static int tg_load_down(struct task_group *tg, void *data)
  1304. {
  1305. unsigned long load;
  1306. long cpu = (long)data;
  1307. if (!tg->parent) {
  1308. load = cpu_rq(cpu)->load.weight;
  1309. } else {
  1310. load = tg->parent->cfs_rq[cpu]->h_load;
  1311. load *= tg->cfs_rq[cpu]->shares;
  1312. load /= tg->parent->cfs_rq[cpu]->load.weight + 1;
  1313. }
  1314. tg->cfs_rq[cpu]->h_load = load;
  1315. return 0;
  1316. }
  1317. static void update_shares(struct sched_domain *sd)
  1318. {
  1319. u64 now = cpu_clock(raw_smp_processor_id());
  1320. s64 elapsed = now - sd->last_update;
  1321. if (elapsed >= (s64)(u64)sysctl_sched_shares_ratelimit) {
  1322. sd->last_update = now;
  1323. walk_tg_tree(tg_nop, tg_shares_up, sd);
  1324. }
  1325. }
  1326. static void update_shares_locked(struct rq *rq, struct sched_domain *sd)
  1327. {
  1328. spin_unlock(&rq->lock);
  1329. update_shares(sd);
  1330. spin_lock(&rq->lock);
  1331. }
  1332. static void update_h_load(long cpu)
  1333. {
  1334. walk_tg_tree(tg_load_down, tg_nop, (void *)cpu);
  1335. }
  1336. #else
  1337. static inline void update_shares(struct sched_domain *sd)
  1338. {
  1339. }
  1340. static inline void update_shares_locked(struct rq *rq, struct sched_domain *sd)
  1341. {
  1342. }
  1343. #endif
  1344. #endif
  1345. #ifdef CONFIG_FAIR_GROUP_SCHED
  1346. static void cfs_rq_set_shares(struct cfs_rq *cfs_rq, unsigned long shares)
  1347. {
  1348. #ifdef CONFIG_SMP
  1349. cfs_rq->shares = shares;
  1350. #endif
  1351. }
  1352. #endif
  1353. #include "sched_stats.h"
  1354. #include "sched_idletask.c"
  1355. #include "sched_fair.c"
  1356. #include "sched_rt.c"
  1357. #ifdef CONFIG_SCHED_DEBUG
  1358. # include "sched_debug.c"
  1359. #endif
  1360. #define sched_class_highest (&rt_sched_class)
  1361. #define for_each_class(class) \
  1362. for (class = sched_class_highest; class; class = class->next)
  1363. static void inc_nr_running(struct rq *rq)
  1364. {
  1365. rq->nr_running++;
  1366. }
  1367. static void dec_nr_running(struct rq *rq)
  1368. {
  1369. rq->nr_running--;
  1370. }
  1371. static void set_load_weight(struct task_struct *p)
  1372. {
  1373. if (task_has_rt_policy(p)) {
  1374. p->se.load.weight = prio_to_weight[0] * 2;
  1375. p->se.load.inv_weight = prio_to_wmult[0] >> 1;
  1376. return;
  1377. }
  1378. /*
  1379. * SCHED_IDLE tasks get minimal weight:
  1380. */
  1381. if (p->policy == SCHED_IDLE) {
  1382. p->se.load.weight = WEIGHT_IDLEPRIO;
  1383. p->se.load.inv_weight = WMULT_IDLEPRIO;
  1384. return;
  1385. }
  1386. p->se.load.weight = prio_to_weight[p->static_prio - MAX_RT_PRIO];
  1387. p->se.load.inv_weight = prio_to_wmult[p->static_prio - MAX_RT_PRIO];
  1388. }
  1389. static void update_avg(u64 *avg, u64 sample)
  1390. {
  1391. s64 diff = sample - *avg;
  1392. *avg += diff >> 3;
  1393. }
  1394. static void enqueue_task(struct rq *rq, struct task_struct *p, int wakeup)
  1395. {
  1396. sched_info_queued(p);
  1397. p->sched_class->enqueue_task(rq, p, wakeup);
  1398. p->se.on_rq = 1;
  1399. }
  1400. static void dequeue_task(struct rq *rq, struct task_struct *p, int sleep)
  1401. {
  1402. if (sleep && p->se.last_wakeup) {
  1403. update_avg(&p->se.avg_overlap,
  1404. p->se.sum_exec_runtime - p->se.last_wakeup);
  1405. p->se.last_wakeup = 0;
  1406. }
  1407. sched_info_dequeued(p);
  1408. p->sched_class->dequeue_task(rq, p, sleep);
  1409. p->se.on_rq = 0;
  1410. }
  1411. /*
  1412. * __normal_prio - return the priority that is based on the static prio
  1413. */
  1414. static inline int __normal_prio(struct task_struct *p)
  1415. {
  1416. return p->static_prio;
  1417. }
  1418. /*
  1419. * Calculate the expected normal priority: i.e. priority
  1420. * without taking RT-inheritance into account. Might be
  1421. * boosted by interactivity modifiers. Changes upon fork,
  1422. * setprio syscalls, and whenever the interactivity
  1423. * estimator recalculates.
  1424. */
  1425. static inline int normal_prio(struct task_struct *p)
  1426. {
  1427. int prio;
  1428. if (task_has_rt_policy(p))
  1429. prio = MAX_RT_PRIO-1 - p->rt_priority;
  1430. else
  1431. prio = __normal_prio(p);
  1432. return prio;
  1433. }
  1434. /*
  1435. * Calculate the current priority, i.e. the priority
  1436. * taken into account by the scheduler. This value might
  1437. * be boosted by RT tasks, or might be boosted by
  1438. * interactivity modifiers. Will be RT if the task got
  1439. * RT-boosted. If not then it returns p->normal_prio.
  1440. */
  1441. static int effective_prio(struct task_struct *p)
  1442. {
  1443. p->normal_prio = normal_prio(p);
  1444. /*
  1445. * If we are RT tasks or we were boosted to RT priority,
  1446. * keep the priority unchanged. Otherwise, update priority
  1447. * to the normal priority:
  1448. */
  1449. if (!rt_prio(p->prio))
  1450. return p->normal_prio;
  1451. return p->prio;
  1452. }
  1453. /*
  1454. * activate_task - move a task to the runqueue.
  1455. */
  1456. static void activate_task(struct rq *rq, struct task_struct *p, int wakeup)
  1457. {
  1458. if (task_contributes_to_load(p))
  1459. rq->nr_uninterruptible--;
  1460. enqueue_task(rq, p, wakeup);
  1461. inc_nr_running(rq);
  1462. }
  1463. /*
  1464. * deactivate_task - remove a task from the runqueue.
  1465. */
  1466. static void deactivate_task(struct rq *rq, struct task_struct *p, int sleep)
  1467. {
  1468. if (task_contributes_to_load(p))
  1469. rq->nr_uninterruptible++;
  1470. dequeue_task(rq, p, sleep);
  1471. dec_nr_running(rq);
  1472. }
  1473. /**
  1474. * task_curr - is this task currently executing on a CPU?
  1475. * @p: the task in question.
  1476. */
  1477. inline int task_curr(const struct task_struct *p)
  1478. {
  1479. return cpu_curr(task_cpu(p)) == p;
  1480. }
  1481. static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
  1482. {
  1483. set_task_rq(p, cpu);
  1484. #ifdef CONFIG_SMP
  1485. /*
  1486. * After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
  1487. * successfuly executed on another CPU. We must ensure that updates of
  1488. * per-task data have been completed by this moment.
  1489. */
  1490. smp_wmb();
  1491. task_thread_info(p)->cpu = cpu;
  1492. #endif
  1493. }
  1494. static inline void check_class_changed(struct rq *rq, struct task_struct *p,
  1495. const struct sched_class *prev_class,
  1496. int oldprio, int running)
  1497. {
  1498. if (prev_class != p->sched_class) {
  1499. if (prev_class->switched_from)
  1500. prev_class->switched_from(rq, p, running);
  1501. p->sched_class->switched_to(rq, p, running);
  1502. } else
  1503. p->sched_class->prio_changed(rq, p, oldprio, running);
  1504. }
  1505. #ifdef CONFIG_SMP
  1506. /* Used instead of source_load when we know the type == 0 */
  1507. static unsigned long weighted_cpuload(const int cpu)
  1508. {
  1509. return cpu_rq(cpu)->load.weight;
  1510. }
  1511. /*
  1512. * Is this task likely cache-hot:
  1513. */
  1514. static int
  1515. task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
  1516. {
  1517. s64 delta;
  1518. /*
  1519. * Buddy candidates are cache hot:
  1520. */
  1521. if (sched_feat(CACHE_HOT_BUDDY) &&
  1522. (&p->se == cfs_rq_of(&p->se)->next ||
  1523. &p->se == cfs_rq_of(&p->se)->last))
  1524. return 1;
  1525. if (p->sched_class != &fair_sched_class)
  1526. return 0;
  1527. if (sysctl_sched_migration_cost == -1)
  1528. return 1;
  1529. if (sysctl_sched_migration_cost == 0)
  1530. return 0;
  1531. delta = now - p->se.exec_start;
  1532. return delta < (s64)sysctl_sched_migration_cost;
  1533. }
  1534. void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
  1535. {
  1536. int old_cpu = task_cpu(p);
  1537. struct rq *old_rq = cpu_rq(old_cpu), *new_rq = cpu_rq(new_cpu);
  1538. struct cfs_rq *old_cfsrq = task_cfs_rq(p),
  1539. *new_cfsrq = cpu_cfs_rq(old_cfsrq, new_cpu);
  1540. u64 clock_offset;
  1541. clock_offset = old_rq->clock - new_rq->clock;
  1542. #ifdef CONFIG_SCHEDSTATS
  1543. if (p->se.wait_start)
  1544. p->se.wait_start -= clock_offset;
  1545. if (p->se.sleep_start)
  1546. p->se.sleep_start -= clock_offset;
  1547. if (p->se.block_start)
  1548. p->se.block_start -= clock_offset;
  1549. if (old_cpu != new_cpu) {
  1550. schedstat_inc(p, se.nr_migrations);
  1551. if (task_hot(p, old_rq->clock, NULL))
  1552. schedstat_inc(p, se.nr_forced2_migrations);
  1553. }
  1554. #endif
  1555. p->se.vruntime -= old_cfsrq->min_vruntime -
  1556. new_cfsrq->min_vruntime;
  1557. __set_task_cpu(p, new_cpu);
  1558. }
  1559. struct migration_req {
  1560. struct list_head list;
  1561. struct task_struct *task;
  1562. int dest_cpu;
  1563. struct completion done;
  1564. };
  1565. /*
  1566. * The task's runqueue lock must be held.
  1567. * Returns true if you have to wait for migration thread.
  1568. */
  1569. static int
  1570. migrate_task(struct task_struct *p, int dest_cpu, struct migration_req *req)
  1571. {
  1572. struct rq *rq = task_rq(p);
  1573. /*
  1574. * If the task is not on a runqueue (and not running), then
  1575. * it is sufficient to simply update the task's cpu field.
  1576. */
  1577. if (!p->se.on_rq && !task_running(rq, p)) {
  1578. set_task_cpu(p, dest_cpu);
  1579. return 0;
  1580. }
  1581. init_completion(&req->done);
  1582. req->task = p;
  1583. req->dest_cpu = dest_cpu;
  1584. list_add(&req->list, &rq->migration_queue);
  1585. return 1;
  1586. }
  1587. /*
  1588. * wait_task_inactive - wait for a thread to unschedule.
  1589. *
  1590. * If @match_state is nonzero, it's the @p->state value just checked and
  1591. * not expected to change. If it changes, i.e. @p might have woken up,
  1592. * then return zero. When we succeed in waiting for @p to be off its CPU,
  1593. * we return a positive number (its total switch count). If a second call
  1594. * a short while later returns the same number, the caller can be sure that
  1595. * @p has remained unscheduled the whole time.
  1596. *
  1597. * The caller must ensure that the task *will* unschedule sometime soon,
  1598. * else this function might spin for a *long* time. This function can't
  1599. * be called with interrupts off, or it may introduce deadlock with
  1600. * smp_call_function() if an IPI is sent by the same process we are
  1601. * waiting to become inactive.
  1602. */
  1603. unsigned long wait_task_inactive(struct task_struct *p, long match_state)
  1604. {
  1605. unsigned long flags;
  1606. int running, on_rq;
  1607. unsigned long ncsw;
  1608. struct rq *rq;
  1609. for (;;) {
  1610. /*
  1611. * We do the initial early heuristics without holding
  1612. * any task-queue locks at all. We'll only try to get
  1613. * the runqueue lock when things look like they will
  1614. * work out!
  1615. */
  1616. rq = task_rq(p);
  1617. /*
  1618. * If the task is actively running on another CPU
  1619. * still, just relax and busy-wait without holding
  1620. * any locks.
  1621. *
  1622. * NOTE! Since we don't hold any locks, it's not
  1623. * even sure that "rq" stays as the right runqueue!
  1624. * But we don't care, since "task_running()" will
  1625. * return false if the runqueue has changed and p
  1626. * is actually now running somewhere else!
  1627. */
  1628. while (task_running(rq, p)) {
  1629. if (match_state && unlikely(p->state != match_state))
  1630. return 0;
  1631. cpu_relax();
  1632. }
  1633. /*
  1634. * Ok, time to look more closely! We need the rq
  1635. * lock now, to be *sure*. If we're wrong, we'll
  1636. * just go back and repeat.
  1637. */
  1638. rq = task_rq_lock(p, &flags);
  1639. trace_sched_wait_task(rq, p);
  1640. running = task_running(rq, p);
  1641. on_rq = p->se.on_rq;
  1642. ncsw = 0;
  1643. if (!match_state || p->state == match_state)
  1644. ncsw = p->nvcsw | LONG_MIN; /* sets MSB */
  1645. task_rq_unlock(rq, &flags);
  1646. /*
  1647. * If it changed from the expected state, bail out now.
  1648. */
  1649. if (unlikely(!ncsw))
  1650. break;
  1651. /*
  1652. * Was it really running after all now that we
  1653. * checked with the proper locks actually held?
  1654. *
  1655. * Oops. Go back and try again..
  1656. */
  1657. if (unlikely(running)) {
  1658. cpu_relax();
  1659. continue;
  1660. }
  1661. /*
  1662. * It's not enough that it's not actively running,
  1663. * it must be off the runqueue _entirely_, and not
  1664. * preempted!
  1665. *
  1666. * So if it wa still runnable (but just not actively
  1667. * running right now), it's preempted, and we should
  1668. * yield - it could be a while.
  1669. */
  1670. if (unlikely(on_rq)) {
  1671. schedule_timeout_uninterruptible(1);
  1672. continue;
  1673. }
  1674. /*
  1675. * Ahh, all good. It wasn't running, and it wasn't
  1676. * runnable, which means that it will never become
  1677. * running in the future either. We're all done!
  1678. */
  1679. break;
  1680. }
  1681. return ncsw;
  1682. }
  1683. /***
  1684. * kick_process - kick a running thread to enter/exit the kernel
  1685. * @p: the to-be-kicked thread
  1686. *
  1687. * Cause a process which is running on another CPU to enter
  1688. * kernel-mode, without any delay. (to get signals handled.)
  1689. *
  1690. * NOTE: this function doesnt have to take the runqueue lock,
  1691. * because all it wants to ensure is that the remote task enters
  1692. * the kernel. If the IPI races and the task has been migrated
  1693. * to another CPU then no harm is done and the purpose has been
  1694. * achieved as well.
  1695. */
  1696. void kick_process(struct task_struct *p)
  1697. {
  1698. int cpu;
  1699. preempt_disable();
  1700. cpu = task_cpu(p);
  1701. if ((cpu != smp_processor_id()) && task_curr(p))
  1702. smp_send_reschedule(cpu);
  1703. preempt_enable();
  1704. }
  1705. /*
  1706. * Return a low guess at the load of a migration-source cpu weighted
  1707. * according to the scheduling class and "nice" value.
  1708. *
  1709. * We want to under-estimate the load of migration sources, to
  1710. * balance conservatively.
  1711. */
  1712. static unsigned long source_load(int cpu, int type)
  1713. {
  1714. struct rq *rq = cpu_rq(cpu);
  1715. unsigned long total = weighted_cpuload(cpu);
  1716. if (type == 0 || !sched_feat(LB_BIAS))
  1717. return total;
  1718. return min(rq->cpu_load[type-1], total);
  1719. }
  1720. /*
  1721. * Return a high guess at the load of a migration-target cpu weighted
  1722. * according to the scheduling class and "nice" value.
  1723. */
  1724. static unsigned long target_load(int cpu, int type)
  1725. {
  1726. struct rq *rq = cpu_rq(cpu);
  1727. unsigned long total = weighted_cpuload(cpu);
  1728. if (type == 0 || !sched_feat(LB_BIAS))
  1729. return total;
  1730. return max(rq->cpu_load[type-1], total);
  1731. }
  1732. /*
  1733. * find_idlest_group finds and returns the least busy CPU group within the
  1734. * domain.
  1735. */
  1736. static struct sched_group *
  1737. find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu)
  1738. {
  1739. struct sched_group *idlest = NULL, *this = NULL, *group = sd->groups;
  1740. unsigned long min_load = ULONG_MAX, this_load = 0;
  1741. int load_idx = sd->forkexec_idx;
  1742. int imbalance = 100 + (sd->imbalance_pct-100)/2;
  1743. do {
  1744. unsigned long load, avg_load;
  1745. int local_group;
  1746. int i;
  1747. /* Skip over this group if it has no CPUs allowed */
  1748. if (!cpus_intersects(group->cpumask, p->cpus_allowed))
  1749. continue;
  1750. local_group = cpu_isset(this_cpu, group->cpumask);
  1751. /* Tally up the load of all CPUs in the group */
  1752. avg_load = 0;
  1753. for_each_cpu_mask_nr(i, group->cpumask) {
  1754. /* Bias balancing toward cpus of our domain */
  1755. if (local_group)
  1756. load = source_load(i, load_idx);
  1757. else
  1758. load = target_load(i, load_idx);
  1759. avg_load += load;
  1760. }
  1761. /* Adjust by relative CPU power of the group */
  1762. avg_load = sg_div_cpu_power(group,
  1763. avg_load * SCHED_LOAD_SCALE);
  1764. if (local_group) {
  1765. this_load = avg_load;
  1766. this = group;
  1767. } else if (avg_load < min_load) {
  1768. min_load = avg_load;
  1769. idlest = group;
  1770. }
  1771. } while (group = group->next, group != sd->groups);
  1772. if (!idlest || 100*this_load < imbalance*min_load)
  1773. return NULL;
  1774. return idlest;
  1775. }
  1776. /*
  1777. * find_idlest_cpu - find the idlest cpu among the cpus in group.
  1778. */
  1779. static int
  1780. find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu,
  1781. cpumask_t *tmp)
  1782. {
  1783. unsigned long load, min_load = ULONG_MAX;
  1784. int idlest = -1;
  1785. int i;
  1786. /* Traverse only the allowed CPUs */
  1787. cpus_and(*tmp, group->cpumask, p->cpus_allowed);
  1788. for_each_cpu_mask_nr(i, *tmp) {
  1789. load = weighted_cpuload(i);
  1790. if (load < min_load || (load == min_load && i == this_cpu)) {
  1791. min_load = load;
  1792. idlest = i;
  1793. }
  1794. }
  1795. return idlest;
  1796. }
  1797. /*
  1798. * sched_balance_self: balance the current task (running on cpu) in domains
  1799. * that have the 'flag' flag set. In practice, this is SD_BALANCE_FORK and
  1800. * SD_BALANCE_EXEC.
  1801. *
  1802. * Balance, ie. select the least loaded group.
  1803. *
  1804. * Returns the target CPU number, or the same CPU if no balancing is needed.
  1805. *
  1806. * preempt must be disabled.
  1807. */
  1808. static int sched_balance_self(int cpu, int flag)
  1809. {
  1810. struct task_struct *t = current;
  1811. struct sched_domain *tmp, *sd = NULL;
  1812. for_each_domain(cpu, tmp) {
  1813. /*
  1814. * If power savings logic is enabled for a domain, stop there.
  1815. */
  1816. if (tmp->flags & SD_POWERSAVINGS_BALANCE)
  1817. break;
  1818. if (tmp->flags & flag)
  1819. sd = tmp;
  1820. }
  1821. if (sd)
  1822. update_shares(sd);
  1823. while (sd) {
  1824. cpumask_t span, tmpmask;
  1825. struct sched_group *group;
  1826. int new_cpu, weight;
  1827. if (!(sd->flags & flag)) {
  1828. sd = sd->child;
  1829. continue;
  1830. }
  1831. span = sd->span;
  1832. group = find_idlest_group(sd, t, cpu);
  1833. if (!group) {
  1834. sd = sd->child;
  1835. continue;
  1836. }
  1837. new_cpu = find_idlest_cpu(group, t, cpu, &tmpmask);
  1838. if (new_cpu == -1 || new_cpu == cpu) {
  1839. /* Now try balancing at a lower domain level of cpu */
  1840. sd = sd->child;
  1841. continue;
  1842. }
  1843. /* Now try balancing at a lower domain level of new_cpu */
  1844. cpu = new_cpu;
  1845. sd = NULL;
  1846. weight = cpus_weight(span);
  1847. for_each_domain(cpu, tmp) {
  1848. if (weight <= cpus_weight(tmp->span))
  1849. break;
  1850. if (tmp->flags & flag)
  1851. sd = tmp;
  1852. }
  1853. /* while loop will break here if sd == NULL */
  1854. }
  1855. return cpu;
  1856. }
  1857. #endif /* CONFIG_SMP */
  1858. /***
  1859. * try_to_wake_up - wake up a thread
  1860. * @p: the to-be-woken-up thread
  1861. * @state: the mask of task states that can be woken
  1862. * @sync: do a synchronous wakeup?
  1863. *
  1864. * Put it on the run-queue if it's not already there. The "current"
  1865. * thread is always on the run-queue (except when the actual
  1866. * re-schedule is in progress), and as such you're allowed to do
  1867. * the simpler "current->state = TASK_RUNNING" to mark yourself
  1868. * runnable without the overhead of this.
  1869. *
  1870. * returns failure only if the task is already active.
  1871. */
  1872. static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
  1873. {
  1874. int cpu, orig_cpu, this_cpu, success = 0;
  1875. unsigned long flags;
  1876. long old_state;
  1877. struct rq *rq;
  1878. if (!sched_feat(SYNC_WAKEUPS))
  1879. sync = 0;
  1880. #ifdef CONFIG_SMP
  1881. if (sched_feat(LB_WAKEUP_UPDATE)) {
  1882. struct sched_domain *sd;
  1883. this_cpu = raw_smp_processor_id();
  1884. cpu = task_cpu(p);
  1885. for_each_domain(this_cpu, sd) {
  1886. if (cpu_isset(cpu, sd->span)) {
  1887. update_shares(sd);
  1888. break;
  1889. }
  1890. }
  1891. }
  1892. #endif
  1893. smp_wmb();
  1894. rq = task_rq_lock(p, &flags);
  1895. old_state = p->state;
  1896. if (!(old_state & state))
  1897. goto out;
  1898. if (p->se.on_rq)
  1899. goto out_running;
  1900. cpu = task_cpu(p);
  1901. orig_cpu = cpu;
  1902. this_cpu = smp_processor_id();
  1903. #ifdef CONFIG_SMP
  1904. if (unlikely(task_running(rq, p)))
  1905. goto out_activate;
  1906. cpu = p->sched_class->select_task_rq(p, sync);
  1907. if (cpu != orig_cpu) {
  1908. set_task_cpu(p, cpu);
  1909. task_rq_unlock(rq, &flags);
  1910. /* might preempt at this point */
  1911. rq = task_rq_lock(p, &flags);
  1912. old_state = p->state;
  1913. if (!(old_state & state))
  1914. goto out;
  1915. if (p->se.on_rq)
  1916. goto out_running;
  1917. this_cpu = smp_processor_id();
  1918. cpu = task_cpu(p);
  1919. }
  1920. #ifdef CONFIG_SCHEDSTATS
  1921. schedstat_inc(rq, ttwu_count);
  1922. if (cpu == this_cpu)
  1923. schedstat_inc(rq, ttwu_local);
  1924. else {
  1925. struct sched_domain *sd;
  1926. for_each_domain(this_cpu, sd) {
  1927. if (cpu_isset(cpu, sd->span)) {
  1928. schedstat_inc(sd, ttwu_wake_remote);
  1929. break;
  1930. }
  1931. }
  1932. }
  1933. #endif /* CONFIG_SCHEDSTATS */
  1934. out_activate:
  1935. #endif /* CONFIG_SMP */
  1936. schedstat_inc(p, se.nr_wakeups);
  1937. if (sync)
  1938. schedstat_inc(p, se.nr_wakeups_sync);
  1939. if (orig_cpu != cpu)
  1940. schedstat_inc(p, se.nr_wakeups_migrate);
  1941. if (cpu == this_cpu)
  1942. schedstat_inc(p, se.nr_wakeups_local);
  1943. else
  1944. schedstat_inc(p, se.nr_wakeups_remote);
  1945. update_rq_clock(rq);
  1946. activate_task(rq, p, 1);
  1947. success = 1;
  1948. out_running:
  1949. trace_sched_wakeup(rq, p);
  1950. check_preempt_curr(rq, p, sync);
  1951. p->state = TASK_RUNNING;
  1952. #ifdef CONFIG_SMP
  1953. if (p->sched_class->task_wake_up)
  1954. p->sched_class->task_wake_up(rq, p);
  1955. #endif
  1956. out:
  1957. current->se.last_wakeup = current->se.sum_exec_runtime;
  1958. task_rq_unlock(rq, &flags);
  1959. return success;
  1960. }
  1961. int wake_up_process(struct task_struct *p)
  1962. {
  1963. return try_to_wake_up(p, TASK_ALL, 0);
  1964. }
  1965. EXPORT_SYMBOL(wake_up_process);
  1966. int wake_up_state(struct task_struct *p, unsigned int state)
  1967. {
  1968. return try_to_wake_up(p, state, 0);
  1969. }
  1970. /*
  1971. * Perform scheduler related setup for a newly forked process p.
  1972. * p is forked by current.
  1973. *
  1974. * __sched_fork() is basic setup used by init_idle() too:
  1975. */
  1976. static void __sched_fork(struct task_struct *p)
  1977. {
  1978. p->se.exec_start = 0;
  1979. p->se.sum_exec_runtime = 0;
  1980. p->se.prev_sum_exec_runtime = 0;
  1981. p->se.last_wakeup = 0;
  1982. p->se.avg_overlap = 0;
  1983. #ifdef CONFIG_SCHEDSTATS
  1984. p->se.wait_start = 0;
  1985. p->se.sum_sleep_runtime = 0;
  1986. p->se.sleep_start = 0;
  1987. p->se.block_start = 0;
  1988. p->se.sleep_max = 0;
  1989. p->se.block_max = 0;
  1990. p->se.exec_max = 0;
  1991. p->se.slice_max = 0;
  1992. p->se.wait_max = 0;
  1993. #endif
  1994. INIT_LIST_HEAD(&p->rt.run_list);
  1995. p->se.on_rq = 0;
  1996. INIT_LIST_HEAD(&p->se.group_node);
  1997. #ifdef CONFIG_PREEMPT_NOTIFIERS
  1998. INIT_HLIST_HEAD(&p->preempt_notifiers);
  1999. #endif
  2000. /*
  2001. * We mark the process as running here, but have not actually
  2002. * inserted it onto the runqueue yet. This guarantees that
  2003. * nobody will actually run it, and a signal or other external
  2004. * event cannot wake it up and insert it on the runqueue either.
  2005. */
  2006. p->state = TASK_RUNNING;
  2007. }
  2008. /*
  2009. * fork()/clone()-time setup:
  2010. */
  2011. void sched_fork(struct task_struct *p, int clone_flags)
  2012. {
  2013. int cpu = get_cpu();
  2014. __sched_fork(p);
  2015. #ifdef CONFIG_SMP
  2016. cpu = sched_balance_self(cpu, SD_BALANCE_FORK);
  2017. #endif
  2018. set_task_cpu(p, cpu);
  2019. /*
  2020. * Make sure we do not leak PI boosting priority to the child:
  2021. */
  2022. p->prio = current->normal_prio;
  2023. if (!rt_prio(p->prio))
  2024. p->sched_class = &fair_sched_class;
  2025. #if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
  2026. if (likely(sched_info_on()))
  2027. memset(&p->sched_info, 0, sizeof(p->sched_info));
  2028. #endif
  2029. #if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
  2030. p->oncpu = 0;
  2031. #endif
  2032. #ifdef CONFIG_PREEMPT
  2033. /* Want to start with kernel preemption disabled. */
  2034. task_thread_info(p)->preempt_count = 1;
  2035. #endif
  2036. put_cpu();
  2037. }
  2038. /*
  2039. * wake_up_new_task - wake up a newly created task for the first time.
  2040. *
  2041. * This function will do some initial scheduler statistics housekeeping
  2042. * that must be done for every newly created context, then puts the task
  2043. * on the runqueue and wakes it.
  2044. */
  2045. void wake_up_new_task(struct task_struct *p, unsigned long clone_flags)
  2046. {
  2047. unsigned long flags;
  2048. struct rq *rq;
  2049. rq = task_rq_lock(p, &flags);
  2050. BUG_ON(p->state != TASK_RUNNING);
  2051. update_rq_clock(rq);
  2052. p->prio = effective_prio(p);
  2053. if (!p->sched_class->task_new || !current->se.on_rq) {
  2054. activate_task(rq, p, 0);
  2055. } else {
  2056. /*
  2057. * Let the scheduling class do new task startup
  2058. * management (if any):
  2059. */
  2060. p->sched_class->task_new(rq, p);
  2061. inc_nr_running(rq);
  2062. }
  2063. trace_sched_wakeup_new(rq, p);
  2064. check_preempt_curr(rq, p, 0);
  2065. #ifdef CONFIG_SMP
  2066. if (p->sched_class->task_wake_up)
  2067. p->sched_class->task_wake_up(rq, p);
  2068. #endif
  2069. task_rq_unlock(rq, &flags);
  2070. }
  2071. #ifdef CONFIG_PREEMPT_NOTIFIERS
  2072. /**
  2073. * preempt_notifier_register - tell me when current is being being preempted & rescheduled
  2074. * @notifier: notifier struct to register
  2075. */
  2076. void preempt_notifier_register(struct preempt_notifier *notifier)
  2077. {
  2078. hlist_add_head(&notifier->link, &current->preempt_notifiers);
  2079. }
  2080. EXPORT_SYMBOL_GPL(preempt_notifier_register);
  2081. /**
  2082. * preempt_notifier_unregister - no longer interested in preemption notifications
  2083. * @notifier: notifier struct to unregister
  2084. *
  2085. * This is safe to call from within a preemption notifier.
  2086. */
  2087. void preempt_notifier_unregister(struct preempt_notifier *notifier)
  2088. {
  2089. hlist_del(&notifier->link);
  2090. }
  2091. EXPORT_SYMBOL_GPL(preempt_notifier_unregister);
  2092. static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
  2093. {
  2094. struct preempt_notifier *notifier;
  2095. struct hlist_node *node;
  2096. hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
  2097. notifier->ops->sched_in(notifier, raw_smp_processor_id());
  2098. }
  2099. static void
  2100. fire_sched_out_preempt_notifiers(struct task_struct *curr,
  2101. struct task_struct *next)
  2102. {
  2103. struct preempt_notifier *notifier;
  2104. struct hlist_node *node;
  2105. hlist_for_each_entry(notifier, node, &curr->preempt_notifiers, link)
  2106. notifier->ops->sched_out(notifier, next);
  2107. }
  2108. #else /* !CONFIG_PREEMPT_NOTIFIERS */
  2109. static void fire_sched_in_preempt_notifiers(struct task_struct *curr)
  2110. {
  2111. }
  2112. static void
  2113. fire_sched_out_preempt_notifiers(struct task_struct *curr,
  2114. struct task_struct *next)
  2115. {
  2116. }
  2117. #endif /* CONFIG_PREEMPT_NOTIFIERS */
  2118. /**
  2119. * prepare_task_switch - prepare to switch tasks
  2120. * @rq: the runqueue preparing to switch
  2121. * @prev: the current task that is being switched out
  2122. * @next: the task we are going to switch to.
  2123. *
  2124. * This is called with the rq lock held and interrupts off. It must
  2125. * be paired with a subsequent finish_task_switch after the context
  2126. * switch.
  2127. *
  2128. * prepare_task_switch sets up locking and calls architecture specific
  2129. * hooks.
  2130. */
  2131. static inline void
  2132. prepare_task_switch(struct rq *rq, struct task_struct *prev,
  2133. struct task_struct *next)
  2134. {
  2135. fire_sched_out_preempt_notifiers(prev, next);
  2136. prepare_lock_switch(rq, next);
  2137. prepare_arch_switch(next);
  2138. }
  2139. /**
  2140. * finish_task_switch - clean up after a task-switch
  2141. * @rq: runqueue associated with task-switch
  2142. * @prev: the thread we just switched away from.
  2143. *
  2144. * finish_task_switch must be called after the context switch, paired
  2145. * with a prepare_task_switch call before the context switch.
  2146. * finish_task_switch will reconcile locking set up by prepare_task_switch,
  2147. * and do any other architecture-specific cleanup actions.
  2148. *
  2149. * Note that we may have delayed dropping an mm in context_switch(). If
  2150. * so, we finish that here outside of the runqueue lock. (Doing it
  2151. * with the lock held can cause deadlocks; see schedule() for
  2152. * details.)
  2153. */
  2154. static void finish_task_switch(struct rq *rq, struct task_struct *prev)
  2155. __releases(rq->lock)
  2156. {
  2157. struct mm_struct *mm = rq->prev_mm;
  2158. long prev_state;
  2159. rq->prev_mm = NULL;
  2160. /*
  2161. * A task struct has one reference for the use as "current".
  2162. * If a task dies, then it sets TASK_DEAD in tsk->state and calls
  2163. * schedule one last time. The schedule call will never return, and
  2164. * the scheduled task must drop that reference.
  2165. * The test for TASK_DEAD must occur while the runqueue locks are
  2166. * still held, otherwise prev could be scheduled on another cpu, die
  2167. * there before we look at prev->state, and then the reference would
  2168. * be dropped twice.
  2169. * Manfred Spraul <manfred@colorfullife.com>
  2170. */
  2171. prev_state = prev->state;
  2172. finish_arch_switch(prev);
  2173. finish_lock_switch(rq, prev);
  2174. #ifdef CONFIG_SMP
  2175. if (current->sched_class->post_schedule)
  2176. current->sched_class->post_schedule(rq);
  2177. #endif
  2178. fire_sched_in_preempt_notifiers(current);
  2179. if (mm)
  2180. mmdrop(mm);
  2181. if (unlikely(prev_state == TASK_DEAD)) {
  2182. /*
  2183. * Remove function-return probe instances associated with this
  2184. * task and put them back on the free list.
  2185. */
  2186. kprobe_flush_task(prev);
  2187. put_task_struct(prev);
  2188. }
  2189. }
  2190. /**
  2191. * schedule_tail - first thing a freshly forked thread must call.
  2192. * @prev: the thread we just switched away from.
  2193. */
  2194. asmlinkage void schedule_tail(struct task_struct *prev)
  2195. __releases(rq->lock)
  2196. {
  2197. struct rq *rq = this_rq();
  2198. finish_task_switch(rq, prev);
  2199. #ifdef __ARCH_WANT_UNLOCKED_CTXSW
  2200. /* In this case, finish_task_switch does not reenable preemption */
  2201. preempt_enable();
  2202. #endif
  2203. if (current->set_child_tid)
  2204. put_user(task_pid_vnr(current), current->set_child_tid);
  2205. }
  2206. /*
  2207. * context_switch - switch to the new MM and the new
  2208. * thread's register state.
  2209. */
  2210. static inline void
  2211. context_switch(struct rq *rq, struct task_struct *prev,
  2212. struct task_struct *next)
  2213. {
  2214. struct mm_struct *mm, *oldmm;
  2215. prepare_task_switch(rq, prev, next);
  2216. trace_sched_switch(rq, prev, next);
  2217. mm = next->mm;
  2218. oldmm = prev->active_mm;
  2219. /*
  2220. * For paravirt, this is coupled with an exit in switch_to to
  2221. * combine the page table reload and the switch backend into
  2222. * one hypercall.
  2223. */
  2224. arch_enter_lazy_cpu_mode();
  2225. if (unlikely(!mm)) {
  2226. next->active_mm = oldmm;
  2227. atomic_inc(&oldmm->mm_count);
  2228. enter_lazy_tlb(oldmm, next);
  2229. } else
  2230. switch_mm(oldmm, mm, next);
  2231. if (unlikely(!prev->mm)) {
  2232. prev->active_mm = NULL;
  2233. rq->prev_mm = oldmm;
  2234. }
  2235. /*
  2236. * Since the runqueue lock will be released by the next
  2237. * task (which is an invalid locking op but in the case
  2238. * of the scheduler it's an obvious special-case), so we
  2239. * do an early lockdep release here:
  2240. */
  2241. #ifndef __ARCH_WANT_UNLOCKED_CTXSW
  2242. spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
  2243. #endif
  2244. /* Here we just switch the register state and the stack. */
  2245. switch_to(prev, next, prev);
  2246. barrier();
  2247. /*
  2248. * this_rq must be evaluated again because prev may have moved
  2249. * CPUs since it called schedule(), thus the 'rq' on its stack
  2250. * frame will be invalid.
  2251. */
  2252. finish_task_switch(this_rq(), prev);
  2253. }
  2254. /*
  2255. * nr_running, nr_uninterruptible and nr_context_switches:
  2256. *
  2257. * externally visible scheduler statistics: current number of runnable
  2258. * threads, current number of uninterruptible-sleeping threads, total
  2259. * number of context switches performed since bootup.
  2260. */
  2261. unsigned long nr_running(void)
  2262. {
  2263. unsigned long i, sum = 0;
  2264. for_each_online_cpu(i)
  2265. sum += cpu_rq(i)->nr_running;
  2266. return sum;
  2267. }
  2268. unsigned long nr_uninterruptible(void)
  2269. {
  2270. unsigned long i, sum = 0;
  2271. for_each_possible_cpu(i)
  2272. sum += cpu_rq(i)->nr_uninterruptible;
  2273. /*
  2274. * Since we read the counters lockless, it might be slightly
  2275. * inaccurate. Do not allow it to go below zero though:
  2276. */
  2277. if (unlikely((long)sum < 0))
  2278. sum = 0;
  2279. return sum;
  2280. }
  2281. unsigned long long nr_context_switches(void)
  2282. {
  2283. int i;
  2284. unsigned long long sum = 0;
  2285. for_each_possible_cpu(i)
  2286. sum += cpu_rq(i)->nr_switches;
  2287. return sum;
  2288. }
  2289. unsigned long nr_iowait(void)
  2290. {
  2291. unsigned long i, sum = 0;
  2292. for_each_possible_cpu(i)
  2293. sum += atomic_read(&cpu_rq(i)->nr_iowait);
  2294. return sum;
  2295. }
  2296. unsigned long nr_active(void)
  2297. {
  2298. unsigned long i, running = 0, uninterruptible = 0;
  2299. for_each_online_cpu(i) {
  2300. running += cpu_rq(i)->nr_running;
  2301. uninterruptible += cpu_rq(i)->nr_uninterruptible;
  2302. }
  2303. if (unlikely((long)uninterruptible < 0))
  2304. uninterruptible = 0;
  2305. return running + uninterruptible;
  2306. }
  2307. /*
  2308. * Update rq->cpu_load[] statistics. This function is usually called every
  2309. * scheduler tick (TICK_NSEC).
  2310. */
  2311. static void update_cpu_load(struct rq *this_rq)
  2312. {
  2313. unsigned long this_load = this_rq->load.weight;
  2314. int i, scale;
  2315. this_rq->nr_load_updates++;
  2316. /* Update our load: */
  2317. for (i = 0, scale = 1; i < CPU_LOAD_IDX_MAX; i++, scale += scale) {
  2318. unsigned long old_load, new_load;
  2319. /* scale is effectively 1 << i now, and >> i divides by scale */
  2320. old_load = this_rq->cpu_load[i];
  2321. new_load = this_load;
  2322. /*
  2323. * Round up the averaging division if load is increasing. This
  2324. * prevents us from getting stuck on 9 if the load is 10, for
  2325. * example.
  2326. */
  2327. if (new_load > old_load)
  2328. new_load += scale-1;
  2329. this_rq->cpu_load[i] = (old_load*(scale-1) + new_load) >> i;
  2330. }
  2331. }
  2332. #ifdef CONFIG_SMP
  2333. /*
  2334. * double_rq_lock - safely lock two runqueues
  2335. *
  2336. * Note this does not disable interrupts like task_rq_lock,
  2337. * you need to do so manually before calling.
  2338. */
  2339. static void double_rq_lock(struct rq *rq1, struct rq *rq2)
  2340. __acquires(rq1->lock)
  2341. __acquires(rq2->lock)
  2342. {
  2343. BUG_ON(!irqs_disabled());
  2344. if (rq1 == rq2) {
  2345. spin_lock(&rq1->lock);
  2346. __acquire(rq2->lock); /* Fake it out ;) */
  2347. } else {
  2348. if (rq1 < rq2) {
  2349. spin_lock(&rq1->lock);
  2350. spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
  2351. } else {
  2352. spin_lock(&rq2->lock);
  2353. spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
  2354. }
  2355. }
  2356. update_rq_clock(rq1);
  2357. update_rq_clock(rq2);
  2358. }
  2359. /*
  2360. * double_rq_unlock - safely unlock two runqueues
  2361. *
  2362. * Note this does not restore interrupts like task_rq_unlock,
  2363. * you need to do so manually after calling.
  2364. */
  2365. static void double_rq_unlock(struct rq *rq1, struct rq *rq2)
  2366. __releases(rq1->lock)
  2367. __releases(rq2->lock)
  2368. {
  2369. spin_unlock(&rq1->lock);
  2370. if (rq1 != rq2)
  2371. spin_unlock(&rq2->lock);
  2372. else
  2373. __release(rq2->lock);
  2374. }
  2375. /*
  2376. * double_lock_balance - lock the busiest runqueue, this_rq is locked already.
  2377. */
  2378. static int double_lock_balance(struct rq *this_rq, struct rq *busiest)
  2379. __releases(this_rq->lock)
  2380. __acquires(busiest->lock)
  2381. __acquires(this_rq->lock)
  2382. {
  2383. int ret = 0;
  2384. if (unlikely(!irqs_disabled())) {
  2385. /* printk() doesn't work good under rq->lock */
  2386. spin_unlock(&this_rq->lock);
  2387. BUG_ON(1);
  2388. }
  2389. if (unlikely(!spin_trylock(&busiest->lock))) {
  2390. if (busiest < this_rq) {
  2391. spin_unlock(&this_rq->lock);
  2392. spin_lock(&busiest->lock);
  2393. spin_lock_nested(&this_rq->lock, SINGLE_DEPTH_NESTING);
  2394. ret = 1;
  2395. } else
  2396. spin_lock_nested(&busiest->lock, SINGLE_DEPTH_NESTING);
  2397. }
  2398. return ret;
  2399. }
  2400. static void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
  2401. __releases(busiest->lock)
  2402. {
  2403. spin_unlock(&busiest->lock);
  2404. lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
  2405. }
  2406. /*
  2407. * If dest_cpu is allowed for this process, migrate the task to it.
  2408. * This is accomplished by forcing the cpu_allowed mask to only
  2409. * allow dest_cpu, which will force the cpu onto dest_cpu. Then
  2410. * the cpu_allowed mask is restored.
  2411. */
  2412. static void sched_migrate_task(struct task_struct *p, int dest_cpu)
  2413. {
  2414. struct migration_req req;
  2415. unsigned long flags;
  2416. struct rq *rq;
  2417. rq = task_rq_lock(p, &flags);
  2418. if (!cpu_isset(dest_cpu, p->cpus_allowed)
  2419. || unlikely(!cpu_active(dest_cpu)))
  2420. goto out;
  2421. trace_sched_migrate_task(rq, p, dest_cpu);
  2422. /* force the process onto the specified CPU */
  2423. if (migrate_task(p, dest_cpu, &req)) {
  2424. /* Need to wait for migration thread (might exit: take ref). */
  2425. struct task_struct *mt = rq->migration_thread;
  2426. get_task_struct(mt);
  2427. task_rq_unlock(rq, &flags);
  2428. wake_up_process(mt);
  2429. put_task_struct(mt);
  2430. wait_for_completion(&req.done);
  2431. return;
  2432. }
  2433. out:
  2434. task_rq_unlock(rq, &flags);
  2435. }
  2436. /*
  2437. * sched_exec - execve() is a valuable balancing opportunity, because at
  2438. * this point the task has the smallest effective memory and cache footprint.
  2439. */
  2440. void sched_exec(void)
  2441. {
  2442. int new_cpu, this_cpu = get_cpu();
  2443. new_cpu = sched_balance_self(this_cpu, SD_BALANCE_EXEC);
  2444. put_cpu();
  2445. if (new_cpu != this_cpu)
  2446. sched_migrate_task(current, new_cpu);
  2447. }
  2448. /*
  2449. * pull_task - move a task from a remote runqueue to the local runqueue.
  2450. * Both runqueues must be locked.
  2451. */
  2452. static void pull_task(struct rq *src_rq, struct task_struct *p,
  2453. struct rq *this_rq, int this_cpu)
  2454. {
  2455. deactivate_task(src_rq, p, 0);
  2456. set_task_cpu(p, this_cpu);
  2457. activate_task(this_rq, p, 0);
  2458. /*
  2459. * Note that idle threads have a prio of MAX_PRIO, for this test
  2460. * to be always true for them.
  2461. */
  2462. check_preempt_curr(this_rq, p, 0);
  2463. }
  2464. /*
  2465. * can_migrate_task - may task p from runqueue rq be migrated to this_cpu?
  2466. */
  2467. static
  2468. int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
  2469. struct sched_domain *sd, enum cpu_idle_type idle,
  2470. int *all_pinned)
  2471. {
  2472. /*
  2473. * We do not migrate tasks that are:
  2474. * 1) running (obviously), or
  2475. * 2) cannot be migrated to this CPU due to cpus_allowed, or
  2476. * 3) are cache-hot on their current CPU.
  2477. */
  2478. if (!cpu_isset(this_cpu, p->cpus_allowed)) {
  2479. schedstat_inc(p, se.nr_failed_migrations_affine);
  2480. return 0;
  2481. }
  2482. *all_pinned = 0;
  2483. if (task_running(rq, p)) {
  2484. schedstat_inc(p, se.nr_failed_migrations_running);
  2485. return 0;
  2486. }
  2487. /*
  2488. * Aggressive migration if:
  2489. * 1) task is cache cold, or
  2490. * 2) too many balance attempts have failed.
  2491. */
  2492. if (!task_hot(p, rq->clock, sd) ||
  2493. sd->nr_balance_failed > sd->cache_nice_tries) {
  2494. #ifdef CONFIG_SCHEDSTATS
  2495. if (task_hot(p, rq->clock, sd)) {
  2496. schedstat_inc(sd, lb_hot_gained[idle]);
  2497. schedstat_inc(p, se.nr_forced_migrations);
  2498. }
  2499. #endif
  2500. return 1;
  2501. }
  2502. if (task_hot(p, rq->clock, sd)) {
  2503. schedstat_inc(p, se.nr_failed_migrations_hot);
  2504. return 0;
  2505. }
  2506. return 1;
  2507. }
  2508. static unsigned long
  2509. balance_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest,
  2510. unsigned long max_load_move, struct sched_domain *sd,
  2511. enum cpu_idle_type idle, int *all_pinned,
  2512. int *this_best_prio, struct rq_iterator *iterator)
  2513. {
  2514. int loops = 0, pulled = 0, pinned = 0;
  2515. struct task_struct *p;
  2516. long rem_load_move = max_load_move;
  2517. if (max_load_move == 0)
  2518. goto out;
  2519. pinned = 1;
  2520. /*
  2521. * Start the load-balancing iterator:
  2522. */
  2523. p = iterator->start(iterator->arg);
  2524. next:
  2525. if (!p || loops++ > sysctl_sched_nr_migrate)
  2526. goto out;
  2527. if ((p->se.load.weight >> 1) > rem_load_move ||
  2528. !can_migrate_task(p, busiest, this_cpu, sd, idle, &pinned)) {
  2529. p = iterator->next(iterator->arg);
  2530. goto next;
  2531. }
  2532. pull_task(busiest, p, this_rq, this_cpu);
  2533. pulled++;
  2534. rem_load_move -= p->se.load.weight;
  2535. /*
  2536. * We only want to steal up to the prescribed amount of weighted load.
  2537. */
  2538. if (rem_load_move > 0) {
  2539. if (p->prio < *this_best_prio)
  2540. *this_best_prio = p->prio;
  2541. p = iterator->next(iterator->arg);
  2542. goto next;
  2543. }
  2544. out:
  2545. /*
  2546. * Right now, this is one of only two places pull_task() is called,
  2547. * so we can safely collect pull_task() stats here rather than
  2548. * inside pull_task().
  2549. */
  2550. schedstat_add(sd, lb_gained[idle], pulled);
  2551. if (all_pinned)
  2552. *all_pinned = pinned;
  2553. return max_load_move - rem_load_move;
  2554. }
  2555. /*
  2556. * move_tasks tries to move up to max_load_move weighted load from busiest to
  2557. * this_rq, as part of a balancing operation within domain "sd".
  2558. * Returns 1 if successful and 0 otherwise.
  2559. *
  2560. * Called with both runqueues locked.
  2561. */
  2562. static int move_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest,
  2563. unsigned long max_load_move,
  2564. struct sched_domain *sd, enum cpu_idle_type idle,
  2565. int *all_pinned)
  2566. {
  2567. const struct sched_class *class = sched_class_highest;
  2568. unsigned long total_load_moved = 0;
  2569. int this_best_prio = this_rq->curr->prio;
  2570. do {
  2571. total_load_moved +=
  2572. class->load_balance(this_rq, this_cpu, busiest,
  2573. max_load_move - total_load_moved,
  2574. sd, idle, all_pinned, &this_best_prio);
  2575. class = class->next;
  2576. if (idle == CPU_NEWLY_IDLE && this_rq->nr_running)
  2577. break;
  2578. } while (class && max_load_move > total_load_moved);
  2579. return total_load_moved > 0;
  2580. }
  2581. static int
  2582. iter_move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
  2583. struct sched_domain *sd, enum cpu_idle_type idle,
  2584. struct rq_iterator *iterator)
  2585. {
  2586. struct task_struct *p = iterator->start(iterator->arg);
  2587. int pinned = 0;
  2588. while (p) {
  2589. if (can_migrate_task(p, busiest, this_cpu, sd, idle, &pinned)) {
  2590. pull_task(busiest, p, this_rq, this_cpu);
  2591. /*
  2592. * Right now, this is only the second place pull_task()
  2593. * is called, so we can safely collect pull_task()
  2594. * stats here rather than inside pull_task().
  2595. */
  2596. schedstat_inc(sd, lb_gained[idle]);
  2597. return 1;
  2598. }
  2599. p = iterator->next(iterator->arg);
  2600. }
  2601. return 0;
  2602. }
  2603. /*
  2604. * move_one_task tries to move exactly one task from busiest to this_rq, as
  2605. * part of active balancing operations within "domain".
  2606. * Returns 1 if successful and 0 otherwise.
  2607. *
  2608. * Called with both runqueues locked.
  2609. */
  2610. static int move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
  2611. struct sched_domain *sd, enum cpu_idle_type idle)
  2612. {
  2613. const struct sched_class *class;
  2614. for (class = sched_class_highest; class; class = class->next)
  2615. if (class->move_one_task(this_rq, this_cpu, busiest, sd, idle))
  2616. return 1;
  2617. return 0;
  2618. }
  2619. /*
  2620. * find_busiest_group finds and returns the busiest CPU group within the
  2621. * domain. It calculates and returns the amount of weighted load which
  2622. * should be moved to restore balance via the imbalance parameter.
  2623. */
  2624. static struct sched_group *
  2625. find_busiest_group(struct sched_domain *sd, int this_cpu,
  2626. unsigned long *imbalance, enum cpu_idle_type idle,
  2627. int *sd_idle, const cpumask_t *cpus, int *balance)
  2628. {
  2629. struct sched_group *busiest = NULL, *this = NULL, *group = sd->groups;
  2630. unsigned long max_load, avg_load, total_load, this_load, total_pwr;
  2631. unsigned long max_pull;
  2632. unsigned long busiest_load_per_task, busiest_nr_running;
  2633. unsigned long this_load_per_task, this_nr_running;
  2634. int load_idx, group_imb = 0;
  2635. #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
  2636. int power_savings_balance = 1;
  2637. unsigned long leader_nr_running = 0, min_load_per_task = 0;
  2638. unsigned long min_nr_running = ULONG_MAX;
  2639. struct sched_group *group_min = NULL, *group_leader = NULL;
  2640. #endif
  2641. max_load = this_load = total_load = total_pwr = 0;
  2642. busiest_load_per_task = busiest_nr_running = 0;
  2643. this_load_per_task = this_nr_running = 0;
  2644. if (idle == CPU_NOT_IDLE)
  2645. load_idx = sd->busy_idx;
  2646. else if (idle == CPU_NEWLY_IDLE)
  2647. load_idx = sd->newidle_idx;
  2648. else
  2649. load_idx = sd->idle_idx;
  2650. do {
  2651. unsigned long load, group_capacity, max_cpu_load, min_cpu_load;
  2652. int local_group;
  2653. int i;
  2654. int __group_imb = 0;
  2655. unsigned int balance_cpu = -1, first_idle_cpu = 0;
  2656. unsigned long sum_nr_running, sum_weighted_load;
  2657. unsigned long sum_avg_load_per_task;
  2658. unsigned long avg_load_per_task;
  2659. local_group = cpu_isset(this_cpu, group->cpumask);
  2660. if (local_group)
  2661. balance_cpu = first_cpu(group->cpumask);
  2662. /* Tally up the load of all CPUs in the group */
  2663. sum_weighted_load = sum_nr_running = avg_load = 0;
  2664. sum_avg_load_per_task = avg_load_per_task = 0;
  2665. max_cpu_load = 0;
  2666. min_cpu_load = ~0UL;
  2667. for_each_cpu_mask_nr(i, group->cpumask) {
  2668. struct rq *rq;
  2669. if (!cpu_isset(i, *cpus))
  2670. continue;
  2671. rq = cpu_rq(i);
  2672. if (*sd_idle && rq->nr_running)
  2673. *sd_idle = 0;
  2674. /* Bias balancing toward cpus of our domain */
  2675. if (local_group) {
  2676. if (idle_cpu(i) && !first_idle_cpu) {
  2677. first_idle_cpu = 1;
  2678. balance_cpu = i;
  2679. }
  2680. load = target_load(i, load_idx);
  2681. } else {
  2682. load = source_load(i, load_idx);
  2683. if (load > max_cpu_load)
  2684. max_cpu_load = load;
  2685. if (min_cpu_load > load)
  2686. min_cpu_load = load;
  2687. }
  2688. avg_load += load;
  2689. sum_nr_running += rq->nr_running;
  2690. sum_weighted_load += weighted_cpuload(i);
  2691. sum_avg_load_per_task += cpu_avg_load_per_task(i);
  2692. }
  2693. /*
  2694. * First idle cpu or the first cpu(busiest) in this sched group
  2695. * is eligible for doing load balancing at this and above
  2696. * domains. In the newly idle case, we will allow all the cpu's
  2697. * to do the newly idle load balance.
  2698. */
  2699. if (idle != CPU_NEWLY_IDLE && local_group &&
  2700. balance_cpu != this_cpu && balance) {
  2701. *balance = 0;
  2702. goto ret;
  2703. }
  2704. total_load += avg_load;
  2705. total_pwr += group->__cpu_power;
  2706. /* Adjust by relative CPU power of the group */
  2707. avg_load = sg_div_cpu_power(group,
  2708. avg_load * SCHED_LOAD_SCALE);
  2709. /*
  2710. * Consider the group unbalanced when the imbalance is larger
  2711. * than the average weight of two tasks.
  2712. *
  2713. * APZ: with cgroup the avg task weight can vary wildly and
  2714. * might not be a suitable number - should we keep a
  2715. * normalized nr_running number somewhere that negates
  2716. * the hierarchy?
  2717. */
  2718. avg_load_per_task = sg_div_cpu_power(group,
  2719. sum_avg_load_per_task * SCHED_LOAD_SCALE);
  2720. if ((max_cpu_load - min_cpu_load) > 2*avg_load_per_task)
  2721. __group_imb = 1;
  2722. group_capacity = group->__cpu_power / SCHED_LOAD_SCALE;
  2723. if (local_group) {
  2724. this_load = avg_load;
  2725. this = group;
  2726. this_nr_running = sum_nr_running;
  2727. this_load_per_task = sum_weighted_load;
  2728. } else if (avg_load > max_load &&
  2729. (sum_nr_running > group_capacity || __group_imb)) {
  2730. max_load = avg_load;
  2731. busiest = group;
  2732. busiest_nr_running = sum_nr_running;
  2733. busiest_load_per_task = sum_weighted_load;
  2734. group_imb = __group_imb;
  2735. }
  2736. #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
  2737. /*
  2738. * Busy processors will not participate in power savings
  2739. * balance.
  2740. */
  2741. if (idle == CPU_NOT_IDLE ||
  2742. !(sd->flags & SD_POWERSAVINGS_BALANCE))
  2743. goto group_next;
  2744. /*
  2745. * If the local group is idle or completely loaded
  2746. * no need to do power savings balance at this domain
  2747. */
  2748. if (local_group && (this_nr_running >= group_capacity ||
  2749. !this_nr_running))
  2750. power_savings_balance = 0;
  2751. /*
  2752. * If a group is already running at full capacity or idle,
  2753. * don't include that group in power savings calculations
  2754. */
  2755. if (!power_savings_balance || sum_nr_running >= group_capacity
  2756. || !sum_nr_running)
  2757. goto group_next;
  2758. /*
  2759. * Calculate the group which has the least non-idle load.
  2760. * This is the group from where we need to pick up the load
  2761. * for saving power
  2762. */
  2763. if ((sum_nr_running < min_nr_running) ||
  2764. (sum_nr_running == min_nr_running &&
  2765. first_cpu(group->cpumask) <
  2766. first_cpu(group_min->cpumask))) {
  2767. group_min = group;
  2768. min_nr_running = sum_nr_running;
  2769. min_load_per_task = sum_weighted_load /
  2770. sum_nr_running;
  2771. }
  2772. /*
  2773. * Calculate the group which is almost near its
  2774. * capacity but still has some space to pick up some load
  2775. * from other group and save more power
  2776. */
  2777. if (sum_nr_running <= group_capacity - 1) {
  2778. if (sum_nr_running > leader_nr_running ||
  2779. (sum_nr_running == leader_nr_running &&
  2780. first_cpu(group->cpumask) >
  2781. first_cpu(group_leader->cpumask))) {
  2782. group_leader = group;
  2783. leader_nr_running = sum_nr_running;
  2784. }
  2785. }
  2786. group_next:
  2787. #endif
  2788. group = group->next;
  2789. } while (group != sd->groups);
  2790. if (!busiest || this_load >= max_load || busiest_nr_running == 0)
  2791. goto out_balanced;
  2792. avg_load = (SCHED_LOAD_SCALE * total_load) / total_pwr;
  2793. if (this_load >= avg_load ||
  2794. 100*max_load <= sd->imbalance_pct*this_load)
  2795. goto out_balanced;
  2796. busiest_load_per_task /= busiest_nr_running;
  2797. if (group_imb)
  2798. busiest_load_per_task = min(busiest_load_per_task, avg_load);
  2799. /*
  2800. * We're trying to get all the cpus to the average_load, so we don't
  2801. * want to push ourselves above the average load, nor do we wish to
  2802. * reduce the max loaded cpu below the average load, as either of these
  2803. * actions would just result in more rebalancing later, and ping-pong
  2804. * tasks around. Thus we look for the minimum possible imbalance.
  2805. * Negative imbalances (*we* are more loaded than anyone else) will
  2806. * be counted as no imbalance for these purposes -- we can't fix that
  2807. * by pulling tasks to us. Be careful of negative numbers as they'll
  2808. * appear as very large values with unsigned longs.
  2809. */
  2810. if (max_load <= busiest_load_per_task)
  2811. goto out_balanced;
  2812. /*
  2813. * In the presence of smp nice balancing, certain scenarios can have
  2814. * max load less than avg load(as we skip the groups at or below
  2815. * its cpu_power, while calculating max_load..)
  2816. */
  2817. if (max_load < avg_load) {
  2818. *imbalance = 0;
  2819. goto small_imbalance;
  2820. }
  2821. /* Don't want to pull so many tasks that a group would go idle */
  2822. max_pull = min(max_load - avg_load, max_load - busiest_load_per_task);
  2823. /* How much load to actually move to equalise the imbalance */
  2824. *imbalance = min(max_pull * busiest->__cpu_power,
  2825. (avg_load - this_load) * this->__cpu_power)
  2826. / SCHED_LOAD_SCALE;
  2827. /*
  2828. * if *imbalance is less than the average load per runnable task
  2829. * there is no gaurantee that any tasks will be moved so we'll have
  2830. * a think about bumping its value to force at least one task to be
  2831. * moved
  2832. */
  2833. if (*imbalance < busiest_load_per_task) {
  2834. unsigned long tmp, pwr_now, pwr_move;
  2835. unsigned int imbn;
  2836. small_imbalance:
  2837. pwr_move = pwr_now = 0;
  2838. imbn = 2;
  2839. if (this_nr_running) {
  2840. this_load_per_task /= this_nr_running;
  2841. if (busiest_load_per_task > this_load_per_task)
  2842. imbn = 1;
  2843. } else
  2844. this_load_per_task = cpu_avg_load_per_task(this_cpu);
  2845. if (max_load - this_load + busiest_load_per_task >=
  2846. busiest_load_per_task * imbn) {
  2847. *imbalance = busiest_load_per_task;
  2848. return busiest;
  2849. }
  2850. /*
  2851. * OK, we don't have enough imbalance to justify moving tasks,
  2852. * however we may be able to increase total CPU power used by
  2853. * moving them.
  2854. */
  2855. pwr_now += busiest->__cpu_power *
  2856. min(busiest_load_per_task, max_load);
  2857. pwr_now += this->__cpu_power *
  2858. min(this_load_per_task, this_load);
  2859. pwr_now /= SCHED_LOAD_SCALE;
  2860. /* Amount of load we'd subtract */
  2861. tmp = sg_div_cpu_power(busiest,
  2862. busiest_load_per_task * SCHED_LOAD_SCALE);
  2863. if (max_load > tmp)
  2864. pwr_move += busiest->__cpu_power *
  2865. min(busiest_load_per_task, max_load - tmp);
  2866. /* Amount of load we'd add */
  2867. if (max_load * busiest->__cpu_power <
  2868. busiest_load_per_task * SCHED_LOAD_SCALE)
  2869. tmp = sg_div_cpu_power(this,
  2870. max_load * busiest->__cpu_power);
  2871. else
  2872. tmp = sg_div_cpu_power(this,
  2873. busiest_load_per_task * SCHED_LOAD_SCALE);
  2874. pwr_move += this->__cpu_power *
  2875. min(this_load_per_task, this_load + tmp);
  2876. pwr_move /= SCHED_LOAD_SCALE;
  2877. /* Move if we gain throughput */
  2878. if (pwr_move > pwr_now)
  2879. *imbalance = busiest_load_per_task;
  2880. }
  2881. return busiest;
  2882. out_balanced:
  2883. #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
  2884. if (idle == CPU_NOT_IDLE || !(sd->flags & SD_POWERSAVINGS_BALANCE))
  2885. goto ret;
  2886. if (this == group_leader && group_leader != group_min) {
  2887. *imbalance = min_load_per_task;
  2888. return group_min;
  2889. }
  2890. #endif
  2891. ret:
  2892. *imbalance = 0;
  2893. return NULL;
  2894. }
  2895. /*
  2896. * find_busiest_queue - find the busiest runqueue among the cpus in group.
  2897. */
  2898. static struct rq *
  2899. find_busiest_queue(struct sched_group *group, enum cpu_idle_type idle,
  2900. unsigned long imbalance, const cpumask_t *cpus)
  2901. {
  2902. struct rq *busiest = NULL, *rq;
  2903. unsigned long max_load = 0;
  2904. int i;
  2905. for_each_cpu_mask_nr(i, group->cpumask) {
  2906. unsigned long wl;
  2907. if (!cpu_isset(i, *cpus))
  2908. continue;
  2909. rq = cpu_rq(i);
  2910. wl = weighted_cpuload(i);
  2911. if (rq->nr_running == 1 && wl > imbalance)
  2912. continue;
  2913. if (wl > max_load) {
  2914. max_load = wl;
  2915. busiest = rq;
  2916. }
  2917. }
  2918. return busiest;
  2919. }
  2920. /*
  2921. * Max backoff if we encounter pinned tasks. Pretty arbitrary value, but
  2922. * so long as it is large enough.
  2923. */
  2924. #define MAX_PINNED_INTERVAL 512
  2925. /*
  2926. * Check this_cpu to ensure it is balanced within domain. Attempt to move
  2927. * tasks if there is an imbalance.
  2928. */
  2929. static int load_balance(int this_cpu, struct rq *this_rq,
  2930. struct sched_domain *sd, enum cpu_idle_type idle,
  2931. int *balance, cpumask_t *cpus)
  2932. {
  2933. int ld_moved, all_pinned = 0, active_balance = 0, sd_idle = 0;
  2934. struct sched_group *group;
  2935. unsigned long imbalance;
  2936. struct rq *busiest;
  2937. unsigned long flags;
  2938. cpus_setall(*cpus);
  2939. /*
  2940. * When power savings policy is enabled for the parent domain, idle
  2941. * sibling can pick up load irrespective of busy siblings. In this case,
  2942. * let the state of idle sibling percolate up as CPU_IDLE, instead of
  2943. * portraying it as CPU_NOT_IDLE.
  2944. */
  2945. if (idle != CPU_NOT_IDLE && sd->flags & SD_SHARE_CPUPOWER &&
  2946. !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
  2947. sd_idle = 1;
  2948. schedstat_inc(sd, lb_count[idle]);
  2949. redo:
  2950. update_shares(sd);
  2951. group = find_busiest_group(sd, this_cpu, &imbalance, idle, &sd_idle,
  2952. cpus, balance);
  2953. if (*balance == 0)
  2954. goto out_balanced;
  2955. if (!group) {
  2956. schedstat_inc(sd, lb_nobusyg[idle]);
  2957. goto out_balanced;
  2958. }
  2959. busiest = find_busiest_queue(group, idle, imbalance, cpus);
  2960. if (!busiest) {
  2961. schedstat_inc(sd, lb_nobusyq[idle]);
  2962. goto out_balanced;
  2963. }
  2964. BUG_ON(busiest == this_rq);
  2965. schedstat_add(sd, lb_imbalance[idle], imbalance);
  2966. ld_moved = 0;
  2967. if (busiest->nr_running > 1) {
  2968. /*
  2969. * Attempt to move tasks. If find_busiest_group has found
  2970. * an imbalance but busiest->nr_running <= 1, the group is
  2971. * still unbalanced. ld_moved simply stays zero, so it is
  2972. * correctly treated as an imbalance.
  2973. */
  2974. local_irq_save(flags);
  2975. double_rq_lock(this_rq, busiest);
  2976. ld_moved = move_tasks(this_rq, this_cpu, busiest,
  2977. imbalance, sd, idle, &all_pinned);
  2978. double_rq_unlock(this_rq, busiest);
  2979. local_irq_restore(flags);
  2980. /*
  2981. * some other cpu did the load balance for us.
  2982. */
  2983. if (ld_moved && this_cpu != smp_processor_id())
  2984. resched_cpu(this_cpu);
  2985. /* All tasks on this runqueue were pinned by CPU affinity */
  2986. if (unlikely(all_pinned)) {
  2987. cpu_clear(cpu_of(busiest), *cpus);
  2988. if (!cpus_empty(*cpus))
  2989. goto redo;
  2990. goto out_balanced;
  2991. }
  2992. }
  2993. if (!ld_moved) {
  2994. schedstat_inc(sd, lb_failed[idle]);
  2995. sd->nr_balance_failed++;
  2996. if (unlikely(sd->nr_balance_failed > sd->cache_nice_tries+2)) {
  2997. spin_lock_irqsave(&busiest->lock, flags);
  2998. /* don't kick the migration_thread, if the curr
  2999. * task on busiest cpu can't be moved to this_cpu
  3000. */
  3001. if (!cpu_isset(this_cpu, busiest->curr->cpus_allowed)) {
  3002. spin_unlock_irqrestore(&busiest->lock, flags);
  3003. all_pinned = 1;
  3004. goto out_one_pinned;
  3005. }
  3006. if (!busiest->active_balance) {
  3007. busiest->active_balance = 1;
  3008. busiest->push_cpu = this_cpu;
  3009. active_balance = 1;
  3010. }
  3011. spin_unlock_irqrestore(&busiest->lock, flags);
  3012. if (active_balance)
  3013. wake_up_process(busiest->migration_thread);
  3014. /*
  3015. * We've kicked active balancing, reset the failure
  3016. * counter.
  3017. */
  3018. sd->nr_balance_failed = sd->cache_nice_tries+1;
  3019. }
  3020. } else
  3021. sd->nr_balance_failed = 0;
  3022. if (likely(!active_balance)) {
  3023. /* We were unbalanced, so reset the balancing interval */
  3024. sd->balance_interval = sd->min_interval;
  3025. } else {
  3026. /*
  3027. * If we've begun active balancing, start to back off. This
  3028. * case may not be covered by the all_pinned logic if there
  3029. * is only 1 task on the busy runqueue (because we don't call
  3030. * move_tasks).
  3031. */
  3032. if (sd->balance_interval < sd->max_interval)
  3033. sd->balance_interval *= 2;
  3034. }
  3035. if (!ld_moved && !sd_idle && sd->flags & SD_SHARE_CPUPOWER &&
  3036. !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
  3037. ld_moved = -1;
  3038. goto out;
  3039. out_balanced:
  3040. schedstat_inc(sd, lb_balanced[idle]);
  3041. sd->nr_balance_failed = 0;
  3042. out_one_pinned:
  3043. /* tune up the balancing interval */
  3044. if ((all_pinned && sd->balance_interval < MAX_PINNED_INTERVAL) ||
  3045. (sd->balance_interval < sd->max_interval))
  3046. sd->balance_interval *= 2;
  3047. if (!sd_idle && sd->flags & SD_SHARE_CPUPOWER &&
  3048. !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
  3049. ld_moved = -1;
  3050. else
  3051. ld_moved = 0;
  3052. out:
  3053. if (ld_moved)
  3054. update_shares(sd);
  3055. return ld_moved;
  3056. }
  3057. /*
  3058. * Check this_cpu to ensure it is balanced within domain. Attempt to move
  3059. * tasks if there is an imbalance.
  3060. *
  3061. * Called from schedule when this_rq is about to become idle (CPU_NEWLY_IDLE).
  3062. * this_rq is locked.
  3063. */
  3064. static int
  3065. load_balance_newidle(int this_cpu, struct rq *this_rq, struct sched_domain *sd,
  3066. cpumask_t *cpus)
  3067. {
  3068. struct sched_group *group;
  3069. struct rq *busiest = NULL;
  3070. unsigned long imbalance;
  3071. int ld_moved = 0;
  3072. int sd_idle = 0;
  3073. int all_pinned = 0;
  3074. cpus_setall(*cpus);
  3075. /*
  3076. * When power savings policy is enabled for the parent domain, idle
  3077. * sibling can pick up load irrespective of busy siblings. In this case,
  3078. * let the state of idle sibling percolate up as IDLE, instead of
  3079. * portraying it as CPU_NOT_IDLE.
  3080. */
  3081. if (sd->flags & SD_SHARE_CPUPOWER &&
  3082. !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
  3083. sd_idle = 1;
  3084. schedstat_inc(sd, lb_count[CPU_NEWLY_IDLE]);
  3085. redo:
  3086. update_shares_locked(this_rq, sd);
  3087. group = find_busiest_group(sd, this_cpu, &imbalance, CPU_NEWLY_IDLE,
  3088. &sd_idle, cpus, NULL);
  3089. if (!group) {
  3090. schedstat_inc(sd, lb_nobusyg[CPU_NEWLY_IDLE]);
  3091. goto out_balanced;
  3092. }
  3093. busiest = find_busiest_queue(group, CPU_NEWLY_IDLE, imbalance, cpus);
  3094. if (!busiest) {
  3095. schedstat_inc(sd, lb_nobusyq[CPU_NEWLY_IDLE]);
  3096. goto out_balanced;
  3097. }
  3098. BUG_ON(busiest == this_rq);
  3099. schedstat_add(sd, lb_imbalance[CPU_NEWLY_IDLE], imbalance);
  3100. ld_moved = 0;
  3101. if (busiest->nr_running > 1) {
  3102. /* Attempt to move tasks */
  3103. double_lock_balance(this_rq, busiest);
  3104. /* this_rq->clock is already updated */
  3105. update_rq_clock(busiest);
  3106. ld_moved = move_tasks(this_rq, this_cpu, busiest,
  3107. imbalance, sd, CPU_NEWLY_IDLE,
  3108. &all_pinned);
  3109. double_unlock_balance(this_rq, busiest);
  3110. if (unlikely(all_pinned)) {
  3111. cpu_clear(cpu_of(busiest), *cpus);
  3112. if (!cpus_empty(*cpus))
  3113. goto redo;
  3114. }
  3115. }
  3116. if (!ld_moved) {
  3117. schedstat_inc(sd, lb_failed[CPU_NEWLY_IDLE]);
  3118. if (!sd_idle && sd->flags & SD_SHARE_CPUPOWER &&
  3119. !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
  3120. return -1;
  3121. } else
  3122. sd->nr_balance_failed = 0;
  3123. update_shares_locked(this_rq, sd);
  3124. return ld_moved;
  3125. out_balanced:
  3126. schedstat_inc(sd, lb_balanced[CPU_NEWLY_IDLE]);
  3127. if (!sd_idle && sd->flags & SD_SHARE_CPUPOWER &&
  3128. !test_sd_parent(sd, SD_POWERSAVINGS_BALANCE))
  3129. return -1;
  3130. sd->nr_balance_failed = 0;
  3131. return 0;
  3132. }
  3133. /*
  3134. * idle_balance is called by schedule() if this_cpu is about to become
  3135. * idle. Attempts to pull tasks from other CPUs.
  3136. */
  3137. static void idle_balance(int this_cpu, struct rq *this_rq)
  3138. {
  3139. struct sched_domain *sd;
  3140. int pulled_task = -1;
  3141. unsigned long next_balance = jiffies + HZ;
  3142. cpumask_t tmpmask;
  3143. for_each_domain(this_cpu, sd) {
  3144. unsigned long interval;
  3145. if (!(sd->flags & SD_LOAD_BALANCE))
  3146. continue;
  3147. if (sd->flags & SD_BALANCE_NEWIDLE)
  3148. /* If we've pulled tasks over stop searching: */
  3149. pulled_task = load_balance_newidle(this_cpu, this_rq,
  3150. sd, &tmpmask);
  3151. interval = msecs_to_jiffies(sd->balance_interval);
  3152. if (time_after(next_balance, sd->last_balance + interval))
  3153. next_balance = sd->last_balance + interval;
  3154. if (pulled_task)
  3155. break;
  3156. }
  3157. if (pulled_task || time_after(jiffies, this_rq->next_balance)) {
  3158. /*
  3159. * We are going idle. next_balance may be set based on
  3160. * a busy processor. So reset next_balance.
  3161. */
  3162. this_rq->next_balance = next_balance;
  3163. }
  3164. }
  3165. /*
  3166. * active_load_balance is run by migration threads. It pushes running tasks
  3167. * off the busiest CPU onto idle CPUs. It requires at least 1 task to be
  3168. * running on each physical CPU where possible, and avoids physical /
  3169. * logical imbalances.
  3170. *
  3171. * Called with busiest_rq locked.
  3172. */
  3173. static void active_load_balance(struct rq *busiest_rq, int busiest_cpu)
  3174. {
  3175. int target_cpu = busiest_rq->push_cpu;
  3176. struct sched_domain *sd;
  3177. struct rq *target_rq;
  3178. /* Is there any task to move? */
  3179. if (busiest_rq->nr_running <= 1)
  3180. return;
  3181. target_rq = cpu_rq(target_cpu);
  3182. /*
  3183. * This condition is "impossible", if it occurs
  3184. * we need to fix it. Originally reported by
  3185. * Bjorn Helgaas on a 128-cpu setup.
  3186. */
  3187. BUG_ON(busiest_rq == target_rq);
  3188. /* move a task from busiest_rq to target_rq */
  3189. double_lock_balance(busiest_rq, target_rq);
  3190. update_rq_clock(busiest_rq);
  3191. update_rq_clock(target_rq);
  3192. /* Search for an sd spanning us and the target CPU. */
  3193. for_each_domain(target_cpu, sd) {
  3194. if ((sd->flags & SD_LOAD_BALANCE) &&
  3195. cpu_isset(busiest_cpu, sd->span))
  3196. break;
  3197. }
  3198. if (likely(sd)) {
  3199. schedstat_inc(sd, alb_count);
  3200. if (move_one_task(target_rq, target_cpu, busiest_rq,
  3201. sd, CPU_IDLE))
  3202. schedstat_inc(sd, alb_pushed);
  3203. else
  3204. schedstat_inc(sd, alb_failed);
  3205. }
  3206. double_unlock_balance(busiest_rq, target_rq);
  3207. }
  3208. #ifdef CONFIG_NO_HZ
  3209. static struct {
  3210. atomic_t load_balancer;
  3211. cpumask_t cpu_mask;
  3212. } nohz ____cacheline_aligned = {
  3213. .load_balancer = ATOMIC_INIT(-1),
  3214. .cpu_mask = CPU_MASK_NONE,
  3215. };
  3216. /*
  3217. * This routine will try to nominate the ilb (idle load balancing)
  3218. * owner among the cpus whose ticks are stopped. ilb owner will do the idle
  3219. * load balancing on behalf of all those cpus. If all the cpus in the system
  3220. * go into this tickless mode, then there will be no ilb owner (as there is
  3221. * no need for one) and all the cpus will sleep till the next wakeup event
  3222. * arrives...
  3223. *
  3224. * For the ilb owner, tick is not stopped. And this tick will be used
  3225. * for idle load balancing. ilb owner will still be part of
  3226. * nohz.cpu_mask..
  3227. *
  3228. * While stopping the tick, this cpu will become the ilb owner if there
  3229. * is no other owner. And will be the owner till that cpu becomes busy
  3230. * or if all cpus in the system stop their ticks at which point
  3231. * there is no need for ilb owner.
  3232. *
  3233. * When the ilb owner becomes busy, it nominates another owner, during the
  3234. * next busy scheduler_tick()
  3235. */
  3236. int select_nohz_load_balancer(int stop_tick)
  3237. {
  3238. int cpu = smp_processor_id();
  3239. if (stop_tick) {
  3240. cpu_set(cpu, nohz.cpu_mask);
  3241. cpu_rq(cpu)->in_nohz_recently = 1;
  3242. /*
  3243. * If we are going offline and still the leader, give up!
  3244. */
  3245. if (!cpu_active(cpu) &&
  3246. atomic_read(&nohz.load_balancer) == cpu) {
  3247. if (atomic_cmpxchg(&nohz.load_balancer, cpu, -1) != cpu)
  3248. BUG();
  3249. return 0;
  3250. }
  3251. /* time for ilb owner also to sleep */
  3252. if (cpus_weight(nohz.cpu_mask) == num_online_cpus()) {
  3253. if (atomic_read(&nohz.load_balancer) == cpu)
  3254. atomic_set(&nohz.load_balancer, -1);
  3255. return 0;
  3256. }
  3257. if (atomic_read(&nohz.load_balancer) == -1) {
  3258. /* make me the ilb owner */
  3259. if (atomic_cmpxchg(&nohz.load_balancer, -1, cpu) == -1)
  3260. return 1;
  3261. } else if (atomic_read(&nohz.load_balancer) == cpu)
  3262. return 1;
  3263. } else {
  3264. if (!cpu_isset(cpu, nohz.cpu_mask))
  3265. return 0;
  3266. cpu_clear(cpu, nohz.cpu_mask);
  3267. if (atomic_read(&nohz.load_balancer) == cpu)
  3268. if (atomic_cmpxchg(&nohz.load_balancer, cpu, -1) != cpu)
  3269. BUG();
  3270. }
  3271. return 0;
  3272. }
  3273. #endif
  3274. static DEFINE_SPINLOCK(balancing);
  3275. /*
  3276. * It checks each scheduling domain to see if it is due to be balanced,
  3277. * and initiates a balancing operation if so.
  3278. *
  3279. * Balancing parameters are set up in arch_init_sched_domains.
  3280. */
  3281. static void rebalance_domains(int cpu, enum cpu_idle_type idle)
  3282. {
  3283. int balance = 1;
  3284. struct rq *rq = cpu_rq(cpu);
  3285. unsigned long interval;
  3286. struct sched_domain *sd;
  3287. /* Earliest time when we have to do rebalance again */
  3288. unsigned long next_balance = jiffies + 60*HZ;
  3289. int update_next_balance = 0;
  3290. int need_serialize;
  3291. cpumask_t tmp;
  3292. for_each_domain(cpu, sd) {
  3293. if (!(sd->flags & SD_LOAD_BALANCE))
  3294. continue;
  3295. interval = sd->balance_interval;
  3296. if (idle != CPU_IDLE)
  3297. interval *= sd->busy_factor;
  3298. /* scale ms to jiffies */
  3299. interval = msecs_to_jiffies(interval);
  3300. if (unlikely(!interval))
  3301. interval = 1;
  3302. if (interval > HZ*NR_CPUS/10)
  3303. interval = HZ*NR_CPUS/10;
  3304. need_serialize = sd->flags & SD_SERIALIZE;
  3305. if (need_serialize) {
  3306. if (!spin_trylock(&balancing))
  3307. goto out;
  3308. }
  3309. if (time_after_eq(jiffies, sd->last_balance + interval)) {
  3310. if (load_balance(cpu, rq, sd, idle, &balance, &tmp)) {
  3311. /*
  3312. * We've pulled tasks over so either we're no
  3313. * longer idle, or one of our SMT siblings is
  3314. * not idle.
  3315. */
  3316. idle = CPU_NOT_IDLE;
  3317. }
  3318. sd->last_balance = jiffies;
  3319. }
  3320. if (need_serialize)
  3321. spin_unlock(&balancing);
  3322. out:
  3323. if (time_after(next_balance, sd->last_balance + interval)) {
  3324. next_balance = sd->last_balance + interval;
  3325. update_next_balance = 1;
  3326. }
  3327. /*
  3328. * Stop the load balance at this level. There is another
  3329. * CPU in our sched group which is doing load balancing more
  3330. * actively.
  3331. */
  3332. if (!balance)
  3333. break;
  3334. }
  3335. /*
  3336. * next_balance will be updated only when there is a need.
  3337. * When the cpu is attached to null domain for ex, it will not be
  3338. * updated.
  3339. */
  3340. if (likely(update_next_balance))
  3341. rq->next_balance = next_balance;
  3342. }
  3343. /*
  3344. * run_rebalance_domains is triggered when needed from the scheduler tick.
  3345. * In CONFIG_NO_HZ case, the idle load balance owner will do the
  3346. * rebalancing for all the cpus for whom scheduler ticks are stopped.
  3347. */
  3348. static void run_rebalance_domains(struct softirq_action *h)
  3349. {
  3350. int this_cpu = smp_processor_id();
  3351. struct rq *this_rq = cpu_rq(this_cpu);
  3352. enum cpu_idle_type idle = this_rq->idle_at_tick ?
  3353. CPU_IDLE : CPU_NOT_IDLE;
  3354. rebalance_domains(this_cpu, idle);
  3355. #ifdef CONFIG_NO_HZ
  3356. /*
  3357. * If this cpu is the owner for idle load balancing, then do the
  3358. * balancing on behalf of the other idle cpus whose ticks are
  3359. * stopped.
  3360. */
  3361. if (this_rq->idle_at_tick &&
  3362. atomic_read(&nohz.load_balancer) == this_cpu) {
  3363. cpumask_t cpus = nohz.cpu_mask;
  3364. struct rq *rq;
  3365. int balance_cpu;
  3366. cpu_clear(this_cpu, cpus);
  3367. for_each_cpu_mask_nr(balance_cpu, cpus) {
  3368. /*
  3369. * If this cpu gets work to do, stop the load balancing
  3370. * work being done for other cpus. Next load
  3371. * balancing owner will pick it up.
  3372. */
  3373. if (need_resched())
  3374. break;
  3375. rebalance_domains(balance_cpu, CPU_IDLE);
  3376. rq = cpu_rq(balance_cpu);
  3377. if (time_after(this_rq->next_balance, rq->next_balance))
  3378. this_rq->next_balance = rq->next_balance;
  3379. }
  3380. }
  3381. #endif
  3382. }
  3383. /*
  3384. * Trigger the SCHED_SOFTIRQ if it is time to do periodic load balancing.
  3385. *
  3386. * In case of CONFIG_NO_HZ, this is the place where we nominate a new
  3387. * idle load balancing owner or decide to stop the periodic load balancing,
  3388. * if the whole system is idle.
  3389. */
  3390. static inline void trigger_load_balance(struct rq *rq, int cpu)
  3391. {
  3392. #ifdef CONFIG_NO_HZ
  3393. /*
  3394. * If we were in the nohz mode recently and busy at the current
  3395. * scheduler tick, then check if we need to nominate new idle
  3396. * load balancer.
  3397. */
  3398. if (rq->in_nohz_recently && !rq->idle_at_tick) {
  3399. rq->in_nohz_recently = 0;
  3400. if (atomic_read(&nohz.load_balancer) == cpu) {
  3401. cpu_clear(cpu, nohz.cpu_mask);
  3402. atomic_set(&nohz.load_balancer, -1);
  3403. }
  3404. if (atomic_read(&nohz.load_balancer) == -1) {
  3405. /*
  3406. * simple selection for now: Nominate the
  3407. * first cpu in the nohz list to be the next
  3408. * ilb owner.
  3409. *
  3410. * TBD: Traverse the sched domains and nominate
  3411. * the nearest cpu in the nohz.cpu_mask.
  3412. */
  3413. int ilb = first_cpu(nohz.cpu_mask);
  3414. if (ilb < nr_cpu_ids)
  3415. resched_cpu(ilb);
  3416. }
  3417. }
  3418. /*
  3419. * If this cpu is idle and doing idle load balancing for all the
  3420. * cpus with ticks stopped, is it time for that to stop?
  3421. */
  3422. if (rq->idle_at_tick && atomic_read(&nohz.load_balancer) == cpu &&
  3423. cpus_weight(nohz.cpu_mask) == num_online_cpus()) {
  3424. resched_cpu(cpu);
  3425. return;
  3426. }
  3427. /*
  3428. * If this cpu is idle and the idle load balancing is done by
  3429. * someone else, then no need raise the SCHED_SOFTIRQ
  3430. */
  3431. if (rq->idle_at_tick && atomic_read(&nohz.load_balancer) != cpu &&
  3432. cpu_isset(cpu, nohz.cpu_mask))
  3433. return;
  3434. #endif
  3435. if (time_after_eq(jiffies, rq->next_balance))
  3436. raise_softirq(SCHED_SOFTIRQ);
  3437. }
  3438. #else /* CONFIG_SMP */
  3439. /*
  3440. * on UP we do not need to balance between CPUs:
  3441. */
  3442. static inline void idle_balance(int cpu, struct rq *rq)
  3443. {
  3444. }
  3445. #endif
  3446. DEFINE_PER_CPU(struct kernel_stat, kstat);
  3447. EXPORT_PER_CPU_SYMBOL(kstat);
  3448. /*
  3449. * Return any ns on the sched_clock that have not yet been banked in
  3450. * @p in case that task is currently running.
  3451. */
  3452. unsigned long long task_delta_exec(struct task_struct *p)
  3453. {
  3454. unsigned long flags;
  3455. struct rq *rq;
  3456. u64 ns = 0;
  3457. rq = task_rq_lock(p, &flags);
  3458. if (task_current(rq, p)) {
  3459. u64 delta_exec;
  3460. update_rq_clock(rq);
  3461. delta_exec = rq->clock - p->se.exec_start;
  3462. if ((s64)delta_exec > 0)
  3463. ns = delta_exec;
  3464. }
  3465. task_rq_unlock(rq, &flags);
  3466. return ns;
  3467. }
  3468. /*
  3469. * Account user cpu time to a process.
  3470. * @p: the process that the cpu time gets accounted to
  3471. * @cputime: the cpu time spent in user space since the last update
  3472. */
  3473. void account_user_time(struct task_struct *p, cputime_t cputime)
  3474. {
  3475. struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
  3476. cputime64_t tmp;
  3477. p->utime = cputime_add(p->utime, cputime);
  3478. account_group_user_time(p, cputime);
  3479. /* Add user time to cpustat. */
  3480. tmp = cputime_to_cputime64(cputime);
  3481. if (TASK_NICE(p) > 0)
  3482. cpustat->nice = cputime64_add(cpustat->nice, tmp);
  3483. else
  3484. cpustat->user = cputime64_add(cpustat->user, tmp);
  3485. /* Account for user time used */
  3486. acct_update_integrals(p);
  3487. }
  3488. /*
  3489. * Account guest cpu time to a process.
  3490. * @p: the process that the cpu time gets accounted to
  3491. * @cputime: the cpu time spent in virtual machine since the last update
  3492. */
  3493. static void account_guest_time(struct task_struct *p, cputime_t cputime)
  3494. {
  3495. cputime64_t tmp;
  3496. struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
  3497. tmp = cputime_to_cputime64(cputime);
  3498. p->utime = cputime_add(p->utime, cputime);
  3499. account_group_user_time(p, cputime);
  3500. p->gtime = cputime_add(p->gtime, cputime);
  3501. cpustat->user = cputime64_add(cpustat->user, tmp);
  3502. cpustat->guest = cputime64_add(cpustat->guest, tmp);
  3503. }
  3504. /*
  3505. * Account scaled user cpu time to a process.
  3506. * @p: the process that the cpu time gets accounted to
  3507. * @cputime: the cpu time spent in user space since the last update
  3508. */
  3509. void account_user_time_scaled(struct task_struct *p, cputime_t cputime)
  3510. {
  3511. p->utimescaled = cputime_add(p->utimescaled, cputime);
  3512. }
  3513. /*
  3514. * Account system cpu time to a process.
  3515. * @p: the process that the cpu time gets accounted to
  3516. * @hardirq_offset: the offset to subtract from hardirq_count()
  3517. * @cputime: the cpu time spent in kernel space since the last update
  3518. */
  3519. void account_system_time(struct task_struct *p, int hardirq_offset,
  3520. cputime_t cputime)
  3521. {
  3522. struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
  3523. struct rq *rq = this_rq();
  3524. cputime64_t tmp;
  3525. if ((p->flags & PF_VCPU) && (irq_count() - hardirq_offset == 0)) {
  3526. account_guest_time(p, cputime);
  3527. return;
  3528. }
  3529. p->stime = cputime_add(p->stime, cputime);
  3530. account_group_system_time(p, cputime);
  3531. /* Add system time to cpustat. */
  3532. tmp = cputime_to_cputime64(cputime);
  3533. if (hardirq_count() - hardirq_offset)
  3534. cpustat->irq = cputime64_add(cpustat->irq, tmp);
  3535. else if (softirq_count())
  3536. cpustat->softirq = cputime64_add(cpustat->softirq, tmp);
  3537. else if (p != rq->idle)
  3538. cpustat->system = cputime64_add(cpustat->system, tmp);
  3539. else if (atomic_read(&rq->nr_iowait) > 0)
  3540. cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
  3541. else
  3542. cpustat->idle = cputime64_add(cpustat->idle, tmp);
  3543. /* Account for system time used */
  3544. acct_update_integrals(p);
  3545. }
  3546. /*
  3547. * Account scaled system cpu time to a process.
  3548. * @p: the process that the cpu time gets accounted to
  3549. * @hardirq_offset: the offset to subtract from hardirq_count()
  3550. * @cputime: the cpu time spent in kernel space since the last update
  3551. */
  3552. void account_system_time_scaled(struct task_struct *p, cputime_t cputime)
  3553. {
  3554. p->stimescaled = cputime_add(p->stimescaled, cputime);
  3555. }
  3556. /*
  3557. * Account for involuntary wait time.
  3558. * @p: the process from which the cpu time has been stolen
  3559. * @steal: the cpu time spent in involuntary wait
  3560. */
  3561. void account_steal_time(struct task_struct *p, cputime_t steal)
  3562. {
  3563. struct cpu_usage_stat *cpustat = &kstat_this_cpu.cpustat;
  3564. cputime64_t tmp = cputime_to_cputime64(steal);
  3565. struct rq *rq = this_rq();
  3566. if (p == rq->idle) {
  3567. p->stime = cputime_add(p->stime, steal);
  3568. account_group_system_time(p, steal);
  3569. if (atomic_read(&rq->nr_iowait) > 0)
  3570. cpustat->iowait = cputime64_add(cpustat->iowait, tmp);
  3571. else
  3572. cpustat->idle = cputime64_add(cpustat->idle, tmp);
  3573. } else
  3574. cpustat->steal = cputime64_add(cpustat->steal, tmp);
  3575. }
  3576. /*
  3577. * Use precise platform statistics if available:
  3578. */
  3579. #ifdef CONFIG_VIRT_CPU_ACCOUNTING
  3580. cputime_t task_utime(struct task_struct *p)
  3581. {
  3582. return p->utime;
  3583. }
  3584. cputime_t task_stime(struct task_struct *p)
  3585. {
  3586. return p->stime;
  3587. }
  3588. #else
  3589. cputime_t task_utime(struct task_struct *p)
  3590. {
  3591. clock_t utime = cputime_to_clock_t(p->utime),
  3592. total = utime + cputime_to_clock_t(p->stime);
  3593. u64 temp;
  3594. /*
  3595. * Use CFS's precise accounting:
  3596. */
  3597. temp = (u64)nsec_to_clock_t(p->se.sum_exec_runtime);
  3598. if (total) {
  3599. temp *= utime;
  3600. do_div(temp, total);
  3601. }
  3602. utime = (clock_t)temp;
  3603. p->prev_utime = max(p->prev_utime, clock_t_to_cputime(utime));
  3604. return p->prev_utime;
  3605. }
  3606. cputime_t task_stime(struct task_struct *p)
  3607. {
  3608. clock_t stime;
  3609. /*
  3610. * Use CFS's precise accounting. (we subtract utime from
  3611. * the total, to make sure the total observed by userspace
  3612. * grows monotonically - apps rely on that):
  3613. */
  3614. stime = nsec_to_clock_t(p->se.sum_exec_runtime) -
  3615. cputime_to_clock_t(task_utime(p));
  3616. if (stime >= 0)
  3617. p->prev_stime = max(p->prev_stime, clock_t_to_cputime(stime));
  3618. return p->prev_stime;
  3619. }
  3620. #endif
  3621. inline cputime_t task_gtime(struct task_struct *p)
  3622. {
  3623. return p->gtime;
  3624. }
  3625. /*
  3626. * This function gets called by the timer code, with HZ frequency.
  3627. * We call it with interrupts disabled.
  3628. *
  3629. * It also gets called by the fork code, when changing the parent's
  3630. * timeslices.
  3631. */
  3632. void scheduler_tick(void)
  3633. {
  3634. int cpu = smp_processor_id();
  3635. struct rq *rq = cpu_rq(cpu);
  3636. struct task_struct *curr = rq->curr;
  3637. sched_clock_tick();
  3638. spin_lock(&rq->lock);
  3639. update_rq_clock(rq);
  3640. update_cpu_load(rq);
  3641. curr->sched_class->task_tick(rq, curr, 0);
  3642. spin_unlock(&rq->lock);
  3643. #ifdef CONFIG_SMP
  3644. rq->idle_at_tick = idle_cpu(cpu);
  3645. trigger_load_balance(rq, cpu);
  3646. #endif
  3647. }
  3648. #if defined(CONFIG_PREEMPT) && (defined(CONFIG_DEBUG_PREEMPT) || \
  3649. defined(CONFIG_PREEMPT_TRACER))
  3650. static inline unsigned long get_parent_ip(unsigned long addr)
  3651. {
  3652. if (in_lock_functions(addr)) {
  3653. addr = CALLER_ADDR2;
  3654. if (in_lock_functions(addr))
  3655. addr = CALLER_ADDR3;
  3656. }
  3657. return addr;
  3658. }
  3659. void __kprobes add_preempt_count(int val)
  3660. {
  3661. #ifdef CONFIG_DEBUG_PREEMPT
  3662. /*
  3663. * Underflow?
  3664. */
  3665. if (DEBUG_LOCKS_WARN_ON((preempt_count() < 0)))
  3666. return;
  3667. #endif
  3668. preempt_count() += val;
  3669. #ifdef CONFIG_DEBUG_PREEMPT
  3670. /*
  3671. * Spinlock count overflowing soon?
  3672. */
  3673. DEBUG_LOCKS_WARN_ON((preempt_count() & PREEMPT_MASK) >=
  3674. PREEMPT_MASK - 10);
  3675. #endif
  3676. if (preempt_count() == val)
  3677. trace_preempt_off(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
  3678. }
  3679. EXPORT_SYMBOL(add_preempt_count);
  3680. void __kprobes sub_preempt_count(int val)
  3681. {
  3682. #ifdef CONFIG_DEBUG_PREEMPT
  3683. /*
  3684. * Underflow?
  3685. */
  3686. if (DEBUG_LOCKS_WARN_ON(val > preempt_count()))
  3687. return;
  3688. /*
  3689. * Is the spinlock portion underflowing?
  3690. */
  3691. if (DEBUG_LOCKS_WARN_ON((val < PREEMPT_MASK) &&
  3692. !(preempt_count() & PREEMPT_MASK)))
  3693. return;
  3694. #endif
  3695. if (preempt_count() == val)
  3696. trace_preempt_on(CALLER_ADDR0, get_parent_ip(CALLER_ADDR1));
  3697. preempt_count() -= val;
  3698. }
  3699. EXPORT_SYMBOL(sub_preempt_count);
  3700. #endif
  3701. /*
  3702. * Print scheduling while atomic bug:
  3703. */
  3704. static noinline void __schedule_bug(struct task_struct *prev)
  3705. {
  3706. struct pt_regs *regs = get_irq_regs();
  3707. printk(KERN_ERR "BUG: scheduling while atomic: %s/%d/0x%08x\n",
  3708. prev->comm, prev->pid, preempt_count());
  3709. debug_show_held_locks(prev);
  3710. print_modules();
  3711. if (irqs_disabled())
  3712. print_irqtrace_events(prev);
  3713. if (regs)
  3714. show_regs(regs);
  3715. else
  3716. dump_stack();
  3717. }
  3718. /*
  3719. * Various schedule()-time debugging checks and statistics:
  3720. */
  3721. static inline void schedule_debug(struct task_struct *prev)
  3722. {
  3723. /*
  3724. * Test if we are atomic. Since do_exit() needs to call into
  3725. * schedule() atomically, we ignore that path for now.
  3726. * Otherwise, whine if we are scheduling when we should not be.
  3727. */
  3728. if (unlikely(in_atomic_preempt_off() && !prev->exit_state))
  3729. __schedule_bug(prev);
  3730. profile_hit(SCHED_PROFILING, __builtin_return_address(0));
  3731. schedstat_inc(this_rq(), sched_count);
  3732. #ifdef CONFIG_SCHEDSTATS
  3733. if (unlikely(prev->lock_depth >= 0)) {
  3734. schedstat_inc(this_rq(), bkl_count);
  3735. schedstat_inc(prev, sched_info.bkl_count);
  3736. }
  3737. #endif
  3738. }
  3739. /*
  3740. * Pick up the highest-prio task:
  3741. */
  3742. static inline struct task_struct *
  3743. pick_next_task(struct rq *rq, struct task_struct *prev)
  3744. {
  3745. const struct sched_class *class;
  3746. struct task_struct *p;
  3747. /*
  3748. * Optimization: we know that if all tasks are in
  3749. * the fair class we can call that function directly:
  3750. */
  3751. if (likely(rq->nr_running == rq->cfs.nr_running)) {
  3752. p = fair_sched_class.pick_next_task(rq);
  3753. if (likely(p))
  3754. return p;
  3755. }
  3756. class = sched_class_highest;
  3757. for ( ; ; ) {
  3758. p = class->pick_next_task(rq);
  3759. if (p)
  3760. return p;
  3761. /*
  3762. * Will never be NULL as the idle class always
  3763. * returns a non-NULL p:
  3764. */
  3765. class = class->next;
  3766. }
  3767. }
  3768. /*
  3769. * schedule() is the main scheduler function.
  3770. */
  3771. asmlinkage void __sched schedule(void)
  3772. {
  3773. struct task_struct *prev, *next;
  3774. unsigned long *switch_count;
  3775. struct rq *rq;
  3776. int cpu;
  3777. need_resched:
  3778. preempt_disable();
  3779. cpu = smp_processor_id();
  3780. rq = cpu_rq(cpu);
  3781. rcu_qsctr_inc(cpu);
  3782. prev = rq->curr;
  3783. switch_count = &prev->nivcsw;
  3784. release_kernel_lock(prev);
  3785. need_resched_nonpreemptible:
  3786. schedule_debug(prev);
  3787. if (sched_feat(HRTICK))
  3788. hrtick_clear(rq);
  3789. spin_lock_irq(&rq->lock);
  3790. update_rq_clock(rq);
  3791. clear_tsk_need_resched(prev);
  3792. if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
  3793. if (unlikely(signal_pending_state(prev->state, prev)))
  3794. prev->state = TASK_RUNNING;
  3795. else
  3796. deactivate_task(rq, prev, 1);
  3797. switch_count = &prev->nvcsw;
  3798. }
  3799. #ifdef CONFIG_SMP
  3800. if (prev->sched_class->pre_schedule)
  3801. prev->sched_class->pre_schedule(rq, prev);
  3802. #endif
  3803. if (unlikely(!rq->nr_running))
  3804. idle_balance(cpu, rq);
  3805. prev->sched_class->put_prev_task(rq, prev);
  3806. next = pick_next_task(rq, prev);
  3807. if (likely(prev != next)) {
  3808. sched_info_switch(prev, next);
  3809. rq->nr_switches++;
  3810. rq->curr = next;
  3811. ++*switch_count;
  3812. context_switch(rq, prev, next); /* unlocks the rq */
  3813. /*
  3814. * the context switch might have flipped the stack from under
  3815. * us, hence refresh the local variables.
  3816. */
  3817. cpu = smp_processor_id();
  3818. rq = cpu_rq(cpu);
  3819. } else
  3820. spin_unlock_irq(&rq->lock);
  3821. if (unlikely(reacquire_kernel_lock(current) < 0))
  3822. goto need_resched_nonpreemptible;
  3823. preempt_enable_no_resched();
  3824. if (unlikely(test_thread_flag(TIF_NEED_RESCHED)))
  3825. goto need_resched;
  3826. }
  3827. EXPORT_SYMBOL(schedule);
  3828. #ifdef CONFIG_PREEMPT
  3829. /*
  3830. * this is the entry point to schedule() from in-kernel preemption
  3831. * off of preempt_enable. Kernel preemptions off return from interrupt
  3832. * occur there and call schedule directly.
  3833. */
  3834. asmlinkage void __sched preempt_schedule(void)
  3835. {
  3836. struct thread_info *ti = current_thread_info();
  3837. /*
  3838. * If there is a non-zero preempt_count or interrupts are disabled,
  3839. * we do not want to preempt the current task. Just return..
  3840. */
  3841. if (likely(ti->preempt_count || irqs_disabled()))
  3842. return;
  3843. do {
  3844. add_preempt_count(PREEMPT_ACTIVE);
  3845. schedule();
  3846. sub_preempt_count(PREEMPT_ACTIVE);
  3847. /*
  3848. * Check again in case we missed a preemption opportunity
  3849. * between schedule and now.
  3850. */
  3851. barrier();
  3852. } while (unlikely(test_thread_flag(TIF_NEED_RESCHED)));
  3853. }
  3854. EXPORT_SYMBOL(preempt_schedule);
  3855. /*
  3856. * this is the entry point to schedule() from kernel preemption
  3857. * off of irq context.
  3858. * Note, that this is called and return with irqs disabled. This will
  3859. * protect us against recursive calling from irq.
  3860. */
  3861. asmlinkage void __sched preempt_schedule_irq(void)
  3862. {
  3863. struct thread_info *ti = current_thread_info();
  3864. /* Catch callers which need to be fixed */
  3865. BUG_ON(ti->preempt_count || !irqs_disabled());
  3866. do {
  3867. add_preempt_count(PREEMPT_ACTIVE);
  3868. local_irq_enable();
  3869. schedule();
  3870. local_irq_disable();
  3871. sub_preempt_count(PREEMPT_ACTIVE);
  3872. /*
  3873. * Check again in case we missed a preemption opportunity
  3874. * between schedule and now.
  3875. */
  3876. barrier();
  3877. } while (unlikely(test_thread_flag(TIF_NEED_RESCHED)));
  3878. }
  3879. #endif /* CONFIG_PREEMPT */
  3880. int default_wake_function(wait_queue_t *curr, unsigned mode, int sync,
  3881. void *key)
  3882. {
  3883. return try_to_wake_up(curr->private, mode, sync);
  3884. }
  3885. EXPORT_SYMBOL(default_wake_function);
  3886. /*
  3887. * The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
  3888. * wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
  3889. * number) then we wake all the non-exclusive tasks and one exclusive task.
  3890. *
  3891. * There are circumstances in which we can try to wake a task which has already
  3892. * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
  3893. * zero in this (rare) case, and we handle it by continuing to scan the queue.
  3894. */
  3895. static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
  3896. int nr_exclusive, int sync, void *key)
  3897. {
  3898. wait_queue_t *curr, *next;
  3899. list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
  3900. unsigned flags = curr->flags;
  3901. if (curr->func(curr, mode, sync, key) &&
  3902. (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
  3903. break;
  3904. }
  3905. }
  3906. /**
  3907. * __wake_up - wake up threads blocked on a waitqueue.
  3908. * @q: the waitqueue
  3909. * @mode: which threads
  3910. * @nr_exclusive: how many wake-one or wake-many threads to wake up
  3911. * @key: is directly passed to the wakeup function
  3912. */
  3913. void __wake_up(wait_queue_head_t *q, unsigned int mode,
  3914. int nr_exclusive, void *key)
  3915. {
  3916. unsigned long flags;
  3917. spin_lock_irqsave(&q->lock, flags);
  3918. __wake_up_common(q, mode, nr_exclusive, 0, key);
  3919. spin_unlock_irqrestore(&q->lock, flags);
  3920. }
  3921. EXPORT_SYMBOL(__wake_up);
  3922. /*
  3923. * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
  3924. */
  3925. void __wake_up_locked(wait_queue_head_t *q, unsigned int mode)
  3926. {
  3927. __wake_up_common(q, mode, 1, 0, NULL);
  3928. }
  3929. /**
  3930. * __wake_up_sync - wake up threads blocked on a waitqueue.
  3931. * @q: the waitqueue
  3932. * @mode: which threads
  3933. * @nr_exclusive: how many wake-one or wake-many threads to wake up
  3934. *
  3935. * The sync wakeup differs that the waker knows that it will schedule
  3936. * away soon, so while the target thread will be woken up, it will not
  3937. * be migrated to another CPU - ie. the two threads are 'synchronized'
  3938. * with each other. This can prevent needless bouncing between CPUs.
  3939. *
  3940. * On UP it can prevent extra preemption.
  3941. */
  3942. void
  3943. __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
  3944. {
  3945. unsigned long flags;
  3946. int sync = 1;
  3947. if (unlikely(!q))
  3948. return;
  3949. if (unlikely(!nr_exclusive))
  3950. sync = 0;
  3951. spin_lock_irqsave(&q->lock, flags);
  3952. __wake_up_common(q, mode, nr_exclusive, sync, NULL);
  3953. spin_unlock_irqrestore(&q->lock, flags);
  3954. }
  3955. EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */
  3956. /**
  3957. * complete: - signals a single thread waiting on this completion
  3958. * @x: holds the state of this particular completion
  3959. *
  3960. * This will wake up a single thread waiting on this completion. Threads will be
  3961. * awakened in the same order in which they were queued.
  3962. *
  3963. * See also complete_all(), wait_for_completion() and related routines.
  3964. */
  3965. void complete(struct completion *x)
  3966. {
  3967. unsigned long flags;
  3968. spin_lock_irqsave(&x->wait.lock, flags);
  3969. x->done++;
  3970. __wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);
  3971. spin_unlock_irqrestore(&x->wait.lock, flags);
  3972. }
  3973. EXPORT_SYMBOL(complete);
  3974. /**
  3975. * complete_all: - signals all threads waiting on this completion
  3976. * @x: holds the state of this particular completion
  3977. *
  3978. * This will wake up all threads waiting on this particular completion event.
  3979. */
  3980. void complete_all(struct completion *x)
  3981. {
  3982. unsigned long flags;
  3983. spin_lock_irqsave(&x->wait.lock, flags);
  3984. x->done += UINT_MAX/2;
  3985. __wake_up_common(&x->wait, TASK_NORMAL, 0, 0, NULL);
  3986. spin_unlock_irqrestore(&x->wait.lock, flags);
  3987. }
  3988. EXPORT_SYMBOL(complete_all);
  3989. static inline long __sched
  3990. do_wait_for_common(struct completion *x, long timeout, int state)
  3991. {
  3992. if (!x->done) {
  3993. DECLARE_WAITQUEUE(wait, current);
  3994. wait.flags |= WQ_FLAG_EXCLUSIVE;
  3995. __add_wait_queue_tail(&x->wait, &wait);
  3996. do {
  3997. if (signal_pending_state(state, current)) {
  3998. timeout = -ERESTARTSYS;
  3999. break;
  4000. }
  4001. __set_current_state(state);
  4002. spin_unlock_irq(&x->wait.lock);
  4003. timeout = schedule_timeout(timeout);
  4004. spin_lock_irq(&x->wait.lock);
  4005. } while (!x->done && timeout);
  4006. __remove_wait_queue(&x->wait, &wait);
  4007. if (!x->done)
  4008. return timeout;
  4009. }
  4010. x->done--;
  4011. return timeout ?: 1;
  4012. }
  4013. static long __sched
  4014. wait_for_common(struct completion *x, long timeout, int state)
  4015. {
  4016. might_sleep();
  4017. spin_lock_irq(&x->wait.lock);
  4018. timeout = do_wait_for_common(x, timeout, state);
  4019. spin_unlock_irq(&x->wait.lock);
  4020. return timeout;
  4021. }
  4022. /**
  4023. * wait_for_completion: - waits for completion of a task
  4024. * @x: holds the state of this particular completion
  4025. *
  4026. * This waits to be signaled for completion of a specific task. It is NOT
  4027. * interruptible and there is no timeout.
  4028. *
  4029. * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
  4030. * and interrupt capability. Also see complete().
  4031. */
  4032. void __sched wait_for_completion(struct completion *x)
  4033. {
  4034. wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
  4035. }
  4036. EXPORT_SYMBOL(wait_for_completion);
  4037. /**
  4038. * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
  4039. * @x: holds the state of this particular completion
  4040. * @timeout: timeout value in jiffies
  4041. *
  4042. * This waits for either a completion of a specific task to be signaled or for a
  4043. * specified timeout to expire. The timeout is in jiffies. It is not
  4044. * interruptible.
  4045. */
  4046. unsigned long __sched
  4047. wait_for_completion_timeout(struct completion *x, unsigned long timeout)
  4048. {
  4049. return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
  4050. }
  4051. EXPORT_SYMBOL(wait_for_completion_timeout);
  4052. /**
  4053. * wait_for_completion_interruptible: - waits for completion of a task (w/intr)
  4054. * @x: holds the state of this particular completion
  4055. *
  4056. * This waits for completion of a specific task to be signaled. It is
  4057. * interruptible.
  4058. */
  4059. int __sched wait_for_completion_interruptible(struct completion *x)
  4060. {
  4061. long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
  4062. if (t == -ERESTARTSYS)
  4063. return t;
  4064. return 0;
  4065. }
  4066. EXPORT_SYMBOL(wait_for_completion_interruptible);
  4067. /**
  4068. * wait_for_completion_interruptible_timeout: - waits for completion (w/(to,intr))
  4069. * @x: holds the state of this particular completion
  4070. * @timeout: timeout value in jiffies
  4071. *
  4072. * This waits for either a completion of a specific task to be signaled or for a
  4073. * specified timeout to expire. It is interruptible. The timeout is in jiffies.
  4074. */
  4075. unsigned long __sched
  4076. wait_for_completion_interruptible_timeout(struct completion *x,
  4077. unsigned long timeout)
  4078. {
  4079. return wait_for_common(x, timeout, TASK_INTERRUPTIBLE);
  4080. }
  4081. EXPORT_SYMBOL(wait_for_completion_interruptible_timeout);
  4082. /**
  4083. * wait_for_completion_killable: - waits for completion of a task (killable)
  4084. * @x: holds the state of this particular completion
  4085. *
  4086. * This waits to be signaled for completion of a specific task. It can be
  4087. * interrupted by a kill signal.
  4088. */
  4089. int __sched wait_for_completion_killable(struct completion *x)
  4090. {
  4091. long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
  4092. if (t == -ERESTARTSYS)
  4093. return t;
  4094. return 0;
  4095. }
  4096. EXPORT_SYMBOL(wait_for_completion_killable);
  4097. /**
  4098. * try_wait_for_completion - try to decrement a completion without blocking
  4099. * @x: completion structure
  4100. *
  4101. * Returns: 0 if a decrement cannot be done without blocking
  4102. * 1 if a decrement succeeded.
  4103. *
  4104. * If a completion is being used as a counting completion,
  4105. * attempt to decrement the counter without blocking. This
  4106. * enables us to avoid waiting if the resource the completion
  4107. * is protecting is not available.
  4108. */
  4109. bool try_wait_for_completion(struct completion *x)
  4110. {
  4111. int ret = 1;
  4112. spin_lock_irq(&x->wait.lock);
  4113. if (!x->done)
  4114. ret = 0;
  4115. else
  4116. x->done--;
  4117. spin_unlock_irq(&x->wait.lock);
  4118. return ret;
  4119. }
  4120. EXPORT_SYMBOL(try_wait_for_completion);
  4121. /**
  4122. * completion_done - Test to see if a completion has any waiters
  4123. * @x: completion structure
  4124. *
  4125. * Returns: 0 if there are waiters (wait_for_completion() in progress)
  4126. * 1 if there are no waiters.
  4127. *
  4128. */
  4129. bool completion_done(struct completion *x)
  4130. {
  4131. int ret = 1;
  4132. spin_lock_irq(&x->wait.lock);
  4133. if (!x->done)
  4134. ret = 0;
  4135. spin_unlock_irq(&x->wait.lock);
  4136. return ret;
  4137. }
  4138. EXPORT_SYMBOL(completion_done);
  4139. static long __sched
  4140. sleep_on_common(wait_queue_head_t *q, int state, long timeout)
  4141. {
  4142. unsigned long flags;
  4143. wait_queue_t wait;
  4144. init_waitqueue_entry(&wait, current);
  4145. __set_current_state(state);
  4146. spin_lock_irqsave(&q->lock, flags);
  4147. __add_wait_queue(q, &wait);
  4148. spin_unlock(&q->lock);
  4149. timeout = schedule_timeout(timeout);
  4150. spin_lock_irq(&q->lock);
  4151. __remove_wait_queue(q, &wait);
  4152. spin_unlock_irqrestore(&q->lock, flags);
  4153. return timeout;
  4154. }
  4155. void __sched interruptible_sleep_on(wait_queue_head_t *q)
  4156. {
  4157. sleep_on_common(q, TASK_INTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  4158. }
  4159. EXPORT_SYMBOL(interruptible_sleep_on);
  4160. long __sched
  4161. interruptible_sleep_on_timeout(wait_queue_head_t *q, long timeout)
  4162. {
  4163. return sleep_on_common(q, TASK_INTERRUPTIBLE, timeout);
  4164. }
  4165. EXPORT_SYMBOL(interruptible_sleep_on_timeout);
  4166. void __sched sleep_on(wait_queue_head_t *q)
  4167. {
  4168. sleep_on_common(q, TASK_UNINTERRUPTIBLE, MAX_SCHEDULE_TIMEOUT);
  4169. }
  4170. EXPORT_SYMBOL(sleep_on);
  4171. long __sched sleep_on_timeout(wait_queue_head_t *q, long timeout)
  4172. {
  4173. return sleep_on_common(q, TASK_UNINTERRUPTIBLE, timeout);
  4174. }
  4175. EXPORT_SYMBOL(sleep_on_timeout);
  4176. #ifdef CONFIG_RT_MUTEXES
  4177. /*
  4178. * rt_mutex_setprio - set the current priority of a task
  4179. * @p: task
  4180. * @prio: prio value (kernel-internal form)
  4181. *
  4182. * This function changes the 'effective' priority of a task. It does
  4183. * not touch ->normal_prio like __setscheduler().
  4184. *
  4185. * Used by the rt_mutex code to implement priority inheritance logic.
  4186. */
  4187. void rt_mutex_setprio(struct task_struct *p, int prio)
  4188. {
  4189. unsigned long flags;
  4190. int oldprio, on_rq, running;
  4191. struct rq *rq;
  4192. const struct sched_class *prev_class = p->sched_class;
  4193. BUG_ON(prio < 0 || prio > MAX_PRIO);
  4194. rq = task_rq_lock(p, &flags);
  4195. update_rq_clock(rq);
  4196. oldprio = p->prio;
  4197. on_rq = p->se.on_rq;
  4198. running = task_current(rq, p);
  4199. if (on_rq)
  4200. dequeue_task(rq, p, 0);
  4201. if (running)
  4202. p->sched_class->put_prev_task(rq, p);
  4203. if (rt_prio(prio))
  4204. p->sched_class = &rt_sched_class;
  4205. else
  4206. p->sched_class = &fair_sched_class;
  4207. p->prio = prio;
  4208. if (running)
  4209. p->sched_class->set_curr_task(rq);
  4210. if (on_rq) {
  4211. enqueue_task(rq, p, 0);
  4212. check_class_changed(rq, p, prev_class, oldprio, running);
  4213. }
  4214. task_rq_unlock(rq, &flags);
  4215. }
  4216. #endif
  4217. void set_user_nice(struct task_struct *p, long nice)
  4218. {
  4219. int old_prio, delta, on_rq;
  4220. unsigned long flags;
  4221. struct rq *rq;
  4222. if (TASK_NICE(p) == nice || nice < -20 || nice > 19)
  4223. return;
  4224. /*
  4225. * We have to be careful, if called from sys_setpriority(),
  4226. * the task might be in the middle of scheduling on another CPU.
  4227. */
  4228. rq = task_rq_lock(p, &flags);
  4229. update_rq_clock(rq);
  4230. /*
  4231. * The RT priorities are set via sched_setscheduler(), but we still
  4232. * allow the 'normal' nice value to be set - but as expected
  4233. * it wont have any effect on scheduling until the task is
  4234. * SCHED_FIFO/SCHED_RR:
  4235. */
  4236. if (task_has_rt_policy(p)) {
  4237. p->static_prio = NICE_TO_PRIO(nice);
  4238. goto out_unlock;
  4239. }
  4240. on_rq = p->se.on_rq;
  4241. if (on_rq)
  4242. dequeue_task(rq, p, 0);
  4243. p->static_prio = NICE_TO_PRIO(nice);
  4244. set_load_weight(p);
  4245. old_prio = p->prio;
  4246. p->prio = effective_prio(p);
  4247. delta = p->prio - old_prio;
  4248. if (on_rq) {
  4249. enqueue_task(rq, p, 0);
  4250. /*
  4251. * If the task increased its priority or is running and
  4252. * lowered its priority, then reschedule its CPU:
  4253. */
  4254. if (delta < 0 || (delta > 0 && task_running(rq, p)))
  4255. resched_task(rq->curr);
  4256. }
  4257. out_unlock:
  4258. task_rq_unlock(rq, &flags);
  4259. }
  4260. EXPORT_SYMBOL(set_user_nice);
  4261. /*
  4262. * can_nice - check if a task can reduce its nice value
  4263. * @p: task
  4264. * @nice: nice value
  4265. */
  4266. int can_nice(const struct task_struct *p, const int nice)
  4267. {
  4268. /* convert nice value [19,-20] to rlimit style value [1,40] */
  4269. int nice_rlim = 20 - nice;
  4270. return (nice_rlim <= p->signal->rlim[RLIMIT_NICE].rlim_cur ||
  4271. capable(CAP_SYS_NICE));
  4272. }
  4273. #ifdef __ARCH_WANT_SYS_NICE
  4274. /*
  4275. * sys_nice - change the priority of the current process.
  4276. * @increment: priority increment
  4277. *
  4278. * sys_setpriority is a more generic, but much slower function that
  4279. * does similar things.
  4280. */
  4281. asmlinkage long sys_nice(int increment)
  4282. {
  4283. long nice, retval;
  4284. /*
  4285. * Setpriority might change our priority at the same moment.
  4286. * We don't have to worry. Conceptually one call occurs first
  4287. * and we have a single winner.
  4288. */
  4289. if (increment < -40)
  4290. increment = -40;
  4291. if (increment > 40)
  4292. increment = 40;
  4293. nice = PRIO_TO_NICE(current->static_prio) + increment;
  4294. if (nice < -20)
  4295. nice = -20;
  4296. if (nice > 19)
  4297. nice = 19;
  4298. if (increment < 0 && !can_nice(current, nice))
  4299. return -EPERM;
  4300. retval = security_task_setnice(current, nice);
  4301. if (retval)
  4302. return retval;
  4303. set_user_nice(current, nice);
  4304. return 0;
  4305. }
  4306. #endif
  4307. /**
  4308. * task_prio - return the priority value of a given task.
  4309. * @p: the task in question.
  4310. *
  4311. * This is the priority value as seen by users in /proc.
  4312. * RT tasks are offset by -200. Normal tasks are centered
  4313. * around 0, value goes from -16 to +15.
  4314. */
  4315. int task_prio(const struct task_struct *p)
  4316. {
  4317. return p->prio - MAX_RT_PRIO;
  4318. }
  4319. /**
  4320. * task_nice - return the nice value of a given task.
  4321. * @p: the task in question.
  4322. */
  4323. int task_nice(const struct task_struct *p)
  4324. {
  4325. return TASK_NICE(p);
  4326. }
  4327. EXPORT_SYMBOL(task_nice);
  4328. /**
  4329. * idle_cpu - is a given cpu idle currently?
  4330. * @cpu: the processor in question.
  4331. */
  4332. int idle_cpu(int cpu)
  4333. {
  4334. return cpu_curr(cpu) == cpu_rq(cpu)->idle;
  4335. }
  4336. /**
  4337. * idle_task - return the idle task for a given cpu.
  4338. * @cpu: the processor in question.
  4339. */
  4340. struct task_struct *idle_task(int cpu)
  4341. {
  4342. return cpu_rq(cpu)->idle;
  4343. }
  4344. /**
  4345. * find_process_by_pid - find a process with a matching PID value.
  4346. * @pid: the pid in question.
  4347. */
  4348. static struct task_struct *find_process_by_pid(pid_t pid)
  4349. {
  4350. return pid ? find_task_by_vpid(pid) : current;
  4351. }
  4352. /* Actually do priority change: must hold rq lock. */
  4353. static void
  4354. __setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
  4355. {
  4356. BUG_ON(p->se.on_rq);
  4357. p->policy = policy;
  4358. switch (p->policy) {
  4359. case SCHED_NORMAL:
  4360. case SCHED_BATCH:
  4361. case SCHED_IDLE:
  4362. p->sched_class = &fair_sched_class;
  4363. break;
  4364. case SCHED_FIFO:
  4365. case SCHED_RR:
  4366. p->sched_class = &rt_sched_class;
  4367. break;
  4368. }
  4369. p->rt_priority = prio;
  4370. p->normal_prio = normal_prio(p);
  4371. /* we are holding p->pi_lock already */
  4372. p->prio = rt_mutex_getprio(p);
  4373. set_load_weight(p);
  4374. }
  4375. static int __sched_setscheduler(struct task_struct *p, int policy,
  4376. struct sched_param *param, bool user)
  4377. {
  4378. int retval, oldprio, oldpolicy = -1, on_rq, running;
  4379. unsigned long flags;
  4380. const struct sched_class *prev_class = p->sched_class;
  4381. struct rq *rq;
  4382. /* may grab non-irq protected spin_locks */
  4383. BUG_ON(in_interrupt());
  4384. recheck:
  4385. /* double check policy once rq lock held */
  4386. if (policy < 0)
  4387. policy = oldpolicy = p->policy;
  4388. else if (policy != SCHED_FIFO && policy != SCHED_RR &&
  4389. policy != SCHED_NORMAL && policy != SCHED_BATCH &&
  4390. policy != SCHED_IDLE)
  4391. return -EINVAL;
  4392. /*
  4393. * Valid priorities for SCHED_FIFO and SCHED_RR are
  4394. * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL,
  4395. * SCHED_BATCH and SCHED_IDLE is 0.
  4396. */
  4397. if (param->sched_priority < 0 ||
  4398. (p->mm && param->sched_priority > MAX_USER_RT_PRIO-1) ||
  4399. (!p->mm && param->sched_priority > MAX_RT_PRIO-1))
  4400. return -EINVAL;
  4401. if (rt_policy(policy) != (param->sched_priority != 0))
  4402. return -EINVAL;
  4403. /*
  4404. * Allow unprivileged RT tasks to decrease priority:
  4405. */
  4406. if (user && !capable(CAP_SYS_NICE)) {
  4407. if (rt_policy(policy)) {
  4408. unsigned long rlim_rtprio;
  4409. if (!lock_task_sighand(p, &flags))
  4410. return -ESRCH;
  4411. rlim_rtprio = p->signal->rlim[RLIMIT_RTPRIO].rlim_cur;
  4412. unlock_task_sighand(p, &flags);
  4413. /* can't set/change the rt policy */
  4414. if (policy != p->policy && !rlim_rtprio)
  4415. return -EPERM;
  4416. /* can't increase priority */
  4417. if (param->sched_priority > p->rt_priority &&
  4418. param->sched_priority > rlim_rtprio)
  4419. return -EPERM;
  4420. }
  4421. /*
  4422. * Like positive nice levels, dont allow tasks to
  4423. * move out of SCHED_IDLE either:
  4424. */
  4425. if (p->policy == SCHED_IDLE && policy != SCHED_IDLE)
  4426. return -EPERM;
  4427. /* can't change other user's priorities */
  4428. if ((current->euid != p->euid) &&
  4429. (current->euid != p->uid))
  4430. return -EPERM;
  4431. }
  4432. if (user) {
  4433. #ifdef CONFIG_RT_GROUP_SCHED
  4434. /*
  4435. * Do not allow realtime tasks into groups that have no runtime
  4436. * assigned.
  4437. */
  4438. if (rt_bandwidth_enabled() && rt_policy(policy) &&
  4439. task_group(p)->rt_bandwidth.rt_runtime == 0)
  4440. return -EPERM;
  4441. #endif
  4442. retval = security_task_setscheduler(p, policy, param);
  4443. if (retval)
  4444. return retval;
  4445. }
  4446. /*
  4447. * make sure no PI-waiters arrive (or leave) while we are
  4448. * changing the priority of the task:
  4449. */
  4450. spin_lock_irqsave(&p->pi_lock, flags);
  4451. /*
  4452. * To be able to change p->policy safely, the apropriate
  4453. * runqueue lock must be held.
  4454. */
  4455. rq = __task_rq_lock(p);
  4456. /* recheck policy now with rq lock held */
  4457. if (unlikely(oldpolicy != -1 && oldpolicy != p->policy)) {
  4458. policy = oldpolicy = -1;
  4459. __task_rq_unlock(rq);
  4460. spin_unlock_irqrestore(&p->pi_lock, flags);
  4461. goto recheck;
  4462. }
  4463. update_rq_clock(rq);
  4464. on_rq = p->se.on_rq;
  4465. running = task_current(rq, p);
  4466. if (on_rq)
  4467. deactivate_task(rq, p, 0);
  4468. if (running)
  4469. p->sched_class->put_prev_task(rq, p);
  4470. oldprio = p->prio;
  4471. __setscheduler(rq, p, policy, param->sched_priority);
  4472. if (running)
  4473. p->sched_class->set_curr_task(rq);
  4474. if (on_rq) {
  4475. activate_task(rq, p, 0);
  4476. check_class_changed(rq, p, prev_class, oldprio, running);
  4477. }
  4478. __task_rq_unlock(rq);
  4479. spin_unlock_irqrestore(&p->pi_lock, flags);
  4480. rt_mutex_adjust_pi(p);
  4481. return 0;
  4482. }
  4483. /**
  4484. * sched_setscheduler - change the scheduling policy and/or RT priority of a thread.
  4485. * @p: the task in question.
  4486. * @policy: new policy.
  4487. * @param: structure containing the new RT priority.
  4488. *
  4489. * NOTE that the task may be already dead.
  4490. */
  4491. int sched_setscheduler(struct task_struct *p, int policy,
  4492. struct sched_param *param)
  4493. {
  4494. return __sched_setscheduler(p, policy, param, true);
  4495. }
  4496. EXPORT_SYMBOL_GPL(sched_setscheduler);
  4497. /**
  4498. * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace.
  4499. * @p: the task in question.
  4500. * @policy: new policy.
  4501. * @param: structure containing the new RT priority.
  4502. *
  4503. * Just like sched_setscheduler, only don't bother checking if the
  4504. * current context has permission. For example, this is needed in
  4505. * stop_machine(): we create temporary high priority worker threads,
  4506. * but our caller might not have that capability.
  4507. */
  4508. int sched_setscheduler_nocheck(struct task_struct *p, int policy,
  4509. struct sched_param *param)
  4510. {
  4511. return __sched_setscheduler(p, policy, param, false);
  4512. }
  4513. static int
  4514. do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
  4515. {
  4516. struct sched_param lparam;
  4517. struct task_struct *p;
  4518. int retval;
  4519. if (!param || pid < 0)
  4520. return -EINVAL;
  4521. if (copy_from_user(&lparam, param, sizeof(struct sched_param)))
  4522. return -EFAULT;
  4523. rcu_read_lock();
  4524. retval = -ESRCH;
  4525. p = find_process_by_pid(pid);
  4526. if (p != NULL)
  4527. retval = sched_setscheduler(p, policy, &lparam);
  4528. rcu_read_unlock();
  4529. return retval;
  4530. }
  4531. /**
  4532. * sys_sched_setscheduler - set/change the scheduler policy and RT priority
  4533. * @pid: the pid in question.
  4534. * @policy: new policy.
  4535. * @param: structure containing the new RT priority.
  4536. */
  4537. asmlinkage long
  4538. sys_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
  4539. {
  4540. /* negative values for policy are not valid */
  4541. if (policy < 0)
  4542. return -EINVAL;
  4543. return do_sched_setscheduler(pid, policy, param);
  4544. }
  4545. /**
  4546. * sys_sched_setparam - set/change the RT priority of a thread
  4547. * @pid: the pid in question.
  4548. * @param: structure containing the new RT priority.
  4549. */
  4550. asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param __user *param)
  4551. {
  4552. return do_sched_setscheduler(pid, -1, param);
  4553. }
  4554. /**
  4555. * sys_sched_getscheduler - get the policy (scheduling class) of a thread
  4556. * @pid: the pid in question.
  4557. */
  4558. asmlinkage long sys_sched_getscheduler(pid_t pid)
  4559. {
  4560. struct task_struct *p;
  4561. int retval;
  4562. if (pid < 0)
  4563. return -EINVAL;
  4564. retval = -ESRCH;
  4565. read_lock(&tasklist_lock);
  4566. p = find_process_by_pid(pid);
  4567. if (p) {
  4568. retval = security_task_getscheduler(p);
  4569. if (!retval)
  4570. retval = p->policy;
  4571. }
  4572. read_unlock(&tasklist_lock);
  4573. return retval;
  4574. }
  4575. /**
  4576. * sys_sched_getscheduler - get the RT priority of a thread
  4577. * @pid: the pid in question.
  4578. * @param: structure containing the RT priority.
  4579. */
  4580. asmlinkage long sys_sched_getparam(pid_t pid, struct sched_param __user *param)
  4581. {
  4582. struct sched_param lp;
  4583. struct task_struct *p;
  4584. int retval;
  4585. if (!param || pid < 0)
  4586. return -EINVAL;
  4587. read_lock(&tasklist_lock);
  4588. p = find_process_by_pid(pid);
  4589. retval = -ESRCH;
  4590. if (!p)
  4591. goto out_unlock;
  4592. retval = security_task_getscheduler(p);
  4593. if (retval)
  4594. goto out_unlock;
  4595. lp.sched_priority = p->rt_priority;
  4596. read_unlock(&tasklist_lock);
  4597. /*
  4598. * This one might sleep, we cannot do it with a spinlock held ...
  4599. */
  4600. retval = copy_to_user(param, &lp, sizeof(*param)) ? -EFAULT : 0;
  4601. return retval;
  4602. out_unlock:
  4603. read_unlock(&tasklist_lock);
  4604. return retval;
  4605. }
  4606. long sched_setaffinity(pid_t pid, const cpumask_t *in_mask)
  4607. {
  4608. cpumask_t cpus_allowed;
  4609. cpumask_t new_mask = *in_mask;
  4610. struct task_struct *p;
  4611. int retval;
  4612. get_online_cpus();
  4613. read_lock(&tasklist_lock);
  4614. p = find_process_by_pid(pid);
  4615. if (!p) {
  4616. read_unlock(&tasklist_lock);
  4617. put_online_cpus();
  4618. return -ESRCH;
  4619. }
  4620. /*
  4621. * It is not safe to call set_cpus_allowed with the
  4622. * tasklist_lock held. We will bump the task_struct's
  4623. * usage count and then drop tasklist_lock.
  4624. */
  4625. get_task_struct(p);
  4626. read_unlock(&tasklist_lock);
  4627. retval = -EPERM;
  4628. if ((current->euid != p->euid) && (current->euid != p->uid) &&
  4629. !capable(CAP_SYS_NICE))
  4630. goto out_unlock;
  4631. retval = security_task_setscheduler(p, 0, NULL);
  4632. if (retval)
  4633. goto out_unlock;
  4634. cpuset_cpus_allowed(p, &cpus_allowed);
  4635. cpus_and(new_mask, new_mask, cpus_allowed);
  4636. again:
  4637. retval = set_cpus_allowed_ptr(p, &new_mask);
  4638. if (!retval) {
  4639. cpuset_cpus_allowed(p, &cpus_allowed);
  4640. if (!cpus_subset(new_mask, cpus_allowed)) {
  4641. /*
  4642. * We must have raced with a concurrent cpuset
  4643. * update. Just reset the cpus_allowed to the
  4644. * cpuset's cpus_allowed
  4645. */
  4646. new_mask = cpus_allowed;
  4647. goto again;
  4648. }
  4649. }
  4650. out_unlock:
  4651. put_task_struct(p);
  4652. put_online_cpus();
  4653. return retval;
  4654. }
  4655. static int get_user_cpu_mask(unsigned long __user *user_mask_ptr, unsigned len,
  4656. cpumask_t *new_mask)
  4657. {
  4658. if (len < sizeof(cpumask_t)) {
  4659. memset(new_mask, 0, sizeof(cpumask_t));
  4660. } else if (len > sizeof(cpumask_t)) {
  4661. len = sizeof(cpumask_t);
  4662. }
  4663. return copy_from_user(new_mask, user_mask_ptr, len) ? -EFAULT : 0;
  4664. }
  4665. /**
  4666. * sys_sched_setaffinity - set the cpu affinity of a process
  4667. * @pid: pid of the process
  4668. * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  4669. * @user_mask_ptr: user-space pointer to the new cpu mask
  4670. */
  4671. asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
  4672. unsigned long __user *user_mask_ptr)
  4673. {
  4674. cpumask_t new_mask;
  4675. int retval;
  4676. retval = get_user_cpu_mask(user_mask_ptr, len, &new_mask);
  4677. if (retval)
  4678. return retval;
  4679. return sched_setaffinity(pid, &new_mask);
  4680. }
  4681. long sched_getaffinity(pid_t pid, cpumask_t *mask)
  4682. {
  4683. struct task_struct *p;
  4684. int retval;
  4685. get_online_cpus();
  4686. read_lock(&tasklist_lock);
  4687. retval = -ESRCH;
  4688. p = find_process_by_pid(pid);
  4689. if (!p)
  4690. goto out_unlock;
  4691. retval = security_task_getscheduler(p);
  4692. if (retval)
  4693. goto out_unlock;
  4694. cpus_and(*mask, p->cpus_allowed, cpu_online_map);
  4695. out_unlock:
  4696. read_unlock(&tasklist_lock);
  4697. put_online_cpus();
  4698. return retval;
  4699. }
  4700. /**
  4701. * sys_sched_getaffinity - get the cpu affinity of a process
  4702. * @pid: pid of the process
  4703. * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  4704. * @user_mask_ptr: user-space pointer to hold the current cpu mask
  4705. */
  4706. asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
  4707. unsigned long __user *user_mask_ptr)
  4708. {
  4709. int ret;
  4710. cpumask_t mask;
  4711. if (len < sizeof(cpumask_t))
  4712. return -EINVAL;
  4713. ret = sched_getaffinity(pid, &mask);
  4714. if (ret < 0)
  4715. return ret;
  4716. if (copy_to_user(user_mask_ptr, &mask, sizeof(cpumask_t)))
  4717. return -EFAULT;
  4718. return sizeof(cpumask_t);
  4719. }
  4720. /**
  4721. * sys_sched_yield - yield the current processor to other threads.
  4722. *
  4723. * This function yields the current CPU to other tasks. If there are no
  4724. * other threads running on this CPU then this function will return.
  4725. */
  4726. asmlinkage long sys_sched_yield(void)
  4727. {
  4728. struct rq *rq = this_rq_lock();
  4729. schedstat_inc(rq, yld_count);
  4730. current->sched_class->yield_task(rq);
  4731. /*
  4732. * Since we are going to call schedule() anyway, there's
  4733. * no need to preempt or enable interrupts:
  4734. */
  4735. __release(rq->lock);
  4736. spin_release(&rq->lock.dep_map, 1, _THIS_IP_);
  4737. _raw_spin_unlock(&rq->lock);
  4738. preempt_enable_no_resched();
  4739. schedule();
  4740. return 0;
  4741. }
  4742. static void __cond_resched(void)
  4743. {
  4744. #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
  4745. __might_sleep(__FILE__, __LINE__);
  4746. #endif
  4747. /*
  4748. * The BKS might be reacquired before we have dropped
  4749. * PREEMPT_ACTIVE, which could trigger a second
  4750. * cond_resched() call.
  4751. */
  4752. do {
  4753. add_preempt_count(PREEMPT_ACTIVE);
  4754. schedule();
  4755. sub_preempt_count(PREEMPT_ACTIVE);
  4756. } while (need_resched());
  4757. }
  4758. int __sched _cond_resched(void)
  4759. {
  4760. if (need_resched() && !(preempt_count() & PREEMPT_ACTIVE) &&
  4761. system_state == SYSTEM_RUNNING) {
  4762. __cond_resched();
  4763. return 1;
  4764. }
  4765. return 0;
  4766. }
  4767. EXPORT_SYMBOL(_cond_resched);
  4768. /*
  4769. * cond_resched_lock() - if a reschedule is pending, drop the given lock,
  4770. * call schedule, and on return reacquire the lock.
  4771. *
  4772. * This works OK both with and without CONFIG_PREEMPT. We do strange low-level
  4773. * operations here to prevent schedule() from being called twice (once via
  4774. * spin_unlock(), once by hand).
  4775. */
  4776. int cond_resched_lock(spinlock_t *lock)
  4777. {
  4778. int resched = need_resched() && system_state == SYSTEM_RUNNING;
  4779. int ret = 0;
  4780. if (spin_needbreak(lock) || resched) {
  4781. spin_unlock(lock);
  4782. if (resched && need_resched())
  4783. __cond_resched();
  4784. else
  4785. cpu_relax();
  4786. ret = 1;
  4787. spin_lock(lock);
  4788. }
  4789. return ret;
  4790. }
  4791. EXPORT_SYMBOL(cond_resched_lock);
  4792. int __sched cond_resched_softirq(void)
  4793. {
  4794. BUG_ON(!in_softirq());
  4795. if (need_resched() && system_state == SYSTEM_RUNNING) {
  4796. local_bh_enable();
  4797. __cond_resched();
  4798. local_bh_disable();
  4799. return 1;
  4800. }
  4801. return 0;
  4802. }
  4803. EXPORT_SYMBOL(cond_resched_softirq);
  4804. /**
  4805. * yield - yield the current processor to other threads.
  4806. *
  4807. * This is a shortcut for kernel-space yielding - it marks the
  4808. * thread runnable and calls sys_sched_yield().
  4809. */
  4810. void __sched yield(void)
  4811. {
  4812. set_current_state(TASK_RUNNING);
  4813. sys_sched_yield();
  4814. }
  4815. EXPORT_SYMBOL(yield);
  4816. /*
  4817. * This task is about to go to sleep on IO. Increment rq->nr_iowait so
  4818. * that process accounting knows that this is a task in IO wait state.
  4819. *
  4820. * But don't do that if it is a deliberate, throttling IO wait (this task
  4821. * has set its backing_dev_info: the queue against which it should throttle)
  4822. */
  4823. void __sched io_schedule(void)
  4824. {
  4825. struct rq *rq = &__raw_get_cpu_var(runqueues);
  4826. delayacct_blkio_start();
  4827. atomic_inc(&rq->nr_iowait);
  4828. schedule();
  4829. atomic_dec(&rq->nr_iowait);
  4830. delayacct_blkio_end();
  4831. }
  4832. EXPORT_SYMBOL(io_schedule);
  4833. long __sched io_schedule_timeout(long timeout)
  4834. {
  4835. struct rq *rq = &__raw_get_cpu_var(runqueues);
  4836. long ret;
  4837. delayacct_blkio_start();
  4838. atomic_inc(&rq->nr_iowait);
  4839. ret = schedule_timeout(timeout);
  4840. atomic_dec(&rq->nr_iowait);
  4841. delayacct_blkio_end();
  4842. return ret;
  4843. }
  4844. /**
  4845. * sys_sched_get_priority_max - return maximum RT priority.
  4846. * @policy: scheduling class.
  4847. *
  4848. * this syscall returns the maximum rt_priority that can be used
  4849. * by a given scheduling class.
  4850. */
  4851. asmlinkage long sys_sched_get_priority_max(int policy)
  4852. {
  4853. int ret = -EINVAL;
  4854. switch (policy) {
  4855. case SCHED_FIFO:
  4856. case SCHED_RR:
  4857. ret = MAX_USER_RT_PRIO-1;
  4858. break;
  4859. case SCHED_NORMAL:
  4860. case SCHED_BATCH:
  4861. case SCHED_IDLE:
  4862. ret = 0;
  4863. break;
  4864. }
  4865. return ret;
  4866. }
  4867. /**
  4868. * sys_sched_get_priority_min - return minimum RT priority.
  4869. * @policy: scheduling class.
  4870. *
  4871. * this syscall returns the minimum rt_priority that can be used
  4872. * by a given scheduling class.
  4873. */
  4874. asmlinkage long sys_sched_get_priority_min(int policy)
  4875. {
  4876. int ret = -EINVAL;
  4877. switch (policy) {
  4878. case SCHED_FIFO:
  4879. case SCHED_RR:
  4880. ret = 1;
  4881. break;
  4882. case SCHED_NORMAL:
  4883. case SCHED_BATCH:
  4884. case SCHED_IDLE:
  4885. ret = 0;
  4886. }
  4887. return ret;
  4888. }
  4889. /**
  4890. * sys_sched_rr_get_interval - return the default timeslice of a process.
  4891. * @pid: pid of the process.
  4892. * @interval: userspace pointer to the timeslice value.
  4893. *
  4894. * this syscall writes the default timeslice value of a given process
  4895. * into the user-space timespec buffer. A value of '0' means infinity.
  4896. */
  4897. asmlinkage
  4898. long sys_sched_rr_get_interval(pid_t pid, struct timespec __user *interval)
  4899. {
  4900. struct task_struct *p;
  4901. unsigned int time_slice;
  4902. int retval;
  4903. struct timespec t;
  4904. if (pid < 0)
  4905. return -EINVAL;
  4906. retval = -ESRCH;
  4907. read_lock(&tasklist_lock);
  4908. p = find_process_by_pid(pid);
  4909. if (!p)
  4910. goto out_unlock;
  4911. retval = security_task_getscheduler(p);
  4912. if (retval)
  4913. goto out_unlock;
  4914. /*
  4915. * Time slice is 0 for SCHED_FIFO tasks and for SCHED_OTHER
  4916. * tasks that are on an otherwise idle runqueue:
  4917. */
  4918. time_slice = 0;
  4919. if (p->policy == SCHED_RR) {
  4920. time_slice = DEF_TIMESLICE;
  4921. } else if (p->policy != SCHED_FIFO) {
  4922. struct sched_entity *se = &p->se;
  4923. unsigned long flags;
  4924. struct rq *rq;
  4925. rq = task_rq_lock(p, &flags);
  4926. if (rq->cfs.load.weight)
  4927. time_slice = NS_TO_JIFFIES(sched_slice(&rq->cfs, se));
  4928. task_rq_unlock(rq, &flags);
  4929. }
  4930. read_unlock(&tasklist_lock);
  4931. jiffies_to_timespec(time_slice, &t);
  4932. retval = copy_to_user(interval, &t, sizeof(t)) ? -EFAULT : 0;
  4933. return retval;
  4934. out_unlock:
  4935. read_unlock(&tasklist_lock);
  4936. return retval;
  4937. }
  4938. static const char stat_nam[] = TASK_STATE_TO_CHAR_STR;
  4939. void sched_show_task(struct task_struct *p)
  4940. {
  4941. unsigned long free = 0;
  4942. unsigned state;
  4943. state = p->state ? __ffs(p->state) + 1 : 0;
  4944. printk(KERN_INFO "%-13.13s %c", p->comm,
  4945. state < sizeof(stat_nam) - 1 ? stat_nam[state] : '?');
  4946. #if BITS_PER_LONG == 32
  4947. if (state == TASK_RUNNING)
  4948. printk(KERN_CONT " running ");
  4949. else
  4950. printk(KERN_CONT " %08lx ", thread_saved_pc(p));
  4951. #else
  4952. if (state == TASK_RUNNING)
  4953. printk(KERN_CONT " running task ");
  4954. else
  4955. printk(KERN_CONT " %016lx ", thread_saved_pc(p));
  4956. #endif
  4957. #ifdef CONFIG_DEBUG_STACK_USAGE
  4958. {
  4959. unsigned long *n = end_of_stack(p);
  4960. while (!*n)
  4961. n++;
  4962. free = (unsigned long)n - (unsigned long)end_of_stack(p);
  4963. }
  4964. #endif
  4965. printk(KERN_CONT "%5lu %5d %6d\n", free,
  4966. task_pid_nr(p), task_pid_nr(p->real_parent));
  4967. show_stack(p, NULL);
  4968. }
  4969. void show_state_filter(unsigned long state_filter)
  4970. {
  4971. struct task_struct *g, *p;
  4972. #if BITS_PER_LONG == 32
  4973. printk(KERN_INFO
  4974. " task PC stack pid father\n");
  4975. #else
  4976. printk(KERN_INFO
  4977. " task PC stack pid father\n");
  4978. #endif
  4979. read_lock(&tasklist_lock);
  4980. do_each_thread(g, p) {
  4981. /*
  4982. * reset the NMI-timeout, listing all files on a slow
  4983. * console might take alot of time:
  4984. */
  4985. touch_nmi_watchdog();
  4986. if (!state_filter || (p->state & state_filter))
  4987. sched_show_task(p);
  4988. } while_each_thread(g, p);
  4989. touch_all_softlockup_watchdogs();
  4990. #ifdef CONFIG_SCHED_DEBUG
  4991. sysrq_sched_debug_show();
  4992. #endif
  4993. read_unlock(&tasklist_lock);
  4994. /*
  4995. * Only show locks if all tasks are dumped:
  4996. */
  4997. if (state_filter == -1)
  4998. debug_show_all_locks();
  4999. }
  5000. void __cpuinit init_idle_bootup_task(struct task_struct *idle)
  5001. {
  5002. idle->sched_class = &idle_sched_class;
  5003. }
  5004. /**
  5005. * init_idle - set up an idle thread for a given CPU
  5006. * @idle: task in question
  5007. * @cpu: cpu the idle task belongs to
  5008. *
  5009. * NOTE: this function does not set the idle thread's NEED_RESCHED
  5010. * flag, to make booting more robust.
  5011. */
  5012. void __cpuinit init_idle(struct task_struct *idle, int cpu)
  5013. {
  5014. struct rq *rq = cpu_rq(cpu);
  5015. unsigned long flags;
  5016. __sched_fork(idle);
  5017. idle->se.exec_start = sched_clock();
  5018. idle->prio = idle->normal_prio = MAX_PRIO;
  5019. idle->cpus_allowed = cpumask_of_cpu(cpu);
  5020. __set_task_cpu(idle, cpu);
  5021. spin_lock_irqsave(&rq->lock, flags);
  5022. rq->curr = rq->idle = idle;
  5023. #if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
  5024. idle->oncpu = 1;
  5025. #endif
  5026. spin_unlock_irqrestore(&rq->lock, flags);
  5027. /* Set the preempt count _outside_ the spinlocks! */
  5028. #if defined(CONFIG_PREEMPT)
  5029. task_thread_info(idle)->preempt_count = (idle->lock_depth >= 0);
  5030. #else
  5031. task_thread_info(idle)->preempt_count = 0;
  5032. #endif
  5033. /*
  5034. * The idle tasks have their own, simple scheduling class:
  5035. */
  5036. idle->sched_class = &idle_sched_class;
  5037. }
  5038. /*
  5039. * In a system that switches off the HZ timer nohz_cpu_mask
  5040. * indicates which cpus entered this state. This is used
  5041. * in the rcu update to wait only for active cpus. For system
  5042. * which do not switch off the HZ timer nohz_cpu_mask should
  5043. * always be CPU_MASK_NONE.
  5044. */
  5045. cpumask_t nohz_cpu_mask = CPU_MASK_NONE;
  5046. /*
  5047. * Increase the granularity value when there are more CPUs,
  5048. * because with more CPUs the 'effective latency' as visible
  5049. * to users decreases. But the relationship is not linear,
  5050. * so pick a second-best guess by going with the log2 of the
  5051. * number of CPUs.
  5052. *
  5053. * This idea comes from the SD scheduler of Con Kolivas:
  5054. */
  5055. static inline void sched_init_granularity(void)
  5056. {
  5057. unsigned int factor = 1 + ilog2(num_online_cpus());
  5058. const unsigned long limit = 200000000;
  5059. sysctl_sched_min_granularity *= factor;
  5060. if (sysctl_sched_min_granularity > limit)
  5061. sysctl_sched_min_granularity = limit;
  5062. sysctl_sched_latency *= factor;
  5063. if (sysctl_sched_latency > limit)
  5064. sysctl_sched_latency = limit;
  5065. sysctl_sched_wakeup_granularity *= factor;
  5066. sysctl_sched_shares_ratelimit *= factor;
  5067. }
  5068. #ifdef CONFIG_SMP
  5069. /*
  5070. * This is how migration works:
  5071. *
  5072. * 1) we queue a struct migration_req structure in the source CPU's
  5073. * runqueue and wake up that CPU's migration thread.
  5074. * 2) we down() the locked semaphore => thread blocks.
  5075. * 3) migration thread wakes up (implicitly it forces the migrated
  5076. * thread off the CPU)
  5077. * 4) it gets the migration request and checks whether the migrated
  5078. * task is still in the wrong runqueue.
  5079. * 5) if it's in the wrong runqueue then the migration thread removes
  5080. * it and puts it into the right queue.
  5081. * 6) migration thread up()s the semaphore.
  5082. * 7) we wake up and the migration is done.
  5083. */
  5084. /*
  5085. * Change a given task's CPU affinity. Migrate the thread to a
  5086. * proper CPU and schedule it away if the CPU it's executing on
  5087. * is removed from the allowed bitmask.
  5088. *
  5089. * NOTE: the caller must have a valid reference to the task, the
  5090. * task must not exit() & deallocate itself prematurely. The
  5091. * call is not atomic; no spinlocks may be held.
  5092. */
  5093. int set_cpus_allowed_ptr(struct task_struct *p, const cpumask_t *new_mask)
  5094. {
  5095. struct migration_req req;
  5096. unsigned long flags;
  5097. struct rq *rq;
  5098. int ret = 0;
  5099. rq = task_rq_lock(p, &flags);
  5100. if (!cpus_intersects(*new_mask, cpu_online_map)) {
  5101. ret = -EINVAL;
  5102. goto out;
  5103. }
  5104. if (unlikely((p->flags & PF_THREAD_BOUND) && p != current &&
  5105. !cpus_equal(p->cpus_allowed, *new_mask))) {
  5106. ret = -EINVAL;
  5107. goto out;
  5108. }
  5109. if (p->sched_class->set_cpus_allowed)
  5110. p->sched_class->set_cpus_allowed(p, new_mask);
  5111. else {
  5112. p->cpus_allowed = *new_mask;
  5113. p->rt.nr_cpus_allowed = cpus_weight(*new_mask);
  5114. }
  5115. /* Can the task run on the task's current CPU? If so, we're done */
  5116. if (cpu_isset(task_cpu(p), *new_mask))
  5117. goto out;
  5118. if (migrate_task(p, any_online_cpu(*new_mask), &req)) {
  5119. /* Need help from migration thread: drop lock and wait. */
  5120. task_rq_unlock(rq, &flags);
  5121. wake_up_process(rq->migration_thread);
  5122. wait_for_completion(&req.done);
  5123. tlb_migrate_finish(p->mm);
  5124. return 0;
  5125. }
  5126. out:
  5127. task_rq_unlock(rq, &flags);
  5128. return ret;
  5129. }
  5130. EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);
  5131. /*
  5132. * Move (not current) task off this cpu, onto dest cpu. We're doing
  5133. * this because either it can't run here any more (set_cpus_allowed()
  5134. * away from this CPU, or CPU going down), or because we're
  5135. * attempting to rebalance this task on exec (sched_exec).
  5136. *
  5137. * So we race with normal scheduler movements, but that's OK, as long
  5138. * as the task is no longer on this CPU.
  5139. *
  5140. * Returns non-zero if task was successfully migrated.
  5141. */
  5142. static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
  5143. {
  5144. struct rq *rq_dest, *rq_src;
  5145. int ret = 0, on_rq;
  5146. if (unlikely(!cpu_active(dest_cpu)))
  5147. return ret;
  5148. rq_src = cpu_rq(src_cpu);
  5149. rq_dest = cpu_rq(dest_cpu);
  5150. double_rq_lock(rq_src, rq_dest);
  5151. /* Already moved. */
  5152. if (task_cpu(p) != src_cpu)
  5153. goto done;
  5154. /* Affinity changed (again). */
  5155. if (!cpu_isset(dest_cpu, p->cpus_allowed))
  5156. goto fail;
  5157. on_rq = p->se.on_rq;
  5158. if (on_rq)
  5159. deactivate_task(rq_src, p, 0);
  5160. set_task_cpu(p, dest_cpu);
  5161. if (on_rq) {
  5162. activate_task(rq_dest, p, 0);
  5163. check_preempt_curr(rq_dest, p, 0);
  5164. }
  5165. done:
  5166. ret = 1;
  5167. fail:
  5168. double_rq_unlock(rq_src, rq_dest);
  5169. return ret;
  5170. }
  5171. /*
  5172. * migration_thread - this is a highprio system thread that performs
  5173. * thread migration by bumping thread off CPU then 'pushing' onto
  5174. * another runqueue.
  5175. */
  5176. static int migration_thread(void *data)
  5177. {
  5178. int cpu = (long)data;
  5179. struct rq *rq;
  5180. rq = cpu_rq(cpu);
  5181. BUG_ON(rq->migration_thread != current);
  5182. set_current_state(TASK_INTERRUPTIBLE);
  5183. while (!kthread_should_stop()) {
  5184. struct migration_req *req;
  5185. struct list_head *head;
  5186. spin_lock_irq(&rq->lock);
  5187. if (cpu_is_offline(cpu)) {
  5188. spin_unlock_irq(&rq->lock);
  5189. goto wait_to_die;
  5190. }
  5191. if (rq->active_balance) {
  5192. active_load_balance(rq, cpu);
  5193. rq->active_balance = 0;
  5194. }
  5195. head = &rq->migration_queue;
  5196. if (list_empty(head)) {
  5197. spin_unlock_irq(&rq->lock);
  5198. schedule();
  5199. set_current_state(TASK_INTERRUPTIBLE);
  5200. continue;
  5201. }
  5202. req = list_entry(head->next, struct migration_req, list);
  5203. list_del_init(head->next);
  5204. spin_unlock(&rq->lock);
  5205. __migrate_task(req->task, cpu, req->dest_cpu);
  5206. local_irq_enable();
  5207. complete(&req->done);
  5208. }
  5209. __set_current_state(TASK_RUNNING);
  5210. return 0;
  5211. wait_to_die:
  5212. /* Wait for kthread_stop */
  5213. set_current_state(TASK_INTERRUPTIBLE);
  5214. while (!kthread_should_stop()) {
  5215. schedule();
  5216. set_current_state(TASK_INTERRUPTIBLE);
  5217. }
  5218. __set_current_state(TASK_RUNNING);
  5219. return 0;
  5220. }
  5221. #ifdef CONFIG_HOTPLUG_CPU
  5222. static int __migrate_task_irq(struct task_struct *p, int src_cpu, int dest_cpu)
  5223. {
  5224. int ret;
  5225. local_irq_disable();
  5226. ret = __migrate_task(p, src_cpu, dest_cpu);
  5227. local_irq_enable();
  5228. return ret;
  5229. }
  5230. /*
  5231. * Figure out where task on dead CPU should go, use force if necessary.
  5232. * NOTE: interrupts should be disabled by the caller
  5233. */
  5234. static void move_task_off_dead_cpu(int dead_cpu, struct task_struct *p)
  5235. {
  5236. unsigned long flags;
  5237. cpumask_t mask;
  5238. struct rq *rq;
  5239. int dest_cpu;
  5240. do {
  5241. /* On same node? */
  5242. mask = node_to_cpumask(cpu_to_node(dead_cpu));
  5243. cpus_and(mask, mask, p->cpus_allowed);
  5244. dest_cpu = any_online_cpu(mask);
  5245. /* On any allowed CPU? */
  5246. if (dest_cpu >= nr_cpu_ids)
  5247. dest_cpu = any_online_cpu(p->cpus_allowed);
  5248. /* No more Mr. Nice Guy. */
  5249. if (dest_cpu >= nr_cpu_ids) {
  5250. cpumask_t cpus_allowed;
  5251. cpuset_cpus_allowed_locked(p, &cpus_allowed);
  5252. /*
  5253. * Try to stay on the same cpuset, where the
  5254. * current cpuset may be a subset of all cpus.
  5255. * The cpuset_cpus_allowed_locked() variant of
  5256. * cpuset_cpus_allowed() will not block. It must be
  5257. * called within calls to cpuset_lock/cpuset_unlock.
  5258. */
  5259. rq = task_rq_lock(p, &flags);
  5260. p->cpus_allowed = cpus_allowed;
  5261. dest_cpu = any_online_cpu(p->cpus_allowed);
  5262. task_rq_unlock(rq, &flags);
  5263. /*
  5264. * Don't tell them about moving exiting tasks or
  5265. * kernel threads (both mm NULL), since they never
  5266. * leave kernel.
  5267. */
  5268. if (p->mm && printk_ratelimit()) {
  5269. printk(KERN_INFO "process %d (%s) no "
  5270. "longer affine to cpu%d\n",
  5271. task_pid_nr(p), p->comm, dead_cpu);
  5272. }
  5273. }
  5274. } while (!__migrate_task_irq(p, dead_cpu, dest_cpu));
  5275. }
  5276. /*
  5277. * While a dead CPU has no uninterruptible tasks queued at this point,
  5278. * it might still have a nonzero ->nr_uninterruptible counter, because
  5279. * for performance reasons the counter is not stricly tracking tasks to
  5280. * their home CPUs. So we just add the counter to another CPU's counter,
  5281. * to keep the global sum constant after CPU-down:
  5282. */
  5283. static void migrate_nr_uninterruptible(struct rq *rq_src)
  5284. {
  5285. struct rq *rq_dest = cpu_rq(any_online_cpu(*CPU_MASK_ALL_PTR));
  5286. unsigned long flags;
  5287. local_irq_save(flags);
  5288. double_rq_lock(rq_src, rq_dest);
  5289. rq_dest->nr_uninterruptible += rq_src->nr_uninterruptible;
  5290. rq_src->nr_uninterruptible = 0;
  5291. double_rq_unlock(rq_src, rq_dest);
  5292. local_irq_restore(flags);
  5293. }
  5294. /* Run through task list and migrate tasks from the dead cpu. */
  5295. static void migrate_live_tasks(int src_cpu)
  5296. {
  5297. struct task_struct *p, *t;
  5298. read_lock(&tasklist_lock);
  5299. do_each_thread(t, p) {
  5300. if (p == current)
  5301. continue;
  5302. if (task_cpu(p) == src_cpu)
  5303. move_task_off_dead_cpu(src_cpu, p);
  5304. } while_each_thread(t, p);
  5305. read_unlock(&tasklist_lock);
  5306. }
  5307. /*
  5308. * Schedules idle task to be the next runnable task on current CPU.
  5309. * It does so by boosting its priority to highest possible.
  5310. * Used by CPU offline code.
  5311. */
  5312. void sched_idle_next(void)
  5313. {
  5314. int this_cpu = smp_processor_id();
  5315. struct rq *rq = cpu_rq(this_cpu);
  5316. struct task_struct *p = rq->idle;
  5317. unsigned long flags;
  5318. /* cpu has to be offline */
  5319. BUG_ON(cpu_online(this_cpu));
  5320. /*
  5321. * Strictly not necessary since rest of the CPUs are stopped by now
  5322. * and interrupts disabled on the current cpu.
  5323. */
  5324. spin_lock_irqsave(&rq->lock, flags);
  5325. __setscheduler(rq, p, SCHED_FIFO, MAX_RT_PRIO-1);
  5326. update_rq_clock(rq);
  5327. activate_task(rq, p, 0);
  5328. spin_unlock_irqrestore(&rq->lock, flags);
  5329. }
  5330. /*
  5331. * Ensures that the idle task is using init_mm right before its cpu goes
  5332. * offline.
  5333. */
  5334. void idle_task_exit(void)
  5335. {
  5336. struct mm_struct *mm = current->active_mm;
  5337. BUG_ON(cpu_online(smp_processor_id()));
  5338. if (mm != &init_mm)
  5339. switch_mm(mm, &init_mm, current);
  5340. mmdrop(mm);
  5341. }
  5342. /* called under rq->lock with disabled interrupts */
  5343. static void migrate_dead(unsigned int dead_cpu, struct task_struct *p)
  5344. {
  5345. struct rq *rq = cpu_rq(dead_cpu);
  5346. /* Must be exiting, otherwise would be on tasklist. */
  5347. BUG_ON(!p->exit_state);
  5348. /* Cannot have done final schedule yet: would have vanished. */
  5349. BUG_ON(p->state == TASK_DEAD);
  5350. get_task_struct(p);
  5351. /*
  5352. * Drop lock around migration; if someone else moves it,
  5353. * that's OK. No task can be added to this CPU, so iteration is
  5354. * fine.
  5355. */
  5356. spin_unlock_irq(&rq->lock);
  5357. move_task_off_dead_cpu(dead_cpu, p);
  5358. spin_lock_irq(&rq->lock);
  5359. put_task_struct(p);
  5360. }
  5361. /* release_task() removes task from tasklist, so we won't find dead tasks. */
  5362. static void migrate_dead_tasks(unsigned int dead_cpu)
  5363. {
  5364. struct rq *rq = cpu_rq(dead_cpu);
  5365. struct task_struct *next;
  5366. for ( ; ; ) {
  5367. if (!rq->nr_running)
  5368. break;
  5369. update_rq_clock(rq);
  5370. next = pick_next_task(rq, rq->curr);
  5371. if (!next)
  5372. break;
  5373. next->sched_class->put_prev_task(rq, next);
  5374. migrate_dead(dead_cpu, next);
  5375. }
  5376. }
  5377. #endif /* CONFIG_HOTPLUG_CPU */
  5378. #if defined(CONFIG_SCHED_DEBUG) && defined(CONFIG_SYSCTL)
  5379. static struct ctl_table sd_ctl_dir[] = {
  5380. {
  5381. .procname = "sched_domain",
  5382. .mode = 0555,
  5383. },
  5384. {0, },
  5385. };
  5386. static struct ctl_table sd_ctl_root[] = {
  5387. {
  5388. .ctl_name = CTL_KERN,
  5389. .procname = "kernel",
  5390. .mode = 0555,
  5391. .child = sd_ctl_dir,
  5392. },
  5393. {0, },
  5394. };
  5395. static struct ctl_table *sd_alloc_ctl_entry(int n)
  5396. {
  5397. struct ctl_table *entry =
  5398. kcalloc(n, sizeof(struct ctl_table), GFP_KERNEL);
  5399. return entry;
  5400. }
  5401. static void sd_free_ctl_entry(struct ctl_table **tablep)
  5402. {
  5403. struct ctl_table *entry;
  5404. /*
  5405. * In the intermediate directories, both the child directory and
  5406. * procname are dynamically allocated and could fail but the mode
  5407. * will always be set. In the lowest directory the names are
  5408. * static strings and all have proc handlers.
  5409. */
  5410. for (entry = *tablep; entry->mode; entry++) {
  5411. if (entry->child)
  5412. sd_free_ctl_entry(&entry->child);
  5413. if (entry->proc_handler == NULL)
  5414. kfree(entry->procname);
  5415. }
  5416. kfree(*tablep);
  5417. *tablep = NULL;
  5418. }
  5419. static void
  5420. set_table_entry(struct ctl_table *entry,
  5421. const char *procname, void *data, int maxlen,
  5422. mode_t mode, proc_handler *proc_handler)
  5423. {
  5424. entry->procname = procname;
  5425. entry->data = data;
  5426. entry->maxlen = maxlen;
  5427. entry->mode = mode;
  5428. entry->proc_handler = proc_handler;
  5429. }
  5430. static struct ctl_table *
  5431. sd_alloc_ctl_domain_table(struct sched_domain *sd)
  5432. {
  5433. struct ctl_table *table = sd_alloc_ctl_entry(13);
  5434. if (table == NULL)
  5435. return NULL;
  5436. set_table_entry(&table[0], "min_interval", &sd->min_interval,
  5437. sizeof(long), 0644, proc_doulongvec_minmax);
  5438. set_table_entry(&table[1], "max_interval", &sd->max_interval,
  5439. sizeof(long), 0644, proc_doulongvec_minmax);
  5440. set_table_entry(&table[2], "busy_idx", &sd->busy_idx,
  5441. sizeof(int), 0644, proc_dointvec_minmax);
  5442. set_table_entry(&table[3], "idle_idx", &sd->idle_idx,
  5443. sizeof(int), 0644, proc_dointvec_minmax);
  5444. set_table_entry(&table[4], "newidle_idx", &sd->newidle_idx,
  5445. sizeof(int), 0644, proc_dointvec_minmax);
  5446. set_table_entry(&table[5], "wake_idx", &sd->wake_idx,
  5447. sizeof(int), 0644, proc_dointvec_minmax);
  5448. set_table_entry(&table[6], "forkexec_idx", &sd->forkexec_idx,
  5449. sizeof(int), 0644, proc_dointvec_minmax);
  5450. set_table_entry(&table[7], "busy_factor", &sd->busy_factor,
  5451. sizeof(int), 0644, proc_dointvec_minmax);
  5452. set_table_entry(&table[8], "imbalance_pct", &sd->imbalance_pct,
  5453. sizeof(int), 0644, proc_dointvec_minmax);
  5454. set_table_entry(&table[9], "cache_nice_tries",
  5455. &sd->cache_nice_tries,
  5456. sizeof(int), 0644, proc_dointvec_minmax);
  5457. set_table_entry(&table[10], "flags", &sd->flags,
  5458. sizeof(int), 0644, proc_dointvec_minmax);
  5459. set_table_entry(&table[11], "name", sd->name,
  5460. CORENAME_MAX_SIZE, 0444, proc_dostring);
  5461. /* &table[12] is terminator */
  5462. return table;
  5463. }
  5464. static ctl_table *sd_alloc_ctl_cpu_table(int cpu)
  5465. {
  5466. struct ctl_table *entry, *table;
  5467. struct sched_domain *sd;
  5468. int domain_num = 0, i;
  5469. char buf[32];
  5470. for_each_domain(cpu, sd)
  5471. domain_num++;
  5472. entry = table = sd_alloc_ctl_entry(domain_num + 1);
  5473. if (table == NULL)
  5474. return NULL;
  5475. i = 0;
  5476. for_each_domain(cpu, sd) {
  5477. snprintf(buf, 32, "domain%d", i);
  5478. entry->procname = kstrdup(buf, GFP_KERNEL);
  5479. entry->mode = 0555;
  5480. entry->child = sd_alloc_ctl_domain_table(sd);
  5481. entry++;
  5482. i++;
  5483. }
  5484. return table;
  5485. }
  5486. static struct ctl_table_header *sd_sysctl_header;
  5487. static void register_sched_domain_sysctl(void)
  5488. {
  5489. int i, cpu_num = num_online_cpus();
  5490. struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);
  5491. char buf[32];
  5492. WARN_ON(sd_ctl_dir[0].child);
  5493. sd_ctl_dir[0].child = entry;
  5494. if (entry == NULL)
  5495. return;
  5496. for_each_online_cpu(i) {
  5497. snprintf(buf, 32, "cpu%d", i);
  5498. entry->procname = kstrdup(buf, GFP_KERNEL);
  5499. entry->mode = 0555;
  5500. entry->child = sd_alloc_ctl_cpu_table(i);
  5501. entry++;
  5502. }
  5503. WARN_ON(sd_sysctl_header);
  5504. sd_sysctl_header = register_sysctl_table(sd_ctl_root);
  5505. }
  5506. /* may be called multiple times per register */
  5507. static void unregister_sched_domain_sysctl(void)
  5508. {
  5509. if (sd_sysctl_header)
  5510. unregister_sysctl_table(sd_sysctl_header);
  5511. sd_sysctl_header = NULL;
  5512. if (sd_ctl_dir[0].child)
  5513. sd_free_ctl_entry(&sd_ctl_dir[0].child);
  5514. }
  5515. #else
  5516. static void register_sched_domain_sysctl(void)
  5517. {
  5518. }
  5519. static void unregister_sched_domain_sysctl(void)
  5520. {
  5521. }
  5522. #endif
  5523. static void set_rq_online(struct rq *rq)
  5524. {
  5525. if (!rq->online) {
  5526. const struct sched_class *class;
  5527. cpu_set(rq->cpu, rq->rd->online);
  5528. rq->online = 1;
  5529. for_each_class(class) {
  5530. if (class->rq_online)
  5531. class->rq_online(rq);
  5532. }
  5533. }
  5534. }
  5535. static void set_rq_offline(struct rq *rq)
  5536. {
  5537. if (rq->online) {
  5538. const struct sched_class *class;
  5539. for_each_class(class) {
  5540. if (class->rq_offline)
  5541. class->rq_offline(rq);
  5542. }
  5543. cpu_clear(rq->cpu, rq->rd->online);
  5544. rq->online = 0;
  5545. }
  5546. }
  5547. /*
  5548. * migration_call - callback that gets triggered when a CPU is added.
  5549. * Here we can start up the necessary migration thread for the new CPU.
  5550. */
  5551. static int __cpuinit
  5552. migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu)
  5553. {
  5554. struct task_struct *p;
  5555. int cpu = (long)hcpu;
  5556. unsigned long flags;
  5557. struct rq *rq;
  5558. switch (action) {
  5559. case CPU_UP_PREPARE:
  5560. case CPU_UP_PREPARE_FROZEN:
  5561. p = kthread_create(migration_thread, hcpu, "migration/%d", cpu);
  5562. if (IS_ERR(p))
  5563. return NOTIFY_BAD;
  5564. kthread_bind(p, cpu);
  5565. /* Must be high prio: stop_machine expects to yield to it. */
  5566. rq = task_rq_lock(p, &flags);
  5567. __setscheduler(rq, p, SCHED_FIFO, MAX_RT_PRIO-1);
  5568. task_rq_unlock(rq, &flags);
  5569. cpu_rq(cpu)->migration_thread = p;
  5570. break;
  5571. case CPU_ONLINE:
  5572. case CPU_ONLINE_FROZEN:
  5573. /* Strictly unnecessary, as first user will wake it. */
  5574. wake_up_process(cpu_rq(cpu)->migration_thread);
  5575. /* Update our root-domain */
  5576. rq = cpu_rq(cpu);
  5577. spin_lock_irqsave(&rq->lock, flags);
  5578. if (rq->rd) {
  5579. BUG_ON(!cpu_isset(cpu, rq->rd->span));
  5580. set_rq_online(rq);
  5581. }
  5582. spin_unlock_irqrestore(&rq->lock, flags);
  5583. break;
  5584. #ifdef CONFIG_HOTPLUG_CPU
  5585. case CPU_UP_CANCELED:
  5586. case CPU_UP_CANCELED_FROZEN:
  5587. if (!cpu_rq(cpu)->migration_thread)
  5588. break;
  5589. /* Unbind it from offline cpu so it can run. Fall thru. */
  5590. kthread_bind(cpu_rq(cpu)->migration_thread,
  5591. any_online_cpu(cpu_online_map));
  5592. kthread_stop(cpu_rq(cpu)->migration_thread);
  5593. cpu_rq(cpu)->migration_thread = NULL;
  5594. break;
  5595. case CPU_DEAD:
  5596. case CPU_DEAD_FROZEN:
  5597. cpuset_lock(); /* around calls to cpuset_cpus_allowed_lock() */
  5598. migrate_live_tasks(cpu);
  5599. rq = cpu_rq(cpu);
  5600. kthread_stop(rq->migration_thread);
  5601. rq->migration_thread = NULL;
  5602. /* Idle task back to normal (off runqueue, low prio) */
  5603. spin_lock_irq(&rq->lock);
  5604. update_rq_clock(rq);
  5605. deactivate_task(rq, rq->idle, 0);
  5606. rq->idle->static_prio = MAX_PRIO;
  5607. __setscheduler(rq, rq->idle, SCHED_NORMAL, 0);
  5608. rq->idle->sched_class = &idle_sched_class;
  5609. migrate_dead_tasks(cpu);
  5610. spin_unlock_irq(&rq->lock);
  5611. cpuset_unlock();
  5612. migrate_nr_uninterruptible(rq);
  5613. BUG_ON(rq->nr_running != 0);
  5614. /*
  5615. * No need to migrate the tasks: it was best-effort if
  5616. * they didn't take sched_hotcpu_mutex. Just wake up
  5617. * the requestors.
  5618. */
  5619. spin_lock_irq(&rq->lock);
  5620. while (!list_empty(&rq->migration_queue)) {
  5621. struct migration_req *req;
  5622. req = list_entry(rq->migration_queue.next,
  5623. struct migration_req, list);
  5624. list_del_init(&req->list);
  5625. complete(&req->done);
  5626. }
  5627. spin_unlock_irq(&rq->lock);
  5628. break;
  5629. case CPU_DYING:
  5630. case CPU_DYING_FROZEN:
  5631. /* Update our root-domain */
  5632. rq = cpu_rq(cpu);
  5633. spin_lock_irqsave(&rq->lock, flags);
  5634. if (rq->rd) {
  5635. BUG_ON(!cpu_isset(cpu, rq->rd->span));
  5636. set_rq_offline(rq);
  5637. }
  5638. spin_unlock_irqrestore(&rq->lock, flags);
  5639. break;
  5640. #endif
  5641. }
  5642. return NOTIFY_OK;
  5643. }
  5644. /* Register at highest priority so that task migration (migrate_all_tasks)
  5645. * happens before everything else.
  5646. */
  5647. static struct notifier_block __cpuinitdata migration_notifier = {
  5648. .notifier_call = migration_call,
  5649. .priority = 10
  5650. };
  5651. static int __init migration_init(void)
  5652. {
  5653. void *cpu = (void *)(long)smp_processor_id();
  5654. int err;
  5655. /* Start one for the boot CPU: */
  5656. err = migration_call(&migration_notifier, CPU_UP_PREPARE, cpu);
  5657. BUG_ON(err == NOTIFY_BAD);
  5658. migration_call(&migration_notifier, CPU_ONLINE, cpu);
  5659. register_cpu_notifier(&migration_notifier);
  5660. return err;
  5661. }
  5662. early_initcall(migration_init);
  5663. #endif
  5664. #ifdef CONFIG_SMP
  5665. #ifdef CONFIG_SCHED_DEBUG
  5666. static inline const char *sd_level_to_string(enum sched_domain_level lvl)
  5667. {
  5668. switch (lvl) {
  5669. case SD_LV_NONE:
  5670. return "NONE";
  5671. case SD_LV_SIBLING:
  5672. return "SIBLING";
  5673. case SD_LV_MC:
  5674. return "MC";
  5675. case SD_LV_CPU:
  5676. return "CPU";
  5677. case SD_LV_NODE:
  5678. return "NODE";
  5679. case SD_LV_ALLNODES:
  5680. return "ALLNODES";
  5681. case SD_LV_MAX:
  5682. return "MAX";
  5683. }
  5684. return "MAX";
  5685. }
  5686. static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
  5687. cpumask_t *groupmask)
  5688. {
  5689. struct sched_group *group = sd->groups;
  5690. char str[256];
  5691. cpulist_scnprintf(str, sizeof(str), sd->span);
  5692. cpus_clear(*groupmask);
  5693. printk(KERN_DEBUG "%*s domain %d: ", level, "", level);
  5694. if (!(sd->flags & SD_LOAD_BALANCE)) {
  5695. printk("does not load-balance\n");
  5696. if (sd->parent)
  5697. printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain"
  5698. " has parent");
  5699. return -1;
  5700. }
  5701. printk(KERN_CONT "span %s level %s\n",
  5702. str, sd_level_to_string(sd->level));
  5703. if (!cpu_isset(cpu, sd->span)) {
  5704. printk(KERN_ERR "ERROR: domain->span does not contain "
  5705. "CPU%d\n", cpu);
  5706. }
  5707. if (!cpu_isset(cpu, group->cpumask)) {
  5708. printk(KERN_ERR "ERROR: domain->groups does not contain"
  5709. " CPU%d\n", cpu);
  5710. }
  5711. printk(KERN_DEBUG "%*s groups:", level + 1, "");
  5712. do {
  5713. if (!group) {
  5714. printk("\n");
  5715. printk(KERN_ERR "ERROR: group is NULL\n");
  5716. break;
  5717. }
  5718. if (!group->__cpu_power) {
  5719. printk(KERN_CONT "\n");
  5720. printk(KERN_ERR "ERROR: domain->cpu_power not "
  5721. "set\n");
  5722. break;
  5723. }
  5724. if (!cpus_weight(group->cpumask)) {
  5725. printk(KERN_CONT "\n");
  5726. printk(KERN_ERR "ERROR: empty group\n");
  5727. break;
  5728. }
  5729. if (cpus_intersects(*groupmask, group->cpumask)) {
  5730. printk(KERN_CONT "\n");
  5731. printk(KERN_ERR "ERROR: repeated CPUs\n");
  5732. break;
  5733. }
  5734. cpus_or(*groupmask, *groupmask, group->cpumask);
  5735. cpulist_scnprintf(str, sizeof(str), group->cpumask);
  5736. printk(KERN_CONT " %s", str);
  5737. group = group->next;
  5738. } while (group != sd->groups);
  5739. printk(KERN_CONT "\n");
  5740. if (!cpus_equal(sd->span, *groupmask))
  5741. printk(KERN_ERR "ERROR: groups don't span domain->span\n");
  5742. if (sd->parent && !cpus_subset(*groupmask, sd->parent->span))
  5743. printk(KERN_ERR "ERROR: parent span is not a superset "
  5744. "of domain->span\n");
  5745. return 0;
  5746. }
  5747. static void sched_domain_debug(struct sched_domain *sd, int cpu)
  5748. {
  5749. cpumask_t *groupmask;
  5750. int level = 0;
  5751. if (!sd) {
  5752. printk(KERN_DEBUG "CPU%d attaching NULL sched-domain.\n", cpu);
  5753. return;
  5754. }
  5755. printk(KERN_DEBUG "CPU%d attaching sched-domain:\n", cpu);
  5756. groupmask = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
  5757. if (!groupmask) {
  5758. printk(KERN_DEBUG "Cannot load-balance (out of memory)\n");
  5759. return;
  5760. }
  5761. for (;;) {
  5762. if (sched_domain_debug_one(sd, cpu, level, groupmask))
  5763. break;
  5764. level++;
  5765. sd = sd->parent;
  5766. if (!sd)
  5767. break;
  5768. }
  5769. kfree(groupmask);
  5770. }
  5771. #else /* !CONFIG_SCHED_DEBUG */
  5772. # define sched_domain_debug(sd, cpu) do { } while (0)
  5773. #endif /* CONFIG_SCHED_DEBUG */
  5774. static int sd_degenerate(struct sched_domain *sd)
  5775. {
  5776. if (cpus_weight(sd->span) == 1)
  5777. return 1;
  5778. /* Following flags need at least 2 groups */
  5779. if (sd->flags & (SD_LOAD_BALANCE |
  5780. SD_BALANCE_NEWIDLE |
  5781. SD_BALANCE_FORK |
  5782. SD_BALANCE_EXEC |
  5783. SD_SHARE_CPUPOWER |
  5784. SD_SHARE_PKG_RESOURCES)) {
  5785. if (sd->groups != sd->groups->next)
  5786. return 0;
  5787. }
  5788. /* Following flags don't use groups */
  5789. if (sd->flags & (SD_WAKE_IDLE |
  5790. SD_WAKE_AFFINE |
  5791. SD_WAKE_BALANCE))
  5792. return 0;
  5793. return 1;
  5794. }
  5795. static int
  5796. sd_parent_degenerate(struct sched_domain *sd, struct sched_domain *parent)
  5797. {
  5798. unsigned long cflags = sd->flags, pflags = parent->flags;
  5799. if (sd_degenerate(parent))
  5800. return 1;
  5801. if (!cpus_equal(sd->span, parent->span))
  5802. return 0;
  5803. /* Does parent contain flags not in child? */
  5804. /* WAKE_BALANCE is a subset of WAKE_AFFINE */
  5805. if (cflags & SD_WAKE_AFFINE)
  5806. pflags &= ~SD_WAKE_BALANCE;
  5807. /* Flags needing groups don't count if only 1 group in parent */
  5808. if (parent->groups == parent->groups->next) {
  5809. pflags &= ~(SD_LOAD_BALANCE |
  5810. SD_BALANCE_NEWIDLE |
  5811. SD_BALANCE_FORK |
  5812. SD_BALANCE_EXEC |
  5813. SD_SHARE_CPUPOWER |
  5814. SD_SHARE_PKG_RESOURCES);
  5815. }
  5816. if (~cflags & pflags)
  5817. return 0;
  5818. return 1;
  5819. }
  5820. static void rq_attach_root(struct rq *rq, struct root_domain *rd)
  5821. {
  5822. unsigned long flags;
  5823. spin_lock_irqsave(&rq->lock, flags);
  5824. if (rq->rd) {
  5825. struct root_domain *old_rd = rq->rd;
  5826. if (cpu_isset(rq->cpu, old_rd->online))
  5827. set_rq_offline(rq);
  5828. cpu_clear(rq->cpu, old_rd->span);
  5829. if (atomic_dec_and_test(&old_rd->refcount))
  5830. kfree(old_rd);
  5831. }
  5832. atomic_inc(&rd->refcount);
  5833. rq->rd = rd;
  5834. cpu_set(rq->cpu, rd->span);
  5835. if (cpu_isset(rq->cpu, cpu_online_map))
  5836. set_rq_online(rq);
  5837. spin_unlock_irqrestore(&rq->lock, flags);
  5838. }
  5839. static void init_rootdomain(struct root_domain *rd)
  5840. {
  5841. memset(rd, 0, sizeof(*rd));
  5842. cpus_clear(rd->span);
  5843. cpus_clear(rd->online);
  5844. cpupri_init(&rd->cpupri);
  5845. }
  5846. static void init_defrootdomain(void)
  5847. {
  5848. init_rootdomain(&def_root_domain);
  5849. atomic_set(&def_root_domain.refcount, 1);
  5850. }
  5851. static struct root_domain *alloc_rootdomain(void)
  5852. {
  5853. struct root_domain *rd;
  5854. rd = kmalloc(sizeof(*rd), GFP_KERNEL);
  5855. if (!rd)
  5856. return NULL;
  5857. init_rootdomain(rd);
  5858. return rd;
  5859. }
  5860. /*
  5861. * Attach the domain 'sd' to 'cpu' as its base domain. Callers must
  5862. * hold the hotplug lock.
  5863. */
  5864. static void
  5865. cpu_attach_domain(struct sched_domain *sd, struct root_domain *rd, int cpu)
  5866. {
  5867. struct rq *rq = cpu_rq(cpu);
  5868. struct sched_domain *tmp;
  5869. /* Remove the sched domains which do not contribute to scheduling. */
  5870. for (tmp = sd; tmp; ) {
  5871. struct sched_domain *parent = tmp->parent;
  5872. if (!parent)
  5873. break;
  5874. if (sd_parent_degenerate(tmp, parent)) {
  5875. tmp->parent = parent->parent;
  5876. if (parent->parent)
  5877. parent->parent->child = tmp;
  5878. } else
  5879. tmp = tmp->parent;
  5880. }
  5881. if (sd && sd_degenerate(sd)) {
  5882. sd = sd->parent;
  5883. if (sd)
  5884. sd->child = NULL;
  5885. }
  5886. sched_domain_debug(sd, cpu);
  5887. rq_attach_root(rq, rd);
  5888. rcu_assign_pointer(rq->sd, sd);
  5889. }
  5890. /* cpus with isolated domains */
  5891. static cpumask_t cpu_isolated_map = CPU_MASK_NONE;
  5892. /* Setup the mask of cpus configured for isolated domains */
  5893. static int __init isolated_cpu_setup(char *str)
  5894. {
  5895. static int __initdata ints[NR_CPUS];
  5896. int i;
  5897. str = get_options(str, ARRAY_SIZE(ints), ints);
  5898. cpus_clear(cpu_isolated_map);
  5899. for (i = 1; i <= ints[0]; i++)
  5900. if (ints[i] < NR_CPUS)
  5901. cpu_set(ints[i], cpu_isolated_map);
  5902. return 1;
  5903. }
  5904. __setup("isolcpus=", isolated_cpu_setup);
  5905. /*
  5906. * init_sched_build_groups takes the cpumask we wish to span, and a pointer
  5907. * to a function which identifies what group(along with sched group) a CPU
  5908. * belongs to. The return value of group_fn must be a >= 0 and < NR_CPUS
  5909. * (due to the fact that we keep track of groups covered with a cpumask_t).
  5910. *
  5911. * init_sched_build_groups will build a circular linked list of the groups
  5912. * covered by the given span, and will set each group's ->cpumask correctly,
  5913. * and ->cpu_power to 0.
  5914. */
  5915. static void
  5916. init_sched_build_groups(const cpumask_t *span, const cpumask_t *cpu_map,
  5917. int (*group_fn)(int cpu, const cpumask_t *cpu_map,
  5918. struct sched_group **sg,
  5919. cpumask_t *tmpmask),
  5920. cpumask_t *covered, cpumask_t *tmpmask)
  5921. {
  5922. struct sched_group *first = NULL, *last = NULL;
  5923. int i;
  5924. cpus_clear(*covered);
  5925. for_each_cpu_mask_nr(i, *span) {
  5926. struct sched_group *sg;
  5927. int group = group_fn(i, cpu_map, &sg, tmpmask);
  5928. int j;
  5929. if (cpu_isset(i, *covered))
  5930. continue;
  5931. cpus_clear(sg->cpumask);
  5932. sg->__cpu_power = 0;
  5933. for_each_cpu_mask_nr(j, *span) {
  5934. if (group_fn(j, cpu_map, NULL, tmpmask) != group)
  5935. continue;
  5936. cpu_set(j, *covered);
  5937. cpu_set(j, sg->cpumask);
  5938. }
  5939. if (!first)
  5940. first = sg;
  5941. if (last)
  5942. last->next = sg;
  5943. last = sg;
  5944. }
  5945. last->next = first;
  5946. }
  5947. #define SD_NODES_PER_DOMAIN 16
  5948. #ifdef CONFIG_NUMA
  5949. /**
  5950. * find_next_best_node - find the next node to include in a sched_domain
  5951. * @node: node whose sched_domain we're building
  5952. * @used_nodes: nodes already in the sched_domain
  5953. *
  5954. * Find the next node to include in a given scheduling domain. Simply
  5955. * finds the closest node not already in the @used_nodes map.
  5956. *
  5957. * Should use nodemask_t.
  5958. */
  5959. static int find_next_best_node(int node, nodemask_t *used_nodes)
  5960. {
  5961. int i, n, val, min_val, best_node = 0;
  5962. min_val = INT_MAX;
  5963. for (i = 0; i < nr_node_ids; i++) {
  5964. /* Start at @node */
  5965. n = (node + i) % nr_node_ids;
  5966. if (!nr_cpus_node(n))
  5967. continue;
  5968. /* Skip already used nodes */
  5969. if (node_isset(n, *used_nodes))
  5970. continue;
  5971. /* Simple min distance search */
  5972. val = node_distance(node, n);
  5973. if (val < min_val) {
  5974. min_val = val;
  5975. best_node = n;
  5976. }
  5977. }
  5978. node_set(best_node, *used_nodes);
  5979. return best_node;
  5980. }
  5981. /**
  5982. * sched_domain_node_span - get a cpumask for a node's sched_domain
  5983. * @node: node whose cpumask we're constructing
  5984. * @span: resulting cpumask
  5985. *
  5986. * Given a node, construct a good cpumask for its sched_domain to span. It
  5987. * should be one that prevents unnecessary balancing, but also spreads tasks
  5988. * out optimally.
  5989. */
  5990. static void sched_domain_node_span(int node, cpumask_t *span)
  5991. {
  5992. nodemask_t used_nodes;
  5993. node_to_cpumask_ptr(nodemask, node);
  5994. int i;
  5995. cpus_clear(*span);
  5996. nodes_clear(used_nodes);
  5997. cpus_or(*span, *span, *nodemask);
  5998. node_set(node, used_nodes);
  5999. for (i = 1; i < SD_NODES_PER_DOMAIN; i++) {
  6000. int next_node = find_next_best_node(node, &used_nodes);
  6001. node_to_cpumask_ptr_next(nodemask, next_node);
  6002. cpus_or(*span, *span, *nodemask);
  6003. }
  6004. }
  6005. #endif /* CONFIG_NUMA */
  6006. int sched_smt_power_savings = 0, sched_mc_power_savings = 0;
  6007. /*
  6008. * SMT sched-domains:
  6009. */
  6010. #ifdef CONFIG_SCHED_SMT
  6011. static DEFINE_PER_CPU(struct sched_domain, cpu_domains);
  6012. static DEFINE_PER_CPU(struct sched_group, sched_group_cpus);
  6013. static int
  6014. cpu_to_cpu_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
  6015. cpumask_t *unused)
  6016. {
  6017. if (sg)
  6018. *sg = &per_cpu(sched_group_cpus, cpu);
  6019. return cpu;
  6020. }
  6021. #endif /* CONFIG_SCHED_SMT */
  6022. /*
  6023. * multi-core sched-domains:
  6024. */
  6025. #ifdef CONFIG_SCHED_MC
  6026. static DEFINE_PER_CPU(struct sched_domain, core_domains);
  6027. static DEFINE_PER_CPU(struct sched_group, sched_group_core);
  6028. #endif /* CONFIG_SCHED_MC */
  6029. #if defined(CONFIG_SCHED_MC) && defined(CONFIG_SCHED_SMT)
  6030. static int
  6031. cpu_to_core_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
  6032. cpumask_t *mask)
  6033. {
  6034. int group;
  6035. *mask = per_cpu(cpu_sibling_map, cpu);
  6036. cpus_and(*mask, *mask, *cpu_map);
  6037. group = first_cpu(*mask);
  6038. if (sg)
  6039. *sg = &per_cpu(sched_group_core, group);
  6040. return group;
  6041. }
  6042. #elif defined(CONFIG_SCHED_MC)
  6043. static int
  6044. cpu_to_core_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
  6045. cpumask_t *unused)
  6046. {
  6047. if (sg)
  6048. *sg = &per_cpu(sched_group_core, cpu);
  6049. return cpu;
  6050. }
  6051. #endif
  6052. static DEFINE_PER_CPU(struct sched_domain, phys_domains);
  6053. static DEFINE_PER_CPU(struct sched_group, sched_group_phys);
  6054. static int
  6055. cpu_to_phys_group(int cpu, const cpumask_t *cpu_map, struct sched_group **sg,
  6056. cpumask_t *mask)
  6057. {
  6058. int group;
  6059. #ifdef CONFIG_SCHED_MC
  6060. *mask = cpu_coregroup_map(cpu);
  6061. cpus_and(*mask, *mask, *cpu_map);
  6062. group = first_cpu(*mask);
  6063. #elif defined(CONFIG_SCHED_SMT)
  6064. *mask = per_cpu(cpu_sibling_map, cpu);
  6065. cpus_and(*mask, *mask, *cpu_map);
  6066. group = first_cpu(*mask);
  6067. #else
  6068. group = cpu;
  6069. #endif
  6070. if (sg)
  6071. *sg = &per_cpu(sched_group_phys, group);
  6072. return group;
  6073. }
  6074. #ifdef CONFIG_NUMA
  6075. /*
  6076. * The init_sched_build_groups can't handle what we want to do with node
  6077. * groups, so roll our own. Now each node has its own list of groups which
  6078. * gets dynamically allocated.
  6079. */
  6080. static DEFINE_PER_CPU(struct sched_domain, node_domains);
  6081. static struct sched_group ***sched_group_nodes_bycpu;
  6082. static DEFINE_PER_CPU(struct sched_domain, allnodes_domains);
  6083. static DEFINE_PER_CPU(struct sched_group, sched_group_allnodes);
  6084. static int cpu_to_allnodes_group(int cpu, const cpumask_t *cpu_map,
  6085. struct sched_group **sg, cpumask_t *nodemask)
  6086. {
  6087. int group;
  6088. *nodemask = node_to_cpumask(cpu_to_node(cpu));
  6089. cpus_and(*nodemask, *nodemask, *cpu_map);
  6090. group = first_cpu(*nodemask);
  6091. if (sg)
  6092. *sg = &per_cpu(sched_group_allnodes, group);
  6093. return group;
  6094. }
  6095. static void init_numa_sched_groups_power(struct sched_group *group_head)
  6096. {
  6097. struct sched_group *sg = group_head;
  6098. int j;
  6099. if (!sg)
  6100. return;
  6101. do {
  6102. for_each_cpu_mask_nr(j, sg->cpumask) {
  6103. struct sched_domain *sd;
  6104. sd = &per_cpu(phys_domains, j);
  6105. if (j != first_cpu(sd->groups->cpumask)) {
  6106. /*
  6107. * Only add "power" once for each
  6108. * physical package.
  6109. */
  6110. continue;
  6111. }
  6112. sg_inc_cpu_power(sg, sd->groups->__cpu_power);
  6113. }
  6114. sg = sg->next;
  6115. } while (sg != group_head);
  6116. }
  6117. #endif /* CONFIG_NUMA */
  6118. #ifdef CONFIG_NUMA
  6119. /* Free memory allocated for various sched_group structures */
  6120. static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
  6121. {
  6122. int cpu, i;
  6123. for_each_cpu_mask_nr(cpu, *cpu_map) {
  6124. struct sched_group **sched_group_nodes
  6125. = sched_group_nodes_bycpu[cpu];
  6126. if (!sched_group_nodes)
  6127. continue;
  6128. for (i = 0; i < nr_node_ids; i++) {
  6129. struct sched_group *oldsg, *sg = sched_group_nodes[i];
  6130. *nodemask = node_to_cpumask(i);
  6131. cpus_and(*nodemask, *nodemask, *cpu_map);
  6132. if (cpus_empty(*nodemask))
  6133. continue;
  6134. if (sg == NULL)
  6135. continue;
  6136. sg = sg->next;
  6137. next_sg:
  6138. oldsg = sg;
  6139. sg = sg->next;
  6140. kfree(oldsg);
  6141. if (oldsg != sched_group_nodes[i])
  6142. goto next_sg;
  6143. }
  6144. kfree(sched_group_nodes);
  6145. sched_group_nodes_bycpu[cpu] = NULL;
  6146. }
  6147. }
  6148. #else /* !CONFIG_NUMA */
  6149. static void free_sched_groups(const cpumask_t *cpu_map, cpumask_t *nodemask)
  6150. {
  6151. }
  6152. #endif /* CONFIG_NUMA */
  6153. /*
  6154. * Initialize sched groups cpu_power.
  6155. *
  6156. * cpu_power indicates the capacity of sched group, which is used while
  6157. * distributing the load between different sched groups in a sched domain.
  6158. * Typically cpu_power for all the groups in a sched domain will be same unless
  6159. * there are asymmetries in the topology. If there are asymmetries, group
  6160. * having more cpu_power will pickup more load compared to the group having
  6161. * less cpu_power.
  6162. *
  6163. * cpu_power will be a multiple of SCHED_LOAD_SCALE. This multiple represents
  6164. * the maximum number of tasks a group can handle in the presence of other idle
  6165. * or lightly loaded groups in the same sched domain.
  6166. */
  6167. static void init_sched_groups_power(int cpu, struct sched_domain *sd)
  6168. {
  6169. struct sched_domain *child;
  6170. struct sched_group *group;
  6171. WARN_ON(!sd || !sd->groups);
  6172. if (cpu != first_cpu(sd->groups->cpumask))
  6173. return;
  6174. child = sd->child;
  6175. sd->groups->__cpu_power = 0;
  6176. /*
  6177. * For perf policy, if the groups in child domain share resources
  6178. * (for example cores sharing some portions of the cache hierarchy
  6179. * or SMT), then set this domain groups cpu_power such that each group
  6180. * can handle only one task, when there are other idle groups in the
  6181. * same sched domain.
  6182. */
  6183. if (!child || (!(sd->flags & SD_POWERSAVINGS_BALANCE) &&
  6184. (child->flags &
  6185. (SD_SHARE_CPUPOWER | SD_SHARE_PKG_RESOURCES)))) {
  6186. sg_inc_cpu_power(sd->groups, SCHED_LOAD_SCALE);
  6187. return;
  6188. }
  6189. /*
  6190. * add cpu_power of each child group to this groups cpu_power
  6191. */
  6192. group = child->groups;
  6193. do {
  6194. sg_inc_cpu_power(sd->groups, group->__cpu_power);
  6195. group = group->next;
  6196. } while (group != child->groups);
  6197. }
  6198. /*
  6199. * Initializers for schedule domains
  6200. * Non-inlined to reduce accumulated stack pressure in build_sched_domains()
  6201. */
  6202. #ifdef CONFIG_SCHED_DEBUG
  6203. # define SD_INIT_NAME(sd, type) sd->name = #type
  6204. #else
  6205. # define SD_INIT_NAME(sd, type) do { } while (0)
  6206. #endif
  6207. #define SD_INIT(sd, type) sd_init_##type(sd)
  6208. #define SD_INIT_FUNC(type) \
  6209. static noinline void sd_init_##type(struct sched_domain *sd) \
  6210. { \
  6211. memset(sd, 0, sizeof(*sd)); \
  6212. *sd = SD_##type##_INIT; \
  6213. sd->level = SD_LV_##type; \
  6214. SD_INIT_NAME(sd, type); \
  6215. }
  6216. SD_INIT_FUNC(CPU)
  6217. #ifdef CONFIG_NUMA
  6218. SD_INIT_FUNC(ALLNODES)
  6219. SD_INIT_FUNC(NODE)
  6220. #endif
  6221. #ifdef CONFIG_SCHED_SMT
  6222. SD_INIT_FUNC(SIBLING)
  6223. #endif
  6224. #ifdef CONFIG_SCHED_MC
  6225. SD_INIT_FUNC(MC)
  6226. #endif
  6227. /*
  6228. * To minimize stack usage kmalloc room for cpumasks and share the
  6229. * space as the usage in build_sched_domains() dictates. Used only
  6230. * if the amount of space is significant.
  6231. */
  6232. struct allmasks {
  6233. cpumask_t tmpmask; /* make this one first */
  6234. union {
  6235. cpumask_t nodemask;
  6236. cpumask_t this_sibling_map;
  6237. cpumask_t this_core_map;
  6238. };
  6239. cpumask_t send_covered;
  6240. #ifdef CONFIG_NUMA
  6241. cpumask_t domainspan;
  6242. cpumask_t covered;
  6243. cpumask_t notcovered;
  6244. #endif
  6245. };
  6246. #if NR_CPUS > 128
  6247. #define SCHED_CPUMASK_ALLOC 1
  6248. #define SCHED_CPUMASK_FREE(v) kfree(v)
  6249. #define SCHED_CPUMASK_DECLARE(v) struct allmasks *v
  6250. #else
  6251. #define SCHED_CPUMASK_ALLOC 0
  6252. #define SCHED_CPUMASK_FREE(v)
  6253. #define SCHED_CPUMASK_DECLARE(v) struct allmasks _v, *v = &_v
  6254. #endif
  6255. #define SCHED_CPUMASK_VAR(v, a) cpumask_t *v = (cpumask_t *) \
  6256. ((unsigned long)(a) + offsetof(struct allmasks, v))
  6257. static int default_relax_domain_level = -1;
  6258. static int __init setup_relax_domain_level(char *str)
  6259. {
  6260. unsigned long val;
  6261. val = simple_strtoul(str, NULL, 0);
  6262. if (val < SD_LV_MAX)
  6263. default_relax_domain_level = val;
  6264. return 1;
  6265. }
  6266. __setup("relax_domain_level=", setup_relax_domain_level);
  6267. static void set_domain_attribute(struct sched_domain *sd,
  6268. struct sched_domain_attr *attr)
  6269. {
  6270. int request;
  6271. if (!attr || attr->relax_domain_level < 0) {
  6272. if (default_relax_domain_level < 0)
  6273. return;
  6274. else
  6275. request = default_relax_domain_level;
  6276. } else
  6277. request = attr->relax_domain_level;
  6278. if (request < sd->level) {
  6279. /* turn off idle balance on this domain */
  6280. sd->flags &= ~(SD_WAKE_IDLE|SD_BALANCE_NEWIDLE);
  6281. } else {
  6282. /* turn on idle balance on this domain */
  6283. sd->flags |= (SD_WAKE_IDLE_FAR|SD_BALANCE_NEWIDLE);
  6284. }
  6285. }
  6286. /*
  6287. * Build sched domains for a given set of cpus and attach the sched domains
  6288. * to the individual cpus
  6289. */
  6290. static int __build_sched_domains(const cpumask_t *cpu_map,
  6291. struct sched_domain_attr *attr)
  6292. {
  6293. int i;
  6294. struct root_domain *rd;
  6295. SCHED_CPUMASK_DECLARE(allmasks);
  6296. cpumask_t *tmpmask;
  6297. #ifdef CONFIG_NUMA
  6298. struct sched_group **sched_group_nodes = NULL;
  6299. int sd_allnodes = 0;
  6300. /*
  6301. * Allocate the per-node list of sched groups
  6302. */
  6303. sched_group_nodes = kcalloc(nr_node_ids, sizeof(struct sched_group *),
  6304. GFP_KERNEL);
  6305. if (!sched_group_nodes) {
  6306. printk(KERN_WARNING "Can not alloc sched group node list\n");
  6307. return -ENOMEM;
  6308. }
  6309. #endif
  6310. rd = alloc_rootdomain();
  6311. if (!rd) {
  6312. printk(KERN_WARNING "Cannot alloc root domain\n");
  6313. #ifdef CONFIG_NUMA
  6314. kfree(sched_group_nodes);
  6315. #endif
  6316. return -ENOMEM;
  6317. }
  6318. #if SCHED_CPUMASK_ALLOC
  6319. /* get space for all scratch cpumask variables */
  6320. allmasks = kmalloc(sizeof(*allmasks), GFP_KERNEL);
  6321. if (!allmasks) {
  6322. printk(KERN_WARNING "Cannot alloc cpumask array\n");
  6323. kfree(rd);
  6324. #ifdef CONFIG_NUMA
  6325. kfree(sched_group_nodes);
  6326. #endif
  6327. return -ENOMEM;
  6328. }
  6329. #endif
  6330. tmpmask = (cpumask_t *)allmasks;
  6331. #ifdef CONFIG_NUMA
  6332. sched_group_nodes_bycpu[first_cpu(*cpu_map)] = sched_group_nodes;
  6333. #endif
  6334. /*
  6335. * Set up domains for cpus specified by the cpu_map.
  6336. */
  6337. for_each_cpu_mask_nr(i, *cpu_map) {
  6338. struct sched_domain *sd = NULL, *p;
  6339. SCHED_CPUMASK_VAR(nodemask, allmasks);
  6340. *nodemask = node_to_cpumask(cpu_to_node(i));
  6341. cpus_and(*nodemask, *nodemask, *cpu_map);
  6342. #ifdef CONFIG_NUMA
  6343. if (cpus_weight(*cpu_map) >
  6344. SD_NODES_PER_DOMAIN*cpus_weight(*nodemask)) {
  6345. sd = &per_cpu(allnodes_domains, i);
  6346. SD_INIT(sd, ALLNODES);
  6347. set_domain_attribute(sd, attr);
  6348. sd->span = *cpu_map;
  6349. cpu_to_allnodes_group(i, cpu_map, &sd->groups, tmpmask);
  6350. p = sd;
  6351. sd_allnodes = 1;
  6352. } else
  6353. p = NULL;
  6354. sd = &per_cpu(node_domains, i);
  6355. SD_INIT(sd, NODE);
  6356. set_domain_attribute(sd, attr);
  6357. sched_domain_node_span(cpu_to_node(i), &sd->span);
  6358. sd->parent = p;
  6359. if (p)
  6360. p->child = sd;
  6361. cpus_and(sd->span, sd->span, *cpu_map);
  6362. #endif
  6363. p = sd;
  6364. sd = &per_cpu(phys_domains, i);
  6365. SD_INIT(sd, CPU);
  6366. set_domain_attribute(sd, attr);
  6367. sd->span = *nodemask;
  6368. sd->parent = p;
  6369. if (p)
  6370. p->child = sd;
  6371. cpu_to_phys_group(i, cpu_map, &sd->groups, tmpmask);
  6372. #ifdef CONFIG_SCHED_MC
  6373. p = sd;
  6374. sd = &per_cpu(core_domains, i);
  6375. SD_INIT(sd, MC);
  6376. set_domain_attribute(sd, attr);
  6377. sd->span = cpu_coregroup_map(i);
  6378. cpus_and(sd->span, sd->span, *cpu_map);
  6379. sd->parent = p;
  6380. p->child = sd;
  6381. cpu_to_core_group(i, cpu_map, &sd->groups, tmpmask);
  6382. #endif
  6383. #ifdef CONFIG_SCHED_SMT
  6384. p = sd;
  6385. sd = &per_cpu(cpu_domains, i);
  6386. SD_INIT(sd, SIBLING);
  6387. set_domain_attribute(sd, attr);
  6388. sd->span = per_cpu(cpu_sibling_map, i);
  6389. cpus_and(sd->span, sd->span, *cpu_map);
  6390. sd->parent = p;
  6391. p->child = sd;
  6392. cpu_to_cpu_group(i, cpu_map, &sd->groups, tmpmask);
  6393. #endif
  6394. }
  6395. #ifdef CONFIG_SCHED_SMT
  6396. /* Set up CPU (sibling) groups */
  6397. for_each_cpu_mask_nr(i, *cpu_map) {
  6398. SCHED_CPUMASK_VAR(this_sibling_map, allmasks);
  6399. SCHED_CPUMASK_VAR(send_covered, allmasks);
  6400. *this_sibling_map = per_cpu(cpu_sibling_map, i);
  6401. cpus_and(*this_sibling_map, *this_sibling_map, *cpu_map);
  6402. if (i != first_cpu(*this_sibling_map))
  6403. continue;
  6404. init_sched_build_groups(this_sibling_map, cpu_map,
  6405. &cpu_to_cpu_group,
  6406. send_covered, tmpmask);
  6407. }
  6408. #endif
  6409. #ifdef CONFIG_SCHED_MC
  6410. /* Set up multi-core groups */
  6411. for_each_cpu_mask_nr(i, *cpu_map) {
  6412. SCHED_CPUMASK_VAR(this_core_map, allmasks);
  6413. SCHED_CPUMASK_VAR(send_covered, allmasks);
  6414. *this_core_map = cpu_coregroup_map(i);
  6415. cpus_and(*this_core_map, *this_core_map, *cpu_map);
  6416. if (i != first_cpu(*this_core_map))
  6417. continue;
  6418. init_sched_build_groups(this_core_map, cpu_map,
  6419. &cpu_to_core_group,
  6420. send_covered, tmpmask);
  6421. }
  6422. #endif
  6423. /* Set up physical groups */
  6424. for (i = 0; i < nr_node_ids; i++) {
  6425. SCHED_CPUMASK_VAR(nodemask, allmasks);
  6426. SCHED_CPUMASK_VAR(send_covered, allmasks);
  6427. *nodemask = node_to_cpumask(i);
  6428. cpus_and(*nodemask, *nodemask, *cpu_map);
  6429. if (cpus_empty(*nodemask))
  6430. continue;
  6431. init_sched_build_groups(nodemask, cpu_map,
  6432. &cpu_to_phys_group,
  6433. send_covered, tmpmask);
  6434. }
  6435. #ifdef CONFIG_NUMA
  6436. /* Set up node groups */
  6437. if (sd_allnodes) {
  6438. SCHED_CPUMASK_VAR(send_covered, allmasks);
  6439. init_sched_build_groups(cpu_map, cpu_map,
  6440. &cpu_to_allnodes_group,
  6441. send_covered, tmpmask);
  6442. }
  6443. for (i = 0; i < nr_node_ids; i++) {
  6444. /* Set up node groups */
  6445. struct sched_group *sg, *prev;
  6446. SCHED_CPUMASK_VAR(nodemask, allmasks);
  6447. SCHED_CPUMASK_VAR(domainspan, allmasks);
  6448. SCHED_CPUMASK_VAR(covered, allmasks);
  6449. int j;
  6450. *nodemask = node_to_cpumask(i);
  6451. cpus_clear(*covered);
  6452. cpus_and(*nodemask, *nodemask, *cpu_map);
  6453. if (cpus_empty(*nodemask)) {
  6454. sched_group_nodes[i] = NULL;
  6455. continue;
  6456. }
  6457. sched_domain_node_span(i, domainspan);
  6458. cpus_and(*domainspan, *domainspan, *cpu_map);
  6459. sg = kmalloc_node(sizeof(struct sched_group), GFP_KERNEL, i);
  6460. if (!sg) {
  6461. printk(KERN_WARNING "Can not alloc domain group for "
  6462. "node %d\n", i);
  6463. goto error;
  6464. }
  6465. sched_group_nodes[i] = sg;
  6466. for_each_cpu_mask_nr(j, *nodemask) {
  6467. struct sched_domain *sd;
  6468. sd = &per_cpu(node_domains, j);
  6469. sd->groups = sg;
  6470. }
  6471. sg->__cpu_power = 0;
  6472. sg->cpumask = *nodemask;
  6473. sg->next = sg;
  6474. cpus_or(*covered, *covered, *nodemask);
  6475. prev = sg;
  6476. for (j = 0; j < nr_node_ids; j++) {
  6477. SCHED_CPUMASK_VAR(notcovered, allmasks);
  6478. int n = (i + j) % nr_node_ids;
  6479. node_to_cpumask_ptr(pnodemask, n);
  6480. cpus_complement(*notcovered, *covered);
  6481. cpus_and(*tmpmask, *notcovered, *cpu_map);
  6482. cpus_and(*tmpmask, *tmpmask, *domainspan);
  6483. if (cpus_empty(*tmpmask))
  6484. break;
  6485. cpus_and(*tmpmask, *tmpmask, *pnodemask);
  6486. if (cpus_empty(*tmpmask))
  6487. continue;
  6488. sg = kmalloc_node(sizeof(struct sched_group),
  6489. GFP_KERNEL, i);
  6490. if (!sg) {
  6491. printk(KERN_WARNING
  6492. "Can not alloc domain group for node %d\n", j);
  6493. goto error;
  6494. }
  6495. sg->__cpu_power = 0;
  6496. sg->cpumask = *tmpmask;
  6497. sg->next = prev->next;
  6498. cpus_or(*covered, *covered, *tmpmask);
  6499. prev->next = sg;
  6500. prev = sg;
  6501. }
  6502. }
  6503. #endif
  6504. /* Calculate CPU power for physical packages and nodes */
  6505. #ifdef CONFIG_SCHED_SMT
  6506. for_each_cpu_mask_nr(i, *cpu_map) {
  6507. struct sched_domain *sd = &per_cpu(cpu_domains, i);
  6508. init_sched_groups_power(i, sd);
  6509. }
  6510. #endif
  6511. #ifdef CONFIG_SCHED_MC
  6512. for_each_cpu_mask_nr(i, *cpu_map) {
  6513. struct sched_domain *sd = &per_cpu(core_domains, i);
  6514. init_sched_groups_power(i, sd);
  6515. }
  6516. #endif
  6517. for_each_cpu_mask_nr(i, *cpu_map) {
  6518. struct sched_domain *sd = &per_cpu(phys_domains, i);
  6519. init_sched_groups_power(i, sd);
  6520. }
  6521. #ifdef CONFIG_NUMA
  6522. for (i = 0; i < nr_node_ids; i++)
  6523. init_numa_sched_groups_power(sched_group_nodes[i]);
  6524. if (sd_allnodes) {
  6525. struct sched_group *sg;
  6526. cpu_to_allnodes_group(first_cpu(*cpu_map), cpu_map, &sg,
  6527. tmpmask);
  6528. init_numa_sched_groups_power(sg);
  6529. }
  6530. #endif
  6531. /* Attach the domains */
  6532. for_each_cpu_mask_nr(i, *cpu_map) {
  6533. struct sched_domain *sd;
  6534. #ifdef CONFIG_SCHED_SMT
  6535. sd = &per_cpu(cpu_domains, i);
  6536. #elif defined(CONFIG_SCHED_MC)
  6537. sd = &per_cpu(core_domains, i);
  6538. #else
  6539. sd = &per_cpu(phys_domains, i);
  6540. #endif
  6541. cpu_attach_domain(sd, rd, i);
  6542. }
  6543. SCHED_CPUMASK_FREE((void *)allmasks);
  6544. return 0;
  6545. #ifdef CONFIG_NUMA
  6546. error:
  6547. free_sched_groups(cpu_map, tmpmask);
  6548. SCHED_CPUMASK_FREE((void *)allmasks);
  6549. kfree(rd);
  6550. return -ENOMEM;
  6551. #endif
  6552. }
  6553. static int build_sched_domains(const cpumask_t *cpu_map)
  6554. {
  6555. return __build_sched_domains(cpu_map, NULL);
  6556. }
  6557. static cpumask_t *doms_cur; /* current sched domains */
  6558. static int ndoms_cur; /* number of sched domains in 'doms_cur' */
  6559. static struct sched_domain_attr *dattr_cur;
  6560. /* attribues of custom domains in 'doms_cur' */
  6561. /*
  6562. * Special case: If a kmalloc of a doms_cur partition (array of
  6563. * cpumask_t) fails, then fallback to a single sched domain,
  6564. * as determined by the single cpumask_t fallback_doms.
  6565. */
  6566. static cpumask_t fallback_doms;
  6567. void __attribute__((weak)) arch_update_cpu_topology(void)
  6568. {
  6569. }
  6570. /*
  6571. * Set up scheduler domains and groups. Callers must hold the hotplug lock.
  6572. * For now this just excludes isolated cpus, but could be used to
  6573. * exclude other special cases in the future.
  6574. */
  6575. static int arch_init_sched_domains(const cpumask_t *cpu_map)
  6576. {
  6577. int err;
  6578. arch_update_cpu_topology();
  6579. ndoms_cur = 1;
  6580. doms_cur = kmalloc(sizeof(cpumask_t), GFP_KERNEL);
  6581. if (!doms_cur)
  6582. doms_cur = &fallback_doms;
  6583. cpus_andnot(*doms_cur, *cpu_map, cpu_isolated_map);
  6584. dattr_cur = NULL;
  6585. err = build_sched_domains(doms_cur);
  6586. register_sched_domain_sysctl();
  6587. return err;
  6588. }
  6589. static void arch_destroy_sched_domains(const cpumask_t *cpu_map,
  6590. cpumask_t *tmpmask)
  6591. {
  6592. free_sched_groups(cpu_map, tmpmask);
  6593. }
  6594. /*
  6595. * Detach sched domains from a group of cpus specified in cpu_map
  6596. * These cpus will now be attached to the NULL domain
  6597. */
  6598. static void detach_destroy_domains(const cpumask_t *cpu_map)
  6599. {
  6600. cpumask_t tmpmask;
  6601. int i;
  6602. unregister_sched_domain_sysctl();
  6603. for_each_cpu_mask_nr(i, *cpu_map)
  6604. cpu_attach_domain(NULL, &def_root_domain, i);
  6605. synchronize_sched();
  6606. arch_destroy_sched_domains(cpu_map, &tmpmask);
  6607. }
  6608. /* handle null as "default" */
  6609. static int dattrs_equal(struct sched_domain_attr *cur, int idx_cur,
  6610. struct sched_domain_attr *new, int idx_new)
  6611. {
  6612. struct sched_domain_attr tmp;
  6613. /* fast path */
  6614. if (!new && !cur)
  6615. return 1;
  6616. tmp = SD_ATTR_INIT;
  6617. return !memcmp(cur ? (cur + idx_cur) : &tmp,
  6618. new ? (new + idx_new) : &tmp,
  6619. sizeof(struct sched_domain_attr));
  6620. }
  6621. /*
  6622. * Partition sched domains as specified by the 'ndoms_new'
  6623. * cpumasks in the array doms_new[] of cpumasks. This compares
  6624. * doms_new[] to the current sched domain partitioning, doms_cur[].
  6625. * It destroys each deleted domain and builds each new domain.
  6626. *
  6627. * 'doms_new' is an array of cpumask_t's of length 'ndoms_new'.
  6628. * The masks don't intersect (don't overlap.) We should setup one
  6629. * sched domain for each mask. CPUs not in any of the cpumasks will
  6630. * not be load balanced. If the same cpumask appears both in the
  6631. * current 'doms_cur' domains and in the new 'doms_new', we can leave
  6632. * it as it is.
  6633. *
  6634. * The passed in 'doms_new' should be kmalloc'd. This routine takes
  6635. * ownership of it and will kfree it when done with it. If the caller
  6636. * failed the kmalloc call, then it can pass in doms_new == NULL,
  6637. * and partition_sched_domains() will fallback to the single partition
  6638. * 'fallback_doms', it also forces the domains to be rebuilt.
  6639. *
  6640. * If doms_new==NULL it will be replaced with cpu_online_map.
  6641. * ndoms_new==0 is a special case for destroying existing domains.
  6642. * It will not create the default domain.
  6643. *
  6644. * Call with hotplug lock held
  6645. */
  6646. void partition_sched_domains(int ndoms_new, cpumask_t *doms_new,
  6647. struct sched_domain_attr *dattr_new)
  6648. {
  6649. int i, j, n;
  6650. mutex_lock(&sched_domains_mutex);
  6651. /* always unregister in case we don't destroy any domains */
  6652. unregister_sched_domain_sysctl();
  6653. n = doms_new ? ndoms_new : 0;
  6654. /* Destroy deleted domains */
  6655. for (i = 0; i < ndoms_cur; i++) {
  6656. for (j = 0; j < n; j++) {
  6657. if (cpus_equal(doms_cur[i], doms_new[j])
  6658. && dattrs_equal(dattr_cur, i, dattr_new, j))
  6659. goto match1;
  6660. }
  6661. /* no match - a current sched domain not in new doms_new[] */
  6662. detach_destroy_domains(doms_cur + i);
  6663. match1:
  6664. ;
  6665. }
  6666. if (doms_new == NULL) {
  6667. ndoms_cur = 0;
  6668. doms_new = &fallback_doms;
  6669. cpus_andnot(doms_new[0], cpu_online_map, cpu_isolated_map);
  6670. dattr_new = NULL;
  6671. }
  6672. /* Build new domains */
  6673. for (i = 0; i < ndoms_new; i++) {
  6674. for (j = 0; j < ndoms_cur; j++) {
  6675. if (cpus_equal(doms_new[i], doms_cur[j])
  6676. && dattrs_equal(dattr_new, i, dattr_cur, j))
  6677. goto match2;
  6678. }
  6679. /* no match - add a new doms_new */
  6680. __build_sched_domains(doms_new + i,
  6681. dattr_new ? dattr_new + i : NULL);
  6682. match2:
  6683. ;
  6684. }
  6685. /* Remember the new sched domains */
  6686. if (doms_cur != &fallback_doms)
  6687. kfree(doms_cur);
  6688. kfree(dattr_cur); /* kfree(NULL) is safe */
  6689. doms_cur = doms_new;
  6690. dattr_cur = dattr_new;
  6691. ndoms_cur = ndoms_new;
  6692. register_sched_domain_sysctl();
  6693. mutex_unlock(&sched_domains_mutex);
  6694. }
  6695. #if defined(CONFIG_SCHED_MC) || defined(CONFIG_SCHED_SMT)
  6696. int arch_reinit_sched_domains(void)
  6697. {
  6698. get_online_cpus();
  6699. /* Destroy domains first to force the rebuild */
  6700. partition_sched_domains(0, NULL, NULL);
  6701. rebuild_sched_domains();
  6702. put_online_cpus();
  6703. return 0;
  6704. }
  6705. static ssize_t sched_power_savings_store(const char *buf, size_t count, int smt)
  6706. {
  6707. int ret;
  6708. if (buf[0] != '0' && buf[0] != '1')
  6709. return -EINVAL;
  6710. if (smt)
  6711. sched_smt_power_savings = (buf[0] == '1');
  6712. else
  6713. sched_mc_power_savings = (buf[0] == '1');
  6714. ret = arch_reinit_sched_domains();
  6715. return ret ? ret : count;
  6716. }
  6717. #ifdef CONFIG_SCHED_MC
  6718. static ssize_t sched_mc_power_savings_show(struct sysdev_class *class,
  6719. char *page)
  6720. {
  6721. return sprintf(page, "%u\n", sched_mc_power_savings);
  6722. }
  6723. static ssize_t sched_mc_power_savings_store(struct sysdev_class *class,
  6724. const char *buf, size_t count)
  6725. {
  6726. return sched_power_savings_store(buf, count, 0);
  6727. }
  6728. static SYSDEV_CLASS_ATTR(sched_mc_power_savings, 0644,
  6729. sched_mc_power_savings_show,
  6730. sched_mc_power_savings_store);
  6731. #endif
  6732. #ifdef CONFIG_SCHED_SMT
  6733. static ssize_t sched_smt_power_savings_show(struct sysdev_class *dev,
  6734. char *page)
  6735. {
  6736. return sprintf(page, "%u\n", sched_smt_power_savings);
  6737. }
  6738. static ssize_t sched_smt_power_savings_store(struct sysdev_class *dev,
  6739. const char *buf, size_t count)
  6740. {
  6741. return sched_power_savings_store(buf, count, 1);
  6742. }
  6743. static SYSDEV_CLASS_ATTR(sched_smt_power_savings, 0644,
  6744. sched_smt_power_savings_show,
  6745. sched_smt_power_savings_store);
  6746. #endif
  6747. int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls)
  6748. {
  6749. int err = 0;
  6750. #ifdef CONFIG_SCHED_SMT
  6751. if (smt_capable())
  6752. err = sysfs_create_file(&cls->kset.kobj,
  6753. &attr_sched_smt_power_savings.attr);
  6754. #endif
  6755. #ifdef CONFIG_SCHED_MC
  6756. if (!err && mc_capable())
  6757. err = sysfs_create_file(&cls->kset.kobj,
  6758. &attr_sched_mc_power_savings.attr);
  6759. #endif
  6760. return err;
  6761. }
  6762. #endif /* CONFIG_SCHED_MC || CONFIG_SCHED_SMT */
  6763. #ifndef CONFIG_CPUSETS
  6764. /*
  6765. * Add online and remove offline CPUs from the scheduler domains.
  6766. * When cpusets are enabled they take over this function.
  6767. */
  6768. static int update_sched_domains(struct notifier_block *nfb,
  6769. unsigned long action, void *hcpu)
  6770. {
  6771. switch (action) {
  6772. case CPU_ONLINE:
  6773. case CPU_ONLINE_FROZEN:
  6774. case CPU_DEAD:
  6775. case CPU_DEAD_FROZEN:
  6776. partition_sched_domains(1, NULL, NULL);
  6777. return NOTIFY_OK;
  6778. default:
  6779. return NOTIFY_DONE;
  6780. }
  6781. }
  6782. #endif
  6783. static int update_runtime(struct notifier_block *nfb,
  6784. unsigned long action, void *hcpu)
  6785. {
  6786. int cpu = (int)(long)hcpu;
  6787. switch (action) {
  6788. case CPU_DOWN_PREPARE:
  6789. case CPU_DOWN_PREPARE_FROZEN:
  6790. disable_runtime(cpu_rq(cpu));
  6791. return NOTIFY_OK;
  6792. case CPU_DOWN_FAILED:
  6793. case CPU_DOWN_FAILED_FROZEN:
  6794. case CPU_ONLINE:
  6795. case CPU_ONLINE_FROZEN:
  6796. enable_runtime(cpu_rq(cpu));
  6797. return NOTIFY_OK;
  6798. default:
  6799. return NOTIFY_DONE;
  6800. }
  6801. }
  6802. void __init sched_init_smp(void)
  6803. {
  6804. cpumask_t non_isolated_cpus;
  6805. #if defined(CONFIG_NUMA)
  6806. sched_group_nodes_bycpu = kzalloc(nr_cpu_ids * sizeof(void **),
  6807. GFP_KERNEL);
  6808. BUG_ON(sched_group_nodes_bycpu == NULL);
  6809. #endif
  6810. get_online_cpus();
  6811. mutex_lock(&sched_domains_mutex);
  6812. arch_init_sched_domains(&cpu_online_map);
  6813. cpus_andnot(non_isolated_cpus, cpu_possible_map, cpu_isolated_map);
  6814. if (cpus_empty(non_isolated_cpus))
  6815. cpu_set(smp_processor_id(), non_isolated_cpus);
  6816. mutex_unlock(&sched_domains_mutex);
  6817. put_online_cpus();
  6818. #ifndef CONFIG_CPUSETS
  6819. /* XXX: Theoretical race here - CPU may be hotplugged now */
  6820. hotcpu_notifier(update_sched_domains, 0);
  6821. #endif
  6822. /* RT runtime code needs to handle some hotplug events */
  6823. hotcpu_notifier(update_runtime, 0);
  6824. init_hrtick();
  6825. /* Move init over to a non-isolated CPU */
  6826. if (set_cpus_allowed_ptr(current, &non_isolated_cpus) < 0)
  6827. BUG();
  6828. sched_init_granularity();
  6829. }
  6830. #else
  6831. void __init sched_init_smp(void)
  6832. {
  6833. sched_init_granularity();
  6834. }
  6835. #endif /* CONFIG_SMP */
  6836. int in_sched_functions(unsigned long addr)
  6837. {
  6838. return in_lock_functions(addr) ||
  6839. (addr >= (unsigned long)__sched_text_start
  6840. && addr < (unsigned long)__sched_text_end);
  6841. }
  6842. static void init_cfs_rq(struct cfs_rq *cfs_rq, struct rq *rq)
  6843. {
  6844. cfs_rq->tasks_timeline = RB_ROOT;
  6845. INIT_LIST_HEAD(&cfs_rq->tasks);
  6846. #ifdef CONFIG_FAIR_GROUP_SCHED
  6847. cfs_rq->rq = rq;
  6848. #endif
  6849. cfs_rq->min_vruntime = (u64)(-(1LL << 20));
  6850. }
  6851. static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
  6852. {
  6853. struct rt_prio_array *array;
  6854. int i;
  6855. array = &rt_rq->active;
  6856. for (i = 0; i < MAX_RT_PRIO; i++) {
  6857. INIT_LIST_HEAD(array->queue + i);
  6858. __clear_bit(i, array->bitmap);
  6859. }
  6860. /* delimiter for bitsearch: */
  6861. __set_bit(MAX_RT_PRIO, array->bitmap);
  6862. #if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
  6863. rt_rq->highest_prio = MAX_RT_PRIO;
  6864. #endif
  6865. #ifdef CONFIG_SMP
  6866. rt_rq->rt_nr_migratory = 0;
  6867. rt_rq->overloaded = 0;
  6868. #endif
  6869. rt_rq->rt_time = 0;
  6870. rt_rq->rt_throttled = 0;
  6871. rt_rq->rt_runtime = 0;
  6872. spin_lock_init(&rt_rq->rt_runtime_lock);
  6873. #ifdef CONFIG_RT_GROUP_SCHED
  6874. rt_rq->rt_nr_boosted = 0;
  6875. rt_rq->rq = rq;
  6876. #endif
  6877. }
  6878. #ifdef CONFIG_FAIR_GROUP_SCHED
  6879. static void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
  6880. struct sched_entity *se, int cpu, int add,
  6881. struct sched_entity *parent)
  6882. {
  6883. struct rq *rq = cpu_rq(cpu);
  6884. tg->cfs_rq[cpu] = cfs_rq;
  6885. init_cfs_rq(cfs_rq, rq);
  6886. cfs_rq->tg = tg;
  6887. if (add)
  6888. list_add(&cfs_rq->leaf_cfs_rq_list, &rq->leaf_cfs_rq_list);
  6889. tg->se[cpu] = se;
  6890. /* se could be NULL for init_task_group */
  6891. if (!se)
  6892. return;
  6893. if (!parent)
  6894. se->cfs_rq = &rq->cfs;
  6895. else
  6896. se->cfs_rq = parent->my_q;
  6897. se->my_q = cfs_rq;
  6898. se->load.weight = tg->shares;
  6899. se->load.inv_weight = 0;
  6900. se->parent = parent;
  6901. }
  6902. #endif
  6903. #ifdef CONFIG_RT_GROUP_SCHED
  6904. static void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
  6905. struct sched_rt_entity *rt_se, int cpu, int add,
  6906. struct sched_rt_entity *parent)
  6907. {
  6908. struct rq *rq = cpu_rq(cpu);
  6909. tg->rt_rq[cpu] = rt_rq;
  6910. init_rt_rq(rt_rq, rq);
  6911. rt_rq->tg = tg;
  6912. rt_rq->rt_se = rt_se;
  6913. rt_rq->rt_runtime = tg->rt_bandwidth.rt_runtime;
  6914. if (add)
  6915. list_add(&rt_rq->leaf_rt_rq_list, &rq->leaf_rt_rq_list);
  6916. tg->rt_se[cpu] = rt_se;
  6917. if (!rt_se)
  6918. return;
  6919. if (!parent)
  6920. rt_se->rt_rq = &rq->rt;
  6921. else
  6922. rt_se->rt_rq = parent->my_q;
  6923. rt_se->my_q = rt_rq;
  6924. rt_se->parent = parent;
  6925. INIT_LIST_HEAD(&rt_se->run_list);
  6926. }
  6927. #endif
  6928. void __init sched_init(void)
  6929. {
  6930. int i, j;
  6931. unsigned long alloc_size = 0, ptr;
  6932. #ifdef CONFIG_FAIR_GROUP_SCHED
  6933. alloc_size += 2 * nr_cpu_ids * sizeof(void **);
  6934. #endif
  6935. #ifdef CONFIG_RT_GROUP_SCHED
  6936. alloc_size += 2 * nr_cpu_ids * sizeof(void **);
  6937. #endif
  6938. #ifdef CONFIG_USER_SCHED
  6939. alloc_size *= 2;
  6940. #endif
  6941. /*
  6942. * As sched_init() is called before page_alloc is setup,
  6943. * we use alloc_bootmem().
  6944. */
  6945. if (alloc_size) {
  6946. ptr = (unsigned long)alloc_bootmem(alloc_size);
  6947. #ifdef CONFIG_FAIR_GROUP_SCHED
  6948. init_task_group.se = (struct sched_entity **)ptr;
  6949. ptr += nr_cpu_ids * sizeof(void **);
  6950. init_task_group.cfs_rq = (struct cfs_rq **)ptr;
  6951. ptr += nr_cpu_ids * sizeof(void **);
  6952. #ifdef CONFIG_USER_SCHED
  6953. root_task_group.se = (struct sched_entity **)ptr;
  6954. ptr += nr_cpu_ids * sizeof(void **);
  6955. root_task_group.cfs_rq = (struct cfs_rq **)ptr;
  6956. ptr += nr_cpu_ids * sizeof(void **);
  6957. #endif /* CONFIG_USER_SCHED */
  6958. #endif /* CONFIG_FAIR_GROUP_SCHED */
  6959. #ifdef CONFIG_RT_GROUP_SCHED
  6960. init_task_group.rt_se = (struct sched_rt_entity **)ptr;
  6961. ptr += nr_cpu_ids * sizeof(void **);
  6962. init_task_group.rt_rq = (struct rt_rq **)ptr;
  6963. ptr += nr_cpu_ids * sizeof(void **);
  6964. #ifdef CONFIG_USER_SCHED
  6965. root_task_group.rt_se = (struct sched_rt_entity **)ptr;
  6966. ptr += nr_cpu_ids * sizeof(void **);
  6967. root_task_group.rt_rq = (struct rt_rq **)ptr;
  6968. ptr += nr_cpu_ids * sizeof(void **);
  6969. #endif /* CONFIG_USER_SCHED */
  6970. #endif /* CONFIG_RT_GROUP_SCHED */
  6971. }
  6972. #ifdef CONFIG_SMP
  6973. init_defrootdomain();
  6974. #endif
  6975. init_rt_bandwidth(&def_rt_bandwidth,
  6976. global_rt_period(), global_rt_runtime());
  6977. #ifdef CONFIG_RT_GROUP_SCHED
  6978. init_rt_bandwidth(&init_task_group.rt_bandwidth,
  6979. global_rt_period(), global_rt_runtime());
  6980. #ifdef CONFIG_USER_SCHED
  6981. init_rt_bandwidth(&root_task_group.rt_bandwidth,
  6982. global_rt_period(), RUNTIME_INF);
  6983. #endif /* CONFIG_USER_SCHED */
  6984. #endif /* CONFIG_RT_GROUP_SCHED */
  6985. #ifdef CONFIG_GROUP_SCHED
  6986. list_add(&init_task_group.list, &task_groups);
  6987. INIT_LIST_HEAD(&init_task_group.children);
  6988. #ifdef CONFIG_USER_SCHED
  6989. INIT_LIST_HEAD(&root_task_group.children);
  6990. init_task_group.parent = &root_task_group;
  6991. list_add(&init_task_group.siblings, &root_task_group.children);
  6992. #endif /* CONFIG_USER_SCHED */
  6993. #endif /* CONFIG_GROUP_SCHED */
  6994. for_each_possible_cpu(i) {
  6995. struct rq *rq;
  6996. rq = cpu_rq(i);
  6997. spin_lock_init(&rq->lock);
  6998. rq->nr_running = 0;
  6999. init_cfs_rq(&rq->cfs, rq);
  7000. init_rt_rq(&rq->rt, rq);
  7001. #ifdef CONFIG_FAIR_GROUP_SCHED
  7002. init_task_group.shares = init_task_group_load;
  7003. INIT_LIST_HEAD(&rq->leaf_cfs_rq_list);
  7004. #ifdef CONFIG_CGROUP_SCHED
  7005. /*
  7006. * How much cpu bandwidth does init_task_group get?
  7007. *
  7008. * In case of task-groups formed thr' the cgroup filesystem, it
  7009. * gets 100% of the cpu resources in the system. This overall
  7010. * system cpu resource is divided among the tasks of
  7011. * init_task_group and its child task-groups in a fair manner,
  7012. * based on each entity's (task or task-group's) weight
  7013. * (se->load.weight).
  7014. *
  7015. * In other words, if init_task_group has 10 tasks of weight
  7016. * 1024) and two child groups A0 and A1 (of weight 1024 each),
  7017. * then A0's share of the cpu resource is:
  7018. *
  7019. * A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
  7020. *
  7021. * We achieve this by letting init_task_group's tasks sit
  7022. * directly in rq->cfs (i.e init_task_group->se[] = NULL).
  7023. */
  7024. init_tg_cfs_entry(&init_task_group, &rq->cfs, NULL, i, 1, NULL);
  7025. #elif defined CONFIG_USER_SCHED
  7026. root_task_group.shares = NICE_0_LOAD;
  7027. init_tg_cfs_entry(&root_task_group, &rq->cfs, NULL, i, 0, NULL);
  7028. /*
  7029. * In case of task-groups formed thr' the user id of tasks,
  7030. * init_task_group represents tasks belonging to root user.
  7031. * Hence it forms a sibling of all subsequent groups formed.
  7032. * In this case, init_task_group gets only a fraction of overall
  7033. * system cpu resource, based on the weight assigned to root
  7034. * user's cpu share (INIT_TASK_GROUP_LOAD). This is accomplished
  7035. * by letting tasks of init_task_group sit in a separate cfs_rq
  7036. * (init_cfs_rq) and having one entity represent this group of
  7037. * tasks in rq->cfs (i.e init_task_group->se[] != NULL).
  7038. */
  7039. init_tg_cfs_entry(&init_task_group,
  7040. &per_cpu(init_cfs_rq, i),
  7041. &per_cpu(init_sched_entity, i), i, 1,
  7042. root_task_group.se[i]);
  7043. #endif
  7044. #endif /* CONFIG_FAIR_GROUP_SCHED */
  7045. rq->rt.rt_runtime = def_rt_bandwidth.rt_runtime;
  7046. #ifdef CONFIG_RT_GROUP_SCHED
  7047. INIT_LIST_HEAD(&rq->leaf_rt_rq_list);
  7048. #ifdef CONFIG_CGROUP_SCHED
  7049. init_tg_rt_entry(&init_task_group, &rq->rt, NULL, i, 1, NULL);
  7050. #elif defined CONFIG_USER_SCHED
  7051. init_tg_rt_entry(&root_task_group, &rq->rt, NULL, i, 0, NULL);
  7052. init_tg_rt_entry(&init_task_group,
  7053. &per_cpu(init_rt_rq, i),
  7054. &per_cpu(init_sched_rt_entity, i), i, 1,
  7055. root_task_group.rt_se[i]);
  7056. #endif
  7057. #endif
  7058. for (j = 0; j < CPU_LOAD_IDX_MAX; j++)
  7059. rq->cpu_load[j] = 0;
  7060. #ifdef CONFIG_SMP
  7061. rq->sd = NULL;
  7062. rq->rd = NULL;
  7063. rq->active_balance = 0;
  7064. rq->next_balance = jiffies;
  7065. rq->push_cpu = 0;
  7066. rq->cpu = i;
  7067. rq->online = 0;
  7068. rq->migration_thread = NULL;
  7069. INIT_LIST_HEAD(&rq->migration_queue);
  7070. rq_attach_root(rq, &def_root_domain);
  7071. #endif
  7072. init_rq_hrtick(rq);
  7073. atomic_set(&rq->nr_iowait, 0);
  7074. }
  7075. set_load_weight(&init_task);
  7076. #ifdef CONFIG_PREEMPT_NOTIFIERS
  7077. INIT_HLIST_HEAD(&init_task.preempt_notifiers);
  7078. #endif
  7079. #ifdef CONFIG_SMP
  7080. open_softirq(SCHED_SOFTIRQ, run_rebalance_domains);
  7081. #endif
  7082. #ifdef CONFIG_RT_MUTEXES
  7083. plist_head_init(&init_task.pi_waiters, &init_task.pi_lock);
  7084. #endif
  7085. /*
  7086. * The boot idle thread does lazy MMU switching as well:
  7087. */
  7088. atomic_inc(&init_mm.mm_count);
  7089. enter_lazy_tlb(&init_mm, current);
  7090. /*
  7091. * Make us the idle thread. Technically, schedule() should not be
  7092. * called from this thread, however somewhere below it might be,
  7093. * but because we are the idle thread, we just pick up running again
  7094. * when this runqueue becomes "idle".
  7095. */
  7096. init_idle(current, smp_processor_id());
  7097. /*
  7098. * During early bootup we pretend to be a normal task:
  7099. */
  7100. current->sched_class = &fair_sched_class;
  7101. scheduler_running = 1;
  7102. }
  7103. #ifdef CONFIG_DEBUG_SPINLOCK_SLEEP
  7104. void __might_sleep(char *file, int line)
  7105. {
  7106. #ifdef in_atomic
  7107. static unsigned long prev_jiffy; /* ratelimiting */
  7108. if ((!in_atomic() && !irqs_disabled()) ||
  7109. system_state != SYSTEM_RUNNING || oops_in_progress)
  7110. return;
  7111. if (time_before(jiffies, prev_jiffy + HZ) && prev_jiffy)
  7112. return;
  7113. prev_jiffy = jiffies;
  7114. printk(KERN_ERR
  7115. "BUG: sleeping function called from invalid context at %s:%d\n",
  7116. file, line);
  7117. printk(KERN_ERR
  7118. "in_atomic(): %d, irqs_disabled(): %d, pid: %d, name: %s\n",
  7119. in_atomic(), irqs_disabled(),
  7120. current->pid, current->comm);
  7121. debug_show_held_locks(current);
  7122. if (irqs_disabled())
  7123. print_irqtrace_events(current);
  7124. dump_stack();
  7125. #endif
  7126. }
  7127. EXPORT_SYMBOL(__might_sleep);
  7128. #endif
  7129. #ifdef CONFIG_MAGIC_SYSRQ
  7130. static void normalize_task(struct rq *rq, struct task_struct *p)
  7131. {
  7132. int on_rq;
  7133. update_rq_clock(rq);
  7134. on_rq = p->se.on_rq;
  7135. if (on_rq)
  7136. deactivate_task(rq, p, 0);
  7137. __setscheduler(rq, p, SCHED_NORMAL, 0);
  7138. if (on_rq) {
  7139. activate_task(rq, p, 0);
  7140. resched_task(rq->curr);
  7141. }
  7142. }
  7143. void normalize_rt_tasks(void)
  7144. {
  7145. struct task_struct *g, *p;
  7146. unsigned long flags;
  7147. struct rq *rq;
  7148. read_lock_irqsave(&tasklist_lock, flags);
  7149. do_each_thread(g, p) {
  7150. /*
  7151. * Only normalize user tasks:
  7152. */
  7153. if (!p->mm)
  7154. continue;
  7155. p->se.exec_start = 0;
  7156. #ifdef CONFIG_SCHEDSTATS
  7157. p->se.wait_start = 0;
  7158. p->se.sleep_start = 0;
  7159. p->se.block_start = 0;
  7160. #endif
  7161. if (!rt_task(p)) {
  7162. /*
  7163. * Renice negative nice level userspace
  7164. * tasks back to 0:
  7165. */
  7166. if (TASK_NICE(p) < 0 && p->mm)
  7167. set_user_nice(p, 0);
  7168. continue;
  7169. }
  7170. spin_lock(&p->pi_lock);
  7171. rq = __task_rq_lock(p);
  7172. normalize_task(rq, p);
  7173. __task_rq_unlock(rq);
  7174. spin_unlock(&p->pi_lock);
  7175. } while_each_thread(g, p);
  7176. read_unlock_irqrestore(&tasklist_lock, flags);
  7177. }
  7178. #endif /* CONFIG_MAGIC_SYSRQ */
  7179. #ifdef CONFIG_IA64
  7180. /*
  7181. * These functions are only useful for the IA64 MCA handling.
  7182. *
  7183. * They can only be called when the whole system has been
  7184. * stopped - every CPU needs to be quiescent, and no scheduling
  7185. * activity can take place. Using them for anything else would
  7186. * be a serious bug, and as a result, they aren't even visible
  7187. * under any other configuration.
  7188. */
  7189. /**
  7190. * curr_task - return the current task for a given cpu.
  7191. * @cpu: the processor in question.
  7192. *
  7193. * ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
  7194. */
  7195. struct task_struct *curr_task(int cpu)
  7196. {
  7197. return cpu_curr(cpu);
  7198. }
  7199. /**
  7200. * set_curr_task - set the current task for a given cpu.
  7201. * @cpu: the processor in question.
  7202. * @p: the task pointer to set.
  7203. *
  7204. * Description: This function must only be used when non-maskable interrupts
  7205. * are serviced on a separate stack. It allows the architecture to switch the
  7206. * notion of the current task on a cpu in a non-blocking manner. This function
  7207. * must be called with all CPU's synchronized, and interrupts disabled, the
  7208. * and caller must save the original value of the current task (see
  7209. * curr_task() above) and restore that value before reenabling interrupts and
  7210. * re-starting the system.
  7211. *
  7212. * ONLY VALID WHEN THE WHOLE SYSTEM IS STOPPED!
  7213. */
  7214. void set_curr_task(int cpu, struct task_struct *p)
  7215. {
  7216. cpu_curr(cpu) = p;
  7217. }
  7218. #endif
  7219. #ifdef CONFIG_FAIR_GROUP_SCHED
  7220. static void free_fair_sched_group(struct task_group *tg)
  7221. {
  7222. int i;
  7223. for_each_possible_cpu(i) {
  7224. if (tg->cfs_rq)
  7225. kfree(tg->cfs_rq[i]);
  7226. if (tg->se)
  7227. kfree(tg->se[i]);
  7228. }
  7229. kfree(tg->cfs_rq);
  7230. kfree(tg->se);
  7231. }
  7232. static
  7233. int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
  7234. {
  7235. struct cfs_rq *cfs_rq;
  7236. struct sched_entity *se, *parent_se;
  7237. struct rq *rq;
  7238. int i;
  7239. tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);
  7240. if (!tg->cfs_rq)
  7241. goto err;
  7242. tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL);
  7243. if (!tg->se)
  7244. goto err;
  7245. tg->shares = NICE_0_LOAD;
  7246. for_each_possible_cpu(i) {
  7247. rq = cpu_rq(i);
  7248. cfs_rq = kmalloc_node(sizeof(struct cfs_rq),
  7249. GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
  7250. if (!cfs_rq)
  7251. goto err;
  7252. se = kmalloc_node(sizeof(struct sched_entity),
  7253. GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
  7254. if (!se)
  7255. goto err;
  7256. parent_se = parent ? parent->se[i] : NULL;
  7257. init_tg_cfs_entry(tg, cfs_rq, se, i, 0, parent_se);
  7258. }
  7259. return 1;
  7260. err:
  7261. return 0;
  7262. }
  7263. static inline void register_fair_sched_group(struct task_group *tg, int cpu)
  7264. {
  7265. list_add_rcu(&tg->cfs_rq[cpu]->leaf_cfs_rq_list,
  7266. &cpu_rq(cpu)->leaf_cfs_rq_list);
  7267. }
  7268. static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
  7269. {
  7270. list_del_rcu(&tg->cfs_rq[cpu]->leaf_cfs_rq_list);
  7271. }
  7272. #else /* !CONFG_FAIR_GROUP_SCHED */
  7273. static inline void free_fair_sched_group(struct task_group *tg)
  7274. {
  7275. }
  7276. static inline
  7277. int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
  7278. {
  7279. return 1;
  7280. }
  7281. static inline void register_fair_sched_group(struct task_group *tg, int cpu)
  7282. {
  7283. }
  7284. static inline void unregister_fair_sched_group(struct task_group *tg, int cpu)
  7285. {
  7286. }
  7287. #endif /* CONFIG_FAIR_GROUP_SCHED */
  7288. #ifdef CONFIG_RT_GROUP_SCHED
  7289. static void free_rt_sched_group(struct task_group *tg)
  7290. {
  7291. int i;
  7292. destroy_rt_bandwidth(&tg->rt_bandwidth);
  7293. for_each_possible_cpu(i) {
  7294. if (tg->rt_rq)
  7295. kfree(tg->rt_rq[i]);
  7296. if (tg->rt_se)
  7297. kfree(tg->rt_se[i]);
  7298. }
  7299. kfree(tg->rt_rq);
  7300. kfree(tg->rt_se);
  7301. }
  7302. static
  7303. int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
  7304. {
  7305. struct rt_rq *rt_rq;
  7306. struct sched_rt_entity *rt_se, *parent_se;
  7307. struct rq *rq;
  7308. int i;
  7309. tg->rt_rq = kzalloc(sizeof(rt_rq) * nr_cpu_ids, GFP_KERNEL);
  7310. if (!tg->rt_rq)
  7311. goto err;
  7312. tg->rt_se = kzalloc(sizeof(rt_se) * nr_cpu_ids, GFP_KERNEL);
  7313. if (!tg->rt_se)
  7314. goto err;
  7315. init_rt_bandwidth(&tg->rt_bandwidth,
  7316. ktime_to_ns(def_rt_bandwidth.rt_period), 0);
  7317. for_each_possible_cpu(i) {
  7318. rq = cpu_rq(i);
  7319. rt_rq = kmalloc_node(sizeof(struct rt_rq),
  7320. GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
  7321. if (!rt_rq)
  7322. goto err;
  7323. rt_se = kmalloc_node(sizeof(struct sched_rt_entity),
  7324. GFP_KERNEL|__GFP_ZERO, cpu_to_node(i));
  7325. if (!rt_se)
  7326. goto err;
  7327. parent_se = parent ? parent->rt_se[i] : NULL;
  7328. init_tg_rt_entry(tg, rt_rq, rt_se, i, 0, parent_se);
  7329. }
  7330. return 1;
  7331. err:
  7332. return 0;
  7333. }
  7334. static inline void register_rt_sched_group(struct task_group *tg, int cpu)
  7335. {
  7336. list_add_rcu(&tg->rt_rq[cpu]->leaf_rt_rq_list,
  7337. &cpu_rq(cpu)->leaf_rt_rq_list);
  7338. }
  7339. static inline void unregister_rt_sched_group(struct task_group *tg, int cpu)
  7340. {
  7341. list_del_rcu(&tg->rt_rq[cpu]->leaf_rt_rq_list);
  7342. }
  7343. #else /* !CONFIG_RT_GROUP_SCHED */
  7344. static inline void free_rt_sched_group(struct task_group *tg)
  7345. {
  7346. }
  7347. static inline
  7348. int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent)
  7349. {
  7350. return 1;
  7351. }
  7352. static inline void register_rt_sched_group(struct task_group *tg, int cpu)
  7353. {
  7354. }
  7355. static inline void unregister_rt_sched_group(struct task_group *tg, int cpu)
  7356. {
  7357. }
  7358. #endif /* CONFIG_RT_GROUP_SCHED */
  7359. #ifdef CONFIG_GROUP_SCHED
  7360. static void free_sched_group(struct task_group *tg)
  7361. {
  7362. free_fair_sched_group(tg);
  7363. free_rt_sched_group(tg);
  7364. kfree(tg);
  7365. }
  7366. /* allocate runqueue etc for a new task group */
  7367. struct task_group *sched_create_group(struct task_group *parent)
  7368. {
  7369. struct task_group *tg;
  7370. unsigned long flags;
  7371. int i;
  7372. tg = kzalloc(sizeof(*tg), GFP_KERNEL);
  7373. if (!tg)
  7374. return ERR_PTR(-ENOMEM);
  7375. if (!alloc_fair_sched_group(tg, parent))
  7376. goto err;
  7377. if (!alloc_rt_sched_group(tg, parent))
  7378. goto err;
  7379. spin_lock_irqsave(&task_group_lock, flags);
  7380. for_each_possible_cpu(i) {
  7381. register_fair_sched_group(tg, i);
  7382. register_rt_sched_group(tg, i);
  7383. }
  7384. list_add_rcu(&tg->list, &task_groups);
  7385. WARN_ON(!parent); /* root should already exist */
  7386. tg->parent = parent;
  7387. INIT_LIST_HEAD(&tg->children);
  7388. list_add_rcu(&tg->siblings, &parent->children);
  7389. spin_unlock_irqrestore(&task_group_lock, flags);
  7390. return tg;
  7391. err:
  7392. free_sched_group(tg);
  7393. return ERR_PTR(-ENOMEM);
  7394. }
  7395. /* rcu callback to free various structures associated with a task group */
  7396. static void free_sched_group_rcu(struct rcu_head *rhp)
  7397. {
  7398. /* now it should be safe to free those cfs_rqs */
  7399. free_sched_group(container_of(rhp, struct task_group, rcu));
  7400. }
  7401. /* Destroy runqueue etc associated with a task group */
  7402. void sched_destroy_group(struct task_group *tg)
  7403. {
  7404. unsigned long flags;
  7405. int i;
  7406. spin_lock_irqsave(&task_group_lock, flags);
  7407. for_each_possible_cpu(i) {
  7408. unregister_fair_sched_group(tg, i);
  7409. unregister_rt_sched_group(tg, i);
  7410. }
  7411. list_del_rcu(&tg->list);
  7412. list_del_rcu(&tg->siblings);
  7413. spin_unlock_irqrestore(&task_group_lock, flags);
  7414. /* wait for possible concurrent references to cfs_rqs complete */
  7415. call_rcu(&tg->rcu, free_sched_group_rcu);
  7416. }
  7417. /* change task's runqueue when it moves between groups.
  7418. * The caller of this function should have put the task in its new group
  7419. * by now. This function just updates tsk->se.cfs_rq and tsk->se.parent to
  7420. * reflect its new group.
  7421. */
  7422. void sched_move_task(struct task_struct *tsk)
  7423. {
  7424. int on_rq, running;
  7425. unsigned long flags;
  7426. struct rq *rq;
  7427. rq = task_rq_lock(tsk, &flags);
  7428. update_rq_clock(rq);
  7429. running = task_current(rq, tsk);
  7430. on_rq = tsk->se.on_rq;
  7431. if (on_rq)
  7432. dequeue_task(rq, tsk, 0);
  7433. if (unlikely(running))
  7434. tsk->sched_class->put_prev_task(rq, tsk);
  7435. set_task_rq(tsk, task_cpu(tsk));
  7436. #ifdef CONFIG_FAIR_GROUP_SCHED
  7437. if (tsk->sched_class->moved_group)
  7438. tsk->sched_class->moved_group(tsk);
  7439. #endif
  7440. if (unlikely(running))
  7441. tsk->sched_class->set_curr_task(rq);
  7442. if (on_rq)
  7443. enqueue_task(rq, tsk, 0);
  7444. task_rq_unlock(rq, &flags);
  7445. }
  7446. #endif /* CONFIG_GROUP_SCHED */
  7447. #ifdef CONFIG_FAIR_GROUP_SCHED
  7448. static void __set_se_shares(struct sched_entity *se, unsigned long shares)
  7449. {
  7450. struct cfs_rq *cfs_rq = se->cfs_rq;
  7451. int on_rq;
  7452. on_rq = se->on_rq;
  7453. if (on_rq)
  7454. dequeue_entity(cfs_rq, se, 0);
  7455. se->load.weight = shares;
  7456. se->load.inv_weight = 0;
  7457. if (on_rq)
  7458. enqueue_entity(cfs_rq, se, 0);
  7459. }
  7460. static void set_se_shares(struct sched_entity *se, unsigned long shares)
  7461. {
  7462. struct cfs_rq *cfs_rq = se->cfs_rq;
  7463. struct rq *rq = cfs_rq->rq;
  7464. unsigned long flags;
  7465. spin_lock_irqsave(&rq->lock, flags);
  7466. __set_se_shares(se, shares);
  7467. spin_unlock_irqrestore(&rq->lock, flags);
  7468. }
  7469. static DEFINE_MUTEX(shares_mutex);
  7470. int sched_group_set_shares(struct task_group *tg, unsigned long shares)
  7471. {
  7472. int i;
  7473. unsigned long flags;
  7474. /*
  7475. * We can't change the weight of the root cgroup.
  7476. */
  7477. if (!tg->se[0])
  7478. return -EINVAL;
  7479. if (shares < MIN_SHARES)
  7480. shares = MIN_SHARES;
  7481. else if (shares > MAX_SHARES)
  7482. shares = MAX_SHARES;
  7483. mutex_lock(&shares_mutex);
  7484. if (tg->shares == shares)
  7485. goto done;
  7486. spin_lock_irqsave(&task_group_lock, flags);
  7487. for_each_possible_cpu(i)
  7488. unregister_fair_sched_group(tg, i);
  7489. list_del_rcu(&tg->siblings);
  7490. spin_unlock_irqrestore(&task_group_lock, flags);
  7491. /* wait for any ongoing reference to this group to finish */
  7492. synchronize_sched();
  7493. /*
  7494. * Now we are free to modify the group's share on each cpu
  7495. * w/o tripping rebalance_share or load_balance_fair.
  7496. */
  7497. tg->shares = shares;
  7498. for_each_possible_cpu(i) {
  7499. /*
  7500. * force a rebalance
  7501. */
  7502. cfs_rq_set_shares(tg->cfs_rq[i], 0);
  7503. set_se_shares(tg->se[i], shares);
  7504. }
  7505. /*
  7506. * Enable load balance activity on this group, by inserting it back on
  7507. * each cpu's rq->leaf_cfs_rq_list.
  7508. */
  7509. spin_lock_irqsave(&task_group_lock, flags);
  7510. for_each_possible_cpu(i)
  7511. register_fair_sched_group(tg, i);
  7512. list_add_rcu(&tg->siblings, &tg->parent->children);
  7513. spin_unlock_irqrestore(&task_group_lock, flags);
  7514. done:
  7515. mutex_unlock(&shares_mutex);
  7516. return 0;
  7517. }
  7518. unsigned long sched_group_shares(struct task_group *tg)
  7519. {
  7520. return tg->shares;
  7521. }
  7522. #endif
  7523. #ifdef CONFIG_RT_GROUP_SCHED
  7524. /*
  7525. * Ensure that the real time constraints are schedulable.
  7526. */
  7527. static DEFINE_MUTEX(rt_constraints_mutex);
  7528. static unsigned long to_ratio(u64 period, u64 runtime)
  7529. {
  7530. if (runtime == RUNTIME_INF)
  7531. return 1ULL << 20;
  7532. return div64_u64(runtime << 20, period);
  7533. }
  7534. /* Must be called with tasklist_lock held */
  7535. static inline int tg_has_rt_tasks(struct task_group *tg)
  7536. {
  7537. struct task_struct *g, *p;
  7538. do_each_thread(g, p) {
  7539. if (rt_task(p) && rt_rq_of_se(&p->rt)->tg == tg)
  7540. return 1;
  7541. } while_each_thread(g, p);
  7542. return 0;
  7543. }
  7544. struct rt_schedulable_data {
  7545. struct task_group *tg;
  7546. u64 rt_period;
  7547. u64 rt_runtime;
  7548. };
  7549. static int tg_schedulable(struct task_group *tg, void *data)
  7550. {
  7551. struct rt_schedulable_data *d = data;
  7552. struct task_group *child;
  7553. unsigned long total, sum = 0;
  7554. u64 period, runtime;
  7555. period = ktime_to_ns(tg->rt_bandwidth.rt_period);
  7556. runtime = tg->rt_bandwidth.rt_runtime;
  7557. if (tg == d->tg) {
  7558. period = d->rt_period;
  7559. runtime = d->rt_runtime;
  7560. }
  7561. /*
  7562. * Cannot have more runtime than the period.
  7563. */
  7564. if (runtime > period && runtime != RUNTIME_INF)
  7565. return -EINVAL;
  7566. /*
  7567. * Ensure we don't starve existing RT tasks.
  7568. */
  7569. if (rt_bandwidth_enabled() && !runtime && tg_has_rt_tasks(tg))
  7570. return -EBUSY;
  7571. total = to_ratio(period, runtime);
  7572. /*
  7573. * Nobody can have more than the global setting allows.
  7574. */
  7575. if (total > to_ratio(global_rt_period(), global_rt_runtime()))
  7576. return -EINVAL;
  7577. /*
  7578. * The sum of our children's runtime should not exceed our own.
  7579. */
  7580. list_for_each_entry_rcu(child, &tg->children, siblings) {
  7581. period = ktime_to_ns(child->rt_bandwidth.rt_period);
  7582. runtime = child->rt_bandwidth.rt_runtime;
  7583. if (child == d->tg) {
  7584. period = d->rt_period;
  7585. runtime = d->rt_runtime;
  7586. }
  7587. sum += to_ratio(period, runtime);
  7588. }
  7589. if (sum > total)
  7590. return -EINVAL;
  7591. return 0;
  7592. }
  7593. static int __rt_schedulable(struct task_group *tg, u64 period, u64 runtime)
  7594. {
  7595. struct rt_schedulable_data data = {
  7596. .tg = tg,
  7597. .rt_period = period,
  7598. .rt_runtime = runtime,
  7599. };
  7600. return walk_tg_tree(tg_schedulable, tg_nop, &data);
  7601. }
  7602. static int tg_set_bandwidth(struct task_group *tg,
  7603. u64 rt_period, u64 rt_runtime)
  7604. {
  7605. int i, err = 0;
  7606. mutex_lock(&rt_constraints_mutex);
  7607. read_lock(&tasklist_lock);
  7608. err = __rt_schedulable(tg, rt_period, rt_runtime);
  7609. if (err)
  7610. goto unlock;
  7611. spin_lock_irq(&tg->rt_bandwidth.rt_runtime_lock);
  7612. tg->rt_bandwidth.rt_period = ns_to_ktime(rt_period);
  7613. tg->rt_bandwidth.rt_runtime = rt_runtime;
  7614. for_each_possible_cpu(i) {
  7615. struct rt_rq *rt_rq = tg->rt_rq[i];
  7616. spin_lock(&rt_rq->rt_runtime_lock);
  7617. rt_rq->rt_runtime = rt_runtime;
  7618. spin_unlock(&rt_rq->rt_runtime_lock);
  7619. }
  7620. spin_unlock_irq(&tg->rt_bandwidth.rt_runtime_lock);
  7621. unlock:
  7622. read_unlock(&tasklist_lock);
  7623. mutex_unlock(&rt_constraints_mutex);
  7624. return err;
  7625. }
  7626. int sched_group_set_rt_runtime(struct task_group *tg, long rt_runtime_us)
  7627. {
  7628. u64 rt_runtime, rt_period;
  7629. rt_period = ktime_to_ns(tg->rt_bandwidth.rt_period);
  7630. rt_runtime = (u64)rt_runtime_us * NSEC_PER_USEC;
  7631. if (rt_runtime_us < 0)
  7632. rt_runtime = RUNTIME_INF;
  7633. return tg_set_bandwidth(tg, rt_period, rt_runtime);
  7634. }
  7635. long sched_group_rt_runtime(struct task_group *tg)
  7636. {
  7637. u64 rt_runtime_us;
  7638. if (tg->rt_bandwidth.rt_runtime == RUNTIME_INF)
  7639. return -1;
  7640. rt_runtime_us = tg->rt_bandwidth.rt_runtime;
  7641. do_div(rt_runtime_us, NSEC_PER_USEC);
  7642. return rt_runtime_us;
  7643. }
  7644. int sched_group_set_rt_period(struct task_group *tg, long rt_period_us)
  7645. {
  7646. u64 rt_runtime, rt_period;
  7647. rt_period = (u64)rt_period_us * NSEC_PER_USEC;
  7648. rt_runtime = tg->rt_bandwidth.rt_runtime;
  7649. if (rt_period == 0)
  7650. return -EINVAL;
  7651. return tg_set_bandwidth(tg, rt_period, rt_runtime);
  7652. }
  7653. long sched_group_rt_period(struct task_group *tg)
  7654. {
  7655. u64 rt_period_us;
  7656. rt_period_us = ktime_to_ns(tg->rt_bandwidth.rt_period);
  7657. do_div(rt_period_us, NSEC_PER_USEC);
  7658. return rt_period_us;
  7659. }
  7660. static int sched_rt_global_constraints(void)
  7661. {
  7662. u64 runtime, period;
  7663. int ret = 0;
  7664. if (sysctl_sched_rt_period <= 0)
  7665. return -EINVAL;
  7666. runtime = global_rt_runtime();
  7667. period = global_rt_period();
  7668. /*
  7669. * Sanity check on the sysctl variables.
  7670. */
  7671. if (runtime > period && runtime != RUNTIME_INF)
  7672. return -EINVAL;
  7673. mutex_lock(&rt_constraints_mutex);
  7674. read_lock(&tasklist_lock);
  7675. ret = __rt_schedulable(NULL, 0, 0);
  7676. read_unlock(&tasklist_lock);
  7677. mutex_unlock(&rt_constraints_mutex);
  7678. return ret;
  7679. }
  7680. #else /* !CONFIG_RT_GROUP_SCHED */
  7681. static int sched_rt_global_constraints(void)
  7682. {
  7683. unsigned long flags;
  7684. int i;
  7685. if (sysctl_sched_rt_period <= 0)
  7686. return -EINVAL;
  7687. spin_lock_irqsave(&def_rt_bandwidth.rt_runtime_lock, flags);
  7688. for_each_possible_cpu(i) {
  7689. struct rt_rq *rt_rq = &cpu_rq(i)->rt;
  7690. spin_lock(&rt_rq->rt_runtime_lock);
  7691. rt_rq->rt_runtime = global_rt_runtime();
  7692. spin_unlock(&rt_rq->rt_runtime_lock);
  7693. }
  7694. spin_unlock_irqrestore(&def_rt_bandwidth.rt_runtime_lock, flags);
  7695. return 0;
  7696. }
  7697. #endif /* CONFIG_RT_GROUP_SCHED */
  7698. int sched_rt_handler(struct ctl_table *table, int write,
  7699. struct file *filp, void __user *buffer, size_t *lenp,
  7700. loff_t *ppos)
  7701. {
  7702. int ret;
  7703. int old_period, old_runtime;
  7704. static DEFINE_MUTEX(mutex);
  7705. mutex_lock(&mutex);
  7706. old_period = sysctl_sched_rt_period;
  7707. old_runtime = sysctl_sched_rt_runtime;
  7708. ret = proc_dointvec(table, write, filp, buffer, lenp, ppos);
  7709. if (!ret && write) {
  7710. ret = sched_rt_global_constraints();
  7711. if (ret) {
  7712. sysctl_sched_rt_period = old_period;
  7713. sysctl_sched_rt_runtime = old_runtime;
  7714. } else {
  7715. def_rt_bandwidth.rt_runtime = global_rt_runtime();
  7716. def_rt_bandwidth.rt_period =
  7717. ns_to_ktime(global_rt_period());
  7718. }
  7719. }
  7720. mutex_unlock(&mutex);
  7721. return ret;
  7722. }
  7723. #ifdef CONFIG_CGROUP_SCHED
  7724. /* return corresponding task_group object of a cgroup */
  7725. static inline struct task_group *cgroup_tg(struct cgroup *cgrp)
  7726. {
  7727. return container_of(cgroup_subsys_state(cgrp, cpu_cgroup_subsys_id),
  7728. struct task_group, css);
  7729. }
  7730. static struct cgroup_subsys_state *
  7731. cpu_cgroup_create(struct cgroup_subsys *ss, struct cgroup *cgrp)
  7732. {
  7733. struct task_group *tg, *parent;
  7734. if (!cgrp->parent) {
  7735. /* This is early initialization for the top cgroup */
  7736. return &init_task_group.css;
  7737. }
  7738. parent = cgroup_tg(cgrp->parent);
  7739. tg = sched_create_group(parent);
  7740. if (IS_ERR(tg))
  7741. return ERR_PTR(-ENOMEM);
  7742. return &tg->css;
  7743. }
  7744. static void
  7745. cpu_cgroup_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
  7746. {
  7747. struct task_group *tg = cgroup_tg(cgrp);
  7748. sched_destroy_group(tg);
  7749. }
  7750. static int
  7751. cpu_cgroup_can_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,
  7752. struct task_struct *tsk)
  7753. {
  7754. #ifdef CONFIG_RT_GROUP_SCHED
  7755. /* Don't accept realtime tasks when there is no way for them to run */
  7756. if (rt_task(tsk) && cgroup_tg(cgrp)->rt_bandwidth.rt_runtime == 0)
  7757. return -EINVAL;
  7758. #else
  7759. /* We don't support RT-tasks being in separate groups */
  7760. if (tsk->sched_class != &fair_sched_class)
  7761. return -EINVAL;
  7762. #endif
  7763. return 0;
  7764. }
  7765. static void
  7766. cpu_cgroup_attach(struct cgroup_subsys *ss, struct cgroup *cgrp,
  7767. struct cgroup *old_cont, struct task_struct *tsk)
  7768. {
  7769. sched_move_task(tsk);
  7770. }
  7771. #ifdef CONFIG_FAIR_GROUP_SCHED
  7772. static int cpu_shares_write_u64(struct cgroup *cgrp, struct cftype *cftype,
  7773. u64 shareval)
  7774. {
  7775. return sched_group_set_shares(cgroup_tg(cgrp), shareval);
  7776. }
  7777. static u64 cpu_shares_read_u64(struct cgroup *cgrp, struct cftype *cft)
  7778. {
  7779. struct task_group *tg = cgroup_tg(cgrp);
  7780. return (u64) tg->shares;
  7781. }
  7782. #endif /* CONFIG_FAIR_GROUP_SCHED */
  7783. #ifdef CONFIG_RT_GROUP_SCHED
  7784. static int cpu_rt_runtime_write(struct cgroup *cgrp, struct cftype *cft,
  7785. s64 val)
  7786. {
  7787. return sched_group_set_rt_runtime(cgroup_tg(cgrp), val);
  7788. }
  7789. static s64 cpu_rt_runtime_read(struct cgroup *cgrp, struct cftype *cft)
  7790. {
  7791. return sched_group_rt_runtime(cgroup_tg(cgrp));
  7792. }
  7793. static int cpu_rt_period_write_uint(struct cgroup *cgrp, struct cftype *cftype,
  7794. u64 rt_period_us)
  7795. {
  7796. return sched_group_set_rt_period(cgroup_tg(cgrp), rt_period_us);
  7797. }
  7798. static u64 cpu_rt_period_read_uint(struct cgroup *cgrp, struct cftype *cft)
  7799. {
  7800. return sched_group_rt_period(cgroup_tg(cgrp));
  7801. }
  7802. #endif /* CONFIG_RT_GROUP_SCHED */
  7803. static struct cftype cpu_files[] = {
  7804. #ifdef CONFIG_FAIR_GROUP_SCHED
  7805. {
  7806. .name = "shares",
  7807. .read_u64 = cpu_shares_read_u64,
  7808. .write_u64 = cpu_shares_write_u64,
  7809. },
  7810. #endif
  7811. #ifdef CONFIG_RT_GROUP_SCHED
  7812. {
  7813. .name = "rt_runtime_us",
  7814. .read_s64 = cpu_rt_runtime_read,
  7815. .write_s64 = cpu_rt_runtime_write,
  7816. },
  7817. {
  7818. .name = "rt_period_us",
  7819. .read_u64 = cpu_rt_period_read_uint,
  7820. .write_u64 = cpu_rt_period_write_uint,
  7821. },
  7822. #endif
  7823. };
  7824. static int cpu_cgroup_populate(struct cgroup_subsys *ss, struct cgroup *cont)
  7825. {
  7826. return cgroup_add_files(cont, ss, cpu_files, ARRAY_SIZE(cpu_files));
  7827. }
  7828. struct cgroup_subsys cpu_cgroup_subsys = {
  7829. .name = "cpu",
  7830. .create = cpu_cgroup_create,
  7831. .destroy = cpu_cgroup_destroy,
  7832. .can_attach = cpu_cgroup_can_attach,
  7833. .attach = cpu_cgroup_attach,
  7834. .populate = cpu_cgroup_populate,
  7835. .subsys_id = cpu_cgroup_subsys_id,
  7836. .early_init = 1,
  7837. };
  7838. #endif /* CONFIG_CGROUP_SCHED */
  7839. #ifdef CONFIG_CGROUP_CPUACCT
  7840. /*
  7841. * CPU accounting code for task groups.
  7842. *
  7843. * Based on the work by Paul Menage (menage@google.com) and Balbir Singh
  7844. * (balbir@in.ibm.com).
  7845. */
  7846. /* track cpu usage of a group of tasks */
  7847. struct cpuacct {
  7848. struct cgroup_subsys_state css;
  7849. /* cpuusage holds pointer to a u64-type object on every cpu */
  7850. u64 *cpuusage;
  7851. };
  7852. struct cgroup_subsys cpuacct_subsys;
  7853. /* return cpu accounting group corresponding to this container */
  7854. static inline struct cpuacct *cgroup_ca(struct cgroup *cgrp)
  7855. {
  7856. return container_of(cgroup_subsys_state(cgrp, cpuacct_subsys_id),
  7857. struct cpuacct, css);
  7858. }
  7859. /* return cpu accounting group to which this task belongs */
  7860. static inline struct cpuacct *task_ca(struct task_struct *tsk)
  7861. {
  7862. return container_of(task_subsys_state(tsk, cpuacct_subsys_id),
  7863. struct cpuacct, css);
  7864. }
  7865. /* create a new cpu accounting group */
  7866. static struct cgroup_subsys_state *cpuacct_create(
  7867. struct cgroup_subsys *ss, struct cgroup *cgrp)
  7868. {
  7869. struct cpuacct *ca = kzalloc(sizeof(*ca), GFP_KERNEL);
  7870. if (!ca)
  7871. return ERR_PTR(-ENOMEM);
  7872. ca->cpuusage = alloc_percpu(u64);
  7873. if (!ca->cpuusage) {
  7874. kfree(ca);
  7875. return ERR_PTR(-ENOMEM);
  7876. }
  7877. return &ca->css;
  7878. }
  7879. /* destroy an existing cpu accounting group */
  7880. static void
  7881. cpuacct_destroy(struct cgroup_subsys *ss, struct cgroup *cgrp)
  7882. {
  7883. struct cpuacct *ca = cgroup_ca(cgrp);
  7884. free_percpu(ca->cpuusage);
  7885. kfree(ca);
  7886. }
  7887. /* return total cpu usage (in nanoseconds) of a group */
  7888. static u64 cpuusage_read(struct cgroup *cgrp, struct cftype *cft)
  7889. {
  7890. struct cpuacct *ca = cgroup_ca(cgrp);
  7891. u64 totalcpuusage = 0;
  7892. int i;
  7893. for_each_possible_cpu(i) {
  7894. u64 *cpuusage = percpu_ptr(ca->cpuusage, i);
  7895. /*
  7896. * Take rq->lock to make 64-bit addition safe on 32-bit
  7897. * platforms.
  7898. */
  7899. spin_lock_irq(&cpu_rq(i)->lock);
  7900. totalcpuusage += *cpuusage;
  7901. spin_unlock_irq(&cpu_rq(i)->lock);
  7902. }
  7903. return totalcpuusage;
  7904. }
  7905. static int cpuusage_write(struct cgroup *cgrp, struct cftype *cftype,
  7906. u64 reset)
  7907. {
  7908. struct cpuacct *ca = cgroup_ca(cgrp);
  7909. int err = 0;
  7910. int i;
  7911. if (reset) {
  7912. err = -EINVAL;
  7913. goto out;
  7914. }
  7915. for_each_possible_cpu(i) {
  7916. u64 *cpuusage = percpu_ptr(ca->cpuusage, i);
  7917. spin_lock_irq(&cpu_rq(i)->lock);
  7918. *cpuusage = 0;
  7919. spin_unlock_irq(&cpu_rq(i)->lock);
  7920. }
  7921. out:
  7922. return err;
  7923. }
  7924. static struct cftype files[] = {
  7925. {
  7926. .name = "usage",
  7927. .read_u64 = cpuusage_read,
  7928. .write_u64 = cpuusage_write,
  7929. },
  7930. };
  7931. static int cpuacct_populate(struct cgroup_subsys *ss, struct cgroup *cgrp)
  7932. {
  7933. return cgroup_add_files(cgrp, ss, files, ARRAY_SIZE(files));
  7934. }
  7935. /*
  7936. * charge this task's execution time to its accounting group.
  7937. *
  7938. * called with rq->lock held.
  7939. */
  7940. static void cpuacct_charge(struct task_struct *tsk, u64 cputime)
  7941. {
  7942. struct cpuacct *ca;
  7943. if (!cpuacct_subsys.active)
  7944. return;
  7945. ca = task_ca(tsk);
  7946. if (ca) {
  7947. u64 *cpuusage = percpu_ptr(ca->cpuusage, task_cpu(tsk));
  7948. *cpuusage += cputime;
  7949. }
  7950. }
  7951. struct cgroup_subsys cpuacct_subsys = {
  7952. .name = "cpuacct",
  7953. .create = cpuacct_create,
  7954. .destroy = cpuacct_destroy,
  7955. .populate = cpuacct_populate,
  7956. .subsys_id = cpuacct_subsys_id,
  7957. };
  7958. #endif /* CONFIG_CGROUP_CPUACCT */